细说STM32F407单片机轮询方式读写SPI FLASH W25Q16BV - ToB企服应用市场:ToB评测及商务社交产业平台

/* 文件： 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 ID
uint64_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 Enable
HAL_StatusTypeDef Flash_Write_Enable(void); //Command=0x06: Write Enable, 使WEL=1
HAL_StatusTypeDef Flash_Write_Disable(void); //Command=0x04, Write Disable，使WEL=0
uint8_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

复制代码

/* 文件： 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=0
SPI_TransmitOneByte(0x05); //Command=0x05: Read Status Register-1
byte=SPI_ReceiveOneByte();
__Deselect_Flash(); //CS=1
return byte;
}
//Command=0x35: Read Status Register-2,返回寄存器SR2的值
uint8_t Flash_ReadSR2(void)
{
uint8_t byte=0;
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0x35); //Command=0x35: Read Status Register-2
byte=SPI_ReceiveOneByte(); //读取一个字节
__Deselect_Flash(); //CS=1
return byte;
}
//Command=0x01: Write Status Register,只写SR1的值
//耗时大约10-15ms
void Flash_WriteSR1(uint8_t SR1)
{
Flash_Write_Enable(); //必须使 WEL=1
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0x01); //Command=0x01:Write Status Register,只写SR1的值
SPI_TransmitOneByte(0x00); //SR1的值
// SPI_WriteOneByte(0x00); //SR2的值, 只发送SR1的值，而不发送SR2的值，QE和CMP将自动被清零
__Deselect_Flash(); //CS=1
Flash_Wait_Busy(); //耗时大约10-15ms
}
/*
HAL_StatusTypeDef Flash_WriteVolatile_Enable(void) //Command=0x50: Write Volatile Enable
{
__Select_Flash(); //CS=0
HAL_StatusTypeDef result=SPI_TransmitOneByte(0x50);
__Deselect_Flash(); //CS=1
return result;
}
*/
//Command=0x06: Write Enable,使WEL=1
HAL_StatusTypeDef Flash_Write_Enable(void)
{
__Select_Flash(); //CS=0
HAL_StatusTypeDef result=SPI_TransmitOneByte(0x06); //Command=0x06: Write Enable,使WEL=1
__Deselect_Flash(); //CS=1
Flash_Wait_Busy(); //等待操作完成
return result;
}
//Command=0x04, Write Disable，使WEL=0
HAL_StatusTypeDef Flash_Write_Disable(void)
{
__Select_Flash(); //CS=0
HAL_StatusTypeDef result=SPI_TransmitOneByte(0x04); //Command=0x04, Write Disable，使WEL=0
__Deselect_Flash(); //CS=1
Flash_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位，等于乘以0x10000
return addr;
}
//根据Sector绝对编号获取地址, 共512个Sector, SectorNo取值范围0-511
//每个扇区4K字节，12位地址，扇区内地址范围0x000-0xFFF
uint32_t Flash_Addr_bySector(uint16_t SectorNo)
{
if (SectorNo>511) //不能超过511
SectorNo=0;
// uint32_t addr=SectorNo*0x1000;
uint32_t addr = SectorNo;
addr = addr<<12; //左移12位,等于乘以0x1000
return 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位，等于乘以0x100
return 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) //不能超过15
SubSectorNo = 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) //不能超过15
SubSectorNo = 0;
if (SubPageNo>15) //不能超过15
SubPageNo = 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=0
SPI_TransmitOneByte(0x90); //指令码，0x90=Manufacturer/Device ID
SPI_TransmitOneByte(0x00); //dummy
SPI_TransmitOneByte(0x00); //dummy
SPI_TransmitOneByte(0x00); //0x00
Temp = SPI_ReceiveOneByte()<<8; //Manufacturer ID
Temp|= SPI_ReceiveOneByte(); //Device ID, 与具体器件相关
__Deselect_Flash(); //CS=1
return 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=0
SPI_TransmitOneByte(0x4B); //发送指令码, 4B=read Unique ID
SPI_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=0
SPI_TransmitOneByte(0x03); //Command=0x03, read data
SPI_TransmitOneByte(byte2); //发送24位地址
SPI_TransmitOneByte(byte3);
SPI_TransmitOneByte(byte4);
byte2 = SPI_ReceiveOneByte();//接收1个字节 //why byte2?
__Deselect_Flash(); //CS=1
return 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=0
SPI_TransmitOneByte(0x03); //Command=0x03, read data
SPI_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=0
SPI_TransmitOneByte(0x0B); //Command=0x0B, fast read data
SPI_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=1
Flash_Wait_Busy(); //等待空闲
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0xC7);//Command=0xC7: Chip Erase, 擦除整个器件
__Deselect_Flash(); //CS=1
Flash_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 WEL
Flash_Wait_Busy();
__Select_Flash(); //CS=0
SPI_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=1
Flash_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写入数据,写入数据的最小单位是Page
uint16_t leftBytes = byteCount % FLASH_PAGE_SIZE; //非整数个Page剩余的字节数，即最后一个Page写入的数据
uint16_t pgCount = byteCount/FLASH_PAGE_SIZE; //前面整数个Page
uint8_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; //地址移动一个Page
buff += 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 WEL
Flash_Wait_Busy();
uint8_t byte2, byte3, byte4;
Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0xD8); //Command=0xD8, Block Erase(64KB)
SPI_TransmitOneByte(byte2); //发送24位地址
SPI_TransmitOneByte(byte3);
SPI_TransmitOneByte(byte4);
__Deselect_Flash(); //CS=1
Flash_Wait_Busy(); //耗时大概150ms
}
// 擦除一个扇区(4KB字节)，Command=0x20, Sector Erase(4KB)
// globalAddr: 扇区的绝对地址，24位地址0x00XXXXXX
// 擦除后，扇区内全部内容为0xFF, 耗时大约30ms，
void Flash_EraseSector(uint32_t globalAddr)
{
Flash_Write_Enable();//SET WEL
Flash_Wait_Busy();
uint8_t byte2, byte3, byte4;
Flash_SpliteAddr(globalAddr, &byte2, &byte3, &byte4);//24位地址分解为3个字节
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0x20); //Command=0x20, Sector Erase(4KB)
SPI_TransmitOneByte(byte2);//发送24位地址
SPI_TransmitOneByte(byte3);
SPI_TransmitOneByte(byte4);
__Deselect_Flash(); //CS=1
Flash_Wait_Busy(); //大约30ms
}
// 检查寄存器SR1的BUSY位，直到BUSY位为0
uint32_t Flash_Wait_Busy(void)
{
uint8_t SR1 = 0;
uint32_t delay = 0;
SR1=Flash_ReadSR1(); //读取状态寄存器SR1
while((SR1 & 0x01)==0x01)
{
HAL_Delay(1);
delay++;
SR1 = Flash_ReadSR1(); //读取状态寄存器SR1
}
return delay;
}
// 进入掉电模式
// Command=0xB9: Power Down
void Flash_PowerDown(void)
{
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0xB9); //Command=0xB9: Power Down
__Deselect_Flash(); //CS=1
HAL_Delay(1); //等待TPD
}
// 唤醒
// Command=0xAB: Release Power Down
void Flash_WakeUp(void)
{
__Select_Flash(); //CS=0
SPI_TransmitOneByte(0xAB); //Command=0xAB: Release Power Down
__Deselect_Flash(); //CS=1
HAL_Delay(1); //等待TRES1
}

