SPI通信（W25Q64）

一.前言

1.SPI的简介

2.SPI的应用

3. SPI的硬件电路

4. SPI硬件电路设计的核心

5. SPI时序基本单元

二. W25Q64简介

1. 芯片简介

2. （非）易失性存储器

3. 引脚定义

4. W25Q64框图

5. Flash操作的注意事项

三. SPI读写W25Q64（使用软件SPI的方式来实现）

1. 程序的整体框架：

2. 代码部分

四. 最终效果展示

1. 实物部分

五. 资源提取

一.前言

1.SPI的简介

SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线。

它拥有四根通信线，分别如下所示：

1）SCK（Serial Clock）串行时钟线。它还拥有一些别名，可以叫做SCLK，CLK，CK.

2）MOSI（Master Output Slave Input) 主机输出从机输入。也可能会叫做DO(Data Output).

3）MISO（Master Input Slave Output) 主机输入从机输出。也可能叫做DI(Data Input).

4）SS(Slave Select) 从机选择。也可以叫做CS片选。

SPI的基本特性就是同步，全双工。

SPI还支持总线挂载多个设备（一主多从）。有一条专门用来指定从机的通信线就是SS，从机选择线。这个线可以不止一条，SPI的主机有多少个从机，它就可以拥有几条SS线。

SPI跟I2C不同之处之一就是SPI没有应答机制，也就是SPI发送数据就发送数据，不会管你有没有接收。

2.SPI的应用

1）要想利用诸如型号为NRF24L01的无线通信模块来进行无线通信，那就需要利用SPI来读写这个芯片，才能实现相关的功能。

2）还可以利用SPI来读写Micro SD卡。

3. SPI的硬件电路

SPI的主要硬件电路可以由下图表示：

从图中我们可以看到这个SPI主机拥有3个SPI从机，所以在主机上面就有3条SS线。同时我们可以观察到在SPI主机当中，只有MISO一条线是输入进来的，并且这条线上连接着所有从机的MISO线。为了避免从机的MISO产生冲突，我们规定当SS电平信号为高电平的时候，就设置MISO为高阻态。

值得注意的是：在这里，输出引脚将配置为推挽输出，输入引脚将配置为浮空或者上拉输入。

原因就在于在推挽输出模式下，高低电平都具有很强的驱动能力，这就使得SPI引脚的上升沿和下降沿变化得非常迅速，使得SPI信号变化得快，所以就让得SPI能够具有很高得传输速度。一般SPI信号都可以达到MHz的速度级别。

4. SPI硬件电路设计的核心

如上所示的移位示意图就是我们SPI硬件电路设计的核心所在。其中的波特率发生器能够产生时钟驱动主机的移位寄存器进行移位，同时这个时钟也会通过SCK引脚进行输出。

接下来我们来讲下它的工作原理：

当产生上升沿的时候，所有的移位寄存器（包括主机和从机）里的数据都会左移一位，SPI主机移出去的那一位数据会先放到MOSI线，SPI从机的那一位数据就会先放到MISO线上。接着等待下降沿，当产生下降沿的时候，就会放到寄存器当中。重复这个过程8次，就会完成主机和从机的数据交换。

5. SPI时序基本单元

起始条件：SS从高电平切换到低电平。

终止条件：SS从低电平切换到高电平。

如下所示（左图为起始条件，右图为终止条件）：

交换字节，总共有四种模式，包括模式0~模式3。这里我主要给大家看下模式0，如果大家对其他模式感兴趣，可以在我文章的最后提取资源。

其中CPOL（Clock Polarity）时钟极性。CPHA(Clock Phase) 时钟相位。我们四个模式就是由这两个参数来的，因为这两个参数可以取0或1，所以总共拥有4种组合模式。这四种模式主要区别就在于采样时钟和时钟极性的不同。如CPHA时钟相位就决定了是第一个时钟采样移入还是第二个是时钟采样移入。

二. W25Q64简介

1. 芯片简介

W25Q64是用来SPI通信的芯片之一。在W25Qxx系列中，它们都是一种低成本，小型化，使用简单的非易失存储器，常应用于数据存储，字库存储，固件程序存储等场景。

W25Q64只是其中一种。如下所示：

其中，xx的不同，它所拥有的容量也就不同。如我们今天所要讲的W25Q64就拥有64Mbit的容量，并且由于1字节等于8位，所以就有后面的8M=64M/8 。

它的存储介质为Nor Flash(闪存)。

时钟频率有80MHz(普通SPI模式)，160MHz(双重SPI),320MHz(四重SPI)。实际上SCK频率都是80MHz，只是因为在双重SPI模式下，一个时钟就会发两位，所以就是两倍频率。

