SPI通信

已于 2024-07-18 21:47:02 修改
阅读量1.2k 收藏 15
点赞数 15
文章标签： 单片机 嵌入式硬件
于 2024-02-19 12:13:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hobertworker/article/details/136102480
版权

目录

一.软件简介

二.时序​编辑

三.SPI外设通信（硬件SPI）

四.代码实现

（1）软件模拟SPI

（2）硬件实现SPI

W25Q64，Flash存储芯片，内部可以存储8M字节的数据，掉电不丢失

SPI较I2C传输更快，速率取决于芯片厂商的设计需求 

硬件开销比较大，通信线个数比较多，通信过程中会有资源浪费的现象

一.软件简介

器件的标号都是一样的

 

 CPOL：极性选择，决定空闲状态SCK的默认电平

 CPHA：时钟相位，并不是单独规定上升沿采样还是下降沿采样，而是决定第一个边沿采样还是第二个边沿快速采样，即“奇数边沿”或“偶数边沿”进行采样

因此SPI支持4种通讯模式

二.时序

指令码+读写数据的模型

在SPI从机的指令手册里都会对应好指令集

 

三.SPI外设通信（硬件SPI）


8位数据帧高位先行，通信一般以字节为单位

SPI的时钟是由PCLK分频而来的

APB２的PCLK是７２ＭＨｚ，挂载了SPI１

APB１的PCLK是３６ＭＨｚ，挂载了SPI２

I２S是一种音频传输协议，可以用于将音频数据传输到DAC（数模转换器）

NSS可以使用软件模拟来进行实现 

TDR将数据写入移位寄存器，置TXE为１

移位寄存器将数据写入RDR，置RXNE为1

void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct);
void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState);
void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);//写DR数据寄存器
uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx);//读DR数据寄存器
void SPI_NSSInternalSoftwareConfig(SPI_TypeDef* SPIx, uint16_t SPI_NSSInternalSoft);//NSS引脚配置

void SPI_DataSizeConfig(SPI_TypeDef* SPIx, uint16_t SPI_DataSize);//8位或16位数据帧的配置
void SPI_BiDirectionalLineConfig(SPI_TypeDef* SPIx, uint16_t SPI_Direction);//半双工时，双向线的方向配置

四.代码实现

（1）软件模拟SPI

 MySPI.c

#include "stm32f10x.h"                  // Device header
void MySPI_W_SS(uint8_t Value)
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_4,(BitAction)Value);
}
void MySPI_W_SCK(uint8_t Value)
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_5,(BitAction)Value);
}
void MySPI_W_MOSI(uint8_t Value)
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_7,(BitAction)Value);
}
uint8_t MySPI_R_MISO_Byte(void)
{
	return GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6);
}
void MySPI_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	
	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_SwapData(uint8_t ReturnData)//模式0
{
	uint8_t i,ReceiveData = 0x00;//记得进行初始化
	for(i=0;i<8;i++)
	{
		MySPI_W_MOSI(ReturnData & (0x80 >> i));//0x80 >> i 用于挑出数据的某一位或者某几位（用于屏蔽其他位数据），该类型的数据就称之为掩码，即高位先行
		MySPI_W_SCK(1);
		if(MySPI_R_MISO_Byte() == 1){ReceiveData |= (0x80 >> i);}//高位先行
		MySPI_W_SCK(0);
	}
	return ReceiveData;
}

