SPI

SPI

协议内容图片代码资料来源均属于B站up主江协科技,仅用于学习使用

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

四种作用的通信线:SCK(Serial Clock 串行时钟线)、MOSI(Master Output Slave Input 主机输出从机输入)、MISO(Master Input Slave Output 主机输入从机输出)、SS(Slave Select 从机选择)

同步(有时钟线),全双工(发送接收可以同时进行不影响,两个通信线就是全双工), 支持总线挂载多设备(一主多从,不支持多主机)

I2C需要进行寻址再发送,SPI直接开辟一条ss通信线,专门指定跟哪一个从机进行通信(ss线可能有很多条,连接所有的从机 )

简单了解使用:使用SPI协议读写W25Q64外设(flash存储器芯片,8M字节而且掉电不丢失); OLED,2.4GHz无线通信模块,SD卡也是通过SPI通信协议进行通信读写。

SPI时钟频率非常快,80MHz


硬件电路图

•所有SPI设备的SCK、MOSI、MISO分别连在一起

•主机另外引出多条SS控制线,分别接到各从机的SS引脚

•输出引脚配置为推挽输出,输入引脚配置为浮空或上拉输入(I2C是因为多个设备响应会导致短路,哪怕你程序上设定仲裁物理层面上会直接短路,并且推挽输出遇到从机拉低SDA也是直接短路;SPI完全独立数据线是单向的:MOSI 永远主机发,MISO 永远从机发,没有被选中的从机,其 MISO 引脚处于高阻态、相当于断开,高阻态很难被动拉高,所以不能使用下拉电阻)

此时之外,这里隐藏这4个设备所必须共地的GND线;SP1能够引出电源线给从机供电

主机想选择谁,就将对应的SS线置低电平,专属通道;但是主机也相当于只能选择一个从机

推挽输出的驱动能力非常强,上升下降沿均非常迅速;开漏输出上升沿由于是通过上拉电阻,所以上升沿变化缓慢,下降沿非常迅速

协议规定当SS处于高电平时(从机未被选中,选中为低电平从机MISO为推挽输出),MISO必须处于高阻态不输出任何信号!如果正常也是推挽输出,那么多个从机全是推挽输出高电平则会造成冲突。

支持一对多通信,但是通信时设备只能一对一通信,不能多设备同时通信。


移位示意图

波特率发生器其实就是时钟,该时钟驱动主机的移位寄存器进行移位(从MOSI左到右边的 从机移位寄存器);同时SPI从机也是由该时钟控制进行移位(通过MISO将数据左移到 主机的移位寄存器中)

时钟信号的上升沿:将主机的移位寄存器的值放在MOSI引脚上,下降沿:将引脚准备好的位采样输入到从机移位寄存器最低位

时钟信号的上升沿:将从机的移位寄存器的值放在MISO引脚上,下降沿:将引脚准备好的位采样输入到主机移位寄存器最低位

其中上升沿和下降沿放数据可以由软件自行设置。重复8个时钟就完成转换数据了,发送数据实际上也会接收数据,只不过我们不去查看接收的部分(我们也必须用无关的数据0x00之类的去把从机的数据交换出来)这也是SPI通信中资源浪费的部分

起始条件为SS切换为低电平,终止条件为SS切换为高电平

CPOL代表初始时钟电平(为0代表低电平)

CPHA=0代表SCK第一个边沿移入数据,第二个边沿移出数据

CPHA=1代表SCK第一个边沿移出数据,第二个边沿移入数据

模式 CPOL CPHA 说明
Mode 0 0 0 ✅ 最常见
Mode 1 0 1
Mode 2 1 0
Mode 3 1 1

MISO位于中间代表高阻态(默认高电平),MOSI两条线是代表0/1的输入电平,MOSI没有硬性规定默认电平


发送指令:向SS指定的设备,发送指令0x06(写使能)

