目录
一、工程配置
1、时钟、DEBUG
2、GPIO
3、SPI2
4、USART6
5、NVIC
二、软件设计
1、FALSH
（1）w25flash.h
（2） w25flash.c
1）W25Q16基本操作指令
2）计算地址的辅助功能函数
3）器件、块、扇区擦除函数
4）存储区读写函数
2、KEY_LED
3、spi.h
4、spi.c
5、main.c
三、下载与运行
本文旨在说明STM32F407单片机通过SPI2扩展FLASH W25Q16BV，对FLASH进行读ID、写操作、读操作、擦除操作。使用的是旺宝红龙开发板STM32F407ZGT6 KIT V1.0。使用开发板上的按键S2、S3、S4、S5、S6依此执行擦除芯片、擦除BLOCK0、写、读操作、MCU复位。使用开发板上的D1、D2、D3、D4作为动作指示灯。通过串口USART6把操作状态显示到串口助手上。资源利用详见工程配置。
工程里创建FLASH目录，包含w25flash.c、w25flash.h。
工程依旧创建KEY_LED目录，包含keyled.c、keyled.h。关于如何在工程中创建目录并添加文件以及keyled.c、keyled.h详见作者的其他文章。
其它资料可以参考本文作者的其他文章：细说STM32F407单片机SPI基础知识_stm32f407 spi2-CSDN博客 https://wenchm.blog.csdn.net/article/details/144376346
细说Flash存储芯片W25Q128FW和W25Q16BV_flash拓展地址寄存器0xc5-CSDN博客 https://wenchm.blog.csdn.net/article/details/144398492
一、工程配置
1、时钟、DEBUG
外部时钟，25MHz，设置到HCLK=168MHz，PCLK1=42MHz，PCLK2=84MHz，其它，都设置成168MHz。
DEBUG，选择serial wire。
2、GPIO
项目工程使用了开发板的按键S2、S3、S4、S5、S6，和开发板上的LED灯D1、D2、D3、D4。详细配置如下表：
| 用户标签 | 开发板 | 引脚名称 | 引脚功能 | GPIO模式 | 默认电平 | 上拉 或下拉 |
| LED1 | D1 | PA6 | GPIO_Output | 推挽输出 | High，MCU输出低电平时灯亮 | 上拉 |
| LED2 | D2 | PA4 | GPIO_Output | 推挽输出 | High，MCU输出低电平时灯亮 | 上拉 |
| LED3 | D3 | PB6 | GPIO_Output | 推挽输出 | High，MCU输出低电平时灯亮 | 上拉 |
| LED4 | D4 | PC6 | GPIO_Output | 推挽输出 | High，MCU输出低电平时灯亮 | 上拉 |
| KeyUp | S2 | PA0 | GPIO_Input | 输入 | 按键输入低电平 | 上拉 |
| KeyDown | S3 | PD3 | GPIO_Input | 输入 | 按键输入低电平 | 上拉 |
| KeyLeft | S4 | PF7 | GPIO_Input | 输入 | 按键输入低电平 | 上拉 |
| KeyRight | S5 | PF6 | GPIO_Input | 输入 | 按键输入低电平 | 上拉 |
| S6 | NRST | GPIO_Input | 输入 | 按键复位 | 上拉 |
3、SPI2
MCU的SPI2与FLASH的连接原理图，详见参考文章。管脚配置见下表：
| 用户标签 | 开发板 标识 | 引脚名称 | 引脚功能 | GPIO模式 | 默认电平 | 上拉 或下拉 |
| FLASH_CS | FLASH_CS | PC13 | GPIO_Output片选 | 推挽输出 | High | 上拉 |
| SPI2_SCK | SPI_SCK | PB10 | 时钟 | Alternate Function | High | No |
| SPI2_MOSI | SPI_MOSI | PB15 | MOSI数据线 | Alternate Function | High | No |
| SPI2_MISO | SPI_MISO | PB14 | MISO数据线 | Alternate Function | High | No |
4、USART6
115200、8、None、1，其它参数默认。占用管脚PG14、PG9。
5、NVIC
不设置中断，但把Time Base的优先级修改为0。
二、软件设计
1、FALSH
创建一个名为FLASH的子目录，创建文件w25flash.h和w25flash.c，并将其存放在这个子目录里。 将W25Q16常用的一些功能编写为函数，也就是实现W25Q16常用操作指令，例如擦除芯片、擦除扇区、读取数据、写入数据等。
注意W25Q16驱动程序与SPI接口的HAL驱动程序的区别。SPI的HAL驱动程序实现了SPI接口数据传输的基本功能，是SPI硬件层的驱动；而W25Q16驱动程序则是根据W25Q16的指令定义，实现器件具体功能操作的一系列函数。W25Q16驱动程序要用到SPI硬件层的HAL驱动程序，要通过SPI的HAL驱动程序实现数据帧的收发。
W25Q16驱动程序涉及的硬件接口包括SPI接口和CS信号，驱动程序应该能很容易地移植到其他电路板上，所以在文件开头定义了硬件接口相关的宏。
- 为CS信号连接的GPIO引脚定义了表示GPIO端口和引脚号的宏CS_PORT和CS_PIN，定义了两个宏函数__Select_Flash()和__Deselect_Flash()用于对CS置位和复位。
- W25Q16器件连接的SPI接口定义为宏SPI_HANDLE，这里指向文件spi.h中的变量hspi2，也就是表示SPI2接口的外设对象变量。在驱动程序的所有函数内部都使用宏SPI_HANDLE表示SPI2接口。
这样定义硬件接口后，如果要将这个驱动程序移植到其他开发板上操作W25Q16，只需修改这3个宏的定义即可。
文件w25flash.h中的函数分为几组，这些函数就是W25Q16常用指令的实现。文件w25flash.c的全部代码有400多行，这里就不全部显示出来了，只选择其中一些典型的函数进行解释说明。
文件w25flash.h是W25Q16驱动程序的头文件，定义了一些宏和函数。这个文件的完整代码如下：
（1）w25flash.h
/* 文件： w25flash.h* 功能描述： Flash 存储器W25Q16的驱动程序* 作者：* 移植：* 修改日期：2019-06-05* 移植日期：2024-12-09* W25Q16BV 芯片参数： 2M字节，24位地址线* 分为32个Block，每个Block 64K字节* 一个Block又分为16个Sector，共512个Sector，每个Sector 4K字节* 一个Sector又分为16个Page，共8192个Page，每个Page 256字节* 写数据操作的基本单元是Page，一次连续写入操作不能超过一个Page的范围。写的Page必须是擦除过的。*/#ifndef _W25FLASH_H
#define _W25FLASH_H#include "stm32f4xx_hal.h"
#include "spi.h" //使用其中的变量 hspi1，表示SPI1接口/* W25Q16硬件接口相关的部分：CS引脚和SPI接口 ，若电路不同，更改这部分配置即可*/
// Flash_CS -->PC13, 片选信号CS操作的宏定义函数
#define CS_PORT GPIOC
#define CS_PIN GPIO_PIN_13
#define SPI_HANDLE hspi1 //SPI接口对象，使用spi.h中的变量 hspi1#define __Select_Flash() HAL_GPIO_WritePin(CS_PORT, CS_PIN, GPIO_PIN_RESET) //CS=0
#define __Deselect_Flash() HAL_GPIO_WritePin(CS_PORT, CS_PIN, GPIO_PIN_SET) //CS=1//===========Flash存储芯片W25Q16的存储容量参数================
#define FLASH_PAGE_SIZE 256 //一个Page是256字节#define FLASH_SECTOR_SIZE 4096 //一个Sector是4096字节#define FLASH_SECTOR_COUNT 512 //总共512个Sector//=======1. SPI 基本发送和接收函数，阻塞式传输============
HAL_StatusTypeDef SPI_TransmitOneByte(uint8_t byteData); //SPI接口发送一个字节
HAL_StatusTypeDef SPI_TransmitBytes(uint8_t* pBuffer, uint16_t byteCount); //SPI接口发送多个字节uint8_t SPI_ReceiveOneByte(); //SPI接口接收一个字节
HAL_StatusTypeDef SPI_ReceiveBytes(uint8_t* pBuffer, uint16_t byteCount); //SPI接口接收多个字节//=========2. W25Qxx 基本控制指令==========
// 0xEF14,表示芯片型号为W25Q16BV, Winbond，0x90指令
// 0xEF16,表示芯片型号为W25Q64JV, Winbond，0x90指令
// 0xEF17,表示芯片型号为W25Q128JV, Winbond，0x90指令
// 根据FLASH数据修改此处，比如：
// 0xC817，表示芯片型号为GD25Q128,ELM，用过
// 0x1C17，表示芯片型号为EN25Q128,台湾EON
// 0xA117，表示芯片型号为FM25Q128，复旦微电子
// 0x2018，表示芯片型号为N25Q128，美光
// 0x2017，表示芯片型号为XM25QH128，武汉新芯，用过uint16_t Flash_ReadID(void); // Command=0x90, Manufacturer/Device IDuint64_t Flash_ReadSerialNum(uint32_t* High32, uint32_t* Low32); //Command=0x4B, Read Unique ID, 64-bit
// W25Q16无此指令
// HAL_StatusTypeDef Flash_WriteVolatile_Enable(void); //Command=0x50: Write Volatile EnableHAL_StatusTypeDef Flash_Write_Enable(void); //Command=0x06: Write Enable, 使WEL=1
HAL_StatusTypeDef Flash_Write_Disable(void); //Command=0x04, Write Disable，使WEL=0uint8_t Flash_ReadSR1(void); //Command=0x05: Read Status Register-1,返回寄存器SR1的值
uint8_t Flash_ReadSR2(void); //Command=0x35: Read Status Register-2,返回寄存器SR2的值void Flash_WriteSR1(uint8_t SR1); //Command=0x01: Write Status Register, 只写SR1的值,禁止写状态寄存器uint32_t Flash_Wait_Busy(void); //读状态寄存器SR1，等待BUSY变为0,返回值是等待时间
void Flash_PowerDown(void); //Command=0xB9: Power Down
void Flash_WakeUp(void); //Command=0xAB: Release Power Down//========3. 计算地址的辅助功能函数========
//根据Block 绝对编号获取地址,共32个Block
uint32_t Flash_Addr_byBlock(uint8_t BlockNo);
//根据Sector 绝对编号获取地址,共512个Sector
uint32_t Flash_Addr_bySector(uint16_t SectorNo);
//根据Page 绝对编号获取地址，共8192个Page
uint32_t Flash_Addr_byPage(uint16_t PageNo);//根据Block编号，和内部Sector编号计算地址，一个Block有16个Sector,
uint32_t Flash_Addr_byBlockSector(uint8_t BlockNo, uint8_t SubSectorNo);
//根据Block编号，内部Sector编号，内部Page编号计算地址
uint32_t Flash_Addr_byBlockSectorPage(uint8_t BlockNo, uint8_t SubSectorNo, uint8_t SubPageNo);
//将24位地址分解为3个字节
void Flash_SpliteAddr(uint32_t globalAddr, uint8_t* addrHigh, uint8_t* addrMid,uint8_t* addrLow);//=======4. chip、Block，Sector擦除函数============
//Command=0xC7: Chip Erase, 擦除整个器件,大约4秒
void Flash_EraseChip(void);//Command=0xD8: Block Erase(64KB) 擦除整个Block, globalAddr是全局地址，耗时大约150ms
void Flash_EraseBlock64K(uint32_t globalAddr);//Command=0x20: Sector Erase(4KB) 扇区擦除, globalAddr是扇区的全局地址，耗时大约30ms
void Flash_EraseSector(uint32_t globalAddr);//=========5. 数据读写函数=============
//Command=0x03, 读取一个字节，任意全局地址
uint8_t Flash_ReadOneByte(uint32_t globalAddr);//Command=0x03, 连续读取多个字节，任意全局地址
void Flash_ReadBytes(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount);//Command=0x0B, 高速连续读取多个字节，任意全局地址， 速度大约是常规读取的2倍
void Flash_FastReadBytes(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount);//Command=0x02: Page program 对一个Page写入数据（最多256字节）, globalAddr是初始位置的全局地址，耗时大约3ms
void Flash_WriteInPage(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount);//从某个Sector的起始地址开始写数据，数据可能跨越多个Page,甚至跨越Sector，总字节数byteCount不能超过64K，也就是一个Block的大小
void Flash_WriteSector(uint32_t globalAddr, const uint8_t* pBuffer, uint16_t byteCount);#endif
定义了4个SPI基本发送和接收函数，用于传输1字节或多字节，接收1字节或多字节。这几个函数实际上就是调用了SPI的HAL驱动程序中阻塞式数据传输函数HAL_SPI_Transmit()和HAL SPI_Receive()。在封装为W25Q16驱动程序的函数时，内部直接使用宏SPI_HANDLE替代了具体的hspil，使用宏定义常量MAX_TIMEOUT作为超时等待时间，这样可以简化函数的调用，因为这几个基本的传输函数在其他函数里被大量调用。
（2） w25flash.c
1）W25Q16基本操作指令
W25Q16的每个函数对应于W25Q16的一个指令。例如：
读器件ID的函数Flash ReadID()就是实现了指令码为0x90的指令；FlashWrite_Enable()函数实现了“写使能”(指令码0x06)指令；Flash_Wait_Busy()函数读取状态寄存器SR1，判断BUSY位是否为0，直到BUSY为0时才退出。
Flash_Write_Enable()和Flash_Wait_Busy()是在其他指令操作函数里经常用到的，例如擦除芯片、擦除扇区、写数据等操作之前必须执行“写使能”指令。一些比较耗时间的操作执行后，必须等待状态寄存器SR1的BUSY位变为0，也就是需要调用函数Flash_Wait_Busy()。
这些函数的代码解释了通过一个函数实现一个指令操作的方法，它们就是根据指令定义以及相应的指令时序图，通过片选信号CS的控制以及SPI接口的字节数据发送和接收来实现一个指令的操作。例如，函数Flash_ReadID()执行查询芯片的制造商和器件ID的指令，指令码0x90。程序先执行宏函数__Select_Flash()使片选信号CS为低电平，从而开始一次SPI传输。然后，按照指令0x90的定义依次发送4个字节数据0x90、0x00、0x00、0x00，其中0x90是指令码，中间两个0x00是dummy字节，最后一个0x00是特定的。最后，W25Q16会返回2字节数据，依次接收这2字节数据，就能得到制造商和器件ID信息。
函数Flash_Wait_Busy()是用于判断状态寄存器SR1的BUSY位是否为0的，所以需要调用函数Flash_ReadSR1()读取状态寄存器SR1的内容，直到BUSY位变为0时，函数才退出。
2）计算地址的辅助功能函数
W25Q16的一些指令需要使用24位的绝对地址，例如块擦除、读数据等指令都需要提供24位绝对地址。直接记住或推算地址是比较麻烦的，在使用Flash的存储空间时，一般以块、扇区、页为单位进行管理，直接根据块、扇区、页的编号计算地址是比较实用的。所以，我们在驱动程序中定义了几个辅助函数，用于根据块、扇区、页的编号计算24位绝对地址，还可以将24位绝对地址分解为3字节数据，便于在指令中使用。
3）器件、块、扇区擦除函数
定义了器件擦除、块擦除和扇区擦除指令的操作函数，其中块擦除和扇区擦除指令需要起始地址。例如，扇区擦除的函数是Flash_EraseSector()。在擦除操作之前，必须执行“写使能”指令，使状态寄存器SR1的WEL位变为1，并且等待BUSY位变为0的时候，才能开始发送擦除操作指令。擦除指令发送结束后，器件执行擦除操作，在此期间BUSY位为1，需等待BUSY位变为0之后，才能退出函数。
执行擦除操作后的Flash存储区域数据为0xFF。向存储区域写数据时，必须是擦除后的区域才能写入数据，否则写入无效。所以，一个存储区域只能有效写入一次，下次再写入之前必须先擦除。从存储区读出数据的次数是无限制的。
4）存储区读写函数
“读数据”指令(指令码0x03)可以从任何一个24位地址开始读取1字节或连续多字节的数据，由此定义了两个函数Flash_ReadOneByte()和Flash_ReadBytes()。
写数据使用“页编程”指令(指令码0x02)，由此定义函数Flash_WriteInPage()用于向一个页内写入数据。
使用函数Flash_ReadBytes(读取数据时，起始地址可以是任何地址，读取的数据长度也可以超过页的容量，也就是可以超过256字节，最多可连续读取65536字节。使用函数Flash_WriteInPage()写入数据时需要注意以下几点。
- 一次的写数据操作是限定在一个页范围内的，所以一次写入数据长度最多256字节。
- 起始地址可以是任何地址，但写数据的偏移地址超过页的边界后，会从该页的开始地址继续写。所以，起始地址为页的开始地址时，最多可写入256字节。
- 写入数据的存储区域必须是擦除过的，也就是存储内容是0xFF，否则写入数据无效。所以一个页只能写入一次，下次再写之前，需要先擦除页。W25Q16擦除的最小单位是扇区。
驱动程序中还有一个函数Flash_WriteSector()，它可以从一个扇区的起始地址开始写入不超过64KB的数据。这个函数内部会先擦除需要用到的扇区，然后将数据按页的大小分解，调用Flash_WriteInPage()逐个页写入数据。
/* 文件： w25flash.c* 功能描述： Flash 存储器W25Q16的驱动程序* 作者：* 移植：* 修改日期：2019-06-05* 移植日期：2024-12-10*/#include "w25flash.h"#define MAX_TIMEOUT 200 //SPI轮询操作时的最大等待时间,ms//SPI接口发送一个字节,byteData是需要发送的数据
HAL_StatusTypeDef SPI_TransmitOneByte(uint8_t byteData)
{return HAL_SPI_Transmit(&SPI_HANDLE, &byteData, 1, MAX_TIMEOUT);
}//SPI接口发送多个字节, pBuffer是发送数据缓存区指针，byteCount是发送数据字节数，byteCount最大256
HAL_StatusTypeDef SPI_TransmitBytes(uint8_t* pBuffer, uint16_t byteCount)
{return HAL_SPI_Transmit(&SPI_HANDLE, pBuffer, byteCount, MAX_TIMEOUT);
}//SPI接口接收一个字节，返回接收的一个字节数据
uint8_t SPI_ReceiveOneByte()
{uint8_t byteData=0;HAL_SPI_Receive(&SPI_HANDLE, &byteData, 1, MAX_TIMEOUT);return byteData;
}//SPI接口接收多个字节，pBuffer是接收数据缓存区指针，byteCount是需要接收数据的字节数
HAL_StatusTypeDef SPI_ReceiveBytes(uint8_t* pBuffer, uint16_t byteCount)
{return HAL_SPI_Receive(&SPI_HANDLE, pBuffer, byteCount, MAX_TIMEOUT);
}//Command=0x05: Read Status Register-1,返回寄存器SR1的值
uint8_t Flash_ReadSR1(void)
{ uint8_t byte=0;__Select_Flash(); //CS=0SPI_TransmitOneByte(0x05); //Command=0x05: Read Status Register-1byte=SPI_ReceiveOneByte();__Deselect_Flash(); //CS=1return byte;
} //Command=0x35: Read Status Register-2,返回寄存器SR2的值
uint8_t Flash_ReadSR2(void)
{uint8_t byte=0;__Select_Flash(); //CS=0SPI_TransmitOneByte(0x35); //Command=0x35: Read Status Register-2byte=SPI_ReceiveOneByte(); //读取一个字节__Deselect_Flash(); //CS=1return byte;
}//Command=0x01: Write Status Register,只写SR1的值
//耗时大约10-15ms
void Flash_WriteSR1(uint8_t SR1)
{ Flash_Write_Enable(); //必须使 WEL=1__Select_Flash(); //CS=0SPI_TransmitOneByte(0x01); //Command=0x01:Write Status Register,只写SR1的值SPI_TransmitOneByte(0x00); //SR1的值
// SPI_WriteOneByte(0x00); //SR2的值, 只发送SR1的值，而不发送SR2的值，QE和CMP将自动被清零__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //耗时大约10-15ms
} /*
HAL_StatusTypeDef Flash_WriteVolatile_Enable(void) //Command=0x50: Write Volatile Enable
{__Select_Flash(); //CS=0HAL_StatusTypeDef result=SPI_TransmitOneByte(0x50);__Deselect_Flash(); //CS=1return result;
}
*///Command=0x06: Write Enable,使WEL=1
HAL_StatusTypeDef Flash_Write_Enable(void)
{__Select_Flash(); //CS=0HAL_StatusTypeDef result=SPI_TransmitOneByte(0x06); //Command=0x06: Write Enable,使WEL=1__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //等待操作完成return result;
} //Command=0x04, Write Disable，使WEL=0
HAL_StatusTypeDef Flash_Write_Disable(void)
{ __Select_Flash(); //CS=0HAL_StatusTypeDef result=SPI_TransmitOneByte(0x04); //Command=0x04, Write Disable，使WEL=0__Deselect_Flash(); //CS=1Flash_Wait_Busy();return result;
} //根据Block绝对编号获取地址, 共32个Block，BlockNo 取值范围0-31
//每个块64K字节，16位地址，块内地址范围0x0000-0xFFFF。
uint32_t Flash_Addr_byBlock(uint8_t BlockNo)
{
// uint32_t addr=BlockNo*0x10000;uint32_t addr = BlockNo;addr = addr<<16; //左移16位，等于乘以0x10000return addr;
}//根据Sector绝对编号获取地址, 共512个Sector, SectorNo取值范围0-511
//每个扇区4K字节，12位地址，扇区内地址范围0x000-0xFFF
uint32_t Flash_Addr_bySector(uint16_t SectorNo)
{if (SectorNo>511) //不能超过511SectorNo=0;
// uint32_t addr=SectorNo*0x1000;uint32_t addr = SectorNo;addr = addr<<12; //左移12位,等于乘以0x1000return addr;
}//根据Page绝对编号获取地址，共8192个Page, PageNo取值范围0-8191
//每个页256字节，8位地址，页内地址范围0x00—0xFF
uint32_t Flash_Addr_byPage(uint16_t PageNo)
{
// uint32_t addr=PageNo*0x100;uint32_t addr = PageNo;addr = addr<<8; //左移8位，等于乘以0x100return addr;
}//根据Block编号和内部Sector编号计算地址，一个Block有16个Sector
//BlockNo取值范围0-31，内部SubSectorNo取值范围0-15
uint32_t Flash_Addr_byBlockSector(uint8_t BlockNo, uint8_t SubSectorNo)
{if (SubSectorNo>15) //不能超过15SubSectorNo = 0;// uint32_t addr=BlockNo*0x10000; //先计算Block的起始地址uint32_t addr = BlockNo;addr = addr<<16; //先计算Block的起始地址// uint32_t offset=SubSectorNo*0x1000; //计算Sector的偏移地址uint32_t offset = SubSectorNo; //计算Sector的偏移地址offset = offset<<12;//计算Sector的偏移地址addr += offset;return addr;
}// 根据Block编号，内部Sector编号，内部Page编号获取地址
// BlockNo取值范围0-31
// 一个Block有16个Sector， 内部SubSectorNo取值范围0-15
// 一个Sector有16个Page , 内部SubPageNo取值范围0-15
uint32_t Flash_Addr_byBlockSectorPage(uint8_t BlockNo, uint8_t SubSectorNo, uint8_t SubPageNo)
{if (SubSectorNo>15) //不能超过15SubSectorNo = 0;if (SubPageNo>15) //不能超过15SubPageNo = 0;// uint32_t addr=BlockNo*0x10000; //先计算Block的起始地址uint32_t addr = BlockNo;addr = addr<<16; //先计算Block的起始地址// uint32_t offset=SubSectorNo*0x1000; //计算Sector的偏移地址uint32_t offset = SubSectorNo; //计算Sector的偏移地址offset = offset<<12;//计算Sector的偏移地址addr += offset;// offset=SubPageNo*0x100; //计算Page的偏移地址offset = SubPageNo;offset = offset<<8;//计算Page的偏移地址addr += offset; //Page的起始地址return addr;
}// 将24位地址分解为3个字节
// globalAddr是全局24位地址, 返回 addrHigh高字节，addrMid中间字节，addrLow低字节
void Flash_SpliteAddr(uint32_t globalAddr, uint8_t* addrHigh, uint8_t* addrMid,uint8_t* addrLow)
{*addrHigh = (globalAddr>>16); //addrHigh=高字节globalAddr = globalAddr & 0x0000FFFF;//屏蔽高字节*addrMid = (globalAddr>>8); //addrMid=中间字节*addrLow = globalAddr & 0x000000FF; //屏蔽中间字节，只剩低字节，addrLow=低字节
}//读取芯片ID
//返回值如下:
// 0xEF17,表示芯片型号为W25Q16, Winbond,用过
// 0xC817，表示芯片型号为GD25Q16,ELM，用过
// 0x1C17，表示芯片型号为EN25Q16,台湾EON
// 0xA117，表示芯片型号为FM25Q16，复旦微电子
// 0x2018，表示芯片型号为N25Q16，美光
// 0x2017，表示芯片型号为XM25QH16，武汉新芯，用过//读取芯片的制造商和器件ID，高字节是Manufacturer ID,低字节是Device ID
uint16_t Flash_ReadID(void)
{uint16_t Temp = 0;__Select_Flash(); //CS=0SPI_TransmitOneByte(0x90); //指令码，0x90=Manufacturer/Device IDSPI_TransmitOneByte(0x00); //dummySPI_TransmitOneByte(0x00); //dummySPI_TransmitOneByte(0x00); //0x00Temp = SPI_ReceiveOneByte()<<8; //Manufacturer IDTemp|= SPI_ReceiveOneByte(); //Device ID, 与具体器件相关__Deselect_Flash(); //CS=1return Temp;
}// 参数High32和Low32分别返回64位序列号的高32位和低32位的值
// 函数返回值为64位序列号的值
uint64_t Flash_ReadSerialNum(uint32_t* High32, uint32_t* Low32)//读取64位序列号，
{uint8_t Temp = 0;uint64_t SerialNum = 0;uint32_t High=0,Low = 0;__Select_Flash(); //CS=0SPI_TransmitOneByte(0x4B); //发送指令码, 4B=read Unique IDSPI_TransmitOneByte(0x00); //发送4个Dummy字节数据SPI_TransmitOneByte(0x00);SPI_TransmitOneByte(0x00);SPI_TransmitOneByte(0x00);for(uint8_t i=0; i<4; i++)//高32位{Temp = SPI_ReceiveOneByte();High = (High<<8);High = High | Temp; //按位或}for(uint8_t i=0; i<4; i++)//低32位{Temp = SPI_ReceiveOneByte();Low = (Low<<8);Low = Low | Temp; //按位或}__Deselect_Flash(); //CS=1*High32 = High;*Low32 = Low;SerialNum = High;SerialNum = SerialNum<<32;//高32位SerialNum = SerialNum | Low;return SerialNum;
}// 在任意地址读取一个字节的数据,返回读取的字节数据
// globalAddr是24位全局地址
uint8_t Flash_ReadOneByte(uint32_t globalAddr)
{uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节__Select_Flash(); //CS=0SPI_TransmitOneByte(0x03); //Command=0x03, read dataSPI_TransmitOneByte(byte2); //发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);byte2 = SPI_ReceiveOneByte();//接收1个字节 //why byte2?__Deselect_Flash(); //CS=1return byte2;
}//从任何地址开始读取指定长度的数据
//globalAddr：开始读取的地址(24bit)， pBuffer：数据存储区指针，byteCount:要读取的字节数
void Flash_ReadBytes(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount)
{ uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节__Select_Flash(); //CS=0SPI_TransmitOneByte(0x03); //Command=0x03, read dataSPI_TransmitOneByte(byte2); //发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);SPI_ReceiveBytes(pBuffer, byteCount);//接收byteCount个字节数据__Deselect_Flash(); //CS=1
} //Command=0x0B, 高速连续读取flash多个字节，任意全局地址， 速度大约是常规读取的2倍
void Flash_FastReadBytes(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount)
{
// uint16_t i;uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节__Select_Flash(); //CS=0SPI_TransmitOneByte(0x0B); //Command=0x0B, fast read dataSPI_TransmitOneByte(byte2); //发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);SPI_TransmitOneByte(0x00); //Dummy字节SPI_ReceiveBytes(pBuffer, byteCount);//接收byteCount个字节数据__Deselect_Flash(); //CS=1}//Command=0xC7: Chip Erase, 擦除整个器件
// 擦除后，所有存储区内容为0xFF,耗时大约25秒
void Flash_EraseChip(void)
{ Flash_Write_Enable(); //使 WEL=1Flash_Wait_Busy(); //等待空闲__Select_Flash(); //CS=0SPI_TransmitOneByte(0xC7);//Command=0xC7: Chip Erase, 擦除整个器件__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //等待芯片擦除结束,大约25秒
} // Command=0x02: Page program, 对一个页（256字节）编程, 耗时大约3ms,
// globalAddr是写入初始地址，全局地址
// pBuffer是要写入数据缓冲区指针，byteCount是需要写入的数据字节数
// 写入的Page必须是前面已经擦除过的，如果写入地址超出了page的边界，就从Page的开头重新写
void Flash_WriteInPage(uint32_t globalAddr, uint8_t* pBuffer, uint16_t byteCount)
{uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节Flash_Write_Enable();//SET WELFlash_Wait_Busy();__Select_Flash(); //CS=0SPI_TransmitOneByte(0x02); //Command=0x02: Page program 对一个扇区编程SPI_TransmitOneByte(byte2); //发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);SPI_TransmitBytes(pBuffer, byteCount);//发送byteCount个字节的数据
// for(uint16_t i=0; i<byteCount; i++)
// {
// byte2=pBuffer[i];
// SPI_WriteOneByte(byte2);//要写入的数据
// }__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //耗时大约3ms
}// 从某个Sector的起始位置开始写数据，数据可能跨越多个Page,甚至跨越Sector,不必提前擦除
// globalAddr是写入初始地址，全局地址,是扇区的起始地址，
// pBuffer是要写入数据缓冲区指针
// byteCount是需要写入的数据字节数，byteCount不能超过64K，也就是一个Block（16个扇区）的大小,但是可以超过一个Sector(4K字节)
// 如果数据超过一个Page，自动分成多个Page，调用EN25Q_WriteInPage分别写入
void Flash_WriteSector(uint32_t globalAddr, const uint8_t* pBuffer, uint16_t byteCount)
{
//需要先擦除扇区，可能是重复写文件uint8_t secCount = (byteCount / FLASH_SECTOR_SIZE);//数据覆盖的扇区个数if ((byteCount % FLASH_SECTOR_SIZE) >0)secCount++;uint32_t startAddr = globalAddr;for (uint8_t k=0; k<secCount; k++){Flash_EraseSector(startAddr); //擦除扇区startAddr += FLASH_SECTOR_SIZE; //移到下一个扇区}//分成Page写入数据,写入数据的最小单位是Pageuint16_t leftBytes = byteCount % FLASH_PAGE_SIZE; //非整数个Page剩余的字节数，即最后一个Page写入的数据uint16_t pgCount = byteCount/FLASH_PAGE_SIZE; //前面整数个Pageuint8_t* buff = (uint8_t*)pBuffer;for(uint16_t i=0; i<pgCount; i++) //写入前面pgCount个Page的数据，{Flash_WriteInPage(globalAddr, buff, FLASH_PAGE_SIZE);//写一整个Page的数据globalAddr += FLASH_PAGE_SIZE; //地址移动一个Pagebuff += FLASH_PAGE_SIZE; //数据指针移动一个Page大小}if (leftBytes>0)Flash_WriteInPage(globalAddr, buff, leftBytes); //最后一个Page，不是一整个Page的数据
}//Command=0xD8: Block Erase(64KB) 擦除整个Block, globalAddr是全局地址
//清除后存储区内容全部为0xFF, 耗时大概150ms
void Flash_EraseBlock64K(uint32_t globalAddr)
{Flash_Write_Enable();//SET WELFlash_Wait_Busy();uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节__Select_Flash(); //CS=0SPI_TransmitOneByte(0xD8); //Command=0xD8, Block Erase(64KB)SPI_TransmitOneByte(byte2); //发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //耗时大概150ms
}// 擦除一个扇区(4KB字节)，Command=0x20, Sector Erase(4KB)
// globalAddr: 扇区的绝对地址，24位地址0x00XXXXXX
// 擦除后，扇区内全部内容为0xFF, 耗时大约30ms，
void Flash_EraseSector(uint32_t globalAddr)
{ Flash_Write_Enable();//SET WELFlash_Wait_Busy();uint8_t byte2, byte3, byte4;Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节__Select_Flash(); //CS=0SPI_TransmitOneByte(0x20); //Command=0x20, Sector Erase(4KB)SPI_TransmitOneByte(byte2);//发送24位地址SPI_TransmitOneByte(byte3);SPI_TransmitOneByte(byte4);__Deselect_Flash(); //CS=1Flash_Wait_Busy(); //大约30ms
}// 检查寄存器SR1的BUSY位，直到BUSY位为0
uint32_t Flash_Wait_Busy(void)
{ uint8_t SR1 = 0;uint32_t delay = 0;SR1=Flash_ReadSR1(); //读取状态寄存器SR1while((SR1 & 0x01)==0x01){HAL_Delay(1);delay++;SR1 = Flash_ReadSR1(); //读取状态寄存器SR1}return delay;
}// 进入掉电模式
// Command=0xB9: Power Down
void Flash_PowerDown(void)
{ __Select_Flash(); //CS=0SPI_TransmitOneByte(0xB9); //Command=0xB9: Power Down__Deselect_Flash(); //CS=1HAL_Delay(1); //等待TPD
} // 唤醒
// Command=0xAB: Release Power Down
void Flash_WakeUp(void)
{ __Select_Flash(); //CS=0SPI_TransmitOneByte(0xAB); //Command=0xAB: Release Power Down__Deselect_Flash(); //CS=1HAL_Delay(1); //等待TRES1
}
2、KEY_LED
修改参考文章里keyled.h关于指示灯的定义，其它不变：
#ifdef LED1_Pin //LED1的控制#define LED1_Toggle() HAL_GPIO_TogglePin(LED1_GPIO_Port,LED1_Pin) //输出翻转#define LED1_ON() HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_RESET) //输出0，亮#define LED1_OFF() HAL_GPIO_WritePin(LED1_GPIO_Port,LED1_Pin,GPIO_PIN_SET) //输出1，灭
#endif#ifdef LED2_Pin //LED2的控制#define LED2_Toggle() HAL_GPIO_TogglePin(LED2_GPIO_Port,LED2_Pin) //输出翻转#define LED2_ON() HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,GPIO_PIN_RESET) //输出0，亮#define LED2_OFF() HAL_GPIO_WritePin(LED2_GPIO_Port,LED2_Pin,GPIO_PIN_SET) //输出1，灭
#endif
//新增LED3、LED4
#ifdef LED3_Pin //LED3的控制#define LED3_Toggle() HAL_GPIO_TogglePin(LED3_GPIO_Port,LED3_Pin) //输出翻转#define LED3_ON() HAL_GPIO_WritePin(LED3_GPIO_Port,LED3_Pin,GPIO_PIN_RESET) //输出0，亮#define LED3_OFF() HAL_GPIO_WritePin(LED3_GPIO_Port,LED3_Pin,GPIO_PIN_SET) //输出1，灭
#endif#ifdef LED4_Pin //LED4的控制#define LED4_Toggle() HAL_GPIO_TogglePin(LED4_GPIO_Port,LED4_Pin) //输出翻转#define LED4_ON() HAL_GPIO_WritePin(LED4_GPIO_Port,LED4_Pin,GPIO_PIN_RESET) //输出0，亮#define LED4_OFF() HAL_GPIO_WritePin(LED4_GPIO_Port,LED4_Pin,GPIO_PIN_SET) //输出1，灭
#endif3、spi.h
/* USER CODE BEGIN Private defines */
void Flash_TestReadStatus(void);
void Flash_TestWrite(void);
void Flash_TestRead(void);/* USER CODE END Private defines */4、spi.c
/* USER CODE BEGIN 0 */
#include "w25flash.h"
#include <string.h> //用到函数strlen()
#include <stdio.h>
/* USER CODE END 0 *//* USER CODE BEGIN 1 */
//读取DeviceID，状态寄存器 SR1和SR2
void Flash_TestReadStatus(void)
{
//读DeviceID,SR1,SR2uint16_t devID = Flash_ReadID(); //读取器件IDprintf("Device ID = %X\r\n",devID); //大写的十六进制printf("The chip is: ");switch (devID){case 0xEF14:printf("W25Q16BV \r\n");break;case 0xEF16:printf("W25Q64JV \r\n");break;case 0xEF17:printf("W25Q128JV \r\n");break;case 0xC817:printf("GD25Q128 \r\n");break;case 0x1C17:printf("EN25Q128 \r\n");break;case 0x2018:printf("N25Q128 \r\n");break;case 0x2017:printf("XM25QH128 \r\n");break;case 0xA117:printf("FM25Q128 \r\n");break;default:printf("Unknown type \r\n");}uint8_t SR1 = Flash_ReadSR1(); //Read SR1=0x00printf("Status Reg1 = %X\r\n",SR1); //Hex显示uint8_t SR2 = Flash_ReadSR2(); //Read SR2=0x00printf("Status Reg2 = %X\r\n",SR2); //Hex显示
}//测试写入Page0 和Page1
//注意：一个Page写入之前必须是被擦除过的，写入之后就不能再重复写��??
void Flash_TestWrite(void)
{uint8_t blobkNo = 0;uint16_t sectorNo = 0;uint16_t pageNo = 0;uint32_t memAddress = 0;//写入Page0 两个stringmemAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo,pageNo); //Page0 addressuint8_t bufStr1[] = "Hello from beginning";uint16_t len = 1+strlen((char*)bufStr1); //Include'\0'Flash_WriteInPage(memAddress,bufStr1,len); //Write data at the beginning of Page0.printf("Write in Page0:0 %s\r\n",bufStr1);uint8_t bufStr2[] = "Hello in page";len = 1+strlen((char*)bufStr2); //include '\0'Flash_WriteInPage(memAddress+100,bufStr2,len); //Offset address 100 within Page0printf("Write in Page0:100 %s\r\n",bufStr2); //display string//写入Page 1uint8_t bufPage[FLASH_PAGE_SIZE]; //EN25Q_PAGE_SIZE=256for (uint16_t i=0;i<FLASH_PAGE_SIZE; i++)bufPage[i] = i; //准备数据pageNo = 1; //Page 1memAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo, pageNo);//page1 addressFlash_WriteInPage(memAddress, bufPage, FLASH_PAGE_SIZE);//写一个Pageprintf("Write 0-255 in Page1 \r\n");
}//test for reading Page0 and Page1
void Flash_TestRead(void)
{uint8_t blobkNo = 0;uint16_t sectorNo = 0;uint16_t pageNo = 0;
//读取Page 0uint8_t bufStr[50]; //Data read from Page0uint32_t memAddress = Flash_Addr_byBlockSectorPage(blobkNo,sectorNo,pageNo);Flash_ReadBytes(memAddress,bufStr,50); //read 50 Bytesprintf("Read from Page0:0 %s\r\n",(char*)bufStr); //display stringFlash_ReadBytes(memAddress+10,bufStr,50); //地址偏移100后的50个字节printf("Read from Page0:100 %s\r\n",bufStr);//display string//读取Page 1uint8_t randData = 0;pageNo = 1;memAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo,pageNo);randData = Flash_ReadOneByte(memAddress+12);//读取1个字节数据，页内地址偏移12printf("Page1[12] = %d\r\n",randData);randData =Flash_ReadOneByte(memAddress+136);//页内地址偏移136printf("Page1[136] = %d\r\n",randData);randData =Flash_ReadOneByte(memAddress+210);//页内地址偏移210printf("Page1[210] = %d\r\n",randData);
}
/* USER CODE END 1 */5、main.c
/* USER CODE BEGIN Includes */
#include "w25flash.h" //W25Q16驱动程序.h
#include "keyled.h"
#include <stdio.h>
/* USER CODE END Includes */ /* USER CODE BEGIN 2 *///Read and display the values of DeviceID, status register SR1 and SR2.Flash_TestReadStatus();// MCU output low level LED light is onLED1_OFF();LED2_OFF();LED3_OFF();LED4_OFF();/* USER CODE END 2 *//* USER CODE BEGIN 3 */KEYS curKey=ScanPressedKey(KEY_WAIT_ALWAYS);switch(curKey){case KEY_UP: //S2printf("Erasing chip, about 30sec...\r\n");Flash_EraseChip();printf("Chip is erased.\r\n");LED1_ON();LED2_OFF();LED3_OFF();LED4_OFF();break;case KEY_DOWN: //S3printf("Erasing Block 0(256 pages)...\r\n");uint32_t globalAddr=0x000000;Flash_EraseBlock64K(globalAddr);printf("Block 0 is erased.\r\n");LED1_OFF();LED2_ON();LED3_OFF();LED4_OFF();break;case KEY_LEFT: //S4Flash_TestWrite(); //测试写入Page0 and Page1LED1_OFF();LED2_OFF();LED3_ON();LED4_OFF();break;case KEY_RIGHT: //S5Flash_TestRead(); //测试读取Page0 and Page1LED1_OFF();LED2_OFF();LED3_OFF();LED4_ON();break;default:LED1_OFF();LED2_OFF();LED3_OFF();LED4_OFF();break;}printf("** Reselect menu or reset **\r\n");HAL_Delay(500); //Delay to eliminate key jitter.}/* USER CODE END 3 *//* USER CODE BEGIN 4 *///串口打印
int __io_putchar(int ch)
{HAL_UART_Transmit(&huart6, (uint8_t*)&ch, 1, 0xFFFF);return ch;
}
/* USER CODE END 4 */三、下载与运行
下载后，自动打印芯片ID为EF14，并打印状态寄存器为0；
按下S2键，对芯片整体格式化，并打印；
按下S3键，对BLOCK0格式化，并打印；
按下S4键， 对芯片进行写操作，并打印；
按下S5键，对芯片进行读操作，并打印；
上述操作结果，如下图：
