STM32—SPI通信

于 2024-08-12 17:32:24 发布
阅读量856 收藏 9
点赞数 15
分类专栏： STM32标准库学习笔记 文章标签： stm32 嵌入式硬件 单片机 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80427506/article/details/141129460
版权

1.SPI简介

四根通信线：SCK(Serial Clock)(时钟线)、MOSI(Master Output Slave Input)、MISO(Master Input Slave Output)、SS(Slave Select)

同步、全双工

支持总线挂载多设备（一主多从）

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

主机另外引出多条SS控制线（低电平有效），分别接到各从机的SS引脚

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

 

2.SPI时序基本单元 

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

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

 

交换一个字节（模式0）

CPOL = 0：空闲状态，SCK为低电平

CPHA = 0：SCK第一个边沿移入数据，第二个边沿移出数据 

交换一个字节（模式1）

CPOL = 0：空闲状态，SCK为低电平

CPHA = 1：SCK第一个边沿移出数据，第二个边沿移入数据

交换一个字节（模式2）

CPOL = 1：空闲状态，SCK为高电平

CPHA = 0：SCK第一个边沿移入数据，第二个边沿移出数据

 

交换一个字节（模式3）

CPOL = 1：空闲状态，SCK为高电平

CPHA = 1：SCK第一个边沿移出数据，第二个边沿移入数据

3.SPI外设简介

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

可配置8位/16位数据帧、高位先行/低位先行

时钟频率：f_{PCLK} / （2，4，8，16，32，64，128，256）

支持多主机模型、主或从模式

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

支持DMA

兼容I2S协议

 

4.SPI基本结构

 

 

 

5.SPI相关标准库函数简介

//恢复缺省配置
void SPI_I2S_DeInit(SPI_TypeDef* SPIx);

//初始化
void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);

//给结构体变量默认值
void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct);

//SPI使能
void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);

//中断使能
void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState);

//DMA使能
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);

6.案例

6.1软件SPI读写W25Q64

#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 ByteReceive = 0x00;
	
	for(uint8_t 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;
}

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

//	return ByteReceive;
//}


#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 = 100000;
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
	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 Cout)
{
	W25Q64_WriteEnable();
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
	MySPI_SwapByte(Address  >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for (uint16_t i = 0;i < Cout;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 Cout)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_DATA);
	MySPI_SwapByte(Address  >> 16);
	MySPI_SwapByte(Address >> 8);
	MySPI_SwapByte(Address);
	for(uint32_t i = 0;i < Cout;i++)
	{
		DataArray[i] = 	MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	}
	MySPI_Stop();
}

6.2硬件SPI读写W25Q64

#include "stm32f10x.h"                  // Device header

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


void MySPI_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
	
	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);

	SPI_InitTypeDef SPI_InitStructure;
	//SPI模式
	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
	//配置SPI裁剪引脚,当前选择为双线全双工
	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
	//配置8位还是16位数据帧
	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
	//选择低位先行还是高位先行
	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
	//波特率预分频器，配置SCK时钟的频率
	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
	//配置SPI模式
	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
	//配置SPI模式
	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
	//CRC校验,当前所给为默认值
	SPI_InitStructure.SPI_CRCPolynomial = 7;
	SPI_Init(SPI1,&SPI_InitStructure);
	
	SPI_Cmd(SPI1,ENABLE);
	
	MySPI_W_SS(1);
}

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