这里是软件模拟的SPI协议,所以存在延时:MOSI第四位0运输之后,下一位1没有准确对齐时钟下降沿(移出上一个数据和移入当前数据应该在几乎同一时间完成)

指定地址写:向SS指定的设备,先发送写指令(0x02),随后指定地址(Address[23:0]),再写入指定数据(Data)

24位地址,这里分三次传输地址,所以一共是5段;发送后不终止,后续字节会写到后续的存储器内(一次性写入多个数据)

因为是写操作,主机的MISO默认上拉到高电平1,从机保持高阻态 [ 相当于从机内部输出管脚“断开”或“悬空”,呈现极高的阻抗(近似开路)。它既不主动输出高电平(1),也不主动输出低电平(0)]

指定地址读:向SS指定的设备,先发送读指令(0x03),随后在指定地址(Address[23:0]),再读取从机数据(Data)

这里抛砖引玉,给的0xff进行交换;也可以利用这里从机内部指针自动加一的特性,一直交换数据直到SS为高电平结束(这样就是多个字节的交换)

这里的MISO 是由被选中从机(W25Q64)的 SPI 硬件根据 SCK 自动移位输出的,由硬件电路产生波形,所以其波形就紧贴时钟上下沿。

对比软件规定模拟SPI协议,减少了延时


W25Q64

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

存储介质:Nor Flash(闪存):Nor Flash 可直接运行代码、读快写擦慢、容量小价贵;Nand Flash 不能直接执行程序、写擦速度非常快、容量大成本低,需坏块与 ECC 管理。(对比非易失存储器中,flash是非常快的存储器,虽然对比RAM很慢)

时钟频率:80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)

存储容量(24位地址):

W25Q64: 64Mbit / 8MByte


硬件电路

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

HOLD:当遇到中断并且想用SPI操作其他外设,SS置回高电平时序终止;又想SPI进入一次中断去操作其他设备又不想结束通信,就使用HOLD引脚:芯片时序不会终止,芯片释放总线但是记住现在的状态。结束后HOLD置回高电平,继续时序。

IO引脚对应双重和四重SPI(因为SPI有数据通信资源的浪费,这进行了优化,将MISO和MOSI均作为通信输入/输出线就是双重SPI;将WP和HOLD也作为IO口就是四重SPI,效率也翻了2/4倍)


W25Q64示意图

对于寄存器:每一个寄存器有很多的块(64KB),每一块有很多的扇区(4KB),每一个扇区有很多的页

从000 000h(24位)到7FF FFFF。2的10次方为1KB,2的20次方我1MB,所以这里就是16MB最大存储,但是该芯片只有8MB,所以就只能存储一半的地址。

块数:每一块是64KB,一共为8MB,得一共为128块(从块0到块127)

扇区数:每一块是4KB,一共为64KB,得一共为16个区域;一页是254个字节,所以一个扇区是16页 (从xx00到xxFF,合计16页)

SPI command黑盒子,实现硬件的操作;high volltage generator高电压生成器,用于修改flash区域(产生一个掉电不丢失的状态,芯片内部已经集成完毕)

page/byte address latch/counter :最高8位指定块地址,4位决定扇区地址,4位决定页地址;最后8位指定页内的具体字节地址页地址通过行解码和写保护选中操作那一页;字节地址通过列解码和256字节缓存进行读写操作,地址锁存有计数器,地址指针读写后可以自动加一(连续指定地址读写)

RAM缓存区(page buffer),写数据是先写入缓冲区,在时序结束后再将缓冲区内的数据复制到flash内永久保存,原因是SPI读写非常迅速,但是flash需要特殊的永久写入肯定就比较慢,所以存放在缓冲区(RAM接收非常快);但是缓冲区内最大的字节存储数是256字节,所以协议规定连续写入的字节不能大于256,时序结束之后,芯片开始写数据到flash,给状态寄存器的busy位置1(status register),在这个时间段内芯片就不会响应其他的数据了。

