Normal-Mode CAN-BUS

[Christoph H. (obbedair)]

Hallo,
folgendes Problem
nachdem ich den CAN-Bus konfiguriert habe möchte ich wieder in den 
Normal-Mode zurück... das geschieht ja bekanntlich mit folgendem 
Codeschnipsel

CANCON = 0x00;

    while(CANSTATbits.OPMODE0 == TRUE &&
          CANSTATbits.OPMODE1 == TRUE &&
          CANSTATbits.OPMODE2 == FALSE );

aber der PIC(PIC18F2480) bleibt in dieser While-schleife einfach 
hängen... also irgendwie läst sich die 0x00 nicht in das CANCON-Register 
schreiben wie mir scheint?
kann mir jemand helfen? habe ich etwas nicht beachtet?
MfG
Christoph

[Christoph H. (obbedair)]

kleiner Fehler...
alle drei Bits müssen NULL/FALSE sein
also ...

CANCON = 0x00;

    while(CANSTATbits.OPMODE0 == FALSE &&
          CANSTATbits.OPMODE1 == FALSE &&
          CANSTATbits.OPMODE2 == FALSE );

[Ste N. (steno)]

Hallo Christoph,

ich nutze den Code aus den Microchip Beispielen und da wird das 
folgendermaßen erledigt...

typedef enum _CAN_OP_MODE
  {
    CAN_OP_MODE_BITS    = 0xe0,   // Use this to access opmode bits
    CAN_OP_MODE_NORMAL  = 0x00,
    CAN_OP_MODE_SLEEP    = 0x20,
    CAN_OP_MODE_LOOP    = 0x40,
    CAN_OP_MODE_LISTEN  = 0x60,
    CAN_OP_MODE_CONFIG  = 0x80
  } CAN_OP_MODE;

:::

void CAN_SetOperationMode(CAN_OP_MODE mode)
{
  CANCON &= 0x1F;                         // clear previous mode
  CANCON |= mode;                         // set new mode
  // Wait untill desired mode is set
  while( (CANSTAT & CAN_OP_MODE_BITS) != mode ); 
}

Das ist ja bis hier praktisch identisch mit deinem Code. Allerdings wird 
diese Funktion nur für das Umschalten in den ConfigMode benutzt, beim 
zurück Schalten in den NormalMode nutzt Microchip ein nicht 
blockierendes Makro (Funktion) ala...

#define CANSetOperationModeNoWait(mode)    \
          {                                  \
            CANCON &= 0x1F;                  \
            CANCON |= mode;                  \
          }

Der Aufruf im Programm sieht dann in etwa so aus...

void CAN_Init (void)
{
  CAN_SetOperationMode(CAN_OP_MODE_CONFIG);
  :::
  CANSetOperationModeNoWait(CAN_OP_MODE_NORMAL);
}

Ich hab mir darüber noch nie Gedanken gemacht, so mach ich es auch und 
es funktioniert! Was will man mehr...



Gruß, Steffen

[Christoph H. (obbedair)]

erstmal besten Dank!
habs noch nicht ausprobiert aber wenns bei dir funzt und es von 
microchip ist bin ich da guter dinge...
allerdings ist mein Code-schnipsle auch von Microchip... und 
funktioniert nicht...
wo genau hast du das her?

[Ste N. (steno)]

...sind aus dem CanOpen Stack von Microchip.

can.h
can.c

Gruß, Steffen

[Ste N. (steno)]

Gerade noch mal nachgeschaut...

in der AN738 von Microchip macht man es auch so wie Du. Hier mal der 
Codeauschnitt.

enum CAN_OP_MODE
{
    CAN_OP_MODE_BITS    = 0b11100000,   // Use this to access opmode
                                        // bits
    CAN_OP_MODE_NORMAL  = 0b00000000,
    CAN_OP_MODE_SLEEP   = 0b00100000,
    CAN_OP_MODE_LOOP    = 0b01000000,
    CAN_OP_MODE_LISTEN  = 0b01100000,
    CAN_OP_MODE_CONFIG  = 0b10000000
};

:::

void CANSetOperationMode(enum CAN_OP_MODE mode)
{
     // Request desired mode.
     CANCON = mode;

    // Wait till desired mode is set.
    while( (CANSTAT & CAN_OP_MODE_BITS) != mode );
}

Hab es jetzt nicht mehr genau in Erinnerung, aber ich würde behaupten 
das auch das bei mir funktioniert hat.

