设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 分享一些CAN总线资料和mcp2515程序，项目上用到，供各位 ...
返回列表 发新帖
查看: 2847|回复: 1
打印 上一主题 下一主题
收起左侧

分享一些CAN总线资料和mcp2515程序，项目上用到，供各位参考

  [复制链接]
跳转到指定楼层
楼主
ID:786943 发表于 2020-6-23 09:10 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
分享一些CAN总线资料，项目上可以用到，供大家参考
CAN_C程序.zip (108.05 KB, 下载次数: 120)
can入门教程.pdf (1.82 MB, 下载次数: 46)
CAN总线协议讲解.pdf (4.71 MB, 下载次数: 42)
MCP2515-CAN 中文数据手册.pdf (1.19 MB, 下载次数: 57)
PCA82C250应用指南中文资料.pdf (663.56 KB, 下载次数: 30)
STM32CAN发送和接收过滤详解.pdf (252.93 KB, 下载次数: 57)

单片机源程序如下:
  1. #include "reg51.h"
  2. #include "intrins.h"
  3. #include "mcp2515.h"
  4. #include "intrins.h"
  5. #include "datadef.h"
  6. //sbit CANSPI_SI  = P0^1;
  7. //sbit CANSPI_SO  = P0^0;
  8. //sbit CAN_RST    = P2^6;
  9. //sbit CANSPI_CS  = P2^7;
  10. //sbit CANSPI_SCK = P0^2;
  11. //sbit CAN_RS     = P2^5;
  12. //sbit CAN_INT    = P3^7;

  14. //sbit LED1       = P1^7;
  15. //sbit LED2       = P1^6;


  18. sbit CANSPI_SI  = P2^6;
  19. sbit CANSPI_SO  = P2^3;
  20. sbit CAN_RST    = P2^1;
  21. sbit CANSPI_CS  = P2^2;
  22. sbit CANSPI_SCK = P2^5;
  23. sbit CAN_RS     = P4^7;

  25. sbit CAN_INT    = P3^4;
  26. sbit CAN_CE     = P2^0;
  27. sbit LED1       = P2^4;
  28. sbit LED2       = P2^7;

  30. sbit PKE_C  = P1^6;
  31. sbit PKE_D  = P1^7;
  32. sbit PKE_A  = P3^3;
  33. sbit PKE_B  = P3^4;
  34. bit B_R2;
  35. bit CAN_OK;

  37. static u8 xdata CAN_READ_BUFF01[15];
  38. static u8 xdata CAN_READ_BUFF02[15];
  39. u8 code SEND_CAN_CODE01[]=             //CAN发送数据流
  40.         {14,                            //数据个数
  41.          COMMAND_WRITE_TXB0SIDH,
  42.          0x2A,0x00,0x00,0x00,0x08,     //ID
  43.          0x12,0x34,0x56,0x78,0x90,0xFF,0xFF,0xFF,  //内容
  44.          COMMAND_RTST0
  45.         };
  46.        
  47. u8 code CAN_INIT_DATA01[]=       //CAN初始化数据流01
  48.         {
  49.          
  50.                         0x02,CANCTRL,     0x80,                 //;进入配置模式

  52.                         0x02,CNF1,        0x04,                        //;CAN速率        100K
  53.                         0x02,CNF2,        0x9E,                        //;CAN速率
  54.                         0x02,CNF3,        0x03,                        //;CAN速率

  56.                         0x02,CANINTE,     0x43,

  58.                         0x02,RXB0CTRL,    0x24,                 //;接收缓冲器0        控制寄存器    24H标准桢、滚存
  59.                         0x02,RXB1CTRL,    0x20,                        //;接收缓冲器1        控制寄存器    20标准桢
  60.                         0x02,BFPCTRL,     0x00,                 //;RXnBF引脚控制和状态寄存器

  62.                         0x02,RXM0SIDH,          0xFF,            //;验收屏蔽寄存器0        标准标识符高位 (验证的是RXB0SIDH，为0的是都接收，为1是开启屏蔽)
  63.                         0x02,RXM0SIDL,          0xE0,                  //;验收屏蔽寄存器0        标准标识符低位
  64.                         0x02,RXM0EID8,          0x00,                  //;验收屏蔽寄存器0        扩展标识符高位
  65.                         0x02,RXM0EID0,          0x00,                  //;验收屏蔽寄存器0        扩展标识符低位

  67.                         0x02,RXM1SIDH,          0xFF,            //;验收屏蔽寄存器1        标准标识符高位
  68.                         0x02,RXM1SIDL,          0xE0,                  //;验收屏蔽寄存器1        标准标识符低位
  69.                         0x02,RXM1EID8,          0x00,            //;验收屏蔽寄存器1        扩展标识符高位
  70.                         0x02,RXM1EID0,          0x00,                  //;验收屏蔽寄存器1        扩展标识符低位
  71.                 //;.........................................................................................


  74.                 //;接收CAN地址 2AH,00H
  75.                         0x02,RXF0SIDH,          0x2A,                  ////;验收滤波寄存器0        标准标识符高位
  76.                         0x02,RXF0SIDL,          0x10,            //;验收滤波寄存器0        标准标识符低位
  77.                         0x02,RXF0EID8,          0x00,                  //;验收滤波寄存器0        扩展标识符高位
  78.                         0x02,RXF0EID0,          0x00,                  //;验收滤波寄存器0        扩展标识符低位

  80.                         0x02,RXF1SIDH,          0xFF,                  //;验收滤波寄存器1        标准标识符高位
  81.                         0x02,RXF1SIDL,          0xE0,                  //;验收滤波寄存器1        标准标识符低位
  82.                         0x02,RXF1EID8,          0x00,                  //;验收滤波寄存器1        扩展标识符高位
  83.                         0x02,RXF1EID0,          0x00,                  //;验收滤波寄存器1        扩展标识符低位
  84.                 //;.........................................................................
  85.                         0x02,RXF2SIDH,          0x00,                  //;验收滤波寄存器2        标准标识符高位
  86.                         0x02,RXF2SIDL,          0x00,                  //;验收滤波寄存器2        标准标识符低位
  87.                         0x02,RXF2EID8,          0x00,                  //;验收滤波寄存器2        扩展标识符高位
  88.                         0x02,RXF2EID0,          0x00,            //;验收滤波寄存器2        扩展标识符低位

  90.                         0x02,RXF3SIDH,          0xFF,                  //;验收滤波寄存器3        标准标识符高位
  91.                         0x02,RXF3SIDL,          0xE0,                  //;验收滤波寄存器3        标准标识符低位
  92.                         0x02,RXF3EID8,          0x00,                  //;验收滤波寄存器3        扩展标识符高位
  93.                         0x02,RXF3EID0,          0x00,            //;验收滤波寄存器3        扩展标识符低位

  95.                         0x02,RXF4SIDH,          0xFF,                   //;验收滤波寄存器4        标准标识符高位
  96.                         0x02,RXF4SIDL,          0xE0,                  //;验收滤波寄存器4        标准标识符低位
  97.                         0x02,RXF4EID8,          0x00,                  //;验收滤波寄存器4        扩展标识符高位
  98.                         0x02,RXF4EID0,          0x00,                  //;验收滤波寄存器4        扩展标识符低位

  100.                         0x02,RXF5SIDH,          0xFF,                  //;验收滤波寄存器5        标准标识符高位
  101.                         0x02,RXF5SIDL,          0xE0,                  //;验收滤波寄存器5        标准标识符低位
  102.                         0x02,RXF5EID8,          0x00,                  //;验收滤波寄存器5        扩展标识符高位
  103.                         0x02,RXF5EID0,          0x00,     //;验收滤波寄存器5        扩展标识符低位

  105.                         0x02,CANCTRL,            0x40               //;模式  00-收发模式   40--自发自收模式
  106.   };
  107. //========================================================================
  108. // 函数:CANSPI_WRITE_BYTE(u8 data_buff)
  109. // 描述:SPI写一个字节
  110. // 参数:data_buff/所传数据
  111. // 返回: none.
  112. //========================================================================
  113. void CANSPI_WRITE_BYTE(u8 data_buff)
  114. {
  115.                 u8 i;
  116.           for(i=0;i<8;i++)        //8位，循环        8次                                                       
  117.           {
  118.                           if(((data_buff << i)&0x80) != 0)  //先传输高位
  119.                                         CANSPI_SI = 1;
  120.                                 else
  121.                                   CANSPI_SI = 0;
  122.                                
  123.                                 _nop_();_nop_(); _nop_(); _nop_(); _nop_();
  124.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  125.                                 _nop_(); _nop_(); _nop_();
  126.                                
  127.                                 CANSPI_SCK = 1;
  128.                                
  129.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  130.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  131.                         _nop_(); _nop_(); _nop_(); _nop_();
  132.                                
  133.                                 CANSPI_SCK = 0;
  134.                                
  135.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  136.                                 _nop_(); _nop_(); _nop_(); _nop_();
  137.           }
  138. }
  139. //========================================================================
  140. // 函数:CANSPI_READ_BYTE(u8 data_buff)
  141. // 描述:SPI读一个字节
  142. // 参数:none.
  143. // 返回:data_buff/所读数据
  144. //========================================================================
  145. u8 CANSPI_READ_BYTE(void)
  146. {
  147.                 u8 i,data_buff;
  148.           for(i=0;i<8;i++)        //8位，循环        8次                                                       
  149.           {
  150.                           CANSPI_SCK = 1;
  151.                           
  152.                           _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  153.                           _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  154.                           _nop_(); _nop_(); _nop_();
  155.                           data_buff = data_buff << 1;
  156.                           if(CANSPI_SO)
  157.                                 {data_buff |= 0x01;}
  158.                                 else
  159.                                 {data_buff &= 0xfe;}       
  160.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  161.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  162.                                 _nop_(); _nop_(); _nop_();
  163.                                
  164.                                 CANSPI_SCK = 0;
  165.                                
  166.                                 _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  167.                         //        _nop_(); _nop_(); _nop_(); _nop_(); _nop_();
  168.                         //        _nop_(); _nop_(); _nop_();
  169.           }
  170.                 return (data_buff);
  171. }
  172. //========================================================================
  173. // 函数:CAN_COMMAND_OUT(u8 *P)
  174. // 描述:CAN发送数据子程序
  175. // 参数:发送数据首地址指针
  176. // 返回:none;
  177. //========================================================================
  178. void CAN_COMMAND_OUT(u8 *p)
  179. {
  180.                 u8 i;
  181.           CANSPI_CS = 0;
  182.                 for(i=0;i<14;i++)
  183.           {
  184.                    CANSPI_WRITE_BYTE(p[i+1]);  
  185.           }
  186.           CANSPI_CS = 1;
  187.           _nop_();_nop_();_nop_();
  188.           CANSPI_CS = 0;
  189.           CANSPI_WRITE_BYTE(p[15]);
  190.                 CANSPI_CS = 1;
  191. }
  192. //========================================================================
  193. // 函数:CAN_BUS_INIT(u8 *P)
  194. // 描述:CAN初始化子程序
  195. // 参数:发送数据首地址指针
  196. // 返回:none;
  197. //========================================================================
  198. void CAN_BUS_INIT(u8 *p,u8 num)
  199. {
  200.                 u8 i;
  201.           CANSPI_CS = 0;
  202.                 for(i=0;i<num;i++)
  203.           {
  204.                           CANSPI_CS = 0;
  205.                                 CANSPI_WRITE_BYTE(p[i*3]);
  206.                                 CANSPI_WRITE_BYTE(p[(i*3)+1]);
  207.                                 CANSPI_WRITE_BYTE(p[(i*3)+2]);
  208.                                 CANSPI_CS = 1;
  209.           }
  210.                 for(i=0;i<15;i++)
  211.                 {
  212.                                 CAN_READ_BUFF01[i] = 0;
  213.         CAN_READ_BUFF02[i] = 0;   
  214.                 }
  215. }
  216. //========================================================================
  217. // 函数:CL_ERRB()
  218. // 描述:清除错误标志寄存器
  219. //      每次接收完数据，执行此子程序，清除接收区
  220. // 参数:
  221. // 返回:none;
  222. //========================================================================
  223. void CL_ERRB()
  224. {
  225.                 CANSPI_CS = 0;
  226.           CANSPI_WRITE_BYTE(COMMAND_BITMDF);
  227.           CANSPI_WRITE_BYTE(EFLG);
  228.           CANSPI_WRITE_BYTE(0xC0);
  229.           CANSPI_WRITE_BYTE(0x00);
  230.           CANSPI_CS = 1;
  231. }
  232. //========================================================================
  233. // 函数:CAN_DATA_CONTRAST(u8 *p)
  234. // 描述:CAN接收数据对比子程序
  235. // 参数:接收数据存放指针
  236. // 返回:none;
  237. //========================================================================
  238. //void CAN_DATA_CONTRAST(u8 *p)
  239. //{
  240. //               
  241. //}
  242. //========================================================================
  243. // 函数:CAN_RECEIVE_DATA()
  244. // 描述:CAN接收子程序
  245. // 参数:
  246. // 返回:none;
  247. //========================================================================
  248. void CAN_RECEIVE_DATA()
  249. {
  250.                 u8 i,RXIF_DATA;
  251.                 CAN_RS = 0;
  252.     CAN_OK = 0;
  253.           B_R2   = 0;
  254.           CANSPI_CS = 0;
  255.           CANSPI_WRITE_BYTE(COMMAND_READ);
  256.           CANSPI_WRITE_BYTE(CANINTF);
  257.           RXIF_DATA = CANSPI_READ_BYTE();
  258.           CANSPI_CS = 1;
  259.           RXIF_DATA &= 0x03;
  260.           switch(RXIF_DATA)
  261.                 {
  262.                          case 1:
  263.                                             CANSPI_CS = 0;
  264.                                                         CANSPI_WRITE_BYTE(COMMAND_READ_RXB0SIDH);
  265.                                                         for(i=0;i<13;i++)
  266.                                                         {
  267.                                                                         CAN_READ_BUFF01[i] = CANSPI_READ_BYTE();
  268.                                                         }
  269.                                                         CAN_READ_BUFF01[1] &= 0xf0;
  270.                                                         CAN_READ_BUFF01[2] = 0x00;
  271.                                                         CAN_READ_BUFF01[3] = 0x00;
  272.                                                         CANSPI_CS = 1;
  273.                                                        
  274.                                                         if(CAN_READ_BUFF01[0] == 0x2A)
  275.                                                         {                  
  276.                                                                   if((CAN_READ_BUFF01[5] == 0x12)&&
  277.                                                                                  (CAN_READ_BUFF01[6] == 0x34)&&
  278.                                                                            (CAN_READ_BUFF01[7] == 0x56)&&
  279.                                                                            (CAN_READ_BUFF01[8] == 0x78)&&
  280.                                                                            (CAN_READ_BUFF01[9] == 0x90))
  281.                                                                         {
  282.                                                                                         CAN_OK = 1;
  283.                                                                                
  284.                                                                         }
  285.                   CL_ERRB();
  286.                                                         }
  287.                                                         else
  288.                                                         {       
  289.                                                                  if(!B_R2)
  290.                                                                  {
  291.                                                                                  CL_ERRB();
  292.                                                                  }
  293.                                                                  else
  294.                                                                  {
  295.                                                                                  B_R2 = 0;
  296.                                                                            CANSPI_CS = 0;
  297.                                                                            CANSPI_WRITE_BYTE(COMMAND_READ_RXB1SIDH);
  298.                                                                            for(i=0;i<13;i++)
  299.                                                                                  {
  300.                                                                                                 CAN_READ_BUFF02[i] = CANSPI_READ_BYTE();
  301.                                                                                  }
  302.                                                                                  CAN_READ_BUFF02[1] &= 0xf0;
  303.                                                                                  CAN_READ_BUFF02[2] = 0x00;
  304.                                                                                  CAN_READ_BUFF02[3] = 0x00;
  305.                                                                                  CANSPI_CS = 1;
  306.                                                                                  if(CAN_READ_BUFF01[0] == 0x2A)
  307.                                                                                  {
  308.                                                                                                  if((CAN_READ_BUFF02[5] == 0x12)&&
  309.                                                                                                           (CAN_READ_BUFF02[6] == 0x34)&&
  310.                                                                                                           (CAN_READ_BUFF02[7] == 0x56)&&
  311.                                                                                                           (CAN_READ_BUFF02[8] == 0x78)&&
  312.                                                                                                           (CAN_READ_BUFF02[9] == 0x90))
  313.                                                                                                  {
  314.                                                                                                                  CAN_OK = 1;
  315.                                                                                                  }
  316.                                                                                                  CL_ERRB();
  317.                                                                                  }                 
  318.                                                          }
  319.                                                         }
  320.                                                                
  321.                                                         break;
  322.                          case 2:      
  323.                                              B_R2 = 0;
  324.                                                                            CANSPI_CS = 0;
  325.                                                                            CANSPI_WRITE_BYTE(COMMAND_READ_RXB1SIDH);
  326.                                                                            for(i=0;i<13;i++)
  327.                                                                                  {
  328.                                                                                                 CAN_READ_BUFF02[i] = CANSPI_READ_BYTE();
  329.                                                                                  }
  330.                                                                                  CAN_READ_BUFF02[1] &= 0xf0;
  331.                                                                                  CAN_READ_BUFF02[2] = 0x00;
  332.                                                                                  CAN_READ_BUFF02[3] = 0x00;
  333.                                                                                  if(CAN_READ_BUFF02[0] == 0x2A)
  334.                                                                                  {   
  335.                                                                                                  if((CAN_READ_BUFF02[5] == 0x12)&&
  336.                                                                                                           (CAN_READ_BUFF02[6] == 0x34)&&
  337.                                                                                                           (CAN_READ_BUFF02[7] == 0x56)&&
  338.                                                                                                           (CAN_READ_BUFF02[8] == 0x78)&&
  339.                                                                                                           (CAN_READ_BUFF02[9] == 0x90))
  340.                                                                                                  {
  341.                                                                                                                  CAN_OK = 1;
  342.                                                                                                  }
  343.                                                                                                  CL_ERRB();
  344.                                                                                  }
  345.                                                         break;
  346.                          case 3:B_R2 = 1;
  347.                                                         CANSPI_CS = 0;
  348.                                                         for(i=0;i<13;i++)
  349.                                                         {
  350.                                                                         CAN_READ_BUFF01[i] = CANSPI_READ_BYTE();
  351.                                                         }
  352.                                                         CAN_READ_BUFF01[1] &= 0xf0;
  353.                                                         CAN_READ_BUFF01[2] = 0x00;
  354.                                                         CAN_READ_BUFF01[3] = 0x00;
  355.                                                         CANSPI_CS = 1;
  356.                                                         if(CAN_READ_BUFF01[0] == 0x2A)
  357.                                                         {
  358.                                                                         if((CAN_READ_BUFF01[5] == 0x12)&&
  359.                                                                                  (CAN_READ_BUFF01[6] == 0x34)&&
  360.                                                                            (CAN_READ_BUFF01[7] == 0x56)&&
  361.                                                                            (CAN_READ_BUFF01[8] == 0x78)&&
  362.                                                                            (CAN_READ_BUFF01[9] == 0x90))
  363. ……………………

  365. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


评分

参与人数 2黑币 +55 收起 理由
SKYLAR123 + 5 很给力！
admin + 50 共享资料的黑币奖励！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏6 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:278170 发表于 2021-4-17 13:52 | 只看该作者
正需要这块的资料，多谢楼主分享，学习 .
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表