devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

STM32—SPI通信_stm32 spi模式3

作者：运维做开发 | 2024-08-16 19:11:28

赞

踩

stm32 spi模式3

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相关标准库函数简介

  1. //恢复缺省配置
  2. void SPI_I2S_DeInit(SPI_TypeDef* SPIx);
  3.  
  4. //初始化
  5. void SPI_Init(SPI_TypeDef* SPIx, SPI_InitTypeDef* SPI_InitStruct);
  6.  
  7. //给结构体变量默认值
  8. void SPI_StructInit(SPI_InitTypeDef* SPI_InitStruct);
  9.  
  10. //SPI使能
  11. void SPI_Cmd(SPI_TypeDef* SPIx, FunctionalState NewState);
  12.  
  13. //中断使能
  14. void SPI_I2S_ITConfig(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT, FunctionalState NewState);
  15.  
  16. //DMA使能
  17. void SPI_I2S_DMACmd(SPI_TypeDef* SPIx, uint16_t SPI_I2S_DMAReq, FunctionalState NewState);
  1. //写DR数据寄存器
  2. void SPI_I2S_SendData(SPI_TypeDef* SPIx, uint16_t Data);
  3.  
  4. //读DR数据寄存器
  5. uint16_t SPI_I2S_ReceiveData(SPI_TypeDef* SPIx);
  1. //获取标志位
  2. FlagStatus SPI_I2S_GetFlagStatus(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG);
  3.  
  4. //清除标志位
  5. void SPI_I2S_ClearFlag(SPI_TypeDef* SPIx, uint16_t SPI_I2S_FLAG);
  6.  
  7. //获取中断标志位
  8. ITStatus SPI_I2S_GetITStatus(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT);
  9.  
  10. //清除中断标志位
  11. void SPI_I2S_ClearITPendingBit(SPI_TypeDef* SPIx, uint8_t SPI_I2S_IT);

6.案例

6.1软件SPI读写W25Q64

  1. #include "stm32f10x.h"                  // Device header
  2.  
  3. void MySPI_W_SS(uint8_t BitValue)
  4. {
  5. 	GPIO_WriteBit(GPIOA,GPIO_Pin_4,(BitAction)BitValue);
  6. }
  7.  
  8. void MySPI_W_SCK(uint8_t BitValue)
  9. {
  10. 	GPIO_WriteBit(GPIOA,GPIO_Pin_5,(BitAction)BitValue);
  11. }
  12.  
  13. void MySPI_W_MOSI(uint8_t BitValue)
  14. {
  15. 	GPIO_WriteBit(GPIOA,GPIO_Pin_7,(BitAction)BitValue);
  16. }
  17.  
  18. uint8_t MySPI_R_MISO(void)
  19. {
  20. 	return GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6);
  21. }
  22.  
  23. void MySPI_Init(void)
  24. {
  25. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  26. 	
  27. 	GPIO_InitTypeDef GPIO_InitStructure;
  28. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  29. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
  30. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  31. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  32. 	
  33. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  34. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  35. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  36. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  37.  
  38. 	MySPI_W_SS(1);
  39. 	MySPI_W_SCK(0);
  40. }
  41.  
  42. void MySPI_Start(void)
  43. {
  44. 	MySPI_W_SS(0);
  45. }
  46.  
  47. void MySPI_Stop(void)
  48. {
  49. 	MySPI_W_SS(1);
  50. }
  51.  
  52. uint8_t MySPI_SwapByte(uint8_t ByteSend)
  53. {
  54. 	uint8_t ByteReceive = 0x00;
  55. 	
  56. 	for(uint8_t i = 0;i < 8;i++)
  57. 	{
  58. 		MySPI_W_MOSI(ByteSend & (0x80 >> i));
  59. 		MySPI_W_SCK(1);
  60. 		if (MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
  61. 		MySPI_W_SCK(0);
  62. 	}
  63.  
  64. 	return ByteReceive;
  65. }
  66.  
  67. //uint8_t MySPI_SwapByte(uint8_t ByteSend)
  68. //{
  69. //	uint8_t ByteReceive = 0x00;
  70. //	
  71. //	for(uint8_t i = 0;i < 8;i++)
  72. //	{
  73. //		MySPI_W_MOSI(ByteSend & (0x80 >> i));
  74. //		ByteSend <<= 1;
  75. //		MySPI_W_SCK(1);
  76. //		if (MySPI_R_MISO() == 1){ByteReceive |= 0x01;}
  77. //		MySPI_W_SCK(0);
  78. //	}
  79.  
  80. //	return ByteReceive;
  81. //}
  82.  
  1. #include "stm32f10x.h"                  // Device header
  2. #include "MySPI.h"                  
  3. #include "W25Q64_Ins.h"                 
  4.  
  5.  
  6. void W25Q64_Init(void)
  7. {
  8. 	MySPI_Init();
  9. }
  10.  
  11. void W25Q64_ReadID(uint8_t *MID,uint16_t *DID)
  12. {
  13. 	MySPI_Start();
  14. 	MySPI_SwapByte(W25Q64_JEDEC_ID);
  15. 	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
  16. 	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);	
  17. 	*DID <<= 8;
  18. 	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);	
  19. 	MySPI_Stop();
  20. }
  21.  
  22. void W25Q64_WriteEnable(void)
  23. {
  24. 	MySPI_Start();
  25. 	MySPI_SwapByte(W25Q64_WRITE_ENABLE);
  26. 	MySPI_Stop();
  27. }
  28.  
  29. void W25Q64_WaitBusy(void)
  30. {
  31. 	uint32_t Timeout = 100000;
  32. 	
  33. 	MySPI_Start();
  34. 	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
  35. 	while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)
  36. 	{
  37. 		Timeout --;
  38. 		if(Timeout == 0)
  39. 		{
  40. 			break;
  41. 		}
  42. 	}
  43. 	MySPI_Stop();
  44. }
  45.  
  46. void W25Q64_PageProgram(uint32_t Address,uint8_t *DataArray,uint16_t Cout)
  47. {
  48. 	W25Q64_WriteEnable();
  49. 	
  50. 	MySPI_Start();
  51. 	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
  52. 	MySPI_SwapByte(Address  >> 16);
  53. 	MySPI_SwapByte(Address >> 8);
  54. 	MySPI_SwapByte(Address);
  55. 	for (uint16_t i = 0;i < Cout;i++)
  56. 	{
  57. 		MySPI_SwapByte(DataArray[i]);
  58. 	}
  59. 	MySPI_Stop();
  60. 	
  61. 	W25Q64_WaitBusy();
  62. }
  63.  
  64. void W25Q64_SectorErase(uint32_t Address)
  65. {
  66. 	W25Q64_WriteEnable();
  67. 	
  68. 	MySPI_Start();
  69. 	MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
  70. 	MySPI_SwapByte(Address  >> 16);
  71. 	MySPI_SwapByte(Address >> 8);
  72. 	MySPI_SwapByte(Address);
  73. 	MySPI_Stop();
  74. 	
  75. 	W25Q64_WaitBusy();
  76. }
  77.  
  78. void W25Q64_ReadData(uint32_t Address,uint8_t *DataArray,uint32_t Cout)
  79. {
  80. 	MySPI_Start();
  81. 	MySPI_SwapByte(W25Q64_READ_DATA);
  82. 	MySPI_SwapByte(Address  >> 16);
  83. 	MySPI_SwapByte(Address >> 8);
  84. 	MySPI_SwapByte(Address);
  85. 	for(uint32_t i = 0;i < Cout;i++)
  86. 	{
  87. 		DataArray[i] = 	MySPI_SwapByte(W25Q64_DUMMY_BYTE);
  88. 	}
  89. 	MySPI_Stop();
  90. }

