• 第十五篇，STM32的SPI串行通信协议

    1.SPI概念

    spi是摩托罗拉公司设计的用于板间的串行通信方式，应用场景类似于IIC，速度快于IIC。

    spi属于高速，全双工，同步的通信总线；和设备连接占用4根线，比较占用引脚，速度最快达到40Mbps。

    2.硬件连接

    CS(chip select):片选引脚

    主设备控制,用于选择当前通信的从设备 ,  一个 Slave 设备要想能够接收到 Master 发过来的控制信号, 必须在此之前能够被 Master 设备进行访问 (Access),所以, Master 设备必须首先通过 CS对 Slave 设备进行片选, 把想要访问的 Slave 设备选上.

    SCLK:时钟线

    产生时钟信号，由主设备控制

    MISO(Master Input Slave output)

    主设备输入，从设备输出

    MOSI(Master Output Slave Input)

    主设备输出，从设备输入（MISO和MOSI实现全双工）

    3.spi协议

     

    spi每一位数据的发送和接收是在时钟信号的边沿完成，根据选择的上升沿/下降沿和时钟信号的高低电平顺序，一共有4种情况。


    CPOL表示高低电平顺序，叫做极性；若CPOL = 0，串行同步时钟的空闲状态为低电平；

    若CPOL = 1，串行同步时钟的空闲状态为高电平；

    CPHA表示第一个/第二个边沿，叫做相位。

    SPI输出串行同步时钟极性和相位可以根据外设工作要求进行配置。 SPI 设备间的数据传输又被称为数据交换, 是因为 SPI 协议规定一个 SPI 设备不能在数据通信过程中仅仅只充当一个 "发送者(Transmitter)" 或者 "接收者(Receiver)". 在每个 Clock 周期内, SPI 设备都会发送并接收一个 bit 大小的数据, 相当于该设备有一个 bit 大小的数据被交换了.

        

    分别是以下四种情况：

    MODE0：CPOL= 0，CPHA=0。串行时钟SCLK空闲状态时为低电平，数据在SCLK时钟的上升沿采样，下降沿输出；

    MODE1：CPOL= 0，CPHA=1。串行时钟SCLK空闲状态时为低电平，数据在SCLK时钟的下降沿采样，上升沿输出；

    MODE2：CPOL= 1，CPHA=0。串行时钟SCLK空闲状态时为高电平，数据在SCLK时钟的下降沿采样，上升沿输出；

    MODE3：CPOL= 1，CPHA=1。串行时钟SCLK空闲状态时为高电平，数据在SCLK时钟的上升沿采样，下降沿输出；

     

     起始信号

    NSS信号线由高变低，是SPI通讯的起始信号
     结束信号

    NSS信号由低变高，是SPI通讯的停止信号
     数据传输

    SPI使用MOSI以及MISO信号来传输数据，使用SCK信号线进行数据同步。

    MOSI及MISO数据线在SCK的每个时钟周期传输一位数据，且数据输入输出时同时进行的。

    SPI每次传输数据可以8位或16位为单位，每次传输的单位数不受限制
     


     

    4.spi flash

    原理图：

     

    spi接口的CS连接到了PB14，SCLK，MISO，MOSI分别连接到了PB3 PB4 PB5，这三个IO口具有SPI的复用功能。

    5.spi通信的实现（两种方法）

    （1）使用GPIO接口模拟SPI的时序，只要是IO口即可以使用。

    （2）使用SPI控制器，只需要配置好SPI的通信参数后，直接进行传输，接口必须有SPI复用功能。

    6.spi控制器的库函数编程

     

    添加spi的库函数源码：

    （1）开启时钟

    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);

    （2）将GPIO配置为SPI复用功能(CS配置为输出)

    GPIO_Init(...); GPIO_AFPinConfig(...);

    （3）初始化SPI

    1. void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
    2.  参数： 
    3.           SPIx - 哪个SPI
    4.           SPI_InitStruct - SPI初始化结构
    5.  typedef struct
    6.  {
    7.  uint16_t SPI_Direction; /*!< 传输方向 单向/双向 @ref SPI_data_direction */ 
    8. uint16_t SPI_Mode; /*!< 主/从设备选择 @ref SPI_mode */ 
    9. uint16_t SPI_DataSize; /*!< 数据位长度 @ref SPI_data_size */ 
    10. uint16_t SPI_CPOL; /*!< 极性 @ref SPI_Clock_Polarity */ 
    11. uint16_t SPI_CPHA; /*!< 相位 @ref SPI_Clock_Phase */ 
    12. uint16_t SPI_NSS; /*!< 片选信号选择 软件/硬件 @ref SPI_Slave_Select_management */ 
    13. uint16_t SPI_BaudRatePrescaler; /*!< 参考时钟的预分频系数 10M左右*/ 
    14. uint16_t SPI_FirstBit; /*!< 传输位顺序 高位/低位 @ref SPI_MSB_LSB_transmission */ 
    15. uint16_t SPI_CRCPolynomial; /*!< CRC校验，无需配置 */
    16.  }SPI_InitTypeDef;

    （4）使能SPI

    SPI_Cmd(...);

    （5）使用SPI传输数据

    //发送和接收同时进行 void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data); uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx);

    （6）查询SPI传输状态

    1. FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG); 
    2. 参数： 
    3. * @arg SPI_I2S_FLAG_TXE: Transmit buffer empty flag. 
    4. * @arg SPI_I2S_FLAG_RXNE: Receive buffer not empty flag. 
    5. * @arg SPI_I2S_FLAG_BSY: Busy flag. 
    6. * @arg SPI_I2S_FLAG_OVR: Overrun flag. 
    7. * @arg SPI_FLAG_MODF: Mode Fault flag. 
    8. * @arg SPI_FLAG_CRCERR: CRC Error flag. 
    9. * @arg SPI_I2S_FLAG_TIFRFE: Format Error. 
    10. * @arg I2S_FLAG_UDR: Underrun Error flag. 
    11. * @arg I2S_FLAG_CHSIDE: Channel Side flag.

    7.W25Q128芯片

    （1）接口和状态寄存器

    CS WP HOLD低电平有效，WP和HOLD接VCC，功能关闭，片选是低电平选中。

    SPI接口支持CPOL和CPHA为0，0和1，1的模式

     

    （2）操作时序

    在进行任何操作前开启片选，操作完成后关闭片选。

    1）读设备ID

    发送90H ===> 发送24位0地址 ===> 收到厂家ID(0xef)和设备ID(0x17)

    *************************************************************************************************************

    //代码实现W25Q128芯片的SPI通信

    //功能函数

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. void spi1_init(void)
    7. {
    8. 	GPIO_InitTypeDef GPIO_InitStruct;
    9. 	SPI_InitTypeDef SPI_InitStruct;
    10. 	
    11. 	//1.开始时钟
    12. 	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
    13. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
    14. 	
    15. 	//2.配置GPIO为SPI功能
    16. 	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;//输出模式
    17. 	GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;//推挽输出
    18. 	GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;//高速
    19. 	GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;//无上下拉
    20. 	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_14;//PB14
    21. 	GPIO_Init(GPIOB,&GPIO_InitStruct);
    22. 	
    23. 	//片选关闭
    24. 	W25Q128_CS = 1;
    25. 	
    26. 	GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;//复用模式
    27. 	GPIO_InitStruct.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5;//PB3 PB4 PB5
    28. 	GPIO_Init(GPIOB,&GPIO_InitStruct);
    29. 	
    30. 	GPIO_PinAFConfig(GPIOB,GPIO_PinSource3,GPIO_AF_SPI1);
    31. 	GPIO_PinAFConfig(GPIOB,GPIO_PinSource4,GPIO_AF_SPI1);
    32. 	GPIO_PinAFConfig(GPIOB,GPIO_PinSource5,GPIO_AF_SPI1);
    33. 	
    34. 	
    35. 	//3.SPI初始化
    36. 	SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//双向全双工
    37. 	SPI_InitStruct.SPI_Mode = SPI_Mode_Master;//主设备
    38. 	SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;//数据长度8位
    39. 	SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;//极性 mode 0
    40. 	SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;//相位 mode 0
    41. 	SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;//软件片选
    42. 	SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;//APB2总线时钟 84M/16分频 = 5.25M
    43. 	SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;//高位先出
    44. 	SPI_Init(SPI1,&SPI_InitStruct);
    45. 	
    46. 	//4.使能SPI1
    47. 	SPI_Cmd(SPI1,ENABLE);
    48. }
    49.  
    50. //发送接收数据 ----- 同时进行
    51. //data是要发送的数据，返回接收的数据
    52. u8 spi1_send_recv_byte(u8 data)
    53. {
    54. 	//等待发送缓冲区为空
    55. 	while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE)!=SET);
    56. 	//发送数据
    57. 	SPI_I2S_SendData(SPI1,data);
    58. 	//等待接收缓冲区非空
    59. 	while(SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE)!=SET);
    60. 	//接收数据
    61. 	return SPI_I2S_ReceiveData(SPI1);
    62. }
    63.  
    64. //读取W25Q128的ID
    65. u16 w25q128_read_id(void)
    66. {
    67. 	u16 id = 0;
    68. 	
    69. 	//片选选中
    70. 	W25Q128_CS = 0;
    71. 	
    72. 	//发送90H
    73. 	spi1_send_recv_byte(0x90);
    74. 	//发送24位0地址
    75. 	spi1_send_recv_byte(0x00);
    76. 	spi1_send_recv_byte(0x00);
    77. 	spi1_send_recv_byte(0x00);
    78. 	
    79. 	//接收厂家ID放在高8位
    80. 	id |= spi1_send_recv_byte(0xff)<<8;
    81. 	//接收设备ID放在低8位
    82. 	id |= spi1_send_recv_byte(0xff);
    83. 	
    84. 	//片选关闭
    85. 	W25Q128_CS = 1;
    86. 	
    87. 	return id;
    88. }
    89.  
    90. //读取W25Q128的数据
    91. void w25q128_read_data(u32 addr,u8 *data,u8 len)
    92. {
    93. 	//片选选中
    94. 	W25Q128_CS = 0;
    95. 	
    96. 	//发送03H
    97. 	spi1_send_recv_byte(0x03);
    98. 	//发送24位读的地址，高位先出
    99. 	spi1_send_recv_byte((addr>>16)&0xff);//16~23位
    100. 	spi1_send_recv_byte((addr>>8)&0xff);//8~15位
    101. 	spi1_send_recv_byte((addr>>0)&0xff);//0~7位
    102. 	
    103. 	//读取数据
    104. 	while(len--){
    105. 		*data++ = spi1_send_recv_byte(0xff);
    106. 	}
    107. 	
    108. 	//片选关闭
    109. 	W25Q128_CS = 1;
    110. }
    111.  
    112. //开启/关闭写使能  enable = 0 开启写使能  enable = 1 关闭写使能
    113. void w25q128_write_enable_disable(u8 enable)
    114. {
    115. 	//片选选中
    116. 	W25Q128_CS = 0;
    117. 	
    118. 	if(enable){
    119. 		spi1_send_recv_byte(0x04);
    120. 	}
    121. 	else{
    122. 		spi1_send_recv_byte(0x06);
    123. 	}
    124. 	
    125. 	//片选关闭
    126. 	W25Q128_CS = 1;
    127. }
    128.  
    129. //读状态寄存器1
    130. u8 w25q128_read_status(void)
    131. {
    132. 	u8 status = 0;
    133. 	
    134. 	//片选选中
    135. 	W25Q128_CS = 0;
    136. 	
    137. 	//发送05H
    138. 	spi1_send_recv_byte(0x05);
    139. 	
    140. 	status = spi1_send_recv_byte(0xff);
    141. 	
    142. 	//片选关闭
    143. 	W25Q128_CS = 1;
    144. 	
    145. 	return status;
    146. }
    147.  
    148. //扇区擦除
    149. void w25q128_sector_erase(u32 addr)
    150. {
    151. 	//开启写使能
    152. 	w25q128_write_enable_disable(0);
    153. 	
    154. 	//延时,让片选信号保持一段时间,使W25Q128感受到
    155. 	delay_us(50);
    156. 	
    157. 	//片选选中
    158. 	W25Q128_CS = 0;
    159. 	
    160. 	//发送20H
    161. 	spi1_send_recv_byte(0x20);
    162. 	
    163. 	//发送24位擦除地址，高位先出
    164. 	spi1_send_recv_byte((addr>>16)&0xff);//16~23位
    165. 	spi1_send_recv_byte((addr>>8)&0xff);//8~15位
    166. 	spi1_send_recv_byte((addr>>0)&0xff);//0~7位
    167. 	
    168. 	//片选关闭
    169. 	W25Q128_CS = 1;
    170. 	
    171. 	delay_us(50);
    172. 	
    173. 	//等待擦除完成
    174. 	while(w25q128_read_status()&0x1){
    175. 		//1ms查询一次
    176. 		delay_ms(1);
    177. 	}
    178. 	
    179. 	delay_us(50);
    180. 	
    181. 	//关闭写使能
    182. 	w25q128_write_enable_disable(1);
    183. }
    184.  
    185. //写数据(按页)
    186. void w25q128_write_page(u32 addr,u8 *data,u8 len)
    187. {
    188. 	//开启写使能
    189. 	w25q128_write_enable_disable(0);
    190. 	
    191. 	//延时,让片选信号保持一段时间,使W25Q128感受到
    192. 	delay_us(50);
    193. 	
    194. 	//片选选中
    195. 	W25Q128_CS = 0;
    196. 	
    197. 	
    198. 	//发送02H
    199. 	spi1_send_recv_byte(0x02);
    200. 	
    201. 	//发送24位写地址，高位先出
    202. 	spi1_send_recv_byte((addr>>16)&0xff);//16~23位
    203. 	spi1_send_recv_byte((addr>>8)&0xff);//8~15位
    204. 	spi1_send_recv_byte((addr>>0)&0xff);//0~7位
    205. 	
    206. 	//发送写的数据
    207. 	while(len--){
    208. 		spi1_send_recv_byte(*data++);
    209. 	}
    210. 	
    211. 	//片选关闭
    212. 	W25Q128_CS = 1;
    213. 	
    214. 	delay_us(50);
    215. 	
    216. 	//等待写完成
    217. 	while(w25q128_read_status()&0x1){
    218. 		//1ms查询一次
    219. 		delay_ms(1);
    220. 	}
    221. 	
    222. 	delay_us(50);
    223. 	
    224. 	//关闭写使能
    225. 	w25q128_write_enable_disable(1);
    226. }
    227.  
    228. void flash_write_temp(u8 temp)
    229. {
    230. 	u8 buf[16] = {0},i,data = 0;
    231. 	u32 addr = 0;
    232. 	
    233. 	//找到未被写过的块
    234. 	while(1){
    235. 		w25q128_read_data(addr,buf,16);
    236. 		if(buf[0]!=0x55)
    237. 			break;
    238. 		
    239. 		addr += 16;
    240. 	}
    241. 	
    242. 	data = 0x55;
    243. 	//写入0x55
    244. 	w25q128_write_page(addr,&data,1);
    245. 	//写入temp
    246. 	w25q128_write_page(addr+1,&temp,1);
    247. 	
    248. 	data = 0;
    249. 	//求校验和
    250. 	w25q128_read_data(addr,buf,16);
    251. 	for(i=0;i<15;i++){
    252. 		data = (data + buf[i])&0xff;
    253. 	}
    254. 	
    255. 	//写入校验和
    256. 	w25q128_write_page(addr+15,&data,1);
    257. }
    258.  
    259. void flash_read_temp(void)
    260. {
    261. 	u8 buf[16] = {0},i,data;
    262. 	u32 addr = 0;
    263. 	
    264. 	//找出所有写入温度的块
    265. 	while(1){
    266. 		data = 0;
    267. 		w25q128_read_data(addr,buf,16);
    268. 		if(buf[0]!=0x55)
    269. 			break;
    270. 		
    271. 		//求校验和
    272. 		for(i=0;i<15;i++){
    273. 			data = (data + buf[i])&0xff;
    274. 		}
    275. 		
    276. 		if(data!=buf[15]){
    277. 			printf("checksum error!data = %#x,buf[15] = %#x\r\n",data,buf[15]);
    278. 			break;
    279. 		}
    280. 		
    281. 		printf("0x%x temp = %d\r\n",addr,buf[1]);
    282. 		
    283. 		addr += 16;
    284. 	}
    285. }

    //头文件声明

    1. #ifndef _SPI_FLASH_H_
    2. #define _SPI_FLASH_H_
    3.  
    4. #include 
    5.  
    6. #define W25Q128_CS PBout(14) 
    7.  
    8. void spi1_init(void);
    9. u16 w25q128_read_id(void);
    10. void w25q128_read_data(u32 addr,u8 *data,u8 len);
    11. void w25q128_sector_erase(u32 addr);
    12. void w25q128_write_page(u32 addr,u8 *data,u8 len);
    13.  
    14. void flash_write_temp(u8 temp);
    15. void flash_read_temp(void);
    16.  
    17. #endif

  • 相关阅读:
    JAVA 多态
    Spring Security-基于表达式的访问控制和基于注解的访问控制
    C# 向us7ascii编码的oracle数据库插入中文数据？？？？问号乱码的解决方案
    k8s之pod控制器
    Spring web security
    使用gitflow时如何合并hotfix
    QGC 飞行模式控制流程分析
    Elasticsearch 7和Elastic Stack：深入实践
    【硅谷创业公司招聘】openai 亚马逊投资的创业公司招聘远程全栈工程师
    Element UI打开表单自动验证问题的解决
  • 原文地址：https://blog.csdn.net/weixin_44651073/article/details/125832907