复制代码

#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，灭
#endif

复制代码

/* USER CODE BEGIN Private defines */
void Flash_TestReadStatus(void);
void Flash_TestWrite(void);
void Flash_TestRead(void);
/* USER CODE END Private defines */

复制代码

/* 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,SR2
uint16_t devID = Flash_ReadID(); //读取器件ID
printf("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=0x00
printf("Status Reg1 = %X\r\n",SR1); //Hex显示
uint8_t SR2 = Flash_ReadSR2(); //Read SR2=0x00
printf("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 两个string
memAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo,pageNo); //Page0 address
uint8_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 Page0
printf("Write in Page0:100 %s\r\n",bufStr2); //display string
//写入Page 1
uint8_t bufPage[FLASH_PAGE_SIZE]; //EN25Q_PAGE_SIZE=256
for (uint16_t i=0;i<FLASH_PAGE_SIZE; i++)
bufPage[i] = i; //准备数据
pageNo = 1; //Page 1
memAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo, pageNo);//page1 address
Flash_WriteInPage(memAddress, bufPage, FLASH_PAGE_SIZE);//写一个Page
printf("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 0
uint8_t bufStr[50]; //Data read from Page0
uint32_t memAddress = Flash_Addr_byBlockSectorPage(blobkNo,sectorNo,pageNo);
Flash_ReadBytes(memAddress,bufStr,50); //read 50 Bytes
printf("Read from Page0:0 %s\r\n",(char*)bufStr); //display string
Flash_ReadBytes(memAddress+10,bufStr,50); //地址偏移100后的50个字节
printf("Read from Page0:100 %s\r\n",bufStr);//display string
//读取Page 1
uint8_t randData = 0;
pageNo = 1;
memAddress = Flash_Addr_byBlockSectorPage(blobkNo, sectorNo,pageNo);
randData = Flash_ReadOneByte(memAddress+12);//读取1个字节数据，页内地址偏移12
printf("Page1[12] = %d\r\n",randData);
randData =Flash_ReadOneByte(memAddress+136);//页内地址偏移136
printf("Page1[136] = %d\r\n",randData);
randData =Flash_ReadOneByte(memAddress+210);//页内地址偏移210
printf("Page1[210] = %d\r\n",randData);
}
/* USER CODE END 1 */

复制代码

/* 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 on
LED1_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: //S2
printf("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: //S3
printf("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: //S4
Flash_TestWrite(); //测试写入Page0 and Page1
LED1_OFF();
LED2_OFF();
LED3_ON();
LED4_OFF();
break;
case KEY_RIGHT: //S5
Flash_TestRead(); //测试读取Page0 and Page1
LED1_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 */

复制代码

用户标签	开发板	引脚名称	引脚功能	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	输入	按键复位	上拉

用户标签	开发板标识	引脚名称	引脚功能	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