读取也是通过RAM缓存区,但是读取的速度非常快,并且只需要接收对应的标志位就能读取数据。


SPI操作规定

写入操作时:

•写入操作前,必须先进行写使能

•每个数据位只能由1改写为0,不能由0改写为1:输入0101 0101,改写1010 1010,结果会是0000 0000

•写入数据前必须先擦除,擦除后,所有数据位变为1

•擦除必须按最小擦除单元进行(扇区,4096个字节;擦除一个字节:只能先读整个扇区的数据,再擦除扇区,修改需要修改的字节,再复制进入扇区,为成本做出的妥协),最大可以整个芯片擦除,擦除也会进入busy状态

•连续写入多字节时,最多写入一页的数据,超过页尾位置的数据,会回到页首覆盖写入(从起始页面开始才有256字节,从中间开始写到页尾会导致地址错乱到页首,一定要注意字节范围不能超过跨越页边沿)

•写入操作结束后,芯片进入忙状态,不响应新的读写操作(检测BUSY位重新为0时才能继续操作)

读取操作时:

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


接线图

软件模拟SPI协议可以任意接引脚,这里是接在了硬件SPI的规定引脚上,方便后续切换

//---------------------------------SPI的GPIO初始化
void MySPI_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	
	/*GPIO初始化*/
	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);					//将PA4、PA5和PA7引脚初始化为推挽输出
	
	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);					//将PA6引脚初始化为上拉输入
	
	/*设置默认电平*/
	MySPI_W_SS(1);											//SS默认高电平
	MySPI_W_SCK(0);											//SCK默认低电平,模式0
}

//------------------------------------引脚配置层

/*
  函    数:SPI写SS引脚电平
  参    数:BitValue 协议层传入的当前需要写入SS的电平,范围0~1
  注意事项:此函数需要用户实现内容,当BitValue为0时,需要置SS为低电平,当BitValue为1时,需要置SS为高电平
*/
void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);		//根据BitValue,设置SS引脚的电平
}

/*
  函    数:SPI写SCK引脚电平
  参    数:BitValue 协议层传入的当前需要写入SCK的电平,范围0~1
*/
void MySPI_W_SCK(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);		//根据BitValue,设置SCK引脚的电平
}

/*
  函    数:SPI写MOSI引脚电平
  参    数:BitValue 协议层传入的当前需要写入MOSI的电平,范围0~1
  代表主机输出给从机的数据
*/
void MySPI_W_MOSI(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);		//根据BitValue,设置MOSI引脚的电平
}

/*
  函    数:SPI读MISO引脚电平
  返 回 值:协议层需要得到的当前MISO的电平,范围0~1
  代表从机输出给主机的数据
*/
uint8_t MySPI_R_MISO(void)
{
	return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);			//读取MISO电平并返回
}


//----------------------------------------协议层
/*
起始信号标志是SS变为低电平
*/
void MySPI_Start(void)
{
	MySPI_W_SS(0);				//拉低SS,开始时序
}

/*
终止信号标志是SS变为高电平  
*/
void MySPI_Stop(void)
{
	MySPI_W_SS(1);				//拉高SS,终止时序
}

