细说STM32F407单片机轮询方式读写SPI FLASH W25Q16BV

耶耶耶耶耶 · 2024-12-25 16:58:01

目次
一、工程设置
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 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

复制代码

定义了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=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
}

复制代码

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

复制代码

3、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,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 */

复制代码

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 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 */

复制代码

三、下载与运行

下载后，自动打印芯片ID为EF14，并打印状态寄存器为0；
按下S2键，对芯片整体格式化，并打印；
按下S3键，对BLOCK0格式化，并打印；
按下S4键，对芯片进行写操纵，并打印；
按下S5键，对芯片进行读操纵，并打印；
上述操纵结果，如下图：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

细说STM32F407单片机轮询方式读写SPI FLASH W25Q16BV

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云