Normal-Mode CAN-BUS

CANCON = 0x00;

    while(CANSTATbits.OPMODE0 == FALSE &&

          CANSTATbits.OPMODE1 == FALSE &&

          CANSTATbits.OPMODE2 == FALSE );

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 ); 

}

#define CANSetOperationModeNoWait(mode)    \

          {                                  \

            CANCON &= 0x1F;                  \

            CANCON |= mode;                  \

          }

void CAN_Init (void)

{

  CAN_SetOperationMode(CAN_OP_MODE_CONFIG);

  :::

  CANSetOperationModeNoWait(CAN_OP_MODE_NORMAL);

}

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 );

}

CANCON = 0x00;

    while(CANSTATbits.OPMODE0 == FALSE &&

          CANSTATbits.OPMODE1 == FALSE &&

          CANSTATbits.OPMODE2 == FALSE );

#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);

}

CAN_Init (CAN_BRP_250K, CAN_VALID_XTD_MSG | CAN_DBL_BUFFER_ON);

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

#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

}

// 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.

  }