Obwohl, ich sehe gerade... hängst Du hier nicht in einer Endlosschleife 
fest?

CANCON = 0x00;

    while(CANSTATbits.OPMODE0 == FALSE &&
          CANSTATbits.OPMODE1 == FALSE &&
          CANSTATbits.OPMODE2 == FALSE );

Die CANSTATbits müssen doch 0 sein. Deine Abfrage macht so doch nicht 
das selbe wie der Code von Microchip.

Gruß, Steffen

[Christoph H. (obbedair)]

ich schreibe doch in das CANSTAT-Register eine 0x00 und frage dann ab ob 
auch wirklich alle null sind? wenn alle null sind gehts weiter. Ich denk 
das ist so richtig... funktioniert hat es allerdings nicht... aber wenns 
falsch ist versteh ich nicht warum...

noch eine Frage zu diesen AN´s,

also ich hab die AN945 gefunden... blicke da aber überhaupt nicht 
durch...
die von dir erwähnt AN738 erscheint mir wesentlich übersichtlicher.
Kann ich die AN738 nutzen? gibt es irgendwo mal einen vollständigen Code 
damit ich mir angucken kann wie soetwas auszusehen hat?

[Ste N. (steno)]

Christoph Herzog schrieb...

> ich schreibe doch in das CANSTAT-Register eine 0x00 und frage dann ab ob
> auch wirklich alle null sind? wenn alle null sind gehts weiter. Ich denk
> das ist so richtig...

Eben nicht... eine While-Schleife wird doch so lange ausgeführt, wie die 
Bedingung wahr ist. Wenn du die CANSTATbits auf FALSE (0) testest ergibt 
es doch Wahr, also wird die Schleife nie verlassen.

Schau dir mal die AN878 an, ist so ähnlich wie AN738, nutzt nur den ECAN 
Mode.

[Christoph H. (obbedair)]

oki also das mit der whileschleife war ein denkfehler von mir... 
danke!!!
AN878 wird angeguckt ! ;)

[Christoph H. (obbedair)]

diese ECAN.def-Datei soll ja noch definiert werden?
ist es sinnvoll das mit dieser Software zu machen oder per Hand? ich hab 
mir die software mal angeguckt und die Datei ... naja und beide sind für 
den Einstieg noch recht schwerzu verstehen finde ich

[Ste N. (steno)]

Keine Ahnung, hab damit nicht gearbeitet. Ich tue mich mit fremdem Code 
auch immer schwer, jeder hat ja da so seine Vorlieben. Ich nehme mir 
immer Teile davon vor und schreibe damit meine eigenen Funktionen. Dabei 
lernt man dann auch wie es wirklich funktioniert.

Hier mal Teile meiner can.h und can.c

#define PORT_CAN_TX_PIN    LATCbits.LATC6  

// CAN Baud Rate Prescaler bei FOSC 64MHz und BitTime 16TQ
#define CAN_BRP_100K      0x13  //  100kbit
#define CAN_BRP_125K      0x0F  //  125kbit
#define CAN_BRP_250K      0x07  //  250kbit
#define CAN_BRP_500K      0x03  //  500kbit
#define CAN_BRP_1000K      0x01  // 1000kbit


typedef enum _CAN_FLAGS
{
  CAN_MSG_STD          = 0,
  CAN_MSG_XTD          = 1,
  
  CAN_CONFIG_B0_BITS  = 0b01100100,
  CAN_CONFIG_B1_BITS  = 0b01100000,
  
  CAN_DBL_BUFFER_ON    = 0b00000100,    // XXX1XXXX
  CAN_DBL_BUFFER_OFF  = 0b00000000,    // XXX0XXXX
 
  CAN_ALL_MSG          = 0b01100000,    // X11XXXXX
  CAN_VALID_XTD_MSG    = 0b01000000,    // X10XXXXX
  CAN_VALID_STD_MSG    = 0b00100000,    // X01XXXXX
  CAN_ALL_VALID_MSG    = 0b00000000    // X00XXXXX
} CAN_FLAGS;


