Can-шина на pic18f25k80, поиск ошибки

#include <xc.h>
#include <stdlib.h>
#include <stdio.h>
#include <p18cxxx.h>
 
#define F_ECAN_250    1       // 1 sets ECAN module for 250kbps
#define F_ECAN_125    0       // 1 sets ECAN module for 125kbps
#define F_ECAN_500    0       // 1 sets ECAN module for 500kbps
#define F_ECAN_1000   0       // 1 sets ECAN module for 1000kbps
 
unsigned char temp_EIDH;    //Extended Identifier, high byte
unsigned char temp_EIDL;    //Extended Identifier, low byte
unsigned char temp_SIDH;    //Standard Identifier, high byte
unsigned char temp_SIDL;    //Standard Identifier, low byte
unsigned char temp_DLC;     //Data Length Control value, 0 to 8
unsigned char temp_D0;      //Data byte 0 through...
unsigned char temp_D1;
unsigned char temp_D2;
unsigned char temp_D3;
unsigned char temp_D4;
unsigned char temp_D5;
unsigned char temp_D6;
unsigned char temp_D7;      //Data byte 7
 
/*********************************************************************
*
*     Function: Check the buffers to determine if they have messages
*               if so, transfer the info to the temporary-storage
*               variables. Note: Messages to receiver 0 or 1 get saved in
*               the same variables.  This id done for simplicity in
*               this example. You could save messages to separate
*               variables, or in separate arrays, if you wish. 
*
*********************************************************************/
unsigned char ECAN_Receive(void)
{
    unsigned char RXMsgFlag;    // Temporary storage for message flag
    RXMsgFlag = 0x00;           // Set message flag to zero to start
    
    if (RXB0CONbits.RXFUL)      // Check RXB0CON bit RXFUL to see if RX Buffer 0
                                // has received a message, if so, get the
                                // associated data from the buffer and save it.
    {
        temp_EIDH = RXB0EIDH;   //????????? ? ?????????? ?????? ?? ??????
        temp_EIDL = RXB0EIDL;
        temp_SIDH = RXB0SIDH;
        temp_SIDL = RXB0SIDL;
        temp_DLC =  RXB0DLC;
        temp_D0 =   RXB0D0;
        temp_D1 =   RXB0D1;
        temp_D2 =   RXB0D2;
        temp_D3 =   RXB0D3;
        temp_D4 =   RXB0D4;
        temp_D5 =   RXB0D5;
        temp_D6 =   RXB0D6;
        temp_D7 =   RXB0D7;
        RXB0CONbits.RXFUL = 0;      // Reset buffer-0-full bit to show "empty"
        RXMsgFlag = 0x01;           // Set message flag to 1
    }
    else if (RXB1CONbits.RXFUL) // Check RXB1CON bit RXFUL to see if RX Buffer 1
                                // has received a message, if so, get the
                                // associated data from the buffer and save it.
    {
        temp_EIDH = RXB1EIDH;   //???? ?? ??????? ?????? ??????, ?? ??????? ??????
        temp_EIDL = RXB1EIDL;   //?????? ? ??? ???????
        temp_SIDH = RXB1SIDH;   //???? ???????, ??????????? ?????????? ?????????? ??????
        temp_SIDL = RXB1SIDL;
        temp_DLC =  RXB1DLC;
        temp_D0 =   RXB1D0;
        temp_D1 =   RXB1D1;
        temp_D2 =   RXB1D2;
        temp_D3 =   RXB1D3;
        temp_D4 =   RXB1D4;
        temp_D5 =   RXB1D5;
        temp_D6 =   RXB1D6;
        temp_D7 =   RXB1D7;
        RXB1CONbits.RXFUL = 0;      //Reset buffer-1-full bit to show "empty"
        RXMsgFlag = 0x01;           // Set message flag to 1
    }
    
    
    if  (RXMsgFlag == 0x01)     // Test message flag.
                                // if message flag is a 1...
    {
        RXMsgFlag = 0x00;       // Clear the message flag
        PIR5bits.RXB1IF = 0;    // Clear the Buffer-1 interrupt bit (if used) 
        return 1;            // Return a "true" condition to the code that
                                // called the ECAN_Receive function.
    }
    else
    {
        return 0;           // Otherwise, return a false condition.
    }    
}
 
void ECAN_Transmit(void)
{
    TXB0EIDH = 0x40;    //?????????? ???????? ?????????
    TXB0EIDL = 0xC1;    //18-?????? ????? id
    
    //0x35E    0110 1011 110
    TXB0SIDH = 0x07;    //11-?????? ????? id
    TXB0SIDL = 0xE2;
 
    TXB0DLC = 0x08;     //?????????? ???????????? ????
    TXB0D0 = temp_D0;   //????? ?????????? ? 1 
    TXB0D1 = temp_D1;
    TXB0D2 = temp_D2;
    TXB0D3 = temp_D3;
    TXB0D4 = temp_D4;
    TXB0D5 = temp_D5;
    TXB0D6 = temp_D6;
    TXB0D7 = temp_D7;   //?? 8
    
    TXB0CONbits.TXREQ = 1; //Set the buffer to transmit
    //RXB0CONbits.RXB0M0 = 1;
 
    
}
 
