STM32入门教程（SPI通信篇）

Zevalin爱灰灰

已于 2024-06-25 15:28:53 修改

阅读量1.5k

点赞数 18

分类专栏： STM32入门教程笔记文章标签： stm32 嵌入式硬件单片机

于 2023-12-03 23:42:32 首次发布

本文链接：https://blog.csdn.net/Zevalin/article/details/134772953

版权

STM32入门教程笔记专栏收录该内容

15 篇文章 36 订阅

订阅专栏

重要的内容写在前面：

该系列是以up主江协科技的STM32视频教程为基础写下去的，大部分内容都参考了老师的课件，对于一些个人认为比较重要但是老师仅口述的部分，笔者都有用文字的方式记录并标出了重点。
文中的图片基本都来源于老师的课件以及开发板和芯片的手册，粘贴过来是为了方便阅读。
如果有条件的可以先学习一些相关课程再去看STM32的教程，学起来会更加轻松（不太建议零基础开始直接STM32，听起来可能会有点困难，可以先学51单片机），相关课程有数字电路（强烈推荐先学数电，不然可能会有很多地方理解起来很困难）、模拟电路、计算机组成原理（像寄存器、存储器、中断等在这门课里有很详细的介绍）、计算机网络等。
如有错漏欢迎指出。

视频链接：[11-1] SPI通信协议_哔哩哔哩_bilibili

一、SPI协议

1、概述

SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线，共四根通信线，分别为SCK（Serial Clock，提供时钟信号）、MOSI（Master Output Slave Input，主机向从机发送数据的线路）、MISO（Master Input Slave Output，主机接收从机数据的线路）、SS（Slave Select，从机选择线，每个从机配一条），采取同步、全双工方式，支持总线挂载多设备（一主多从）。

2、SPI协议硬件电路

（1）所有SPI设备的SCK、MOSI、MISO分别连在一起。

（2）主机另外引出多条SS控制线，分别接到各从机的SS引脚。（SS用于主机选择从机，低电平代表选中，同一时刻只能选择一台从机，未被选中的从机，其MISO引脚要处于高阻态）

（3）输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入。

3、移位示意图

（1）SPI传输数据一般都采取高位先行，移位寄存器每接收一个时钟脉冲（时钟源由主机的波特率发生器提供），移位寄存器（无论是主机还是从机）就会向左进行移位，主机中被移出的数据通过MOSI进入从机的移位寄存器最右端，从机中被移出的数据通过MOSO进入主机的移位寄存器最右端，以此循环8次，主机和从机实现1个字节的数据交换。

（2）可以规定波特率发生器产生时钟上升沿时所有移位寄存器向左移一位，被移出位置于相应引脚上，波特率发生器产生时钟下降沿时引脚上的位移入到移位寄存器的最低位，也就是下面的模式1/3；也可以规定波特率发生器产生时钟下降沿时所有移位寄存器向左移一位，被移出位置于相应引脚上，波特率发生器产生时钟上升沿时引脚上的位移入到移位寄存器的最低位，也就是下面的模式0/2。

（3）基于数据交换，主机和从机可以实现数据的单向传输，比如主机需要接收从机的数据，那么就“随便”使用一个数据和从机做数据交换即可（一般用0x00或0xFF进行数据交换）。

4、SPI时序基本单元

（1）起始条件和终止条件：SS为低电平，代表从机被选中。

①起始条件：SS从高电平切换到低电平。（左图）

②终止条件：SS从低电平切换到高电平。（右图）

（2）交换一个字节（模式0，应用最多）：

CPOL（时钟极性）=0：空闲状态时，SCK为低电平

CPHA（时钟相位）=0：SCK第一个边沿移入数据，第二个边沿移出数据（SS下降沿移出一位数据）

（3）交换一个字节（模式1）：

CPOL（时钟极性）=0：空闲状态时，SCK为低电平

CPHA（时钟相位）=1：SCK第一个边沿移出数据，第二个边沿移入数据（SS上升沿移出一位数据）

（4）交换一个字节（模式2）：

CPOL（时钟极性）=1：空闲状态时，SCK为高电平

CPHA（时钟相位）=0：SCK第一个边沿移入数据，第二个边沿移出数据（SS下降沿移出一位数据）

（5）交换一个字节（模式3）：

CPOL（时钟极性）=1：空闲状态时，SCK为高电平

