#include  "msp430x13x.h"
#include  "mcp2510.h"
#include  "math.h"
uchar mcp_RD_address(uchar address);

void nop(uchar time)
{
    uchar i;
    for(i=0;i<time;i++);
}

//清看門狗程序
void ClearWDT (void)
{
  WDTCTL=WDT_ARST_250;//看門狗模式,ACLK,250mS
  P3OUT ^=WDI;
}

uchar Get_CAN_address(void)
{
    uchar address;
    address = P1IN & 0xF0;
    address >>= 4;
    address = address-2;
    address *= 4;
    return address;
}
/* This function produce a byte on the SPI communication */
uchar SPI_putch(uchar outdata)
{
   TXBUF0 = outdata;
   while (!(TXEPT & UTCTL0));      // TX finish    
   return RXBUF0;
}
/* Select the MCP2510 by hardware signal CS */
void mcp_select(void)
{
    P3OUT &= ~mcpCS0;               // MCP2510 SELECT        
}

/* Remove the CS from the MCP */
void mcp_unselect(void)
{
    P3OUT |= mcpCS0; 	
}

void mcp_reset(void)
{ 
    uint i;  
    P2OUT&=~RST0;    
    for(i=0;i<50000;i++); 
    ClearWDT();
    for(i=0;i<50000;i++); 
    P2OUT|=RST0;
    
}

uchar mcp_RD_address(uchar address)
{
    uchar store=0X55; 
    mcp_select( );                 // Select the mcp2510    
    SPI_putch(READ);               // Write the command     
    SPI_putch(address);            // Write address 
    store = SPI_putch(DUMMY);      // Write dummy byte to produce clock    
    mcp_unselect( );
    return store;
    
}

void mcp_WR_address(uchar address,uchar output)
{    
    mcp_select( );                 // Select the mcp2510    
    SPI_putch( WRITE );            // Write the command      
    SPI_putch( address );          // Write the address       
    SPI_putch( output );           // Write byte in address     
    mcp_unselect( );
}

uchar mcp_RD_status(void)
{
    uchar store;
    mcp_select( );                 // Select the mcp2510    
    SPI_putch(RD_STAT);            // Write the command    
    store =  SPI_putch(DUMMY);     // Write any byte to get a byte in return     
    mcp_unselect( );
    return store;                  // Command done OK
}

void mcp_write_bits(uchar address,uchar mask,uchar data)
{
    mcp_select();
    SPI_putch(BIT_MOD);
    SPI_putch(address);
    SPI_putch(mask);
    SPI_putch(data);
    mcp_unselect();
}

// TXnumber can be 0,1,2
void mcp_RTS(uchar TXnumber)
{  
    uchar temp;
    switch(TXnumber)
    {
        case 0:
             temp = 0x81;
             break;
        case 1:
             temp = 0x82;
             break;
        case 2:
             temp = 0x84;
             break;
        default:
             break;    
    }
    mcp_select( );     // Select the mcp2510   
    SPI_putch(temp);   // Write the command   
    mcp_unselect();        
}

/* Read one or more registers in the MCP2510, starting at address
   readdata.  */
void mcp_read( uchar address, uchar* readdata, uchar length )
{
    uchar loopCnt;
    mcp_select();               // Select the MCP device at the SPI bus     
    for (loopCnt=0; loopCnt < length; loopCnt++) 
    {        
        *readdata=mcp_RD_address(address);  // reading
        address++;                          // Increment the pointers to next location
        readdata++;
    }
    mcp_unselect();
}

/* Write to one or more registers in the MCP2510, starting at address
   writedata.  */
void mcp_write( uchar address, uchar* writedata, uchar length )
{
    uchar loopCnt;   
    mcp_select();      
    for (loopCnt=0; loopCnt < length; loopCnt++) 
    {        
        mcp_WR_address(address++,*(writedata++)); 
    }
    mcp_unselect();
}

// RXnumber can be 0,1
void mcp_read_can( uchar RXnumber, uchar* data )
{   
    uchar dlc; 
    uchar mcp_addr = RXnumber*16 + 0x61;       
    mcp_read( mcp_addr+4, &dlc, 1 );    
    dlc &= DLC_MASK;
    mcp_read( mcp_addr+5, data, dlc );
}

// TXnumber can be 0,1,2
void mcp_write_can( uchar TXnumber,uchar number,uchar dlc,uchar* data )
{
    uchar canid;
    uchar mcp_addr = TXnumber*16 + 0x31;
    canid = Get_CAN_address();
    mcp_write(mcp_addr, &canid, 1 );       // write TXBNSIDH     
    canid = 0;
    mcp_write((mcp_addr+1),&canid, 0);     // write  TXBNSIDL
    mcp_write((mcp_addr+2),&canid, 0);     // write  TXBNEID8
    mcp_write((mcp_addr+3),&canid, 0);     // write  TXBNEID0
    mcp_write((mcp_addr+4), &dlc,  1);     // write data length   
    mcp_write((mcp_addr+5), &number, 1);   // write frame number   
    mcp_write((mcp_addr+6), data, (dlc-1));   // write data bytes    
}

/* Initialize the MCP2510.  */
void init_can(void)
{
    uchar tmp=0;    
    
    mcp_reset( ); 
    mcp_WR_address(CNF1,0x00);          //16M crystal , 1000KBPS; TQ=125ns, Synchronization Jump Width Length:1TQ
    mcp_WR_address(CNF2,0x90);          //one sample, Phase Segment 1 Length:3TQ, Propagation Segment Length:1TQ
    mcp_WR_address(CNF3,0x02);          //Phase Segment 2 Length : 3TQ
    mcp_WR_address(TXRTSCTRL,0x00);     //Disable RTS PINs    
    mcp_WR_address(TXB0CTRL,0x03);      //Lowest Message Priority   
    mcp_WR_address(TXB1CTRL,0x02);      //High Intermediate Message Priority
    mcp_WR_address(TXB2CTRL,0x00);      //Highest Message Priority  
    
    mcp_WR_address(BFPCTRL,0x00);       //disable RX PINs
    mcp_WR_address(RXB0CTRL,0x00);      //0x00, normal ; Rollover disenabled ; Acceptance Filter 0 (RXF0)   
    mcp_WR_address(RXF0SIDH,Get_CAN_address());      //RXF0SIDH        
    mcp_WR_address(RXF0SIDL,0x00);      //RXF0SIDL      
    mcp_WR_address(RXM0SIDH,0xff);      //RXM0SIDH   
    mcp_WR_address(RXM0SIDL,0xff);      //RXM0SIDL   
    
    mcp_WR_address(CANINTE,0x00);
    mcp_WR_address(CANINTF,0x00);       //INTERRUPT FLAG
    
    tmp=mcp_RD_address(CNF2); 
    mcp_WR_address(CANCTRL,RQM_NORMAL);    
    tmp=mcp_RD_address(CANSTAT);       
    tmp &= 0xE0; 
    while(tmp!=0)    
    { 
        mcp_WR_address(CANCTRL,RQM_CONFIG);                      
        mcp_WR_address(CANCTRL,RQM_NORMAL);         
        tmp=mcp_RD_address(CANSTAT); 
        tmp &= 0xE0;                
    } 
     
}