void main(void) {
    //SYSTEM_Initialize();
    unsigned char temp;
    TRISC = 0x00;   //??? ????? ? ??? ??????
    //ODCONbits.CCP2OD = 1;
    //ODCONbits.SSPOD = 1;
    //ODCONbits.U1OD = 1;
    LATC = 0x00;    //????? ??? ??????????
    // Enter CAN module into config mode
    CANCON = 0x80;
    while(!(CANCON & 0x80));
    
    // Enter CAN module into Mode 1
    ECANCON = 0x40;
    
    // Initialize CAN Timing
    //  100 Kbps @ 25Mhz
    //BRGCON1 = 0x44; //0100 0100
    //BRGCON2 = 0xBF; //1011 1111
    //BRGCON3 = 0x07; //0000 0111
    
    //  250 Kbps @ 16Mhz
    BRGCON1 = 0x01; //0000 0011
    BRGCON2 = 0xB8; //1001 0010
    BRGCON3 = 0x05; //0000 0010
   // BRGCON1    b'00000001'     0x01
//BRGCON2    b'10111000'     0xB8
//BRGCON3    b'00000101'     0x05
    //  100 Kbps @ 64MHz
//    BRGCON1 = 0x1F; //0001 1111  
//    BRGCON2 = 0xA0; //1010 0000
//    BRGCON3 = 0x02; //0000 0010 
 
    // Setup Programmable buffers
    //  B0 is a receive buffer AND B2,B3,B4,B5 are Transmit buffers
   // BSEL0 = 0xF8;   //1111 10--
    
    // Initialize Receive Masks
    //  The first mask is used that accepts all SIDs and no EIDs
    //  The second mask is used to ignore all SIDs and EIDs
    RXM0EIDH = 0xFF;    // 1's for EID and 1's for SID
    RXM0EIDL = 0xFF;
    RXM0SIDH = 0xFF;
    RXM0SIDL = 0xFF;
 
    RXM1EIDH = 0xFF;    // 0's for EID and SID
    RXM1EIDL = 0xFF;
    RXM1SIDH = 0xFF;
    RXM1SIDL = 0xFF;
    
    // Enable Filters
    //  Only using first three filters, so the rest can be disabled.
    RXFCON0 = 0x07;     //Enable Filters 0,1,2
    RXFCON1 = 0x00;     //Disable all others
    
    // Assign Filters to Masks
    //  Only one mask is used for three filters
    MSEL0 = 0xC0;     //Assign Filters 0-2 to Mask 0 and 3 to Mask 1
    
    
    // Assign Filters to Buffers
    //  Have the first buffer only accept the first filter, the second buffer accept
    //  the second filter, and the third buffer accept the third filter.
    RXFBCON0 = 0x10;     //Assign Filter 0 to RXB0, and Filter 1 to RXB1
    
    RXFBCON1 = 0xFF;    
    RXFBCON2 = 0xFF;     //Assign the rest of the buffers with no filter
    RXFBCON3 = 0xFF;
    RXFBCON4 = 0xFF;
    RXFBCON5 = 0xFF;
    RXFBCON6 = 0xFF;
    RXFBCON7 = 0xFF;
    
    // Initialize Receive Filters
    //  Filter 0 = 0x444
    //  Filter 1 = 0x111
    //  Filter 2 = 0x0A0
    RXF0EIDH = 0x41;
    RXF0EIDL = 0x17;
    RXF0SIDH = 0x07;
    RXF0SIDL = 0xEA;
    RXF1EIDH = 0x41;
    RXF1EIDL = 0x39;
    RXF1SIDH = 0x07;
    RXF1SIDL = 0xE2;
    
    // Enter CAN module into normal mode
    CANCON = 0x00;
    while(CANCON & 0xE0);
    
    // Set Receive and Transmit Modes for buffers
    RXB0CON = 0x00;
    RXB1CON = 0x00;
    TXB0CON = 0x00;
    
    while(1)
        {
            ECAN_Receive(); //????????? ????????? ??????
  
            if (temp_D7 == 0xFD)    //???? ? 8 ????? ?????????? ??????, ?? ???????? ??????
            {
                ECAN_Transmit();
            }
            if (temp_D1 == 0xDF)    //?????? ?? ????????? ??????? ????????
            {
                LATCbits.LATC7 = 1; //???????? ?????????
            }
           
            if (temp_D2 == 0xFD)    //??????? ??????? ????, ? ??????? ????????????? ???????????? ?????????
            {
                LATCbits.LATC3 = 1;
                LATCbits.LATC5 = 1;
            }
            if (temp_D2 == 0xDF)    //??????? ????-???????, ?????????? ????
            {
                LATCbits.LATC6 = 1;
            }
            if (temp_D3 == 0x7F)    //??????? ??????????? ????, ????
            {
                LATCbits.LATC4 = 1;
            }
            if (temp_D4 == 0xFD)    //??????? ??? ??????????????
            {
                LATCbits.LATC2 = 1;
            }
    }
}