CPHA（时钟相位）=1：SCK第一个边沿移出数据，第二个边沿移入数据（SS上升沿移出一位数据）

5、SPI时序（每个芯片对时序的字节流定义可能不同，下面以W25Q64为例）

（1）发送指令：向SS指定的设备发送写使能指令（0x06）

（2）指定地址写：向SS指定的设备发送写指令（0x02），随后在指定地址（Address[23:0]）下写入指定数据（Data）。（Address[23:0]占3个字节，需要进行3次字节数据交换）

（3）指定地址读：向SS指定的设备发送读指令（0x03），随后在指定地址（Address[23:0]）下读取从机数据（Data）。（Address[23:0]占3个字节，需要进行3次字节数据交换）

二、W25Qxx

1、W25Qxx简介

（1）W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储、字库存储、固件程序存储等场景。

（2）存储介质：Nor Flash（闪存）。

（3）时钟频率：80MHz / 160MHz (Dual SPI，双重SPI模式等效频率) / 320MHz (Quad SPI，四重SPI模式等效频率)

（4）存储容量（24位地址）：

W25Q40： 4Mbit / 512KByte

W25Q80： 8Mbit / 1MByte

W25Q16： 16Mbit / 2MByte

W25Q32： 32Mbit / 4MByte

W25Q64： 64Mbit / 8MByte

W25Q128： 128Mbit / 16MByte

W25Q256： 256Mbit / 32MByte

2、W25Qxx硬件电路

引脚	功能
VCC、GND	电源（2.7~3.6V）
CS（SS）	SPI片选
CLK（SCK）	SPI时钟
DI（MOSI）	SPI主机输出从机输入
DO（MISO）	SPI主机输入从机输出
WP	写保护
HOLD	数据保持

3、W25Q64框图

（1）存储器总容量为8MB，以64KB为一块进行划分，每64KB再划分为16个4KB大小的扇区，整个存储空间同时也划分为很多页，每页大小256字节。

（2）左下角是SPI控制逻辑，负责完成芯片内部的地址锁存、数据读写等操作，主控芯片使用SPI协议将指令和数据发送给芯片的SPI控制逻辑，控制逻辑会自动操作内部电路。

（3）SPI控制逻辑上方有一个状态寄存器（Status Register），芯片是否处于忙状态、是否写使能、是否写保护都在该寄存器中有体现。

（4）状态寄存器上方是写控制逻辑，和外部的WP引脚相连，配合WP引脚实现硬件写保护。

（5）SPI控制逻辑右侧有一个高电压生成器（High Voltage Generators），配合Flash进行编程，实现数据掉电不丢失。

（6）SPI控制逻辑右侧还有页地址锁存/计数器和字节地址锁存/计数器，页地址选择操作存储空间的哪一页，字节地址选择操作存储页中的哪一个字节，相当于一个地址指针，它在进行读/写操作之后还能自增。

（7）数据读/写通过RAM缓存区（Buffer）进行，写入Flash的数据会暂存在缓冲区中，在时序结束后芯片才会将缓存区的数据复制到的Flash中，复制数据的过程中缓冲区会将状态寄存器的BUSY位置1表示芯片处于忙状态。（Flash的运行速度慢于SPI控制逻辑，缓冲区就是用于解决收发速度不匹配的问题，不过缓冲区只有256个字节的容量，不能一次性往缓冲区写入太多数据）

4、Flash操作注意事项

（1）写入操作时：

①写入操作前，必须先进行写使能。

②每个数据位只能由1改写为0，不能由0改写为1。

③写入数据前必须先擦除，擦除后，所有数据位变为1。

④擦除必须按最小擦除单元（W25Q64中最小擦除单元是一个扇区）进行。

⑤连续写入多字节时，最多写入一页的数据，超过页尾位置的数据，会回到页首覆盖写入（不可跨页写数据）。

⑥写入操作结束后，芯片进入忙状态，不响应新的读写操作。

（2）读取操作时：

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

三、STM32的SPI外设

1、SPI外设简介

（1）STM32内部集成了硬件SPI收发电路，可以由硬件自动执行时钟生成、数据收发等功能，减轻CPU的负担（不过SS线仍然需要软件控制）。

（2）可配置8位/16位数据帧、高位先行/低位先行。

（3）时钟频率：fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)。

（4）支持多主机模型、主或从操作，可精简为半双工/单工通信，支持DMA，兼容I2S协议。

