浅谈STM32之SPI_FLASH之应用实例

　　SPI Flash

 

　　首先它是个Flash，Flash是什么东西就不多说了（非易失性存储介质），分为NOR和NAND两种（NOR和NAND的区别本篇不做介绍）。SPI一种通信接口。那么严格的来说SPI Flash是一种使用SPI通信的Flash，即，可能指NOR也可能是NAND。但现在大部分情况默认下人们说的SPI Flash指的是SPI NorFlash。早期Norflash的接口是parallel的形式，即把数据线和地址线并排与IC的管脚连接。但是后来发现不同容量的Norflash不能硬件上兼容（数据线和地址线的数量不一样），并且封装比较大，占用了较大的PCB板位置，所以后来逐渐被SPI（串行接口）Norflash所取代。同时不同容量的SPI Norflash管脚也兼容封装也更小。，至于现在很多人说起NOR flash直接都以SPI flash来代称。

 

　　NorFlash根据数据传输的位数可以分为并行（Parallel，即地址线和数据线直接和处理器相连）NorFlash和串行（SPI，即通过SPI接口和处理器相连）NorFlash；区别主要就是：1、SPI NorFlash每次传输一bit位的数据，parallel连接的NorFlash每次传输多个bit位的数据（有x8和x16bit两种）； 2、SPI NorFlash比parallel便宜，接口简单点，但速度慢。

 

　　NandFlash是地址数据线复用的方式，接口标准统一（x8bit和x16bit），所以不同容量再兼容性上基本没什么问题。但是目前对产品的需求越来越小型化以及成本要求也越来越高，所以SPI NandFlash渐渐成为主流，并且采用SPI NANDFlash方案，主控也可以不需要传统NAND控制器，只需要有SPI接口接口操作访问，从而降低成本。另外SPI NandFlash封装比传统的封装也小很多，故节省了PCB板的空间。

 

　　怎么用说白了对于Flash就是读写擦，也就是实现flash的驱动。先简单了解下spi flash的物理连接。

 

　　之前介绍SPI的时候说过，SPI接口目前的使用是多种方式（具体指的是物理连线有几种方式），Dual SPI、Qual SPI和标准的SPI接口（这种方式肯定不会出现在连接外设是SPI Flash上，这玩意没必要全双工），对于SPI Flash来说，主要就是Dual和Qual这两种方式。具体项目具体看了，理论上在CLK一定的情况下， 线数越多访问速度也越快。我们项目采用的Dual SPI方式，即两线。

　　本实例用的是STM32F103VET6平台，它有3个SPI接口（这里使用SPI1），各信号线连接到FLASH（型号：W25X16）的CS，CLK，DO，DIO线，以实现SPI通讯，对FLASH进行读写。

　　（这里采用主模式，全双工通讯，通过查询发送数据寄存器和接收数据寄存器状态确保通讯正常）

　　mian函数：

　　1#define sFLASH_ID 0xEF3015（前面加个1，免得变大）

　　u32 DeviceID;

　　u32 FlashID;

　　int main（void）

