【赛元95F】 + 11、SC95F8617 CAN收发测试

#include "config.h"



        uchar can_tx_buf[8];

        uchar can_rx_buf[14];



void main(void)

{

        uint i=0;

        uchar js=0;



         

        

        Init_led();

        Init_uart(32, 9600);

        uart_chl(1);   //usb-ttl

        Init_enit();

        Init_mcp2515();

        while(1)

        {

                js++;

                if(can_int_flag==1)

                {

                        can_int_flag=0;

                        

                        CAN_RecRXB(can_rx_buf);

                        CAN_Send(can_rx_buf);

                }

        }

}

#include "config.h"



bit SPI0Flag;

bit can_int_flag=0;



void SPI0_Init(void)

{

        OTCON |= 0X10;    //SPI0

        US0CON0 = 0x3F;   

        US0CON1 = 0x01;   

        US0CON0 |= 0x80;  

        IE1 |= 0x01;

        EA = 1;

}



void SpiInt(void) interrupt 7    

{          

        if(US0CON1&0X08)    

        {

                US0CON1 &= ~0X08;

        }

        if(US0CON1&0X80)   //write eint

        {

                US0CON1 &= ~0X80;

                SPI0Flag = 1;

        }

}



void SPI0_WRITE(uchar dat)

{

        US0CON2 = dat;

        while(!SPI0Flag);

        SPI0Flag = 0;

}



uchar SPI0_READ(void)

{

        uchar rxdat;

        SPI0_WRITE(0x00);

        rxdat=US0CON2;;

        return rxdat;

}





void MCP2515_Reset(void)

{

        CAN_CS=0;

        SPI0_WRITE(CAN_RESET);

        CAN_CS=1;

}



void MCP2515_BitModity(uchar addr, uchar msk, uchar dat)

{

     CAN_CS=0;     

     SPI0_WRITE(CAN_BIT_MODIFY);      

     SPI0_WRITE(addr);                                                         

     SPI0_WRITE(msk);                                                                 

     SPI0_WRITE(dat);                                                         

     CAN_CS=1;

     return;

}



void SPI0_WriteByte(uchar adr,uchar dat)

{

        CAN_CS=0;

        SPI0_WRITE(CAN_WRITE);

        SPI0_WRITE(adr);

        SPI0_WRITE(dat);

        CAN_CS=1;

}



void CAN_Send(uchar *CAN_TX_Buf)

{

        uint i;

        MCP2515_BitModity(TXB0CTRL,0x08,0x00);   

        SPI0_WriteByte(TXB0SIDH,0x55); 

        SPI0_WriteByte(TXB0SIDL,0x08); 

        SPI0_WriteByte(TXB0EID8,0x55); 

        SPI0_WriteByte(TXB0EID0,0x88);



        SPI0_WriteByte(TXB0DLC,DLC_8);         

        SPI0_WriteByte(TXB0D0,CAN_TX_Buf[0]);          

        SPI0_WriteByte(TXB0D1,CAN_TX_Buf[1]);

        SPI0_WriteByte(TXB0D2,CAN_TX_Buf[2]);

        SPI0_WriteByte(TXB0D3,CAN_TX_Buf[3]);

        SPI0_WriteByte(TXB0D4,CAN_TX_Buf[4]);

        SPI0_WriteByte(TXB0D5,CAN_TX_Buf[5]);

        SPI0_WriteByte(TXB0D6,CAN_TX_Buf[6]);

        SPI0_WriteByte(TXB0D7,CAN_TX_Buf[7]);

        CAN_CS=0;

        SPI0_WRITE(CAN_RTS | 0x01);                

        CAN_CS=1;

}



void Init_mcp2515(void)

{

        uint i;

        P0CON &= ~0x02;   //CANCS

        P0CON |= 0x02;

        P0PH |= 0x02;

        

        SPI0_Init();                   //SPI INIT

        

        MCP2515_Reset();

        for(i=0;i<5000;i++);

        

        MCP2515_BitModity(CANCTRL,0xE0,0x80);

        SPI0_WriteByte(CNF1,0x04);         //100k

        SPI0_WriteByte(CNF2,0x80|PHSEG1_3TQ|PRSEG_1TQ);                  

        SPI0_WriteByte(CNF3,PHSEG2_3TQ);                                                                                 

         SPI0_WriteByte(CANINTF,0x00);                                                                        

         SPI0_WriteByte(CANINTE,0x03);        

        

        SPI0_WriteByte(RXB0CTRL,0x60);                                                                  

        //SPI0_WriteByte(RXB1CTRL,0x40);                                                            



        SPI0_WriteByte(RXM0SIDH,0xff);

        SPI0_WriteByte(RXM0SIDL,0xff);

        SPI0_WriteByte(RXM0EID8,0xff);

        SPI0_WriteByte(RXM0EID0,0xff);

        

//        SPI0_WriteByte(RXM1SIDH,0xff);

//        SPI0_WriteByte(RXM1SIDL,0xff);

//        SPI0_WriteByte(RXM1EID8,0xff);

//        SPI0_WriteByte(RXM1EID0,0xff);



        SPI0_WriteByte( BFPCTRL, 0 );                                                         

        SPI0_WriteByte( TXRTSCTRL, 0 );        

                                        

        MCP2515_BitModity(CANCTRL,0xE0,0x00);

}







uchar SPI0_ReadByte(uchar adr)

{

        uchar rxdat;



        CAN_CS=0;

        SPI0_WRITE(CAN_READ);         //???

        SPI0_WRITE(adr);                //???

        rxdat=SPI0_READ();

        CAN_CS=1;

        return rxdat;

}



void CAN_RecRXB(uchar *CAN_RX_Buf)

{



                CAN_RX_Buf[0]=SPI0_ReadByte(RXB0D0);                 

                CAN_RX_Buf[1]=SPI0_ReadByte(RXB0D1);                 

                CAN_RX_Buf[2]=SPI0_ReadByte(RXB0D2);

                CAN_RX_Buf[3]=SPI0_ReadByte(RXB0D3);

                CAN_RX_Buf[4]=SPI0_ReadByte(RXB0D4);

                CAN_RX_Buf[5]=SPI0_ReadByte(RXB0D5);

                CAN_RX_Buf[6]=SPI0_ReadByte(RXB0D6);

                CAN_RX_Buf[7]=SPI0_ReadByte(RXB0D7);        

                SPI0_WriteByte(CANINTF,0);                                                         

}

#include "config.h"





void Init_enit(void)

{

//        P2CON &= ~0x08;    //p2.3  

//        

//        INT2F |= 0x08;

//        INT2R |= 0x08;

        

        P1CON &= ~0x20 ;//P1.5   

        //P1CON |= 0x20; 

        P1PH |= 0x20;

        

        INT1F |= 0x20; 

//        INT1R |= 0x20;

        IE |= 0x04;        

        EA=1;

}



void EX1() interrupt        2

{

  

        if( (CAN_INT==0)||((CAN_INT==1)))  

        {

            can_int_flag=1;

        }

}