（5）STM32F103C8T6的硬件SPI资源：SPI1（挂载在APB2上）、SPI2（挂载在APB1上）。

2、SPI框图

（1）左上角的移位寄存器（SPI_DR）是最核心的部分，移位寄存器的工作流程在“移位示意图”中有很详细的描述。

（2）当STM32作为从机时，MOSI就是从机输入，MISO就是从机输出；STM32作为主机时，MOSI和MISO还是原来的功能。

（3）主机将需要发送的数据写入发送缓冲区，主机在接收缓冲区中读取接收到的数据，两个缓冲区在软件中占用同一个地址，这部分和USART非常相似。

（4）当移位寄存器没有数据移位时，发送缓冲区的数据会立刻转入移位寄存器并自动置状态寄存器的TXE位为1，这时主机可以往发送缓冲区写入下一个要发送的数据，发送缓冲区收到主机的数据后TXE位自动置为0。

（5）当移位寄存器接收到从机的完整字节数据时，如果状态寄存器的RXNE位为0，移位寄存器的数据转入接收缓冲区并自动置RXNE位为1，待主机读取接收缓冲区的数据后，RXNE才会被置为0。

（6）波特率发生器生成的时钟和移位寄存器的时钟同步。

（7）CR1寄存器的三个位BR0、BR1、BR2用于控制分频系数（fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)），LSBFIRST决定高位先行还是低位先行，SPE是SPI使能位，MSTR负责配置主/从模式，CPOL和CPHA用来选择SPI交换字节的4种模式。

3、主模式全双工连续传输

4、非连续传输

注：软件等待移位寄存器将数据交换完后才将数据写入发送缓冲区，因此效率较连续传输低，在时钟频率高时差别会更明显，但是非连续传输对程序编写更友好。

四、读取W25Q64

1、软件SPI读取W25Q64

（1）按照下图所示接好电路，并将OLED显示屏的项目文件夹复制一份作为模板使用。

（2）在项目的Hardware组中添加MySPI.h文件和MySPI.c文件用于封装SPI模块的代码。

①MySPI.h文件：

#ifndef __MySPI_H
#define __MySPI_H

void MySPI_Init(void);
void MySPI_Start(void);
void MySPI_Stop(void);
uint8_t MySPI_SwapByte(uint8_t ByteSend);

#endif

②MySPI.c文件：

#include "stm32f10x.h"                  // Device header

void MySPI_W_SS(uint8_t BitValue)  //设置SS线电平
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_W_SCK(uint8_t BitValue) //设置SCK线电平
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

void MySPI_W_MOSI(uint8_t BitValue)//设置MOSI线电平
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)         //读MISO线电平
{
	return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}

void MySPI_Init(void)
{
	//开启GPIO的时钟
	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);   //使用模式0，模式0下SCK开始时是低电平
}

void MySPI_Start(void)
{
	MySPI_W_SS(0);				//拉低SS，开始时序
}

void MySPI_Stop(void)
{
	MySPI_W_SS(1);				//拉高SS，终止时序
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;					//定义接收的数据，并赋初值0x00，此处必须赋初值0x00，后面会用到
	
	for (i = 0; i < 8; i ++)						//循环8次，依次交换每一位数据
	{
		MySPI_W_MOSI(ByteSend & (0x80 >> i));		//使用掩码的方式取出ByteSend的指定一位数据并写入到MOSI线
		MySPI_W_SCK(1);								//拉高SCK，上升沿移出数据
		if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}	//读取MISO数据，并存储到Byte变量中
																//当MISO为1时，置变量指定位为1，当MISO为0时，不做处理，指定位为默认的初值0
		MySPI_W_SCK(0);								//拉低SCK，下降沿移入数据
	}						
	/*下面这个for循环与上面的for循环等效
	for(i = 0; i < 8; i++)
	{
		MySPI_W_MOSI(ByteSend & 0x80);  //主机将高位写在MOSI上
		ByteSend << 1;                  //ByteSend左移一位
		MySPI_W_SCK(1);                 //SCK上升沿，从机中的移位寄存器将高位数据写在MISO上
		if(MySPI_R_MISO())
		{
			ByteSend |= 0x01;           //ByteSend低位接收从机移位寄存器移出的数据
		}
		MySPI_W_SCK(0);                 //SCK下降沿，MOSI的数据移入从机中的移位寄存器
	}
	*/	
	return ByteReceive;                             //返回接收到的一个字节数据
}