/*
  函    数:SPI交换传输一个字节(SPI模式0),前面的所有铺垫就是为了这个函数的实现
  参    数:ByteSend要发送的一个字节
  返 回 值:接收的一个字节
 
这里先后顺序为SS拉低,移出数据,SCK上升沿移入数据,SCK下降沿移出数据
在很多 SPI 硬件设计中,SS 拉低的瞬间,从机就会把移位寄存器的最高位放到 MISO 线上(即“移出数据”),主机也同步把首位放到 MOSI 上。这样,当第一个 SCK 上升沿到来时,双方同时“移入(采样)”对方的数据

这里的软件没有单独“设置传输时间”的步骤,是因为这段代码属于 软件模拟 SPI(bit-bang SPI),SCK 完全由 CPU 执行 GPIO 读写来手动翻转。

传输速度由系统时钟、每条指令需要的周期数、GPIO 操作耗时,以及从机的时序限制共同决定。 
*/
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i, ByteReceive = 0x00;				//定义接收的数据,并赋初值0x00,此处必须赋初值0x00,后面会用到
	for (i = 0; i < 8; i ++)						//循环8次,依次交换每一位数据
	{
		//两个!可以对数据进行两次逻辑取反,作用是把非0值统一转换为1,即:!!(0) = 0,!!(非0) = 1
		MySPI_W_MOSI(!!(ByteSend & (0x80 >> i)));	//使用掩码的方式取出ByteSend的指定一位数据并写入到MOSI线
		MySPI_W_SCK(1);								//拉高SCK,上升沿移出数据,从机自动读取
        
//读取MISO数据,并存储到Bytereceive变量,本身是0000 0000,读取到0就不需要修改,只需要修改读取为1的部分为1	
//当MISO为1时,置变量指定位为1,当MISO为0时,不做处理,指定位为默认的初值0
        if (MySPI_R_MISO()==1)                       
        {
            ByteReceive |= (0x80 >> i); 
        }	
		MySPI_W_SCK(0);								//拉低SCK,下降沿移入数据
	}
	
	return ByteReceive;								//返回接收到的一个字节数据
}


/*
for (i=0;i<8;i++)
{
		MySPI_W_MOSI(ByteSend & 0x80);
		ByteSend <<=1;
		MySPI_W_SCK(1);
		if (MySPI_R_MISO()==1)
          {
            ByteSend |= 0x01;
          }
        MySPI_W_SCK(0);	
        return ByteReceive;
}
*/
#include "stm32f10x.h"                  // Device header
#include "MySPI.h"
#include "W25Q64_Ins.h"

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

/**
  * 函    数:W25Q64读取ID号
  * 参    数:MID 工厂ID 8位,使用输出参数的形式返回
  * 参    数:DID 设备ID 16位,使用输出参数的形式返回
  * 返 回 值:无
  */
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_WaitBusy();           //事前等待,写入前先等待上个代码擦写完成,不忙了在写入,读取操作之前也必须使用
    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终止
}

#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等待忙,等待到busy为0
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)	//循环等待busy标志位(为1正忙)
	{
		Timeout --;								//等待时,计数值自减
		if (Timeout == 0)						//自减到0后,等待超时
		{
			/*超时的错误处理代码*/
			break;								//跳出等待
		}
	}
	MySPI_Stop();								//SPI终止
}

/*
  函    数:W25Q64页编程
  参    数:Address 页编程的起始地址,范围:0x000000~0x7FFFFF
  参    数:DataArray	用于写入数据的数组(只写一个字节太麻烦了,所以使用数组)
  参    数:Count 要写入数据的数量,范围:0~256,如果是8位,那么第256个数据写不了,所以是16位
  返 回 值:无
  注意事项:写入的地址范围不能跨页
*/
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位(例如0xABCDEF右移16位为0xAB)
	MySPI_SwapByte(Address >> 8);				//交换发送地址15~8位(例如0xABCDEF右移8位为0xCD)
	MySPI_SwapByte(Address);					//交换发送地址7~0位(例如0xABCDEF读出为0xEF)
    
    //写入数组,有i个每次写入第i个,自增
	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
  MYSPI_SwapByte()函数抛砖引玉读写交换数据
*/
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终止
}

/*------------------------宏定义指令码-------------------*/
//指令都存放在对应寄存器内,需要根据芯片手册进行查找,这里是查找后宏定义,变得直观
#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//busy在这里

#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

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

uint8_t MID;							//定义用于存放MID号的变量
uint16_t DID;							//定义用于存放DID号的变量