2. （非）易失性存储器

易失性存储器一般就是SRAM，DRAM等。非易失性存储器一般就是E2PROM,Flash等。

3. 引脚定义

如上所示就为W25Q64的引脚定义。其中大部分我们都已经熟悉。这里主要介绍两个大家可能没有见过的。如/WP就表示写保护，在旁边加个/，就表示只有当WP接低电平的时候，才能触发写保护，不让写；如果是高电平，则不保护，可以写。

如HOLD，就表示数据保持。主要作用就在于能够回到原来的时序，保证数据的完整性。

4. W25Q64框图

关于W25Q64的框图，大家也可以在我文章末尾的资源当中提取到W25Q64的手册，在手册中可以找到它的框图。

这里主要给大家讲解下几个重要的地方：

1）整个Flash的空间划分，会划分为块，扇区和页。

2）SPI控制逻辑，它就是整个芯片的管理员，执行指令，读写数据都靠它。

3）状态寄存器，它和忙状态，写使能和写保护等功能相关。

4）256字节的页缓存，它会对一次性写入的数据量产生限制。值得注意的是：写入数据不能跨页写入。

5. Flash操作的注意事项

写入操作需要注意以下事项：

1）写入操作之前，必须先进行写使能。（这个我们可以直接加在我们封装好的功能函数当中，在后面会提到）。

2）每个数据位只能由1改写为0，而不能由0改写为1。这个可能就是因为工艺水平的限制。举个例子，比如我们原本数据为0x55,要改写为0xAA，由于这个的限制，最后的结果就只能是0x00.

3）写入数据前必须先进行擦除，擦除后，所有的数据变为1。也就是0xFF，所以在Flash当中，FF代表空白，而不是00.

4）擦除必须按最小擦除单元进行。

5）连续写入多字节时，最多写入一页的数据，超过页尾位置的数据，会回到页首覆盖写入。也就是我们上面所说的不能跨页写入。

6）写入操作结束后，芯片会进行忙状态。这在我们后面的代码部分会体现，会添加一个忙状态检测。

读取操作由于只要进行读取，没有太多的要求：

直接调用读取时序，无需使能，无需额外操作，没有页的限制。读取操作结束后不会进入忙状态，但不能在忙状态时读取。

三. SPI读写W25Q64（使用软件SPI的方式来实现）

下面我们来实现软件读取W25Q64的操作。由于硬件实现只需要调用相关库函数即可，所以我们主要介绍软件实现（更底层）。

首先由于使用的软件模拟SPI,所以诸如CS和SCK等4根线可以接到STM32的任意GPIO口。这里我还是选择了接到硬件SPI所在的GPIO口，这样可以方便大家随时进行软件和硬件的相互转换。

1. 程序的整体框架：

首先先建立一个MySPI的模块，在这个模块中主要包含引脚封装，初始化以及SPI通信的3个时序单元（起始，终止和交换一个字节）。

接着基于通信层再建立一个W25Q64的模块，在这个模块里，调用底层SPI的拼图，来拼接各种指令和功能的完整时序（比如写使能，擦除，页编程，读数据等）。

最后在主函数中，调用驱动层的函数，来完成我们想要实现的功能。这就是程序的整体框架。

2. 代码部分

MySPI.c部分

#include "stm32f10x.h" // Device header