//下面的函数设计更加契合移位模型
//uint8_t MySPI_ReceiveData(uint8_t ReturnData)
//{
//		uint8_t i;
//		for(i=0;i<8;i++)
//		{
//			
//			MySPI_W_MOSI(ReturnData & 0x80);
//			ReturnData <<= 1;//移位模型，左移一位末尾自动补0,移出最高位，空出最低位
//			MySPI_W_SCK(1);
//			if(MySPI_R_MISO_Byte() == 1){ReturnData |= 0x01;}
//			MySPI_W_SCK(0);
//			return ReturnData;
//		}
//}

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_SwapData(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapData(W25Q64_DUMMY_BYTE);
	*DID = MySPI_SwapData(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapData(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}
void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapData(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}
void W25Q64_WAITBUSY(void)
{
	uint32_t Timeout = 1000000;
	MySPI_Start();
	MySPI_SwapData(W25Q64_READ_STATUS_REGISTER_1);
	//这里只读最低的busy位                                       
	while((MySPI_SwapData(W25Q64_DUMMY_BYTE) & 0x01) == 1)//可以连续一直读状态
	{
		Timeout --;
		if(Timeout == 0)
		{
			
			break;
		}
	}
	MySPI_Stop();
}
//这种Flag的写法不能一直读出busy的数据位
//void W25Q64_WAITBUSY(void)
//{
//	uint32_t Timeout = 1000000;
//	uint8_t Flag;
//	MySPI_Start();
//	MySPI_SwapData(W25Q64_READ_STATUS_REGISTER_1);
//	Flag = (MySPI_SwapData(W25Q64_DUMMY_BYTE) & 0x01);//这里只读最低的busy位                                       
//	while(Flag == 1)
//	{
//		Timeout --;
//		if(Timeout == 0)
//		{
//			
//			break;
//		}
//	}
//	MySPI_Stop();
//}

//c语言没有24位的数据类型，所以地址直接设置成32位既可
void W25Q64_Page_Program(uint32_t Address,uint8_t *DataArray,uint16_t count)//这里的count要设置为16位数据，页编程可以写0~256个数的数据，而8位的count只能写０～２５５
{
	uint16_t i;
	W25Q64_WriteEnable();//该函数在一条时序结束后会自动失能，会顺手关门
	
	MySPI_Start();
	MySPI_SwapData(W25Q64_PAGE_PROGRAM);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	for(i = 0; i<count; i++)
	{
		MySPI_SwapData(DataArray[i]);//这里要将数据进行交换，也就是发送出去
	}
	MySPI_Stop();
	W25Q64_WAITBUSY();//事后等待
}
//事前等待效率高，但每一个函数（写入+读取）都要加；事后等待最保险，只用在写操作函数等待即可
void W25Q64_Sector_Erase(uint32_t Address)
{
	W25Q64_WriteEnable();
	MySPI_Start();
	MySPI_SwapData(W25Q64_SECTOR_ERASE_4KB);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	MySPI_Stop();
	W25Q64_WAITBUSY();
}
void W25Q64_ReadData(uint32_t Address,uint8_t *DataReceiveArray,uint32_t count)//读取数据没有页限制，所以可以取得更大
{
	
	uint32_t i;
	MySPI_Start();
	MySPI_SwapData(W25Q64_READ_DATA);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	for(i = 0; i<count; i++)
	{
		DataReceiveArray[i] = MySPI_SwapData(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 DataArray[] = {0x00,0x01,0x02,0x04};
uint8_t DataReceiveArray[4] = {0,0,0,0};
int main()
{
	OLED_Init();
	W25Q64_Init();
	W25Q64_ReadID(&MID,&DID);
	OLED_ShowString(1,1,"MID:");
	OLED_ShowString(1,8,"DID:");
	OLED_ShowString(2,1,"D:");
	OLED_ShowString(3,1,"R:");
	OLED_ShowHexNum(1,5,MID,2);
	OLED_ShowHexNum(1,12,DID,4);
	
	W25Q64_Sector_Erase(0x000000);
	W25Q64_Page_Program(0x000000,DataArray,4);//写入数据不能跨页
	
	W25Q64_ReadData(0x000000,DataReceiveArray,4);//读取数据可以跨页
	
	OLED_ShowHexNum(2,3,DataArray[0],2);
	OLED_ShowHexNum(2,6,DataArray[1],2);
	OLED_ShowHexNum(2,9,DataArray[2],2);
	OLED_ShowHexNum(2,12,DataArray[3],2);
	
	OLED_ShowHexNum(3,3,DataReceiveArray[0],2);
	OLED_ShowHexNum(3,6,DataReceiveArray[1],2);
	OLED_ShowHexNum(3,9,DataReceiveArray[2],2);
	OLED_ShowHexNum(3,12,DataReceiveArray[3],2);
	while(1)
	{

		
	}	
}

（2）硬件实现SPI

 MySPI.c

#include "stm32f10x.h"                  // Device header
void MySPI_W_SS(uint8_t Value)
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_4,(BitAction)Value);
}

void MySPI_Init(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	SPI_InitTypeDef SPI_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);

	
	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_IPU;//主机输入引脚为上拉输入
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_6;
	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);
	
	SPI_InitStructure.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_128;
	SPI_InitStructure.SPI_CPHA=SPI_CPHA_1Edge;//第一个边沿开始采样，CPHA=0
	SPI_InitStructure.SPI_CPOL=SPI_CPOL_Low;//设置SCK空闲默认低电平
	SPI_InitStructure.SPI_CRCPolynomial=7;
	SPI_InitStructure.SPI_DataSize=SPI_DataSize_8b;//8为数据帧
	SPI_InitStructure.SPI_Direction=SPI_Direction_2Lines_FullDuplex;//双线全双工，该参数配置SPI裁剪引脚
	SPI_InitStructure.SPI_FirstBit=SPI_FirstBit_MSB;
	SPI_InitStructure.SPI_Mode=SPI_Mode_Master;//设置设备为主机或从机
	SPI_InitStructure.SPI_NSS=SPI_NSS_Soft;//软件NSS
	SPI_Init(SPI1,&SPI_InitStructure);
	
	SPI_Cmd(SPI1,ENABLE);
	
	MySPI_W_SS(1);//默认设置SCK为高电平，不选择为从机

}
void MySPI_Start(void)
{
	MySPI_W_SS(0);
}
void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}
uint8_t MySPI_SwapData(uint8_t ReturnData)//模式0
{
	while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE) != SET);//TXE会在写入数据后自动清除
	
	SPI_I2S_SendData(SPI1,ReturnData);//数据转移到移位寄存器，会自动生成波形
	
	while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE) != SET);//RXNE会在读取数据后自动清除
	
	return SPI_I2S_ReceiveData(SPI1);
}

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_SwapData(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapData(W25Q64_DUMMY_BYTE);
	*DID = MySPI_SwapData(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapData(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}
void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapData(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}
void W25Q64_WAITBUSY(void)
{
	uint32_t Timeout = 1000000;
	MySPI_Start();
	MySPI_SwapData(W25Q64_READ_STATUS_REGISTER_1);
	//这里只读最低的busy位                                       
	while((MySPI_SwapData(W25Q64_DUMMY_BYTE) & 0x01) == 1)//可以连续一直读状态
	{
		Timeout --;
		if(Timeout == 0)
		{
			
			break;
		}
	}
	MySPI_Stop();
}
void W25Q64_Page_Program(uint32_t Address,uint8_t *DataArray,uint16_t count)//这里的count要设置为16位数据，页编程可以写0~256个数的数据，而8位的count只能写０～２５５
{
	uint16_t i;
	W25Q64_WriteEnable();//该函数在一条时序结束后会自动失能，会顺手关门
	
	MySPI_Start();
	MySPI_SwapData(W25Q64_PAGE_PROGRAM);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	for(i = 0; i<count; i++)
	{
		MySPI_SwapData(DataArray[i]);//这里要将数据进行交换，也就是发送出去
	}
	MySPI_Stop();
	W25Q64_WAITBUSY();//事后等待
}
void W25Q64_Sector_Erase(uint32_t Address)
{
	W25Q64_WriteEnable();
	MySPI_Start();
	MySPI_SwapData(W25Q64_SECTOR_ERASE_4KB);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	MySPI_Stop();
	W25Q64_WAITBUSY();
}
void W25Q64_ReadData(uint32_t Address,uint8_t *DataReceiveArray,uint32_t count)//读取数据没有页限制，所以可以取得更大
{
	
	uint32_t i;
	MySPI_Start();
	MySPI_SwapData(W25Q64_READ_DATA);
	MySPI_SwapData(Address>>16);
	MySPI_SwapData(Address>>8);
	MySPI_SwapData(Address);
	for(i = 0; i<count; i++)
	{
		DataReceiveArray[i] = MySPI_SwapData(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 DataArray[] = {0x00,0x01,0x02,0x04};
uint8_t DataReceiveArray[4] = {0,0,0,0};
int main()
{
	OLED_Init();
	W25Q64_Init();
	W25Q64_ReadID(&MID,&DID);
	OLED_ShowString(1,1,"MID:");
	OLED_ShowString(1,8,"DID:");
	OLED_ShowString(2,1,"D:");
	OLED_ShowString(3,1,"R:");
	OLED_ShowHexNum(1,5,MID,2);
	OLED_ShowHexNum(1,12,DID,4);
	
	W25Q64_Sector_Erase(0x000000);
	W25Q64_Page_Program(0x000000,DataArray,4);//写入数据不能跨页
	
	W25Q64_ReadData(0x000000,DataReceiveArray,4);//读取数据可以跨页
	
	OLED_ShowHexNum(2,3,DataArray[0],2);
	OLED_ShowHexNum(2,6,DataArray[1],2);
	OLED_ShowHexNum(2,9,DataArray[2],2);
	OLED_ShowHexNum(2,12,DataArray[3],2);
	
	OLED_ShowHexNum(3,3,DataReceiveArray[0],2);
	OLED_ShowHexNum(3,6,DataReceiveArray[1],2);
	OLED_ShowHexNum(3,9,DataReceiveArray[2],2);
	OLED_ShowHexNum(3,12,DataReceiveArray[3],2);
	while(1)
	{

		
	}	
}

注：

五.QSPI通讯协议

上图是QSPI传输Flash设备

QSPI可以去查看具体的手册

4线传输

QSPI也可以实现标准的SPI功能

Akebi.h
关注
SPI通讯
友谊的博客
01-02 1537
本章可与I2C章节对比阅读，体会两种通讯总线差异。本章主要对SPI物理层和协议层进行总结。
2016.12.02_SPI通信方式的使用总结
热门推荐
我夏了夏天的技术博客
12-23 1万+
最近工作中使用了SPI通信方式来做TM4C129和STM32之间的通信，为了更好地解决问题就学习了SPI原理的相关内容，完成了项目之后，也对这种通信方式有了较为深入的了解，现在来对SPI的使用方法进行详细的总结。
SPI通信协议
最新发布
Hungry_11的博客
03-28 2329
SPI 是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola(摩托罗拉)首先在其MC68HCXX系列处理器上定义的。SPI，是一种高速的，全双工同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI分为主、从两种模式，一个SPI通讯系统需要包含一个（且只能是一个）主设备。
SPI 通信
logan
02-04 3509
一.简介 串行外围设备接口（SPI：Serial Peripheral Interface）总线是由Motorola开发的，用于在从设备之间提供全双工同步串行通信。 SPI总线通常用于与闪存，传感器，实时时钟（RTC），模数转换器等进行通信。SPI是一主多从的总线。 标准SPI主机通过SCK，MOSI，MISO和SS线与从机通信。 从站可以共享SCK，MOSI和MISO信号，而每个从站都有唯一的SS线，SS在SPI中与其他总线协议中的从机地址具有同样的功能。 SPI优点 支持全双工通信，通信简单，数据
STC8单片机硬件SPI通信例程W25Q16
09-13
STC8单片机是一种高性能的8051系列单片机，它支持硬件SPI通信，这种通信方式在数据传输中非常高效。W25Q16是一种常用的Flash存储芯片，其容量为16Mbit（即2MB），在嵌入式系统中经常被用作程序存储器或数据存储器。 ...
用C语言实现SPI通信协议
05-04
在C语言环境中，实现SPI通信涉及到对硬件寄存器的操作、时序控制以及数据帧格式的理解。FPGA（Field-Programmable Gate Array）作为可编程逻辑器件，可以通过配置来实现SPI主设备或从设备的功能。 SPI协议的基本...
FPGA的spi通信_FPGA的SPI通信
07-15
首先，SPI通信的核心组件包括主设备（Master）和从设备（Slave）。在FPGA作为主设备的配置下，它将控制通信的时序，而从设备则响应主设备的命令。SPI协议通常有四种模式，根据时钟极性和相位的不同组合（CPOL和CPHA...
基于FPGA的spi通信接口设计，quartusii开发，包括仿真结果截图，说明文档等
05-05
标题中的“基于FPGA的spi通信接口设计，quartusii开发”指的是使用Field Programmable Gate Array（FPGA）进行SPI（Serial Peripheral Interface）通信接口的设计，并利用Altera的Quartus II软件作为开发工具。...
SPI通信（简单入门）
03-15
简单实用的SPI通信教程
SPI 通信程序
09-21
SPI 通信 程序
SPI通信-（STM32）
aloneboyooo的博客
01-02 1440
非易失性存储器一般为Flash（Nor Flash、Nand Flash）、EEPROM。易失性存储器一般为SRAM、DRAM。固件程序存储为XIP（eXecute in Place）：直接把程序文件下载到外挂芯片中，需要执行程序时，直接读取外挂文件的程序芯片进行执行。就地执行，比如电脑里的BIOS固件。双重SPI和四重SPI，利用总线线束进行多根一起收发（MISO、MOSI、WP写保护、HOLD），提高通信速率。寻址为24bit，
CC2430芯片的SPI通信实现方法
除了上述直接知识点，从代码片段中还可以推测一些隐藏知识点，例如SPI通信的初始化设置、SPI模式的选择（例如CPOL和CPHA）、SPI通信的中断处理、错误检测与处理机制、SPI通信的效率优化措施等。 8. **编程实践**： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值