uint8_t ArrayWrite[] = {0x01, 0x02, 0x03, 0x04};	//定义要写入数据的测试数组
uint8_t ArrayRead[4];								//定义要读取数据的测试数组

int main(void)
{
	/*模块初始化*/
	OLED_Init();						//OLED初始化
	W25Q64_Init();						//W25Q64初始化
	
	/*显示静态字符串*/
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	/*显示ID号*/
	W25Q64_ReadID(&MID, &DID);			//获取W25Q64的ID号
	OLED_ShowHexNum(1, 5, MID, 2);		//显示MID
	OLED_ShowHexNum(1, 12, DID, 4);		//显示DID
	
	/*W25Q64功能函数测试*/
	W25Q64_SectorErase(0x000000);					//扇区擦除
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);	//将写入数据的测试数组写入到W25Q64中	
	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)
	{
		
	}
}

SPI硬件外设

•STM32内部集成了硬件SPI收发电路,可以由硬件自动执行时钟生成、数据收发等功能,减轻CPU的负担

•可配置8位/16位数据帧、高位先行/低位先行(串口是低位先行,其他一般是高位先行)

•时钟频率: fPCLK / (2, 4, 8, 16, 32, 64, 128, 256)

•可精简为半双工/单工通信

•支持DMA

•兼容I2S协议(转运音乐声音的)

•STM32F103C8T6 硬件SPI资源:SPI1、SPI2,注意SPI1挂载在APB2,时钟fPCLK是72MHz;SPI2挂载在APB1,时钟是fPCLK是36MHz

这里有非常多非常杂的功能,这里仅仅学习最基础常规的知识点,后续工程中在学习分支(遇到了再学)


硬件框图

左上角,移位寄存器缓冲区(不用多说了吧);MOSI和MISO交叉输入输出是作为从机时使用;接收缓冲区实际上就是DR(数据寄存器,写入叫TDR,读取叫RDR,公用移位寄存器,数据发送读出也是类似I2C硬件外设,会在缓冲区等待,上一个数据发送就马上进入到移位寄存器,实现连续读写,这里是全双工可以同时进行,I2C是半双工只能进行一边)

LSBFIRST控制位(帧格式)代表高低位先行顺序

SPE 使能控制

BR1 控制分频系数的标志位

MSTR 主从模式(1为主模式)

CPOL, CPHA 选择SPI四种模式

SPI_SR的TxE和RXNE很熟悉了吧,发送寄存器空和接收寄存器非空

NSS是多主机切换使用的,当NSS可以输出和输入,输出时可以告诉其他设备:我要变为主机;输入时可以接收其他信号,有一个主机并且NSS拉低时,其他设备就不能变成主机了(当前设备变成主设备时,NSS输出低电平,主机模式结束后SSOE清零,NSS变为输入)NSS输入的信号通过选择器由SSM进行路线(0为硬件NSS模式,1为软件NSS模式)SSI决定NSS是1还是0(输出还是输入)了解即可


硬件逻辑图


非连续传输(对比连续传输更加简单)

注意这里实例是模式3

等待TxE为1,写入数据到DR,等待RXNE为1并且及时读取数据(RXNE标志位需要读取之后才能清空,不读取就一直卡住;这里相当于是等一个数据完全发送,并且读取完毕之后才进行下一个数据的传输)然后才能交换第二个字节(第一个字节发送后,下一个字节没有在DR中等候,有时间间隙)

连续传输模式下,类似I2C协议,当第一个字节发送出去后,第二个字节已经会在缓存区进行等候

这里可以看出当采样频率变快,非连续传输模式下由于等待间隙就无法忽略了

软件和硬件的差异同SPI,硬件的采样时刻都是紧贴时钟沿,但是软件由于delay,所以会导致采样时刻有延迟(数据移入移出对不齐,虽然一般没什么影响)


硬件SPI代码