（3）在项目的Hardware组中添加W25Q64_Ins.h文件用于存放指令集的宏定义，添加W25Q64.h文件和W25Q64.c文件用于封装W25Q64模块的代码。

①W25Q64_Ins.h文件：

#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.h文件：

#ifndef __W25Q64_H
#define __W25Q64_H

void W25Q64_Init(void);
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID);
void W25Q64_PageProgram(uint32_t Address, uint8_t* DataArray, uint16_t Count);
void W25Q64_SectorErase(uint32_t Address);
void W25Q64_ReadData(uint32_t Address, uint8_t* DataArray, uint32_t Count);

#endif

③W25Q64.c文件：

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

/**
  * 函    数：W25Q64初始化
  * 参    数：无
  * 返 回 值：无
  */
void W25Q64_Init(void)
{
	MySPI_Init();					//先初始化底层的SPI
}

/**
  * 函    数：W25Q64读取ID号
  * 参    数：MID 工厂ID，使用输出参数的形式返回
  * 参    数：DID 设备ID，使用输出参数的形式返回
  * 返 回 值：无
  */
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_JEDEC_ID);			//交换发送读取ID的指令
	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);	//交换接收MID，通过输出参数返回
	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);	//交换接收DID高8位
	*DID <<= 8;									//高8位移到高位
	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);	//或上交换接收DID的低8位，通过输出参数返回
	MySPI_Stop();								//SPI终止
}

/**
  * 函    数：W25Q64写使能
  * 参    数：无
  * 返 回 值：无
  */
void W25Q64_WriteEnable(void)
{
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);		//交换发送写使能的指令
	MySPI_Stop();								//SPI终止
}

/**
  * 函    数：W25Q64等待忙
  * 参    数：无
  * 返 回 值：无
  */
void W25Q64_WaitBusy(void)
{
	uint32_t Timeout;
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);				//交换发送读状态寄存器1的指令
	Timeout = 100000;							//给定超时计数时间
	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)	//循环等待忙标志位
	{
		Timeout --;								//等待时，计数值自减
		if (Timeout == 0)						//自减到0后，等待超时
		{
			/*超时的错误处理代码，可以添加到此处*/
			break;								//超时，跳出等待
		}
	}
	MySPI_Stop();								//SPI终止
}

/**
  * 函    数：W25Q64页编程
  * 参    数：Address 页编程的起始地址，范围：0x000000~0x7FFFFF
  * 参    数：DataArray	用于写入数据的数组
  * 参    数：Count 要写入数据的数量，范围：0~256
  * 返 回 值：无
  * 注意事项：写入的地址范围不能跨页
  */
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)
{
	uint16_t i;
	
	W25Q64_WriteEnable();						//写使能（写入操作前，必须先进行写使能）
	
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);		//交换发送页编程的指令
	MySPI_SwapByte(Address >> 16);				//交换发送地址23~16位
	MySPI_SwapByte(Address >> 8);				//交换发送地址15~8位
	MySPI_SwapByte(Address);					//交换发送地址7~0位
	for (i = 0; i < Count; i ++)				//循环Count次
	{
		MySPI_SwapByte(DataArray[i]);			//从起始地址开始写数据，地址指针会自增
	}
	MySPI_Stop();								//SPI终止
	
	W25Q64_WaitBusy();							//等待忙（忙状态不能进行读写，需要等芯片处理完事情再继续下面的操作）
}

/**
  * 函    数：W25Q64扇区擦除（4KB）
  * 参    数：Address 指定扇区的地址，范围：0x000000~0x7FFFFF
  * 返 回 值：无
  */
void W25Q64_SectorErase(uint32_t Address)
{
	W25Q64_WriteEnable();						//写使能（写入操作前，必须先进行写使能）
	
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);	//交换发送扇区擦除的指令
	MySPI_SwapByte(Address >> 16);				//交换发送地址23~16位
	MySPI_SwapByte(Address >> 8);				//交换发送地址15~8位
	MySPI_SwapByte(Address);					//交换发送地址7~0位
	MySPI_Stop();								//SPI终止
	
	W25Q64_WaitBusy();							//等待忙（忙状态不能进行读写，需要等芯片处理完事情再继续下面的操作）
}