void CAN_SetBaudRate (BYTE brp)
{
  /*                              Sync Jump Width
                                   <--->
  |_Sync_|_Delay _|______Phase1______|__Phase2__|
  |                              ^ ^ ^          |
  |                              SamplePoint    |
  |<---------------- Bit Time ----------------->|  */
  
  // Die folgenden 4 Elemente ergeben die CAN Bit Time
  #define CAN_SYNC_SEG    1      // (immer 1) Sync Segment = 1TQ
  #define CAN_PROP_DELAY  2      // (1-8)     Propagation Delay = 2TQ
  #define CAN_PH_SEG_1    8      // (1-8)     Phase Segment 1 = 8TQ
  #define CAN_PH_SEG_2    5      // (1-8)     Phase Segment 2 = 5TQ
  // Bit Time = (Sync Segment + Propagation Delay + Phase Segment 1 + Phase Segment 2) = 16*TQ
  
  #define CAN_JUMP_WDH    1      // Syncronization Jump Width = 1 (1-4)
  
  #define CAN_SEG_2_FREE  1      // (bit) Phase Segment 2 frei Programierbar
  #define CAN_MULTI_SMPL  1      // (bit) Multiple sampling is on
  #define CAN_WAKE_UP_DIS  0      // (bit) Wake-up Disable
  #define CAN_LINE_FLT    0      // (bit) Selects CAN bus Line Filter for Wake-up

  BRGCON1 = ((CAN_JUMP_WDH-1) << 6) | (brp);
  
  BRGCON2 =  (CAN_SEG_2_FREE << 7)    |
            (CAN_MULTI_SMPL << 6)    |
            ((CAN_PH_SEG_1-1) << 3)  |
            (CAN_PROP_DELAY-1);          
  
  BRGCON3 =  (CAN_WAKE_UP_DIS << 7) |
            (CAN_LINE_FLT << 6)    |
            (CAN_PH_SEG_2-1);
}


void CAN_Init (BYTE brp, BYTE config)
{
  CAN_SetOperationMode(CAN_OP_MODE_CONFIG);
  
  // Set I/O control
  CIOCON = 0x00;          // Reset CAN I/O Control Register
  CIOCONbits.ENDRHI = 1;  // CANTX pin will drive VDD when recessive 
  CIOCONbits.CLKSEL = 0;  // Use the PLL as the source of the CAN system clock
  
  PORT_CAN_TX_PIN = 1;    // CAN TX Pin auf 1 setzen, der Tranceiver funktioniert sonst nicht
  
  CAN_SetBaudRate (brp);
  
  // ECAN Module in mode 0
  ECANCON = 0x00;
  
  RXB0CON = config & CAN_CONFIG_B0_BITS;
  RXB1CON = config & CAN_CONFIG_B1_BITS;
  
  // Set default filter and mask registers for all receive buffers.
  CANSetMask(CAN_MASK_B1, 0x0800FF00, CAN_MSG_XTD);
  CANSetMask(CAN_MASK_B2, 0x000000FF, CAN_MSG_XTD);
  
  // By default, there will be no mask on any receive filters,
  // hence filter value of '0' will be ignored.
  CANSetFilter(CAN_FILTER_B1_F1, 0x08000000, CAN_MSG_XTD);  // Filter 1
  CANSetFilter(CAN_FILTER_B1_F2, 0x08000400, CAN_MSG_XTD);          // Filter 2
  CANSetFilter(CAN_FILTER_B2_F1, 0x00000000, CAN_MSG_XTD);          // Filter 3
  CANSetFilter(CAN_FILTER_B2_F2, 0x00000000, CAN_MSG_XTD);          // Filter 4
  CANSetFilter(CAN_FILTER_B2_F3, 0x00000000, CAN_MSG_XTD);          // Filter 5
  CANSetFilter(CAN_FILTER_B2_F4, 0x00000000, CAN_MSG_XTD);          // Filter 6
  
  // Set interrupts
  PIE5bits.RXB0IE = 1;  // Receive Buffer 0 Interrupt enabled
  PIE5bits.RXB1IE = 1;  // Receive Buffer 1 Interrupt enabled
  IPR5bits.RXB0IP = 0;  // Low priority for Receive Buffer 0
  IPR5bits.RXB1IP = 0;  // Low priority for Receive Buffer 1
  
  CANSetOperationModeNoWait(CAN_OP_MODE_NORMAL);
}

in der Main

CAN_Init (CAN_BRP_250K, CAN_VALID_XTD_MSG | CAN_DBL_BUFFER_ON);

CANSetMask() und CANSetFilter() sind fast 1:1 aus der AN738

[Christoph H. (obbedair)]

folgendes Probelm tut sich gerad bei meinem Code auf

typedef enum _BOOL { FALSE = 0, TRUE } BOOL;

