21ic电子技术开发论坛 › 单片机与嵌入式系统 › Megawin(笙泉)单片机 › c语言实现SPI通信源程序
12下一页
返回列表 发新帖我要提问

[范例教程] c语言实现SPI通信源程序

[复制链接]
1646|22
 楼主| eefas 发表于 2023-7-13 21:42 | 显示全部楼层 |阅读模式
C语言, pi, spi, spi通信, 信源
复制
  1. *************
    

  2. ***************/
    

  3. void SPI_SendData(uint8_t data)
    

  4. {
    

  5.         uint8_t cnt;
    

  6.         for(cnt=0;cnt<8;cnt++)
    

  7.         {
    

  8.                 SPI_CLK_L;//拉低
    

  9.           Delay1us(10);//这个延时时间任意，但要大于芯片数据手册上的(纳秒级的)
    

  10.                 if(data &0x80)
    

  11.                 {
    

  12.                         SPI_MOSI_H;
    

  13.                 }
    

  14.                 else
    

  15.                 {
    

  16.                         SPI_MOSI_L;
    

  17.                 }
    

  18.                 data <<= 1;//
    

  19.                 Delay1us(10);
    

  20.                 SPI_CLK_H;//拉高
    

  21.                 Delay1us(10);
    

  22.         }
    

  23. }
    


  24. 

  25. /*****************************************/
    

  26. uint8_t SPI_ReadData(void)
    

  27. {
    

  28.         uint8_t i = 0;
    

  29.         uint8_t value=0;
    

  30.         SPI_CLK_H;       
    

  31.         Delay1us(2);
    

  32.         for(i=0;i<8;i++)
    

  33.         {
    

  34.                 SPI_CLK_L;               
    

  35.                 value<<=1;
    

  36.                 if(SPI_MISO_READ())
    

  37.                 {
    

  38.                         value |= 0x01;
    

  39.                 }
    

  40.                 Delay1us(2);
    

  41.                 SPI_CLK_H;
    

  42.                 Delay1us(2);
    

  43.         }
    

  44.        
    

  45.         return value;
    

  46. }
    


  47. 

  48. /*************
    

  49. 等待擦除完成
    

  50. **************/
    

  51. void SPI_WaitErase(void)
    

  52. {
    

  53.         uint8_t status = 0x01;
    

  54.         SPI_CS_L;
    

  55.         SPI_SendData(0x05); //读取状态寄存器命令
    

  56.   do
    

  57.         {
    

  58.                 status = SPI_ReadData();
    

  59.         }
    

  60.         while((status&0x01) == 1);
    

  61.         SPI_CS_H;
    

  62. }
    


  63. 

  64. /************
    

  65. 扇区擦除
    

  66. 4k
    

  67. **************/
    

  68. void SPI_EraseSector(uint32_t addr)
    

  69. {       
    

  70.         SPI_CLK_L;
    

  71.         SPI_CS_L;
    

  72.         SPI_SendData(0x06);
    

  73.         SPI_CLK_L;
    

  74.         SPI_CS_H;
    

  75.         SPI_CLK_L;
    

  76.         SPI_CS_L;
    

  77.         SPI_SendData(0x20);
    

  78.         SPI_SendData((uint8_t)(addr&0xFF0000)>>16);
    

  79.         SPI_SendData((addr&0xFF00)>>8);
    

  80.         SPI_SendData((addr&0xFF));
    

  81.         SPI_CLK_L;
    

  82.         SPI_CS_H;
    

  83.         SPI_WaitErase();
    

  84. }
    


  85. 


  86. 

  87. /************
    

  88. 块擦除
    

  89. 32k
    

  90. **************/
    

  91. void SPI_EraseBlock(uint32_t addr)
    

  92. {       
    

  93.         SPI_CLK_L;
    

  94.         SPI_CS_L;
    

  95.         SPI_SendData(0x06);
    

  96.         SPI_CLK_L;
    

  97.         SPI_CS_H;
    

  98.         SPI_CLK_L;
    

  99.         SPI_CS_L;
    

  100.         SPI_SendData(0x52);
    

  101.         SPI_SendData((uint8_t)(addr&0xFF0000)>>16);
    

  102.         SPI_SendData((addr&0xFF00)>>8);
    

  103.         SPI_SendData((addr&0xFF));
    

  104.         SPI_CLK_L;
    

  105.         SPI_CS_H;
    

  106.         SPI_WaitErase();
    

  107. }
    


  108. 


  109. 

  110. /************
    

  111. 块擦除
    

  112. 64k
    

  113. **************/
    

  114. void SPI_Erase64kBlock(uint32_t addr)
    

  115. {       
    

  116.         SPI_CLK_L;
    

  117.         SPI_CS_L;
    

  118.         SPI_SendData(0x06);
    

  119.         SPI_CLK_L;
    

  120.         SPI_CS_H;
    

  121.         SPI_CLK_L;
    

  122.         SPI_CS_L;
    

  123.         SPI_SendData(0xd8);
    

  124.         SPI_SendData((uint8_t)(addr&0xFF0000)>>16);
    

  125.         SPI_SendData((addr&0xFF00)>>8);
    

  126.         SPI_SendData((addr&0xFF));
    

  127.         SPI_CLK_L;
    

  128.         SPI_CS_H;
    

  129.         SPI_WaitErase();
    

  130. }
    


  131. 

  132. /*****************
    

  133. 检测设备是否正确
    

  134. 设备ID为ID=0XEF4017
    

  135. 正常才继续后面的页写入和读取数据
    

  136. ******************/
    

  137. uint32_t SPI_CheckDevice(void)
    

  138. {
    

  139.         uint8_t temp0,temp1,temp2;
    

  140.         uint32_t Device_ID=0;
    

  141.         SPI_CLK_L;
    

  142.         SPI_CS_L;
    

  143.         SPI_SendData(0x9F);
    

  144.         temp0 = SPI_ReadData();
    

  145.   temp1 = SPI_ReadData();
    

  146.         temp2 = SPI_ReadData();
    

  147.         SPI_CLK_L;
    

  148.         SPI_CS_H;
    

  149.         Device_ID = (temp0<<16) | (temp1<<8) | (temp2);
    

  150.         return Device_ID;
    

  151. }
    


  152. 


  153. 

  154. /**************
    

  155. 读取数据
    

  156. readlen： 读取长度
    

  157. ***************/
    

  158. void SPI_BufferRead(uint8_t *pBuffer,uint32_t addr,uint32_t readlen)
    

  159. {
    

  160.         SPI_CLK_L;
    

  161.         SPI_CS_L;
    

  162.         SPI_SendData(0x03);//读数据命令
    

  163.         SPI_SendData((uint8_t)(addr&0xFF0000)>>16);
    

  164.         SPI_SendData((addr&0xFF00)>>8);
    

  165.         SPI_SendData((addr&0xFF));
    

  166.         while(readlen--)
    

  167.         {
    

  168.                 *pBuffer = SPI_ReadData();
    

  169.                  pBuffer++;
    

  170.         }
    

  171.         SPI_CLK_L;
    

  172.         SPI_CS_H;
    

  173. }
    


  174. 

  175. /************
    

  176. 页写入---写入字节数低于256可用页编程
    

  177. **************/
    

  178. void SPI_PageWrite(uint8_t *pBuffer,uint32_t addr,uint16_t writelen)
    

  179. {       
    

  180.         SPI_CLK_L;
    

  181.         SPI_CS_L;
    

  182.         SPI_SendData(0x06);
    

  183.         SPI_CLK_L
    

  184.         SPI_CS_H;
    

  185.         SPI_CLK_L;//拉低
    

  186.         SPI_CS_L;
    

  187.         SPI_SendData(0x02);
    

  188.         SPI_SendData((addr&0xFF0000)>>16);
    

  189.         SPI_SendData((addr&0xFF00)>>8);
    

  190.         SPI_SendData((addr&0xFF));
    

  191.         if(writelen>Page_Size)
    

  192.         {
    

  193. //                printf("\r\n页写入最大为256字节\r\n");
    

  194.                 writelen = Page_Size ;
    

  195.         }
    

  196.         while(writelen--)
    

  197.         {
    

  198.                 SPI_SendData(*pBuffer);
    

  199.                 pBuffer++;
    

  200.         }
    

  201.         SPI_CLK_L;//拉低
    

  202.         SPI_CS_H;
    

  203.         SPI_WaitErase();
    

  204. }
    


  205. 


  206. 

  207. /*************
    

  208. 写入任意长度数据
    

  209. *pBuffer ：待写入数据
    

  210. addr                 ：需写入flash的地址
    

  211. numToWrite ：待写入数据长度
    

  212. ***************/
    

  213. void SPI_BufferWrite(uint8_t *pBuffer,uint32_t addr,uint32_t numToWrite)
    

  214. {
    

  215.         uint32_t count=0,numPage=0,numSingle=0,Addr=0;
    

  216.         Addr = addr%Page_Size;//某个page的地址
    

  217.         count = Page_Size - Addr;//某page剩余字节数
    

  218.         numPage = numToWrite/Page_Size;//待写入的数据占用page数
    

  219.         numSingle = numToWrite%Page_Size;//待写入数据不够一个page的字节数
    

  220.         if(Addr == 0)//在某page 起始位置 1
    

  221.         {
    

  222.                 if(numPage==0)//写入字节数小于一个page
    

  223.                 {
    

  224.                         SPI_PageWrite(pBuffer,addr,numToWrite);
    

  225.                 }
    

  226.                 else//写入字节数大于等于1个page
    

  227.                 {
    

  228.                         while(numPage--)
    

  229.                         {
    

  230.                                 SPI_PageWrite(pBuffer,addr,Page_Size);
    

  231.                                 pBuffer+=Page_Size;
    

  232.                                 addr+=Page_Size;
    

  233.                         }
    

  234.                         SPI_PageWrite(pBuffer,addr,numSingle);
    

  235.                 }
    

  236.         }
    

  237.         else //在某page的2~256位置
    

  238.         {
    

  239.                 if(numPage==0)//写入字节数小于一个page
    

  240.                 {
    

  241.                         if(numSingle>count)//剩余字节数>该page剩余位置
    

  242.                         {
    

  243.                                 SPI_PageWrite(pBuffer,addr,count);//向该page的剩余位置写入对应字节
    

  244.                                 pBuffer+=count;
    

  245.                                 addr+=count;
    

  246.                                 SPI_PageWrite(pBuffer,addr,(numSingle-count));//其余的写入下一个page
    

  247.                         }
    

  248.                         else
    

  249.                         {
    

  250.                                 SPI_PageWrite(pBuffer,addr,numToWrite);
    

  251.                         }
    

  252.                 }
    

  253.                 else//写入字节数大于等于一个page
    

  254.                 {
    

  255.                         numToWrite -= count;
    

  256.                         numPage = numToWrite/Page_Size;
    

  257.                         numSingle        =        numToWrite%Page_Size;
    

  258.                         SPI_PageWrite(pBuffer,addr,count);//写入该page还可写入的字节数
    

  259.                         addr+=count;
    

  260.                         pBuffer+=count;
    

  261.                         while(numPage--)//page个数
    

  262.                         {
    

  263.                                 SPI_PageWrite(pBuffer,addr,Page_Size);
    

  264.                                 pBuffer+=Page_Size;
    

  265.                                 addr+=Page_Size;
    

  266.                         }
    

  267.                         if(numSingle!=0)//剩余字节数
    

  268.                         {
    

  269.                                 SPI_PageWrite(pBuffer,addr,numSingle);
    

  270.                         }
    

  271.                 }
    

  272.         }
    

  273.         SPI_WaitErase();
    

  274. }
    


  275. 


  276. 

  277. /************
    

  278. 数据比较
    

  279. len :数据长度
    

  280. 不等：0
    

  281. 相等：1
    

  282. ************/
    

  283. uint8_t pBuffer_Cmp(uint8_t *buffer1,uint8_t *buffer2,uint32_t len)
    

  284. {
    

  285.         while(len--)
    

  286.         {
    

  287.                 if(*buffer1!=*buffer2)
    

  288.                 {
    

  289.                         return 0;
    

  290.                 }
    

  291.                 buffer1++;
    

  292.                 buffer2++;
    

  293.         }
    

  294.         return 1;
    

  295. }
    


  296. 

  297. uint8_t Write_pBuffer[]={"软件模拟SPI成功!"};
    

  298. uint8_t Read_pBuffer[3500]={0};
    


  299. 


  300. 

  301. /***********
    

  302. 读写测试,验证是否正常
    

  303. ***********/
    

  304. void SPI_Test(void)
    

  305. {
    

  306.         uint32_t Device_ID = 0;
    

  307.         Device_ID = SPI_CheckDevice();
    

  308. //        printf("ID=0x%x \r\n", Device_ID);
    

  309.         if(Device_ID == 0xEF4016)
    

  310.         {
    

  311.                 if(comparm.DebugComm & F_DebugStart)
    

  312.                         DebgStr_FramProc("SPI FLASH设备正常!\r\n");
    

  313.                 SPI_EraseSector(0x001000);//sector1
    

  314.                 SPI_BufferWrite(Write_pBuffer,0x001000,(sizeof(Write_pBuffer)/sizeof(*(Write_pBuffer))-1));
    

  315.                 SPI_BufferRead(Read_pBuffer,0x001000,(sizeof(Write_pBuffer)/sizeof(*(Write_pBuffer))-1));
    

  316.                 if(pBuffer_Cmp(Write_pBuffer,Read_pBuffer,(sizeof(Write_pBuffer)/sizeof(*(Write_pBuffer))-1)) == 1)
    

  317.                 {       
    

  318.                        
    

  319.                         if(comparm.DebugComm & F_DebugStart)
    

  320.                                 DebgStr_FramProc("软件模拟SPI的读写数据一致！\r\n");
    

  321. //                        DebgStr_FramProc("\r\n 读出的数据为：%s \r\n", Read_pBuffer);
    

  322.                 }
    

  323.                 else
    

  324.                 {
    

  325.                         if(comparm.DebugComm & F_DebugStart)
    

  326.                                 DebgStr_FramProc("软件模拟SPI的读写数据不一致！\r\n");
    

  327.                 }
    

  328.         }
    

  329.         else
    

  330.         {
    

  331.                 if(comparm.DebugComm & F_DebugStart)
    

  332.                         DebgStr_FramProc("SPI FLASH设备异常!\r\n");
    

  333.         }
    

  334. }