void MySPI_W_SS(uint8_t BitValue)
{
   GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_W_SCK(uint8_t BitValue)
{
   GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

void MySPI_W_MOSI(uint8_t BitValue)
{
   GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)
{
   return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}

void MySPI_Init(void)
{
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

   GPIO_InitTypeDef GPIO_InitStructure;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOA, &GPIO_InitStructure);

   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_Init(GPIOA, &GPIO_InitStructure);

   MySPI_W_SS(1);
   MySPI_W_SCK(0);
}

void MySPI_Start(void)
{
   MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
   MySPI_W_SS(1);
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
   uint8_t i, ByteReceive = 0x00;

   for (i = 0; i < 8; i ++)
   {
       MySPI_W_MOSI(ByteSend & (0x80 >> i));
       MySPI_W_SCK(1);
       if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
       MySPI_W_SCK(0);
   }

   return ByteReceive;
}

值得注意的是，我们可以对于SPI的相关指令进行包装，例如获取设备ID号，就需要发送指令0x9F。

#ifndef __W25Q64_INS_H
#define __W25Q64_INS_H

#define W25Q64_WRITE_ENABLE                           0x06
#define W25Q64_WRITE_DISABLE                       0x04
#define W25Q64_READ_STATUS_REGISTER_1               0x05
#define W25Q64_READ_STATUS_REGISTER_2               0x35
#define W25Q64_WRITE_STATUS_REGISTER               0x01
#define W25Q64_PAGE_PROGRAM                           0x02
#define W25Q64_QUAD_PAGE_PROGRAM                   0x32
#define W25Q64_BLOCK_ERASE_64KB                       0xD8
#define W25Q64_BLOCK_ERASE_32KB                       0x52
#define W25Q64_SECTOR_ERASE_4KB                       0x20
#define W25Q64_CHIP_ERASE                           0xC7
#define W25Q64_ERASE_SUSPEND                       0x75
#define W25Q64_ERASE_RESUME                           0x7A
#define W25Q64_POWER_DOWN                           0xB9
#define W25Q64_HIGH_PERFORMANCE_MODE               0xA3
#define W25Q64_CONTINUOUS_READ_MODE_RESET           0xFF
#define W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID       0xAB
#define W25Q64_MANUFACTURER_DEVICE_ID               0x90
#define W25Q64_READ_UNIQUE_ID                       0x4B
#define W25Q64_JEDEC_ID                               0x9F
#define W25Q64_READ_DATA                           0x03
#define W25Q64_FAST_READ                           0x0B
#define W25Q64_FAST_READ_DUAL_OUTPUT               0x3B
#define W25Q64_FAST_READ_DUAL_IO                   0xBB
#define W25Q64_FAST_READ_QUAD_OUTPUT               0x6B
#define W25Q64_FAST_READ_QUAD_IO                   0xEB
#define W25Q64_OCTAL_WORD_READ_QUAD_IO               0xE3

#define W25Q64_DUMMY_BYTE                           0xFF

#endif

W25Q64.c部分

#include "stm32f10x.h" // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"

void W25Q64_Init(void)
{
   MySPI_Init();
}

void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
   MySPI_Start();
   MySPI_SwapByte(W25Q64_JEDEC_ID);
   *MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
   *DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
   *DID <<= 8;
   *DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);
   MySPI_Stop();
}

void W25Q64_WriteEnable(void)
{
   MySPI_Start();
   MySPI_SwapByte(W25Q64_WRITE_ENABLE);
   MySPI_Stop();
}

void W25Q64_WaitBusy(void)
{
   uint32_t Timeout;
   MySPI_Start();
   MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
   Timeout = 100000;
   while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
   {
       Timeout --;
       if (Timeout == 0)
       {
           break;
       }
   }
   MySPI_Stop();
}

void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
   uint16_t i;

   W25Q64_WriteEnable();

   MySPI_Start();
   MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
   MySPI_SwapByte(Address >> 16);
   MySPI_SwapByte(Address >> 8);
   MySPI_SwapByte(Address);
   for (i = 0; i < Count; i ++)
   {
       MySPI_SwapByte(DataArray[i]);
   }
   MySPI_Stop();

   W25Q64_WaitBusy();
}

void W25Q64_SectorErase(uint32_t Address)
{
   W25Q64_WriteEnable();

   MySPI_Start();
   MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
   MySPI_SwapByte(Address >> 16);
   MySPI_SwapByte(Address >> 8);
   MySPI_SwapByte(Address);
   MySPI_Stop();

   W25Q64_WaitBusy();
}

void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
   uint32_t i;
   MySPI_Start();
   MySPI_SwapByte(W25Q64_READ_DATA);
   MySPI_SwapByte(Address >> 16);
   MySPI_SwapByte(Address >> 8);
   MySPI_SwapByte(Address);
   for (i = 0; i < Count; i ++)
   {
       DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
   }
   MySPI_Stop();
}

主函数测试main.c部分

#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"

uint8_t MID;
uint16_t DID;

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};
uint8_t ArrayRead[4];

int main(void)
{
   OLED_Init();
   W25Q64_Init();

   OLED_ShowString(1, 1, "MID: DID:");
   OLED_ShowString(2, 1, "W:");
   OLED_ShowString(3, 1, "R:");

   W25Q64_ReadID(&MID, &DID);
   OLED_ShowHexNum(1, 5, MID, 2);
   OLED_ShowHexNum(1, 12, DID, 4);

   W25Q64_SectorErase(0x000000);
   W25Q64_PageProgram(0x000000, ArrayWrite, 4);

   W25Q64_ReadData(0x000000, ArrayRead, 4);

   OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
   OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
   OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
   OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);

   OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
   OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
   OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
   OLED_ShowHexNum(3, 12, ArrayRead[3], 2);

   while (1)
   {

   }
}