void MySPI_Stop(void)
{
	MySPI_W_SS(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);
}
尘️
关注
专栏目录
STM32入门教程：SPI通信
2401_85625565的博客
07-30 1001
SPI（Serial Peripheral Interface）是一种常用的串行通信协议，用于实现芯片之间的通信。在本教程中，我们将介绍如何使用STM32微控制器进行SPI通信。
STM32基础（14）SPI通信
神奇的大喵
11-23 2137
原理 SPI介绍 SPI（Serial Peripheral Interface）串行外围接口，是一种高速、全双工、同步的通信总线，并且在芯片的管脚上只占用四根线，出于简单易用的特性，被越来越多的芯片集成，比如 STM32 系列芯片。 SPI总线包括4条逻辑线： MISO：Master input slave output MOSI：Master output slave input SCLK ：Serial Clock 串行时钟信号线，由主机产生，发送给从机 SS：Slave Selec
STM32之间的SPI通信
08-18
两个STM32之间进行SPI通信，望对你有帮助
STM32——SPI通信
NRWHF的博客
03-12 4180
STM32——SPI通信
基于 STM32 的 SPI 通讯
12-01
基于 STM32 的 SPI 通信，使用 keil 编译
CEPARK-IAR_Stm32Spi.rar_stm32SPI通信_stm32spi
09-21
本文将深入探讨STM32 SPI通信的基本原理以及如何在实际项目中实现。 首先，SPI通信协议是基于主从模式的全双工通信方式，由一个主设备控制数据传输方向，多个从设备通过共享总线接收或发送数据。在STM32中，SPI可以...
stm32 spi双机通信
07-24
在SPI通信中，通常有一个主机（Master）和一个或多个从机（Slave）。主机控制时钟信号（SCK），并决定数据传输的方向和时机。从机则根据主机的时钟信号响应数据传输。在双机通信中，两台STM32设备都可以既是主机又是...
STM32 F103SPI双机通信(中断方式)
10-15
1. **SPI通信协议基础** SPI是一种同步、全双工的串行通信协议，通常由主设备控制时钟和通信过程。它有四个主要信号线：SCLK（时钟）、MISO（主输入/从输出）、MOSI（主输出/从输入）和NSS（片选，也称为CS）。在...
STM32 SPI通信
09-29
STM32 SPI通信是嵌入式系统中常用的一种串行通信协议，由意法半导体（STMicroelectronics）的STM32微控制器支持。SPI（Serial Peripheral Interface）是一种全双工、同步、串行通信接口，它允许主机（Master）与一个...
STM32中SPI通讯
08-24
经过本人测试，程序可以正常运行，可以在STM32控制器上实现SPI的接收与发送。
STM32 SPI双机通信.zip_STM32 SPI从机_stm32 spi 主从机_stm32F0 SPI_stm32双机通
07-15
stm32f0使用spi实现主从通讯,可以实现主主机发送和从机发送
STM32之间SPI通信
chouchaos的专栏
07-18 4554
这几天实验室比较忙，所以博客这边停了一下，继续吧。     继串口中断后，大家可以尝试单片机间串口通信，这里就不再多赘述。串口完了之后，我接着学的就是SPI通信了，作为hello moto公司推出的这种4线全双工通信，很节约PCB布局空间，比I2C在硬件上要简单许多，但缺点就是没有指定的流控制，没有应答机制来确定信号收到与否。     话不多说，上程序最有助理解。下面是SPI通信的发送端的SP
STM32单片机SPI通信详解
最新发布
TENET123的博客
06-21 1959
SPI是一种串行同步通信协议。它通过四根通信线（SCK、MOSI、MISO、SS）进行数据传输。和I2C一样，都是实现主控芯片和外挂芯片之间的数据交流。
STM32 SPI 通信
weixin_30810583的博客
06-12 150
SPI是英语SerialPeripheralinterface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时...
16 玩转STM32之SPI通信
南山府的博客
11-03 3581
1、发送数据：数据字节在写周期内被并行加载到发送缓冲区中，当从器件收到时钟信号和数据的高有效位时，开始发送数据。SPI_SR 寄存器中的TXE 标志在数据从发送缓冲区传输到移位寄存器时置 1，并且在SPI_CR2 寄存器中的 TXEIE 位置 1 时将生成中断。
STM32（十）------- SPI通信
07-29 2738
在万物互联时代，“通信”对物联网尤为重要。在单片机或嵌入式开发领域，几乎很少有一个硬件单独就能实现所有功能的，即使是单片机裸机开发，往往也需要与传感器进行通信。 SPI可以说是我们在嵌入式开发中，最常用的通信协议之一，本文将来介绍什么是SPI协议l，SPI协议的特点是什么，怎么用SPI协议。......
STM32—SPI通信（上）
2301_76477939的博客
09-02 1664
一、SPI通信协议 SPI 为全双工 SPI共有四根通信线：SCK（串行时钟线）、MOSI（主机输出从机输入）、MISO（主机输入从机输出）、SS（从机选择）。 1.1、硬件电路 所有SPI设备的SCK、MOSI、MISO分别连在一起 主机另外引出多条SS控制线，分别接到各从机的SS引脚 输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入 SPI通信线为单端信号，器电平高低都是相对GND的电压差，因此所有设备需共地。 1.2、SPI 数据传输流程 在时钟驱动（波特率发生器）下，SPI主
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值