回复

收藏 举报

相关帖子
zerorobert 发表于 2023-8-9 14:55 | 显示全部楼层
如果支持中断方式的SPI通信，可以使用中断来提高效率和响应性
回复

收藏 举报

mollylawrence 发表于 2023-8-9 17:18 | 显示全部楼层
可以使用示波器或逻辑分析仪来监视和分析SPI信号，以验证通信的正确性。
回复

收藏 举报

juliestephen 发表于 2023-8-9 22:39 | 显示全部楼层
在进行SPI通信之前，需要设置SPI通信参数，包括SPI主机和从机的极性、数据位数、传输方式等。
回复

收藏 举报

robincotton 发表于 2023-8-14 11:21 | 显示全部楼层
在编写代码时，考虑到代码的可重用性和可维护性
回复

收藏 举报

kkzz 发表于 2023-8-14 12:24 | 显示全部楼层
在C语言中实现SPI通信源程序时，需要注意SPI控制器的初始化、通信参数的设置、数据的控制和错误处理等
回复

收藏 举报

fengm 发表于 2023-8-14 13:06 | 显示全部楼层
在程序开始时，需要对SPI控制器进行初始化，包括选择SPI模式、时钟极性、数据位数等参数。
回复

收藏 举报

benjaminka 发表于 2023-8-14 14:06 | 显示全部楼层
SPI通信是全双工的，意味着主设备和从设备可以同时发送和接收数据
回复