ich habe mich zu diesem enum-Zeug ein bissel belesen und kann kein 
Fehler finden... ist ja eigentlich auch von Mircochip selbst... ich hab 
das gar nicht angefast... :(

ECAN.h:77: error: enum tag "_BOOL" redefined (from C:\Program Files 
(x86)\Microchip\xc8\v1.12\include\GenericTypeDefs.h:65)

in der GenericTypeDefs.h hab ich mich auch mal umgeschaut...

was will der compiler jetzt von mir?

[Christoph H. (obbedair)]

das Problem hab ich gelöst ;)

aber werden sicher weitere Folgen ;)

[Christoph H. (obbedair)]

hallo nochmal... also ich habe die Konfiguration für den CAN-Bus jetzt 
fertig denke ich...

wenn ich jetzt einen Frame senden möchte wird allerdings das ERRI und 
das IRXI Flag gesetzt...
ich weiß aber nicht genau was die beiden auslöst...
 Auf dem Bus ist auf jeden fall ne Menge los. wenn ich ein Frame senden 
möchte hört der Pic gar nicht mehr auf zu senden.

wie kann ich mir das erklären?
an bei mal meine Init und die Transmitfunktion
wer toll wenn mal einer drüber schauen könnte
MfG
   Christoph

#include <p18cxxx.h>
#include "ECAN.h"


/*********************************************************************
*
*                             Defines 
*
*********************************************************************/


// ECAN 
#define   F_ECANMode2_FP        CANCON&0x0F
#define   F_ECANFIFO_0          RXB0CONbits.RXFUL
#define   F_ECANFIFO_1          RXB1CONbits.RXFUL
#define   F_ECANFIFO_2          B0CONbits.RXFUL
#define   F_ECANFIFO_3          B1CONbits.RXFUL
#define   F_ECANFIFO_4          B2CONbits.RXFUL
#define   F_ECANFIFO_5          B3CONbits.RXFUL
#define   F_ECANFIFO_6          B4CONbits.RXFUL
#define   F_ECANFIFO_7          B5CONbits.RXFUL



#define CANSetOperationModeNoWait(mode)    \
          {                                  \
            CANCON &= 0x1F;                  \
            CANCON |= mode;                  \
          }


/*********************************************************************
*
*                            Global Variables 
*
*********************************************************************/
unsigned char temp_EIDH;
unsigned char temp_EIDL;
unsigned char temp_SIDH;
unsigned char temp_SIDL;
unsigned char temp_DLC;
unsigned char temp_D0;
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;

typedef enum _CAN_OP_MODE
  {
    CAN_OP_MODE_BITS    = 0xe0,   // Use this to access opmode bits
    CAN_OP_MODE_NORMAL  = 0x00,
    CAN_OP_MODE_SLEEP    = 0x20,
    CAN_OP_MODE_LOOP    = 0x40,
    CAN_OP_MODE_LISTEN  = 0x60,
    CAN_OP_MODE_CONFIG  = 0x80
  } CAN_OP_MODE;



/*********************************************************************
*
*                       Configure the CAN Module
*
*********************************************************************/
void InitECAN(void)
{
    // Enter CAN module into config mode


  CANSTAT &= 0x1F;                         // clear previous mode
  CANSTAT |= 0x80;                         // set new mode
  // Wait untill desired mode is set
  while( CANSTAT != 0x80 );

  
    // Enter CAN module into Mode 2
   
    ECANCON = 0x80;


    // Initialize CAN Timing  
    
        //  8MHz
        BRGCON1 = 0xE1; //1110 0001     //SJW=4 TQ     BRP  4
        BRGCON2 = 0x1B; //0001 1011     //SEG2PHTS 1    sampled once  PS1=4TQ  PropagationT 4TQ
        BRGCON3 = 0x03; //0000 0011     //PS2  4TQ
    
    
    
    
    // Setup Programmable buffers
    //  B0 is a receive buffer AND B2,B3,B4,B5 are Transmit buffers
    BSEL0 = 0xF8;   //1111 10--
    
    // Initialize Receive Masks
    
    RXM0EIDH = 0x00;    // 0's for EID and SID
    RXM0EIDL = 0x00;
    RXM0SIDH = 0xFF;    // Standard ID FILTER
    RXM0SIDL = 0x80;
    
    RXM1EIDH = 0x00;    
    RXM1EIDL = 0x00;
    RXM1SIDH = 0xFF;
    RXM1SIDL = 0x80;
   

    // Enable Filters
    // Filter 0
    RXFCON0 = 0x01;     //
    RXFCON1 = 0x00;     //Disable all from Filter 1-15
    
    // Assign Filters to Masks
   
    MSEL0 = 0xFF;     //Assign Filters 0-3     to   // No mask
    MSEL1 = 0xFF;     //Assign Filters 4-7     to   // No mask
    MSEL2 = 0xFF;     //Assign Filters 8-11    to   // No mask
    MSEL3 = 0xFF;     //Assign Filters 12-15   to   // No mask
   
    
  

    // Initialize Receive Filters
    //  Filter 0 = 0xFFC
    RXF0EIDH = 0x00;
    RXF0EIDL = 0x00;
    RXF0SIDH = 0x6B;
    RXF0SIDL = 0xC0;
    //  Filter 1 = 0xFFC
    RXF1EIDH = 0x00;
    RXF1EIDL = 0x00;
    RXF1SIDH = 0xFF;
    RXF1SIDL = 0xC0;

    // Enter CAN module into normal mode
    CANSetOperationModeNoWait(CAN_OP_MODE_NORMAL);

    // Set Receive Mode for buffers
    RXB0CON = 0x00;
    RXB1CON = 0x00;

}


