欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標題: 分享一些CAN總線資料和mcp2515程序，項目上用到，供各位參考 [打印本頁]
作者: 青春V未央    時間: 2020-6-23 09:10
標題: 分享一些CAN總線資料和mcp2515程序，項目上用到，供各位參考
分享一些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黑下載附件…………
復制代碼


作者: sxtz531    時間: 2021-4-17 13:52
正需要這塊的資料，多謝樓主分享，學習 .



歡迎光臨 (http://m.raoushi.com/bbs/) Powered by Discuz! X3.1