　　{

　　/115200 8-N-1/

　　USART1_Config（）;

　　SPI_FLASH_Init（）;

　　DeviceID = SPI_FLASH_ReadDeviceID（）;

　　Delay（200）;

　　FlashID = SPI_FLASH_ReadID（）;

　　printf（“\r\n FlashID is 0x%X， Manufacturer Device ID is 0x%X\r\n”，FlashID，DeviceID）;

　　if（FlashID == sFLASH_ID）

　　{

　　printf（“\r\n 检测到 flash W25X16 ！\r\n”）;

　　SPI_FLASH_SectorErase（FLASH_SectorToErase）;

　　SPI_FLASH_BufferWrite（Tx_Buffer， FLASH_WriteAddress， BufferSize）;

　　printf（“\r\n 写入的数据为：%s \r\t”， Tx_Buffer）;

　　SPI_FLASH_BufferRead（Rx_Buffer， FLASH_ReadAddress， BufferSize）;

　　printf（“\r\n 读出的数据为：%s \r\n”， Tx_Buffer）;

　　TransferStatus1 = Buffercmp（Tx_Buffer， Rx_Buffer， BufferSize）;

　　if（ PASSED == TransferStatus1）

　　{

　　printf（“\r\n 2M 串行 flash（W25X16）测试成功！\n\r”）;

　　}

　　else

　　{

　　printf（“\r\n 2M 串行 flash（W25X16）测试失败！\n\r”）;

　　}

　　}

　　else

　　{

　　printf（“\r\n 获取不到 W25X16 ID！\n\r”）;

　　}

　　SPI_Flash_PowerDown（）;

　　while（1）;

　　1234567891011121314151617181920212223242526272829303132333435363738

　　}

　　mian函数的流程：

　　1，调用 USART1_Config（） 初始化串口;

　　2，调用 SPI_FLASH_Init（） 初始化SPI模块;

　　3，调用 SPI_FLASH_ReadDeviceID 读取FLASH器件生产厂商的ID信息;

　　4，调用 SPI_FLASH_ReadID 读取FLASH器件的设备ID信息;

　　5，如果读取ID正确，则调用 SPI_FLASH_SectorErase（）把FLASH内容擦除，擦除后调用 SPI_FLASH_BufferWrite（）向FLASH写入数据，然后再调用 SPI_FLASH_BufferRead（）从刚刚写入的地址中读出数据，最后调用 Buffercmp（）对写入和读取的数据进行匹配，匹配成功则把标志变量 TransferStatus1赋值为 PASSED（自定义的枚举变量）;

　　6，根据标志量 TransferStatus1判断FLASH数据的：擦除，写入，读取是否正常，分情况输出到终端;

　　7，如果读取FLASH的ID信息错误，则直接向终端输出检测不到FLASH信息;

　　8，最后调用 SPI_Flash_PowerDown（）函数关闭 FLASH设备的电源（因为数据写入到FLASH后并不会因断电而丢失，所以需要使用的时候再开启FLASH电源）;

　　PS：

　　读取器件ID信息可以知道设备与主机是否能够正常工作，也便于区分不同的器件，可以在使用的FLASH用户数据手册找到ID表

　　SPI的初始化：

　　void SPI_FLASH_Init（void）

　　{

　　SPI_InitTypeDef SPI_InitStructure;

　　GPIO_InitTypeDef GPIO_InitStructure;

　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_GPIOA ， ENABLE）;

　　RCC_APB2PeriphClockCmd（RCC_APB2Periph_SPI1， ENABLE）;

　　/这里是GPIO初始化部分，将4个引脚都设定好/

　　/！《 Configure SPI_FLASH_SPI pins： SCK /

　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;

　　GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;

　　GPIO_Init（GPIOA， &GPIO_InitStructure）;

　　/！《 Configure SPI_FLASH_SPI pins： MISO /

　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;

　　GPIO_Init（GPIOA， &GPIO_InitStructure）;

　　/！《 Configure SPI_FLASH_SPI pins： MOSI /

　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;

　　GPIO_Init（GPIOA， &GPIO_InitStructure）;

　　/！《 Configure SPI_FLASH_SPI_CS_PIN pin： SPI_FLASH Card CS pin /

　　GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;

　　GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;

　　GPIO_Init（GPIOA， &GPIO_InitStructure）;

　　/* Deselect the FLASH： Chip Select high */

　　SPI_FLASH_CS_HIGH（）; //不用的时候就拉高

　　/这里是SPI设置部分/

　　SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;

　　SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

　　SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;

　　SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;

　　SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;

　　SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

　　SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;

　　SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

　　SPI_InitStructure.SPI_CRCPolynomial = 3;

　　SPI_Init（SPI1， &SPI_InitStructure）;

　　/* Enable SPI1 */

　　SPI_Cmd（SPI1， ENABLE）;

　　}