6.2硬件SPI读写W25Q64

  1. #include "stm32f10x.h"                  // Device header
  2.  
  3. void MySPI_W_SS(uint8_t BitValue)
  4. {
  5. 	GPIO_WriteBit(GPIOA,GPIO_Pin_4,(BitAction)BitValue);
  6. }
  7.  
  8.  
  9. void MySPI_Init(void)
  10. {
  11. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  12. 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
  13. 	
  14. 	GPIO_InitTypeDef GPIO_InitStructure;
  15. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  16. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
  17. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  18. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  19. 	
  20. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  21. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
  22. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  23. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  24.  
  25. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  26. 	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  27. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  28. 	GPIO_Init(GPIOA,&GPIO_InitStructure);
  29.  
  30. 	SPI_InitTypeDef SPI_InitStructure;
  31. 	//SPI模式
  32. 	SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  33. 	//配置SPI裁剪引脚,当前选择为双线全双工
  34. 	SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  35. 	//配置8位还是16位数据帧
  36. 	SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  37. 	//选择低位先行还是高位先行
  38. 	SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  39. 	//波特率预分频器，配置SCK时钟的频率
  40. 	SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
  41. 	//配置SPI模式
  42. 	SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  43. 	//配置SPI模式
  44. 	SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  45. 	SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  46. 	//CRC校验,当前所给为默认值
  47. 	SPI_InitStructure.SPI_CRCPolynomial = 7;
  48. 	SPI_Init(SPI1,&SPI_InitStructure);
  49. 	
  50. 	SPI_Cmd(SPI1,ENABLE);
  51. 	
  52. 	MySPI_W_SS(1);
  53. }
  54.  
  55. void MySPI_Start(void)
  56. {
  57. 	MySPI_W_SS(0);
  58. }
  59.  
  60. void MySPI_Stop(void)
  61. {
  62. 	MySPI_W_SS(1);
  63. }
  64.  
  65. uint8_t MySPI_SwapByte(uint8_t ByteSend)
  66. {
  67. 	while (SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE) != SET);
  68. 	
  69. 	SPI_I2S_SendData(SPI1,ByteSend);
  70. 	
  71. 	while (SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE) != SET);
  72.  
  73. 	return SPI_I2S_ReceiveData(SPI1);
  74. }
  75.
本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号