/**
  * 函    数：W25Q64读取数据
  * 参    数：Address 读取数据的起始地址，范围：0x000000~0x7FFFFF
  * 参    数：DataArray 用于接收读取数据的数组，通过输出参数返回
  * 参    数：Count 要读取数据的数量，范围：0~0x800000
  * 返 回 值：无
  */
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)
{
	uint32_t i;
	MySPI_Start();								//SPI起始
	MySPI_SwapByte(W25Q64_READ_DATA);			//交换发送读取数据的指令
	MySPI_SwapByte(Address >> 16);				//交换发送地址23~16位
	MySPI_SwapByte(Address >> 8);				//交换发送地址15~8位
	MySPI_SwapByte(Address);					//交换发送地址7~0位
	for (i = 0; i < Count; i ++)				//循环Count次
	{
		DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);	//从起始地址开始读取数据，地址指针会自增
	}
	MySPI_Stop();								//SPI终止
}

（4）W25Q64的ID号、相关指令及时序：

（5）在main.c文件中粘贴以下代码，然后编译，将程序下载到开发板中，观察OLED屏显示。

#include "stm32f10x.h"                  // Device headerCmd
#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()
{
	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);  //在指定地址处往后写4个字节数据
	W25Q64_ReadData(0x000000, ArrayRead, 4);      //读取指定地址往后的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)
	{
		
	}
}

2、硬件SPI读取W25Q64

（1）按照下图所示接好电路，并将上例的项目文件夹复制一份作为模板使用。（SPI1_NSS复用在PA4，SPI1_SCK复用在PA5，SPI1_MISO复用在PA6，SPI1_MOSI复用在PA7）

（2）在stm32f10x_spi.h文件中有SPI相关的函数。

[1]SPI_I2S_DeInit函数：恢复缺省配置。

[2]SPI_Init函数：使用结构体中的参数初始化SPI。

[3]SPI_StructInit函数：给结构体中的参数赋一个初始值。

[4]SPI_Cmd函数：使能SPI。

[5]SPI_I2S_ITConfig函数：开启SPI前往NVIC的通道。

[6]SPI_I2S_DMACmd函数：允许SPI向DMA发送请求。

[7]SPI_I2S_SendData函数：往数据寄存器（发送缓冲区）中写数据。

[8]SPI_I2S_ReceiveData函数：读取数据寄存器（接收缓冲区）中的数据。

[9]SPI_I2S_GetFlagStatus函数：获取状态寄存器标志位。

[10]SPI_I2S_ClearFlag函数：清除状态寄存器标志位。

[11]SPI_I2S_GetITStatus函数：获取中断标志位。

[12]SPI_I2S_ClearITPendingBit函数：清除中断标志位。

（3）修改MySPI.c文件，无需改动main.c文件，直接编译，将程序下载到开发板中，观察OLED屏显示。

#include "stm32f10x.h"                  // Device header

void MySPI_W_SS(uint8_t BitValue)  //设置SS线电平
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_Init(void)
{
	//开启SPI和GPIO的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
	
	//配置端口模式（SCK、MOSI配置为复用推挽输出，MISO引脚配置为上拉输入，SS配置为通用推挽输出）
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = 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);

	//配置SPI1
	SPI_InitTypeDef SPI_InitStructure;
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;  //指定当前设备为主机
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //双线全双工
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;  //8位数据帧
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //高位先行
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;  //时钟频率 = 72MHz / 128
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;  //CPHA = 0
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;    //CPOL = 0
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
	SPI_InitStructure.SPI_CRCPolynomial = 7;
	SPI_Init(SPI1, &SPI_InitStructure);
	
	//使能SPI1
	SPI_Cmd(SPI1, ENABLE);
	
	MySPI_W_SS(1);  //初始时不选择从机
}

void MySPI_Start(void)
{
	MySPI_W_SS(0);				//拉低SS，开始时序
}

void MySPI_Stop(void)
{
	MySPI_W_SS(1);				//拉高SS，终止时序
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)  //非连续传输
{
	while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != SET);
	//等待TXE=1，也就是发送缓冲区的数据被移位寄存器读走
	SPI_I2S_SendData(SPI1, ByteSend);    //主机往发送缓冲区写数据，TXE被置为0
	while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) != SET);
	//等待移位寄存器完成交换数据的操作，移位寄存器完成数据交换后接收缓冲区会将数据读走，RXNE被置为1
	return SPI_I2S_ReceiveData(SPI1);    //主机读走接收缓冲区的数据，RXNE被置为0
}