　　GPIO初始化：

　　根据《STM32数据手册》以及《STM32参考手册》，把PA5（SCK），PA6（MISO），PA7（MOSI）设置成复用推挽输出，因为PA4（NSS）是使用软件模式，所以设置为通用退完输出。

　　SPI模式初始化：

　　对于初始化，是需要根据通讯的设备FLASH的SPI特性来决定的，下面成员分析：

　　SPI_InitStructure.SPI_Direction= SPI_Direction_2Lines_FullDuplex;

　　这里设置通讯模式，这里设置成全双工模式（可以在keil环境下查找其他模式）

　　SPI_InitStructure.SPI_Mode = SPI_Mode_Master;

　　这里是设置工作模式，STM32的SPI设备可以gon工作在主机模式（SPI_Mode_Master）或从机模式（SPI_Mode_Slave），这两个模式最大的区别就是SPI的SCK信号线时序，SCK的时序是由通讯中的主机产生的，如果配置成从机模式，STM32的SPI模块将接收外来的SCK信号。（这里STM32作为SPI通讯主机，所以设置成 SPI_Mode_Master）。

　　SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;

　　这个是设置SPI每次通讯的数据大小（称为数据帧）为8位还是16位（从FLASH的数据手册可以查到，这里的FLASH的数据帧大小为8为，所以要把STM32的SPI模块设置相同的）

　　SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;&SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;

　　这两个成员是配置SPI的时钟极性（CPOL）和时钟相位（CPHA），这两个配置影响到SPI的通讯模式，要设置成符合将要互相通讯的设备的要求。

　　CPOL：可以取 SPI_CPOL_High（SPI 通讯空闲时 SCK 为高电平）或者SPI_CPOL_Low（SPI 通讯空闲时 SCK 为低电平）;

　　CPHA：可以取 SPI_CPHA_1Edge（在 SCK 的奇数边沿采集数据）或者SPI_CPHA_2Edge （在 SCK 的偶数边沿采集数据）;

　　查询这个FLASH的使用手册，可以了解到这个FLASH支持以SPI的模式0和模式3通讯。

　　模式0：在SPI空闲时，SCK为低电平，奇数边沿采样;

　　模式3：在SPI空闲时，SCK为高电平，偶数变异采样;

　　所以这里配置成模式3，把CPOL赋值为SPI_CPOL_High（SPI空闲时SCK为高电平），把CPHA赋值为SPI_CPHA_2Edge（在SCK的偶数边沿超级数据）

　　SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;

　　这里是配置NSS引脚的使用模式，可以选择为硬件模式（SPI_NSS_Hard）与软件模式（SPI_NSS_Soft），在硬件模式中的SPI片选由硬件自动产生，而软件模式则需要手动把相应的FPIO端口拉高或拉低产生非片选和片选信号（如果外界条件允许，硬件模式还会自动将STM32的SPI设置为主机）

　　这里是由软件产生模式，所以赋值为SPI_NSS_Soft.

　　SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;

　　这里是设置波特率分频值，分频后的时钟为SPI的SCK信号线的时钟频率，这个成员可以设置为fpclk的2，4，6，8，32，64，128，256分频。这里设置为4分频

　　SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;

　　所有串行的通讯协议都会有MSB先行（高位数据在前）还是LSB先行（地位数据在前）的问题，STM32的SPI模块可以通过对这个结构体成员，对这个特性编程控制。

　　根据FLASH的通讯时序，这里设置为MSB先行（SPI_FirstBit_MSB）

　　SPI_InitStructure.SPI_CRCPolynomial = 3;

　　这里是设置SPI的CEC校验的多项式，如果使用到CRC校验时，就是用这个成员的参数（多项式），来计算CRC的值。（这里的FLASH不支持CRC校验，所以赋值为3其实没意义）