//库函数
void SPI_I2S_DeInit(SPI_TypeDef* SPIx);
void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
void I2S_Init(SPI_TypeDef* SPIx, I2S_InitTypeDef* I2S_InitStruct);
void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct);
void I2S_StructInit(I2S_InitTypeDef* I2S_InitStruct);
void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
void I2S_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);

void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState);
void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState);

//写DR
void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);
//读DR
uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx);

FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG);
void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG);
ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT);
void SPI_I2S_ClearITPendingBit(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT);


//其他的函数用的很少,如果需要再通过AI进行查找吧
void MySPI_W_SS(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);		//根据BitValue,设置SS引脚的电平
}

/*
函    数:SPI初始化
*/
void MySPI_Init(void)
{
	/*开启时钟*/
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);	//开启GPIOA的时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);	//开启SPI1的时钟
	
	/*GPIO初始化*/
	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);					//将PA4引脚初始化为推挽输出
	
	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);					//将PA5和PA7引脚初始化为复用推挽输出
	
	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);					//将PA6引脚初始化为上拉输入
	
	/*SPI初始化*/
	SPI_InitTypeDef SPI_InitStructure;						//定义结构体变量
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;			//模式,选择为SPI主模式
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;	//方向,选择2线全双工
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;		//数据宽度,选择为8位
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;		//先行位,选择高位先行
   
    //分频系数决定了SCK时钟线翻转的时间/频率,极性和采样点(上升下降沿)决定了数据输入输出的位置
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;	//波特率分频,选择128分频
    
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;				//SPI极性,选择默认低电平
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //SPI相位,选择第一个时钟边沿采样(移入),两者一起决定了SPI模式0
    
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;				//NSS一般是软件模拟
	SPI_InitStructure.SPI_CRCPolynomial = 7;				//CRC多项式,暂时用不到,给默认值7
	SPI_Init(SPI1, &SPI_InitStructure);						//将结构体变量交给SPI_Init,配置SPI1
	
	/*SPI使能*/
	SPI_Cmd(SPI1, ENABLE);									//使能SPI1,硬件开始运行
	
	/*设置默认电平*/
	MySPI_W_SS(1);											//SS默认高电平
}

//函数:SPI起始
void MySPI_Start(void)
{
	MySPI_W_SS(0);				//拉低SS,开始时序
}

//函数:SPI终止
void MySPI_Stop(void)
{
	MySPI_W_SS(1);				//拉高SS,终止时序
}

/*
  函    数:SPI交换传输一个字节,使用SPI模式0
  参    数:ByteSend 要发送的一个字节
  四行代码就完成了
  逻辑链是等待TxE为1,写入数据到DR,等待RXNE为1,读取数据
*/
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != SET);	//等待发送数据寄存器空
	SPI_I2S_SendData(SPI1, ByteSend);							//写入数据到发送数据寄存器,硬件自动产生时序
	
    //如果接收数据完成,那么代表发送数据也完成了(两者对称),所以可以通过接收数据寄存器来判断是否完成发送
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) != SET);	//等待接收数据寄存器非空
    //这既能收到数据,也能证明发送成功
	return SPI_I2S_ReceiveData(SPI1);								//读取接收到的数据并返回
}

/*
实际的引脚电平变化、时序产生、数据采样等全部由硬件SPI外设自动完成。软件驱动硬件完成对应的操作

这里的写入DR和读取DR会自动清零TxE和RXNE,代码刚刚好自动实现清除标志位
这里就是硬件实现交换一个字节的数据,其他的具体协议设计和之前软件部分是一模一样的
省略了引脚监听电平的函数例如void MySPI_W_MOSI(uint8_t BitValue)

你还是需要写W25Q64的操作函数,只不过实现一个字节数据的最基本的流程由软件改为了硬件实现
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);

本质上代码和硬件都只会完成最基本的操作,具体实现还是需要其他的函数进行封装
*/
posted @ 2026-11-09 06:19  narilove  阅读(13)  评论(0)    收藏  举报