搜索

[活动专区] 【赛元95F】 + 11、SC95F8617 CAN收发测试

[复制链接]
839|0
 楼主 | 2020-3-26 08:17 | 显示全部楼层 |阅读模式
本帖最后由 tlled 于 2020-3-26 08:21 编辑

    在上一帖子  赛元95F】 + 10、SC95F8617 CAN发送测试 中增加接收功能。

    一、代码

   1.1、main.c

  1. #include "config.h"

  2.         uchar can_tx_buf[8];
  3.         uchar can_rx_buf[14];

  4. void main(void)
  5. {
  6.         uint i=0;
  7.         uchar js=0;

  8.          
  9.         
  10.         Init_led();
  11.         Init_uart(32, 9600);
  12.         uart_chl(1);   //usb-ttl
  13.         Init_enit();
  14.         Init_mcp2515();
  15.         while(1)
  16.         {
  17.                 js++;
  18.                 if(can_int_flag==1)
  19.                 {
  20.                         can_int_flag=0;
  21.                         
  22.                         CAN_RecRXB(can_rx_buf);
  23.                         CAN_Send(can_rx_buf);
  24.                 }
  25.         }
  26. }
复制代码

    1.2、mcp2515.c

  1. #include "config.h"

  2. bit SPI0Flag;
  3. bit can_int_flag=0;

  4. void SPI0_Init(void)
  5. {
  6.         OTCON |= 0X10;    //SPI0
  7.         US0CON0 = 0x3F;   
  8.         US0CON1 = 0x01;   
  9.         US0CON0 |= 0x80;  
  10.         IE1 |= 0x01;
  11.         EA = 1;
  12. }

  13. void SpiInt(void) interrupt 7   
  14. {          
  15.         if(US0CON1&0X08)   
  16.         {
  17.                 US0CON1 &= ~0X08;
  18.         }
  19.         if(US0CON1&0X80)   //write eint
  20.         {
  21.                 US0CON1 &= ~0X80;
  22.                 SPI0Flag = 1;
  23.         }
  24. }

  25. void SPI0_WRITE(uchar dat)
  26. {
  27.         US0CON2 = dat;
  28.         while(!SPI0Flag);
  29.         SPI0Flag = 0;
  30. }

  31. uchar SPI0_READ(void)
  32. {
  33.         uchar rxdat;
  34.         SPI0_WRITE(0x00);
  35.         rxdat=US0CON2;;
  36.         return rxdat;
  37. }


  38. void MCP2515_Reset(void)
  39. {
  40.         CAN_CS=0;
  41.         SPI0_WRITE(CAN_RESET);
  42.         CAN_CS=1;
  43. }

  44. void MCP2515_BitModity(uchar addr, uchar msk, uchar dat)
  45. {
  46.      CAN_CS=0;     
  47.      SPI0_WRITE(CAN_BIT_MODIFY);      
  48.      SPI0_WRITE(addr);                                                         
  49.      SPI0_WRITE(msk);                                                                 
  50.      SPI0_WRITE(dat);                                                         
  51.      CAN_CS=1;
  52.      return;
  53. }

  54. void SPI0_WriteByte(uchar adr,uchar dat)
  55. {
  56.         CAN_CS=0;
  57.         SPI0_WRITE(CAN_WRITE);
  58.         SPI0_WRITE(adr);
  59.         SPI0_WRITE(dat);
  60.         CAN_CS=1;
  61. }

  62. void CAN_Send(uchar *CAN_TX_Buf)
  63. {
  64.         uint i;
  65.         MCP2515_BitModity(TXB0CTRL,0x08,0x00);   
  66.         SPI0_WriteByte(TXB0SIDH,0x55);
  67.         SPI0_WriteByte(TXB0SIDL,0x08);
  68.         SPI0_WriteByte(TXB0EID8,0x55);
  69.         SPI0_WriteByte(TXB0EID0,0x88);

  70.         SPI0_WriteByte(TXB0DLC,DLC_8);         
  71.         SPI0_WriteByte(TXB0D0,CAN_TX_Buf[0]);          
  72.         SPI0_WriteByte(TXB0D1,CAN_TX_Buf[1]);
  73.         SPI0_WriteByte(TXB0D2,CAN_TX_Buf[2]);
  74.         SPI0_WriteByte(TXB0D3,CAN_TX_Buf[3]);
  75.         SPI0_WriteByte(TXB0D4,CAN_TX_Buf[4]);
  76.         SPI0_WriteByte(TXB0D5,CAN_TX_Buf[5]);
  77.         SPI0_WriteByte(TXB0D6,CAN_TX_Buf[6]);
  78.         SPI0_WriteByte(TXB0D7,CAN_TX_Buf[7]);
  79.         CAN_CS=0;
  80.         SPI0_WRITE(CAN_RTS | 0x01);               
  81.         CAN_CS=1;
  82. }

  83. void Init_mcp2515(void)
  84. {
  85.         uint i;
  86.         P0CON &= ~0x02;   //CANCS
  87.         P0CON |= 0x02;
  88.         P0PH |= 0x02;
  89.        
  90.         SPI0_Init();                   //SPI INIT
  91.        
  92.         MCP2515_Reset();
  93.         for(i=0;i<5000;i++);
  94.        
  95.         MCP2515_BitModity(CANCTRL,0xE0,0x80);
  96.         SPI0_WriteByte(CNF1,0x04);         //100k
  97.         SPI0_WriteByte(CNF2,0x80|PHSEG1_3TQ|PRSEG_1TQ);                 
  98.         SPI0_WriteByte(CNF3,PHSEG2_3TQ);                                                                                
  99.         SPI0_WriteByte(CANINTF,0x00);                                                                       
  100.         SPI0_WriteByte(CANINTE,0x03);       
  101.        
  102.         SPI0_WriteByte(RXB0CTRL,0x60);                                                                 
  103.         //SPI0_WriteByte(RXB1CTRL,0x40);                                                           

  104.         SPI0_WriteByte(RXM0SIDH,0xff);
  105.         SPI0_WriteByte(RXM0SIDL,0xff);
  106.         SPI0_WriteByte(RXM0EID8,0xff);
  107.         SPI0_WriteByte(RXM0EID0,0xff);
  108.        
  109. //        SPI0_WriteByte(RXM1SIDH,0xff);
  110. //        SPI0_WriteByte(RXM1SIDL,0xff);
  111. //        SPI0_WriteByte(RXM1EID8,0xff);
  112. //        SPI0_WriteByte(RXM1EID0,0xff);

  113.         SPI0_WriteByte( BFPCTRL, 0 );                                                        
  114.         SPI0_WriteByte( TXRTSCTRL, 0 );       
  115.                                        
  116.         MCP2515_BitModity(CANCTRL,0xE0,0x00);
  117. }



  118. uchar SPI0_ReadByte(uchar adr)
  119. {
  120.         uchar rxdat;

  121.         CAN_CS=0;
  122.         SPI0_WRITE(CAN_READ);         //???
  123.         SPI0_WRITE(adr);                //???
  124.         rxdat=SPI0_READ();
  125.         CAN_CS=1;
  126.         return rxdat;
  127. }

  128. void CAN_RecRXB(uchar *CAN_RX_Buf)
  129. {

  130.                 CAN_RX_Buf[0]=SPI0_ReadByte(RXB0D0);                
  131.                 CAN_RX_Buf[1]=SPI0_ReadByte(RXB0D1);                
  132.                 CAN_RX_Buf[2]=SPI0_ReadByte(RXB0D2);
  133.                 CAN_RX_Buf[3]=SPI0_ReadByte(RXB0D3);
  134.                 CAN_RX_Buf[4]=SPI0_ReadByte(RXB0D4);
  135.                 CAN_RX_Buf[5]=SPI0_ReadByte(RXB0D5);
  136.                 CAN_RX_Buf[6]=SPI0_ReadByte(RXB0D6);
  137.                 CAN_RX_Buf[7]=SPI0_ReadByte(RXB0D7);       
  138.                 SPI0_WriteByte(CANINTF,0);                                                         
  139. }
复制代码
   1.3、eint.c
  1. #include "config.h"


  2. void Init_enit(void)
  3. {
  4. //        P2CON &= ~0x08;    //p2.3  
  5. //       
  6. //        INT2F |= 0x08;
  7. //        INT2R |= 0x08;
  8.        
  9.         P1CON &= ~0x20 ;//P1.5   
  10.         //P1CON |= 0x20;
  11.         P1PH |= 0x20;
  12.        
  13.         INT1F |= 0x20;
  14. //        INT1R |= 0x20;
  15.         IE |= 0x04;       
  16.         EA=1;
  17. }

  18. void EX1() interrupt        2
  19. {
  20.   
  21.         if( (CAN_INT==0)||((CAN_INT==1)))  
  22.         {
  23.             can_int_flag=1;
  24.         }
  25. }
复制代码

    二、测试结果

    CAN通信收到什么数据就发送什么数据。

    200.png

使用特权

评论回复
扫描二维码,随时随地手机跟帖
您需要登录后才可以回帖 登录 | 注册

本版积分规则

我要发帖 投诉建议 创建版块 申请版主

快速回复

您需要登录后才可以回帖
登录 | 注册
高级模式

论坛热帖

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