　　配置完这些结构体成员后，调用 SPI_Init（）把这些参数写入到寄存器中，然后调用SPI_Cmd（）使能SPI1外设。

　　PS：

　　SPI_FLASH_CS_HIGH（）这个实际是上一个自定义的宏：

　　#define SPI_FLASH_CS_HIGH（） GPIO_SetBits（GPIOA， GPIO_Pin_4）

　　实际上这个宏就是用来把 PA4（NSS）引脚拉高，从而禁止SPI通讯

　　#define SPI_FLASH_CS_LOW（） GPIO_ResetBits（GPIOA， GPIO_Pin_4）

　　如果要需要使用的时候，就直接拉低就行了这样就可以开始通讯了

　　控制FLASH的命令：

　　因为不同的设备，都会相应的有不同的指令，如 EEPROM 中会把第一个数据解释为存储矩阵的地址（实质就是指令）。而 FLASH 则定义了更多的指令，有写指令，读指令，读 ID 指令等等。

　　这些指令，对主机来说，只是它遵守最基本的通讯协议发送出的数据。但设备把这些数据解释成不同的意义（指令编码），所以才成为指令。在我们配置好 STM32 的协议模块后，想要控制设备，就要遵守相应设备所定义的命令规则。

　　指 令 表 中 的 A0~A23 指 地 址 ； M0~M7 为 器 件 的 制 造 商 ID（MANUFACTURER ID）；D0~D7 为数据。

　　读取FLASH ID：

　　在命令列表可以了解到读取设备 ID 的命令（Device ID）编码为 ABh、dummy、dummy、dummy。表示此命令由这四个字节组成，其中dummy意为任意编码，即这几个字节必须发送数据，但这些数据是任意的，命令列表中带括号的字节数据表示由FLASH返回给主机的响应，可以看到Device ID命令的第5个字节为从机返回的响应，（ID7~ID0），即返回设备的ID号。

　　使用DeviceID命令时的时序图

　　可以看到主机首先通过MOSI线（即FLASH的DIO线）发送第一个字节为ABh编码，紧接着三个字节的dummy编码，然后FLASH就忽略DIO线上的信号，通过MISO线（即FLASH的DO线）把它的FLASH设备ID发送给主机。

　　u32 SPI_FLASH_ReadDeviceID（void）

　　{

　　u32 Temp = 0;

　　/使用的时候就拉低/

　　SPI_FLASH_CS_LOW（）;

　　/* Send “RDID ” instruction */

　　SPI_FLASH_SendByte（W25X_DeviceID）;

　　SPI_FLASH_SendByte（Dummy_Byte）;

　　SPI_FLASH_SendByte（Dummy_Byte）;

　　SPI_FLASH_SendByte（Dummy_Byte）;

　　/* Read a byte from the FLASH */

　　Temp = SPI_FLASH_SendByte（Dummy_Byte）;

　　/* Deselect the FLASH： Chip Select high */

　　SPI_FLASH_CS_HIGH（）;

　　return Temp;

　　}

　　SPI_FLASH_CS_LOW（）;

　　把片选拉低，开始通讯

　　SPI_FLASH_SendByte（W25X_DeviceID）;

　　向FLASH发送一个命令字节编码：W25X_DeviceID （这里定义的宏为：0XAB）

　　SPI_FLASH_SendByte（Dummy_Byte）;

　　根据指令表，发送完指令后，后面要接着发送三个字节的dummy_Byte（这里宏定义为：0xff，设置为其他也无所谓）

　　Temp = SPI_FLASH_SendByte（Dummy_Byte）;

　　在前面发送完三个字节的 Dummy_Byte后，在第五个字节，FLASH通过DIO端口输出它的器件ID，所以这里再调用一次SPI_FLASH_SendByte（Dummy_Byte）接收返回值，赋值给Temp.

　　SPI_FLASH_CS_HIGH（）;