/*********************************************************************
*
*                      Transmit Sample Mesaage
*
*********************************************************************/
void ECAN_Transmit(void)
{
    TXB0EIDH = 0x00;            // Identifier
    TXB0EIDL = 0x00;            // Identifier
    
    //0x35E    0110 1011 110
    TXB0SIDH = 0x6B;            // Identifier
    TXB0SIDL = 0xC0;            // Identifier

    TXB0DLC = 0x03;             // DataLength
    TXB0D0 = 0xAA;              // DataByte
    TXB0D1 = 0xCC;              // DataByte
    TXB0D2 = 0x55;              // DataByte
    TXB0D3 = 0x00;              // DataByte
    TXB0D4 = 0x00;              // DataByte
    TXB0D5 = 0x00;              // DataByte
    TXB0D6 = 0x00;              // DataByte
    TXB0D7 = 0x00;              // DataByte
    
    TXB0CONbits.TXREQ = 1; //Set the buffer to transmit
    

    
}

[Ste N. (steno)]

Du hast aber mindestens noch einen 2. aktiven Teilnehmer am CAN-Bus?

[Christoph H. (obbedair)]

ja den hab ich...

aber da ich nicht weiß ob die initialisierung wirklich richtig ist weiß 
ich auch nicht ob das alles so hin haut

[Ste N. (steno)]

Da kann ich dir jetzt leider auch nicht direkt helfen, ich habe das 
CAN-Modul im Mode0 benutzt.

Was für einen Quarz hängt an deinem PIC und benutzt Du die interne PLL? 
Bedenke das die Werte im BRP-Register von FOSC ausgehen. Z.B. bei einem 
8MHz Quarz und 4xPLL = 32MHz. Die Pic rechnet dann wieder nur mit 8MHz, 
da er immer 4 Taktzyklen für einen Befehl benötigt.

Stimmen alle Richtungen der IO's? Ich weiß jetzt nicht ob sich das 
CAN-Modul die Ein- und Ausgänge selber setzt. Ich mußte bei mir, in der 
Init() Routine den CAN-TX Pin von Hand auf high setzen, sonst ging 
nichts. Aber bei dir scheint ja auf dem Bus schon was los zu sein...

Kennst Du das Tool MBTime von Microchip, mit dem kann man die Werte für 
die BRP-Register berechnen lassen. Funktioniert für den mcp2551 und die 
pic18.

http://www.codeforge.com/article/200254

Gruß, Steffen

Sehe gerade das man sich zum Download anmelden muß, also wenn du es 
benötigst kurze Nachricht an mich. Sende es dir dann per mail.

[Christoph H. (obbedair)]

ich werde das jetzt auch alles für den Mode 0 machen...
zum einen weiß ich noch gar nicht genau was der FIFO-Mode ist zum 
anderen brauch ich den EXTENDED-Kram gar nicht...

Auf dem Bus ist schon ordentlich Party ja... also gesendet wird sobald 
ich das will... aber ich weiß halt nicht genau für was die beiden 
Fehler-bits ERRI und IRXI stehen...