收藏 举报

sdCAD 发表于 2023-8-14 17:26 | 显示全部楼层
SPI通信对时序有严格要求。              
回复

收藏 举报

jtracy3 发表于 2023-8-14 19:39 | 显示全部楼层
SPI通信过程中，可能会出现错误，如数据传输错误、时钟同步错误等，需要对这些错误进行处理。
回复

收藏 举报

lzmm 发表于 2023-8-14 19:48 | 显示全部楼层
SPI通信有多种模式，包括时钟极性（CPOL）和时钟相位（CPHA）
回复

收藏 举报

alvpeg 发表于 2023-8-15 13:07 | 显示全部楼层
设置时钟频率、选择主从机角色以及配置其他相关参数
回复

收藏 举报

pixhw 发表于 2023-8-15 17:47 | 显示全部楼层
在SPI通信中，可能会发生错误，如传输错误或超时
回复

收藏 举报

maudlu 发表于 2023-8-15 18:31 | 显示全部楼层
使用适当的数据结构和函数来组织代码
回复

收藏 举报

yeates333 发表于 2023-8-15 19:09 | 显示全部楼层
选择适当的时钟速率以满足目标设备的要求，并确保主设备和从设备的时钟速率匹配。
回复

收藏 举报

jimmhu 发表于 2023-8-15 19:22 | 显示全部楼层
SPI通信的速率由时钟频率决定              
回复

收藏 举报

ingramward 发表于 2023-8-15 19:34 | 显示全部楼层
在编程之前，你需要确定SPI接口的引脚分配。通常，SPI接口有三个信号线：MOSI(主从机数据输出/输入线)、SCK(时钟线)和SS(片选线)
回复

收藏 举报

bartonalfred 发表于 2023-8-15 20:04 | 显示全部楼层
可以利用中断或DMA来处理SPI通信
回复

收藏 举报

saservice 发表于 2023-8-15 22:04 | 显示全部楼层
连接SPI设备，包括主设备和从设备之间的物理连接，以及正确的引脚配置。
回复

收藏 举报

mollylawrence 发表于 2023-8-18 22:37 | 显示全部楼层
需要确定合适的缓冲区大小，并确保在发送和接收之间正确管理缓冲区的数据。
回复

收藏 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

eefas

98

主题

3179

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部