　　把片选拉高，结束通讯

　　这样就完成了读取FLASH ID，这里有一个相对底层的函数SPI_FLASH_SendByte（），它实现了利用SPI发送和接收数据的功能

　　u8 SPI_FLASH_SendByte（u8 byte）

　　{

　　/等待发送数据寄存器清空/

　　while （SPI_I2S_GetFlagStatus（SPI1， SPI_I2S_FLAG_TXE） == RESET）;

　　/发送数据/

　　SPI_I2S_SendData（SPI1， byte）;

　　/等待接收数据寄存器为非空/

　　while （SPI_I2S_GetFlagStatus（SPI1， SPI_I2S_FLAG_RXNE） == RESET）;

　　/返回接收到的数值/

　　return SPI_I2S_ReceiveData（SPI1）;

　　}

　　流程：

　　1，调用库函数 SPI_I2S_GetFlagStatus（）等待发送数据寄存器清空;

　　2，发送数据寄存器准备好后，调用库函数SPI_I2S_SendData（）向从机发送数据;

　　3，调用库函数SPI_I2S_GetFlagStatus（）等待接收数据寄存器非空;

　　4，接收寄存器非空时，调用SPI_I2S_ReceiveData（）获取接收寄存器中的数据并作为函数的返回值，这个数据即由从机发送给主机的数据;

　　这是最底层的发送数据和接收数据的函数，利用了库函数的标志检测确保通讯正常。

　　读取厂商ID：

　　u8 SPI_FLASH_ReadID（void）

　　{

　　u32 Temp = 0， Temp0 = 0， Temp1 = 0， Temp2 = 0;

　　SPI_FLASH_CS_LOW（）;//拉低开始通讯

　　SPI_FLASH_SendByte（W25x_JedecDeviceID）;

　　Temp0 = SPI_FLASH_SendByte（Dummy_Byte）;

　　Temp1 = SPI_FLASH_SendByte（Dummy_Byte）;

　　Temp2 = SPI_FLASH_SendByte（Dummy_Byte）;

　　Temp = （Temp0 《《 16） | （Temp1 《《 8） | （Temp2）;

　　SPI_FLASH_CS_HIGH（）;

　　return Temp;

　　123456789101112131415

　　}

　　这个函数和之前的读取设备ID流程也是类型的，差别在于发送一个字节的命令编码JEDEC ID（9Fh）之后，从机就通过D0线返回厂商ID以及0~16位的设备ID。

　　读厂商ID时序图

　　擦除FLASH内容：

　　扇区擦除（根据FLASH的储存原理，在写入数据前，要先对存储区域进行擦除，也叫预写）

　　void SPI_FLASH_SectorErase（u32 SectorAddr）

　　{

　　/写使能并且判断FLASH状态/

　　SPI_FLASH_WriteEnable（）;

　　SPI_FLASH_WaitForWriteEnd（）;

　　/*这里开始是FLASH擦除操作*/

　　SPI_FLASH_CS_LOW（）;

　　SPI_FLASH_SendByte（W25X_SectorErase）;

　　/*这里是擦除一个扇区，也就是4KB*/

　　SPI_FLASH_SendByte（（SectorAddr & 0xFF0000） 》》 16）;

　　SPI_FLASH_SendByte（（SectorAddr & 0xFF00） 》》 8）;

　　SPI_FLASH_SendByte（SectorAddr & 0xFF）;

　　SPI_FLASH_CS_HIGH（）;

　　/*再次判断FLASH状态确保可以执行下一次操作*/

　　SPI_FLASH_WaitForWriteEnd（）;

　　1234567891011121314

　　}

　　这是扇区擦除时序，其中的第一个字节为扇区擦除命令编码（20h），紧跟其后的为要进行擦除的，根据FLASH的说明，整个存储矩阵分为块区和扇区，每块（Block）的大小为64KB，每个扇区（Sector）的大小为4KB，对存储矩阵进行擦除时，最小的单位为扇区。

