STM32 通过 SPI 驱动 W25Q128
目录
- 一、STM32 SPI 框图
- 1、通讯引脚
- 2、时钟控制
- 3、数据控制逻辑
- 4、整体控制逻辑
- 5、主模式收发流程及事件说明如下：
- 二、程序编写
- 1、SPI 初始化
- 2、W25Q128 驱动代码
- 2.1 读写厂商 ID 和设备 ID
- 2.2 读数据
- 2.3 写使能/写禁止
- 2.4 读/写状态寄存器
- 2.5 擦除扇区
- 2.6 擦除整个芯片
- 2.7 页写
- 2.7.1 写 SPI FLASH
- 3、main 测试代码
有关 SPI 的内容在 SPI 通信协议详解
，不熟悉的可以参考一下
我使用设备的是 STM32F407 + W25Q128
一、STM32 SPI 框图
1、通讯引脚
这四个引脚想必大家也很熟悉了，就不过多介绍。我是用的是 SPI1，引脚如下：
SPI1 是 APB2 总线上的设备，最高通信速率达 42Mbtis/s。
如下是 W25Q128 的引脚图：
所以连接方式为：
W25Q STM32
VCC --> VCC
GND --> GND
DO --> PA6 (MISO)
DI --> PA7 (MOSI)
CLK --> PA5 (SCK)
CS --> PA4 (CS)
2、时钟控制
SCK 线的时钟信号，由波特率发生器根据“控制寄存器CR1”中的 BR[0:2] 位控制，该位是对 fpclk 时钟的分频因子， 对 fpclk 的分频结果就是 SCK 引脚的输出时钟频率，计算方法见下表：
其中的 fpclk 频率是指 SPI 所在的 APB 总线频率，APB1 为 fpclk1，APB2 为 fpckl2。
通过配置“控制寄存器 CR”的 CPOL 位及 CPHA 位可以把 SPI 设置成之前分析的 4 种 SPI 模式。
3、数据控制逻辑
SPI 的 MOSI 及 MISO 都连接到数据移位寄存器上，数据移位寄存器的内容来源于接收缓冲区及发送缓冲区以及 MISO、MOSI 线。
- 当向外发送数据的时候， 数据移位寄存器以“发送缓冲区”为数据源，把数据一位一位地通过数据线发送出去；
- 当从外部接收数据的时候， 数据移位寄存器把数据线采样到的数据一位一位地存储到“接收缓冲区”中。
通过写 SPI 的“数据寄存器 DR”把数据填充到发送缓冲区中， 通过 “数据寄存器 DR”，可以获取接收缓冲区中的内容。其中数据帧长度可以通过“控制寄存器 CR1”的“DFF位”配置成 8 位及 16 位模式；配置“LSBFIRST位”可选择 MSB 先行还是 LSB 先行。
4、整体控制逻辑
整体控制逻辑负责协调整个 SPI 外设，控制逻辑的工作模式根据我们配置的“控制寄存器(CR1/CR2)”的参数而改变，基本的控制参数包括 SPI 模式、 波特率、LSB 先行、主从模式、单双向模式等等。在外设工作时，控制逻辑会根据外设的工作状态修改“状态寄存器(SR)”，我们只要读取状态寄存器相关的寄存器位， 就可以了解 SPI 的工作状态了。除此之外，控制逻辑还根据要求，负责控制产生 SPI 中断信号、DMA 请求及控制 NSS 信号线。
实际应用中，我们一般不使用 STM32 SPI 外设的标准 NSS 信号线，而是更简单地使用普通的 GPIO，软件控制它的电平输出，从而产生通讯起始和停止信号。
5、主模式收发流程及事件说明如下：
STM32 使用 SPI 外设通讯时，在通讯的不同阶段它会对“状态寄存器SR”的不同数据位写入参数，我们通过读取这些寄存器标志来了解通讯状态。
下图演示的是“主模式”流程，即 STM32 作为 SPI 通讯的主机端时的数据收发过程。
- 控制 NSS 信号线， 产生起始信号(图中没有画出)；
- 把要发送的数据写入到“数据寄存器 DR”中， 该数据会被存储到发送缓冲区；
- 通讯开始，SCK 时钟开始运行。MOSI 把发送缓冲区中的数据一位一位地传输出去； MISO 则把数据一位一位地存储进接收缓冲区中；
- 当发送完一帧数据的时候，“状态寄存器 SR”中的“TXE 标志位”会被置 1，表示传输完一帧，发送缓冲区已空；类似地， 当接收完一帧数据的时候，“RXNE 标志位”会被置 1，表示传输完一帧，接收缓冲区非空；
- 等待到“TXE 标志位”为 1 时，若还要继续发送数据，则再次往“数据寄存器 DR”写入数据即可；等待到“RXNE 标志位”为 1 时， 通过读取“数据寄存器 DR”可以获取接收缓冲区中的内容。
假如我们使能了 TXE 或 RXNE 中断，TXE 或 RXNE 置 1 时会产生 SPI 中断信号，进入同一个中断服务函数，到 SPI 中断服务程序后， 可通过检查寄存器位来了解是哪一个事件，再分别进行处理。也可以使用 DMA 方式来收发“数据寄存器 DR”中的数据。
有了这些基础，下面写相应的代码就轻松多了。
二、程序编写
1、SPI 初始化
我们首先实现如下两个函数：
// ctl_spi.h
#ifndef __CTL_SPI_H
#define __CTL_SPI_H
void spi_init(void);
uint8_t spi_read_write_byte(uint8_t tx_data);
#endif /* __CTL_SPI_H */
实现如下：
/******************************************************************************
* @brief SPI GPIO 初始化
*
* @return none
*
******************************************************************************/
static void spi_pin_init(void)
{
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
memset(&GPIO_InitStructure, 0, sizeof(GPIO_InitStructure));
// CS
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// SCK MISO MOSI
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// 引脚复用
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
}
/******************************************************************************
* @brief SPI 初始化
*
* @return none
*
******************************************************************************/
static void spi_lowlevel_init(void)
{
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
SPI_InitTypeDef SPI_InitStructure;
memset(&SPI_InitStructure, 0, sizeof(SPI_InitStructure));
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // 双线全双工
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; // 波特率预分频值为256
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; // 同步时钟的第二个跳变沿（上升或下降）数据被采样
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; // 同步时钟的空闲状态为高电平
SPI_InitStructure.SPI_CRCPolynomial = 7; // CRC计算的多项式
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; // 8位帧数据结构
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; // 数据传输从MSB位开始
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; // 主机模式
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; // NSS 信号由软件(使用 SSI位)管理
SPI_Init(SPI1, &SPI_InitStructure);
SPI_Cmd(SPI1, ENABLE);
}
void spi_init(void)
{
spi_pin_init();
spi_lowlevel_init();
}
还有 SPI 的读写函数：
/******************************************************************************
* @brief SPI 数据读写函数
*
* @param[in] tx_data : 要发送的数据
*
* @return uint8_t : 接收到的数据
*
******************************************************************************/
uint8_t spi_read_write_byte(uint8_t tx_data)
{
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) // 等待发送区空
{ }
SPI_I2S_SendData(SPI1, tx_data); // SPIx发送一个 byte 数据
while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET) // 等待接收完一个 byte
{ }
return SPI_I2S_ReceiveData(SPI1); // 返回接收的数据
}
2、W25Q128 驱动代码
接下来需要参考手册中的时序图和指令来编写代码：W25Q128JV
下面是 FLASH常用芯片指令表：
该表中的第一列为指令名，第二列为指令编码，第三至第N列的具体内容根据指令的不同而有不同的含义。
- 其中带括号的是字节参数，方向为 FLASH 向主机传输，即命令响应；不带括号的则为主机向 FLASH 传输。
- “
A0~A23”指 FLASH 芯片内部存储器组织的地址；- “
M0~M7”为厂商号（MANUFACTURERID）；- “
ID0-ID15”为 FLASH 芯片的 ID；- “
dummy”指该处可为任意数据；- “
D0~D7”为 FLASH 内部存储矩阵的内容。
如下代码，接下来，我们就将实现对应的函数：
// w25q.h
#ifndef __W25Q_H
#define __W25Q_H
#include <stdint.h>
// 指令表
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_FastReadDual 0x3B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_PowerDown 0xB9
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
#define W25X_Dummy 0x00
typedef struct w25qxx_device_s
{
void (*init)(void);
void (*wr)(uint8_t *pbuffer, uint32_t read_addr, uint16_t num_byte_to_read);
void (*rd)(uint8_t *pbuffer, uint32_t write_addr, uint16_t num_byte_to_write);
uint16_t type;
} w25qxx_device_t;
extern w25qxx_device_t w25q32_dev;
void w25qxx_init(void);
uint16_t w25qxx_readid(void);
uint8_t w25qxx_readsr(void); // 读取状态寄存器
void w25qxx_write_sr(uint8_t sr); // 写状态寄存器
void w25qxx_write_enable(void); // 写使能
void w25qxx_write_disable(void); // 写保护
void w25qxx_read(uint8_t *pbuffer, uint32_t read_addr, uint16_t num_byte_to_read); // 读取flash
void w25qxx_write(uint8_t *pbuffer, uint32_t write_addr, uint16_t num_byte_to_write); // 写入flash
void w25qxx_erase_chip(void); // 整片擦除
void w25qxx_erase_sector(uint32_t dst_addr); // 扇区擦除
void w25qxx_powerdown(void); // 进入掉电模式
void w25qxx_wakeup(void); // 唤醒
#endif /* __W25Q_H */
除此之外，为了程序的简洁以及方便实现，定义如下的功能函数：
// w25q.c
#define w25qxx_cs_high() GPIO_SetBits(GPIOA, GPIO_Pin_4)
#define w25qxx_cs_low() GPIO_ResetBits(GPIOA, GPIO_Pin_4)
#define w25qxx_r_w_byte(n) spi_read_write_byte(n)
#define w25qxx_spi_init() spi_init()
#define w25qxx_delay_us(n) bl_delay_us(n)
w25qxx_device_t w25q32_dev = {
.init = w25qxx_init,
.wr = w25qxx_write,
.rd = w25qxx_read,
.type = 0x00,
};
void w25qxx_init(void)
{
w25qxx_spi_init();
w25q32_dev.type = w25qxx_readid();
}
2.1 读写厂商 ID 和设备 ID
由上图可知厂商 ID 是 0xEF,设备 ID 是 0x17。
读取设备 ID 和时序图图下：
该指令以 /CS 拉低开始，然后通过 DI 传输指令代码 90H 和 24 位的地址(全为 00000H )。这之后 W25Q 的 ID(EFH)和芯片 ID 将在时钟的下降沿以高位在前的方式传出。关于 W25Q128 的芯片和制造商 ID，在上面的图中已经列出。如果 24 位地址传输的是 00001H，那么芯片 ID 将首先被传出，然后紧接着的是制造商 ID。这两个是连续读出来的。该指令以 /CS 拉高结束。
格式如下：
实现如下：
/******************************************************************************
* @brief 读取读写厂商 ID 和设备 ID
*
* @return uint16_t : 读取到的 ID
*
******************************************************************************/
uint16_t w25qxx_readid(void)
{
uint16_t id = 0;
w25qxx_cs_low();
w25qxx_r_w_byte(W25X_ManufactDeviceID); // 发送读取ID命令
w25qxx_r_w_byte(W25X_Dummy); // Dummy
w25qxx_r_w_byte(W25X_Dummy); // Dummy
w25qxx_r_w_byte(0x00); // 决定芯片ID 和制造商ID 的传送顺序
// 随便发两个字节数据，分别返回制造商ID 和设备ID
id |= (w25qxx_r_w_byte(0xFF) << 8); // 0xEF
id |= w25qxx_r_w_byte(0xFF); // 0x17
w25qxx_cs_high();
return id;
}
2.2 读数据
读数据指令允许从存储器读一个或连续多个字节。该指令是以 /CS 拉低开始，然后通过 DI 在时钟的上升沿来传输指令代码(03H)和 24 位地址。当芯片接受完地址位后，相应地址处的值将会在时钟的下降沿，以高位在前、低位在后的方式，在 DO 上传输。如果连续的读多个字节的话，地址是自动加 1 的。这意味着可以一次读出整个芯片。该指令也是以 /CS 拉高来结束的。
/******************************************************************************
* @brief 读取SPI FLASH
*
* @param[in] pbuffer : 数据存储区
* @param[in] read_addr : 开始读取的地址(24bit)
* @param[in] num_byte_to_read : 要读取的字节数(最大65535)
*
* @return none
*
******************************************************************************/
void w25qxx_read(uint8_t *pbuffer, uint32_t read_addr, uint16_t num_byte_to_read)
{
uint16_t i;
w25qxx_cs_low();
w25qxx_r_w_byte(W25X_ReadData); // 发送读取命令
w25qxx_r_w_byte((uint8_t)((read_addr) >> 16)); // 发送24bit地址
w25qxx_r_w_byte((uint8_t)((read_addr) >> 8));
w25qxx_r_w_byte((uint8_t)read_addr);
for (i = 0; i < num_byte_to_read; i++)
{
pbuffer[i] = w25qxx_r_w_byte(0XFF); // 循环读数
}
w25qxx_cs_high();
}
2.3 写使能/写禁止
分别发送对应的两条指令即可，非常简单。
写使能指可以设置状态寄存器中的 WEL 位置 1。在页写，QUAD 页写，扇区擦除，块擦除，片擦除，写状态寄存器，擦写安全寄存器指令之前，必须先将 WEL 位置 1。写使能指令是以 /CS 拉低开始的，将
06H通过 DI 在时钟的上升沿锁存，然后 /CS 拉高来结束指令。
写禁用指令将状态寄存器中的写启用锁存器(WEL)位重置为 0。通过低电平驱动 /CS 进入写禁用指令，将指令代码“
04h”移到 DI 引脚，然后驱动 /CS 为高电平。请注意，通电后和通电后，WEL 位会自动复位完成写状态寄存器，擦除/程序安全寄存器，页程序，扇区擦除，块擦除，芯片擦除和复位指令。
/******************************************************************************
* @brief SPI_FLASH写使能(将WEL置位)
*
* @return none
*
******************************************************************************/
void w25qxx_write_enable(void)
{
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_WriteEnable); // 发送写使能
w25qxx_cs_high(); // 取消片选
}
/******************************************************************************
* @brief SPI_FLASH写禁止(将WEL清零)
*
* @return none
*
******************************************************************************/
void w25qxx_write_disable(void)
{
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_WriteDisable); // 发送写禁止指令
w25qxx_cs_high(); // 取消片选
}
2.4 读/写状态寄存器
读/写状态寄存器各有三条指令，相应内容查阅手册。
读状态寄存指令可以任何时间使用，在擦写，写状态寄存器指令周期中依然可以。这样就可以随时检查 BUSY 位，检查相应的指令周期有没有结束，芯片是不是可以接受新的指令。状态寄存器可以连续的读出来：
/******************************************************************************
* @brief 读取SPI_FLASH的状态寄存器
*
* @return uint8_t : 状态寄存器的值
*
* @note 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 w25qxx_readsr(void)
{
uint8_t byte = 0;
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_ReadStatusReg); // 发送读取状态寄存器命令
byte = w25qxx_r_w_byte(0xff); // 读取一个字节
w25qxx_cs_high(); // 取消片选
return byte;
}
/******************************************************************************
* @brief 写SPI_FLASH状态寄存器
*
* @param[in] sr : 要写入的状态寄存器的值
*
* @return none
*
* @note 只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写
*
******************************************************************************/
void w25qxx_write_sr(uint8_t sr)
{
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_WriteStatusReg); // 发送写取状态寄存器命令
w25qxx_r_w_byte(sr); // 写入一个字节
w25qxx_cs_high(); // 取消片选
}
2.5 擦除扇区
扇区擦除可以擦除 4Kbit 存储空间(全为0XFF)。进行扇区擦写指令之前，必须进行写使能指令。该指令是以 /CS 拉低开始的，然后在 DI 上传输指令代码 20H 和 24 位地址。
时序图如下图。当最后字节的第 8 位进入芯片后，/CS 必须拉高。如果 /CS 没有拉高，那么扇区擦写指令将不被执行。/CS 拉高后，扇区擦写指令的内建时间为 tSE。在扇区擦写指令执行期间，读状态寄存器指令仍然可以识别，以此来进行检查 BUSY 位。当扇区擦写指令执行期间，BUSY 位为 1。当执行完后，BUSY 为 0，表明可以接受新的指令了。扇区擦写指令完成后 WEL 位自动清零。如果该指令要操作的任何–页已经被保护起来，那么该指令也将不执行。
/******************************************************************************
* @brief 等待W25QXX芯片Busy标志位清空
*
* @return none
*
******************************************************************************/
static void w25qxx_wait_busy(void)
{
while ((w25qxx_readsr() & 0x01) == 0x01)
; // 等待BUSY位清空
}
/******************************************************************************
* @brief 擦除一个扇区
*
* @param[in] dst_addr : 扇区地址 0~511 for w25x16
*
* @return none
*
* @note 擦除一个山区的最少时间:150ms
*
******************************************************************************/
void w25qxx_erase_sector(uint32_t dst_addr)
{
dst_addr *= 4096;
w25qxx_write_enable(); // SET WEL
w25qxx_wait_busy();
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_SectorErase); // 发送扇区擦除指令
w25qxx_r_w_byte((uint8_t)((dst_addr) >> 16)); // 发送24bit地址
w25qxx_r_w_byte((uint8_t)((dst_addr) >> 8));
w25qxx_r_w_byte((uint8_t)dst_addr);
w25qxx_cs_high(); // 取消片选
w25qxx_wait_busy(); // 等待擦除完成
}
2.6 擦除整个芯片
芯片擦除指令将设备内的所有内存设置为全1 (FFh)的擦除状态。一个写启用指令必须在设备接受芯片擦除指令(状态)之前执行寄存器位 WEL 必须等于 1)。指令通过驱动 /CS 引脚低电平和移位启动指令代码“C7h”或“60h”。芯片擦除指令序列如下图所示。
芯片擦除指令将不会被执行如果任何内存区域是受块保护(CMP、SEC、TB、BP2、BP1 和 BP0)位或单个块/扇区保护锁。
/******************************************************************************
* @brief 擦除整个芯片
*
* @return none
*
* @note 整片擦除时间非常长！！
*
******************************************************************************/
void w25qxx_erase_chip(void)
{
w25qxx_write_enable(); // SET WEL
w25qxx_wait_busy();
w25qxx_cs_low(); // 使能器件
w25qxx_r_w_byte(W25X_ChipErase); // 发送片擦除命令
w25qxx_cs_high(); // 取消片选
w25qxx_wait_busy(); // 等待芯片擦除结束
}
2.7 页写
页编程指令允许 1 到 256 字节写入存储器的某一页，这一页必须是被擦除过的（也就是只能写 0，不能写 1，擦除时是全写为 1)。
在页编程指令之前，必须先写入写使能指令。页编程指令是以 /CS 拉低开始，然后在 DI 上传输指令代码 02H，再接着传输 24 位的地址，接着是至少-一个字节的数据。/CS 管脚必须一直保持低。页编程指令的时序图如下图。
- 如果一次写一整页数据(256 字节)，最后的地址字节应该全为 0。如果最后 8 字节地址不为 0，但是要写入的数据长度超过页剩下的长度，那么芯片会回到当前页的开始地址写。
- 写入少于 256 字节的的数据，对页内的其他数据没有任何影响。对于这种情况的唯一要求是，时钟数不能超过剩下页的长度。
- 如果一次写入多于 256 字节的数据，那么在页内会回头写，先前写的数据可能已经被覆盖。
作为擦写指令，当最后字节的第 8 位进入芯片后，/CS 必须拉高。如果 /CS 没有拉高, .那么页写指令将不被执行。/CS 拉高后，页编程指令的内建时间为 tpp。在页写指令执行期间，读状态寄存器指令仍然可以识别，以此来进行检查 BUSY 位。当页写指令执行期间，BUSY 位为了 1。当执行完后，BUSY 为 0，表明可以接受新的指令了。页写指令完成后 WEL 位自动清零。如果该指令要操作的页已经被保护起来，那么该指令也将不执行。
/******************************************************************************
* @brief 在指定地址开始写入最大256字节的数据
*
* @param[in] pbuffer : 数据存储区
* @param[in] write_addr : 开始写入的地址(24bit)
* @param[in] num_byte_to_write : 要写入的字节数(最大256),该数不应该超过该页的剩余字节数
*
* @return none
*
******************************************************************************/
static void w25qxx_write_page(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
{
uint16_t i;
w25qxx_write_enable(); // SET WEL
w25qxx_cs_low();
w25qxx_r_w_byte(W25X_PageProgram); // 发送写页命令
w25qxx_r_w_byte((uint8_t)((write_addr) >> 16)); // 发送24bit地址
w25qxx_r_w_byte((uint8_t)((write_addr) >> 8));
w25qxx_r_w_byte((uint8_t)write_addr);
for(i = 0; i < num_byte_to_write; i++)
w25qxx_r_w_byte(pbuffer[i]); // 循环写数
w25qxx_cs_high();
w25qxx_wait_busy(); // 等待写入结束
}
接下来在这个函数的基础上，实现写函数。
2.7.1 写 SPI FLASH
/******************************************************************************
* @brief 在指定地址开始写入指定长度的数据,不检查数据是否为0XFF(具有自动换页功能)
*
* @param[in] pbuffer : 数据存储区
* @param[in] write_addr : 开始写入的地址(24bit)
* @param[in] num_byte_to_write : 要写入的字节数(最大65535)
*
* @return none
*
* @note 必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败
*
******************************************************************************/
static void w25qxx_write_nocheck(uint8_t* pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
{
uint16_t pageremain;
pageremain = 256 - write_addr % 256; //单页剩余的字节数
if(num_byte_to_write <= pageremain)
pageremain = num_byte_to_write; //不大于256个字节
while(1)
{
w25qxx_write_page(pbuffer, write_addr, pageremain);
if(num_byte_to_write == pageremain) //写入结束了
break;
else //num_byte_to_write>pageremain
{
pbuffer += pageremain;
write_addr += pageremain;
num_byte_to_write -= pageremain; //减去已经写入了的字节数
if(num_byte_to_write > 256)
pageremain = 256; //一次可以写入256个字节
else
pageremain = num_byte_to_write; //不够256个字节了
}
};
}
uint8_t W25QXX_BUFFER[4096];
/******************************************************************************
* @brief 在指定地址开始写入指定长度的数据
*
* @param[in] pbuffer : 数据存储区
* @param[in] write_addr : 开始写入的地址(24bit)
* @param[in] num_byte_to_write : 要写入的字节数(最大65535)
*
* @return none
*
* @note 该函数带擦除操作
*
******************************************************************************/
void w25qxx_write(uint8_t *pbuffer, uint32_t write_addr, uint16_t num_byte_to_write)
{
uint32_t secpos;
uint16_t secoff;
uint16_t secremain;
uint16_t i;
secpos = write_addr / 4096; // 扇区地址 0~511 for w25x16
secoff = write_addr % 4096; // 在扇区内的偏移
secremain = 4096 - secoff; // 扇区剩余空间大小
if (num_byte_to_write <= secremain)
secremain = num_byte_to_write; // 不大于4096个字节
while (1)
{
w25qxx_read(W25QXX_BUFFER, secpos * 4096, 4096); // 读出整个扇区的内容
for (i = 0; i < secremain; i++) // 校验数据
{
if (W25QXX_BUFFER[secoff + i] != 0XFF)
break; // 需要擦除
}
if (i < secremain) // 需要擦除
{
w25qxx_erase_sector(secpos); // 擦除这个扇区
for (i = 0; i < secremain; i++) // 复制
{
W25QXX_BUFFER[i + secoff] = pbuffer[i];
}
w25qxx_write_nocheck(W25QXX_BUFFER, secpos * 4096, 4096); // 写入整个扇区
}
else
w25qxx_write_nocheck(pbuffer, write_addr, secremain); // 写已经擦除了的,直接写入扇区剩余区间.
if (num_byte_to_write == secremain)
break; // 写入结束了
else // 写入未结束
{
secpos++; // 扇区地址增1
secoff = 0; // 偏移位置为0
pbuffer += secremain; // 指针偏移
write_addr += secremain; // 写地址偏移
num_byte_to_write -= secremain; // 字节数递减
if (num_byte_to_write > 4096)
secremain = 4096; // 下一个扇区还是写不完
else
secremain = num_byte_to_write; // 下一个扇区可以写完了
}
};
}
3、main 测试代码
// main.c
uint8_t wr_data[128] = {0};
uint8_t rd_data[128] = {0};
int main(void)
{
uint8_t i = 0;
/*
* 外设初始化
*/
// ...
w25q32_dev.init();
printf("\r\n\r\nw25q128 id is: 0x%x\r\n", w25q32_dev.type);
printf("detact w25q128 ok!\r\n");
printf("write data !\r\n"); // 向flash写入数据
for (i = 0; i < 128; i++)
{
wr_data[i] = i;
}
w25q32_dev.wr(wr_data, 0, 128);
w25q32_dev.rd(rd_data, 0, 128); // 从falsh读取数据并打印
printf("\r\nread data is :\r\n");
for (i = 0; i < 128; i++)
{
printf("%d, ", rd_data[i]);
}
return 0;
}
测试结果如下：