der andere Busteilnehmer müssten doch den empfang bestätigen ne? sonst 
hört der sendende Busteilnehmer nicht auf???

[Ste N. (steno)]

Christoph Herzog schrieb:
> der andere Busteilnehmer müssten doch den empfang bestätigen ne? sonst
> hört der sendende Busteilnehmer nicht auf???

Genau so sollte es sein. Allerdings müßte der sendende Knoten irgendwann 
in der Error Status gehen und das Senden aufgeben. Haben auch alle 
Knoten die selbe Baudrate?

Versuch doch mal den Loopback Modus, dann solltest Du keinen weiteren 
Teilnehmer benötigen. Du empfängst dann praktisch deine eigenen 
Telegramme.

[Christoph H. (obbedair)]

Baudrate ist die gleiche... sind beides Pic18F2480 mit internen 8Mhz 
gleiche ECAN-ini... nur die Filter sind geändert bzw. die Identifier.

was genau bringt mir der Loopback modus... also ich habe ihn schon mal 
ausprobiert und benutzt allerdings nicht mit dir jetztige von mir selbst 
geschriebenen ECAN.h / ECAN.c.

also ich schicke was und Empfange es gleich wieder... liegt es dann auch 
auf dem bus?oder Passiert das nur intern im Controller?
muss ich im Loopback-modus den gleichen Filter haben wie ich als 
identifier raus gebe?
na mal sehen was wird ;) teste das jetzt mal

danke erstmal
PS.: auch für die Datei

[Ste N. (steno)]

Du arbeitest mit dem internen 8Mhz Oszillator? Ich kann mich täuschen, 
aber ich glaube da reichen die Toleranzen nicht. Bei CAN sollte man 
schon einen externen Quarz nehmen, oder mal ganz ganz niedrige Baudraten 
versuchen.

So ganz genau kenne ich mich mit dem Loopbackmodus auch nicht aus. Ich 
habe das so verstanden, das er dann quasi mit sich selbst kommuniziert 
ohne die Signale auf den Bus zu legen. Du mußt natürlich auch die Filter 
so setzen, das die Frames durchgehen. Damit kann man im Prinzip die 
grundlegende Funktionalität ohne weitere Teilnehmer testen.

PS: Gerne...

[Christoph H. (obbedair)]

eine Frage mal noch zum auslesen bzw. senden auf den Can-Bus

ich habe das ganze jetzt erstmal im Loop-modus zu laufen.
wenn ich einmal sende ist alles oki... es wird gesendet und empfangen 
und der pic läuft weiter...
wenn ich ein zweites mal senden will bleibt das ding irgendwo hängen, 
also in einem Interrupt mit sicherheit. komischer weiße wird mir nicht 
angezeigt welches der 4 Flags auslöst ( ERRI IRXIF TXB0IF TXB1IF)
da stellt sich mir die frage was ich mit den empfangenen Daten anstellen 
darf/muss... müssen irgendwelche bits nach dem Empfangen manuel zurück 
gesetzt werden??


beim schreiben setze ich einfache alle notwendigen variablen und setze 
am ende das TXREQ-Bit zum senden

beim auslesen, lese ich alle Daten aus beschreibe sie danach mit Null 
und setze das PIR3.RXB0IF = 0

[Ste N. (steno)]

Kann dir jetzt auf die Schnelle nur meine Intrruptabfrage zeigen, muß 
gleich los...

// CAN Receive Buffer 0 Interrupt Flag 
  if (PIR5bits.RXB0IF)
  {
    if (RXB0CONbits.RXFUL)
    {
      CAN_ReceiveMessage ();
      RXB0CONbits.RXFUL = 0;
    }
    PIR5bits.RXB0IF = 0;        // Clear the received flag.
  }

  // CAN Receive Buffer 1 Interrupt Flag
  if (PIR5bits.RXB1IF)
  {
    if (RXB1CONbits.RXFUL)
    {
      CAN_ReceiveMessage ();
      RXB1CONbits.RXFUL = 0;
    }
    PIR5bits.RXB1IF = 0;        // Clear the received flag.
  }

Die Funktion CAN_ReceiveMessage() liest nur die Register aus, da wird 
nichts geändert. Störe dich nicht an den Registernamen, ich arbeite mit 
dem PIC18F46K80. Versuch doch auch mal mit den Prioritäten der Interrups 
zu spielen, sind da alle Register richtig gesetzt?

Gruß, viel Erfolg und ein schönes WE... :-)