　　写使能：

　　void SPI_FLASH_WriteEnable（void）

　　{

　　SPI_FLASH_CS_LOW（）;

　　SPI_FLASH_SendByte（W25X_WriteEnable）;

　　SPI_FLASH_CS_HIGH（）;

　　123

　　}

　　这里根据写使能命令时序，只要发送命令WriteEnable（06h）就行了。

　　读FLASH状态：

　　在擦除操作之前，需要调用SPI_FLASH_WaitForWriteEnd（）来确保FLASH不忙碌的时候，才发送命令或者数据，通过读取FLASH的状态寄存器来获知他的工作状态。

　　void SPI_FLASH_WaitForWriteEnd（void）

　　{

　　u8 FLASH_Status = 0;

　　SPI_FLASH_CS_LOW（）;

　　SPI_FLASH_SendByte（W25X_ReadStatusReg）;

　　/*一直检测FLASH状态寄存器状态，直到Bit0位（BUSY位）为0）*/

　　do

　　{

　　FLASH_Status = SPI_FLASH_SendByte（Dummy_Byte）;

　　}while（（FLASH_Status & WIP_Flag） == SET）;

　　SPI_FLASH_CS_HIGH（）;

　　12345678910

　　}

　　整个函数实质是不断的循环检测FLASH状态寄存器的Busy位，知道FLASH的内部写时序完成，从而确保下一通讯操作正常。主机通过发送读状态寄存器命令Read Status Register（05h 编码），返回的为他的8为状态寄存的值。

　　检测FLASH的状态寄存器的Bit0（BUSY位），当FLASH在执行内部写时序的时候，除了读状态寄存器命令，其他的一切命令他都会忽略，并且BUSY位保持为1，所以我们需要等待BUSY位为0的时候，再向FLASH发送其他命令。

　　向FLASH写入数据：

　　对FLASH写入数据，最小单位是256字节，厂商把这个单位曾为页。写入时，一般也只有页写入的方式，所以为了方便的把一个很长的数据写入到FLASH时，一般需要进行转换，把数据按页分好，再写入到FLASH中（类似于I2C对EEPROM的页写入，只是页的大小不同而已）。

　　void SPI_FLASH_BufferWrite（u8* pBuffer， u32 WriteAddr， u16 NumByteToWrite）

　　{

　　u8 NumOfPage = 0， NumOfSingle = 0， Addr = 0， count = 0， temp= 0;

　　/这里划分好数据需要写多少页，写地址，写大小/

　　Addr = WriteAddr % SPI_FLASH_PageSize;

　　count = SPI_FLASH_PageSize - Addr;

　　NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;

　　NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

　　if （Addr == 0）

　　{

　　if（NumOfPage == 0）

　　{

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， NumByteToWrite）;

　　}

　　else

　　{

　　while（NumOfPage--）

　　{

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， SPI_FLASH_PageSize）;

　　WriteAddr += SPI_FLASH_PageSize;

　　pBuffer += SPI_FLASH_PageSize;

　　}

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， NumOfSingle）;

　　}

　　}

　　else

　　{

　　if（NumOfPage == 0）

　　{

　　if（NumOfSingle 》 count）

　　{

　　temp = NumOfSingle - count;

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， count）;

　　WriteAddr += count;

　　pBuffer += count;

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， temp）;

　　}

　　else

　　{

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， NumByteToWrite）

　　}

　　}

　　else

　　{

　　NumByteToWrite -= count;

　　NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;

　　NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， count）;

　　WriteAddr += count;

　　pBuffer += count;

　　while （NumOfPage--）

　　{

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， SPI_FLASH_PageS

　　WriteAddr += SPI_FLASH_PageSize;

　　pBuffer += SPI_FLASH_PageSize;

　　}

　　if（NumOfSingle ！= 0）

　　{

　　SPI_FLASH_PageWrite（pBuffer， WriteAddr， NumOfSingle）;

　　}

　　}

　　}

　　1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556

　　}

　　对数组进行分页后，就调用SPI_FLASH_PageWrite（）对数据进行按页写入（是不是和I2C写入EEPROM的写函数一样（连行数都差不多-_-！），不了解的话可以去看之前的I2C部分）

　　底层写操作：SPI_FLASH_PageWrite（）

　　void SPI_FLASH_PageWrite（u8* pBuffer， u32 WriteAddr， u16 NumByteToWrite）

　　{

　　/写使能/

　　SPI_FLASH_WriteEnable（）;

　　/拉低开始通讯/

　　SPI_FLASH_CS_LOW（）;

　　/发送PageProgram（02h））/

　　SPI_FLASH_SendByte（W25X_PageProgram）;

　　/* Send WriteAddr high nibble address byte to write to */

　　SPI_FLASH_SendByte（（WriteAddr & 0xFF0000） 》》 16）;

　　/* Send WriteAddr medium nibble address byte to write to */

　　SPI_FLASH_SendByte（（WriteAddr & 0xFF00） 》》 8）;

　　/* Send WriteAddr low nibble address byte to write to */

　　SPI_FLASH_SendByte（WriteAddr & 0xFF）;

　　/这里是判断写大小是否符合FLASH规定的256/

　　if（NumByteToWrite 》 SPI_FLASH_PerWritePageSize）

　　{

　　NumByteToWrite = SPI_FLASH_PerWritePageSize;

　　//printf（“\n\r Err： SPI_FLASH_PageWrite too large！”）;

　　}

　　/这里才是写真是数据/

　　while （NumByteToWrite–）

　　{

　　/* Send the current byte */

　　SPI_FLASH_SendByte（*pBuffer）;

　　/* Point on the next byte to be written */

　　pBuffer++;

　　}

　　/* Deselect the FLASH： Chip Select high */

　　SPI_FLASH_CS_HIGH（）;

　　/* Wait the end of Flash writing */

　　SPI_FLASH_WaitForWriteEnd（）;

　　}

　　发送完写入命令Page Program（编码 02h）及地址之后，可以连续写入最多256个字节的数据（SPI_FLASH_PerWritePageSize = 256），在发送完数据之后，记得调用SPI_FLASH_WaitForWriteEnd（）等待FLASH内部写时序完成再推出函数。

　　从FLASH读取数据：

　　对于读取数据，发送一个命令后，可以无限制的一直把整个FLASH的数据都读取完，直到读取的数据量足够了，就拉高片选信号以表示读取数据结束。

　　void SPI_FLASH_BufferRead（u8* pBuffer， u32 ReadAddr， u16 NumByteToRead）

　　{

　　SPI_FLASH_CS_LOW（）;

　　SPI_FLASH_SendByte（W25X_ReadData）;

　　/* Send ReadAddr high nibble address byte to read from */

　　SPI_FLASH_SendByte（（ReadAddr & 0xFF0000） 》》 16）;

　　/* Send ReadAddr medium nibble address byte to read from */

　　SPI_FLASH_SendByte（（ReadAddr& 0xFF00） 》》 8）;

　　/* Send ReadAddr low nibble address byte to read from */

　　SPI_FLASH_SendByte（ReadAddr & 0xFF）;

　　while （NumByteToRead–）

　　{

　　/* Read a byte from the FLASH */

　　*pBuffer = SPI_FLASH_SendByte（Dummy_Byte）;

　　/* Point to the next location where the byte read will be saved*/

　　pBuffer++;

　　}

　　/* Deselect the FLASH： Chip Select high */

　　SPI_FLASH_CS_HIGH（）;

　　}

　　首先发送一个读取数据命令 Read Data（03h），接着发送24位读数据起始地址，STM32再通过D0线接收数据，并使用指针的方式记录起来