The mikroPascal PRO for PIC provides a library (driver) for working with the CAN module.

The CAN is a very robust protocol that has error detection and signalization, self–checking and fault confinement. Faulty CAN data and remote frames are re-transmitted automatically, similar to the Ethernet.

Data transfer rates depends on the distance. For example, 1 Mbit/s can be achieved at network lengths below 40m while 250 Kbit/s can be achieved at network lengths below 250m. The greater distance the lower maximum bitrate that can be achieved. The lowest bitrate defined by the standard is 200Kbit/s. Cables used are shielded twisted pairs.

CAN supports two message formats:

• Standard format, with 11 identifier bits, and
• Extended format, with 29 identifier bits

  Important :

• Consult the CAN standard about CAN bus termination resistance.

Library Routines

• CANSetOperationMode
• CANGetOperationMode
• CANInitialize
• CANSetBaudRate
• CANSetMask
• CANSetFilter
• CANRead
• CANWrite
• CANSetTxIdleLevel

CANSetOperationMode

CANSetOperationMode(_CAN_MODE_CONFIG, 0xFF);

CANGetOperationMode

if (CANGetOperationMode = _CAN_MODE_NORMAL) then
...

CANInitialize

if (_CAN_CONFIG_FLAGS and _CAN_CONFIG_VALID_XTD_MSG) <> 0
  // Set all filters to XTD_MSG
else if (config and CONFIG_VALID_STD_MSG) <> 0
  // Set all filters to STD_MSG
else
  // Set half of the filters to STD, and the rest to XTD_MSG.

init := _CAN_CONFIG_SAMPLE_THRICE and
        _CAN_CONFIG_PHSEG2_PRG_ON and
        _CAN_CONFIG_STD_MSG       and
        _CAN_CONFIG_DBL_BUFFER_ON and
        _CAN_CONFIG_VALID_XTD_MSG and
        _CAN_CONFIG_LINE_FILTER_OFF;
...
CANInitialize(1, 1, 3, 3, 1, init);   // initialize CAN

CANSetBaudRate

init := _CAN_CONFIG_SAMPLE_THRICE and
        _CAN_CONFIG_PHSEG2_PRG_ON and
        _CAN_CONFIG_STD_MSG       and
        _CAN_CONFIG_DBL_BUFFER_ON and
        _CAN_CONFIG_VALID_XTD_MSG and
        _CAN_CONFIG_LINE_FILTER_OFF;
...
CANSetBaudRate(1, 1, 3, 3, 1, init);

CANSetMask

// Set all mask bits to 1, i.e. all filtered bits are relevant:
CANSetMask(_CAN_MASK_B1, -1, _CAN_CONFIG_XTD_MSG);

// Note that -1 is just a cheaper way to write 0xFFFFFFFF.
   Complement will do the trick and fill it up with ones.

CANSetFilter

// Set id of filter B1_F1 to 3:
CANSetFilter(_CAN_FILTER_B1_F1, 3, _CAN_CONFIG_XTD_MSG);

CANRead

var
  rcv, rx, len : byte;
  data : array[8] of byte;
  id : longint;

// ...
rx := 0;
// ...
rcv := CANRead(id, data, len, rx);

CANWrite

var
  tx, data : byte;
  id : longint;

// ...
tx := _CAN_TX_PRIORITY_0 and
      _CAN_TX_XTD_FRAME;
// ...
CANWrite(id, data, 2, tx);

CANSetTxIdleLevel

CANSetTxIdleLevel(_CAN_DRIVE_HIGH_STATE_ENABLE);

CAN Constants

There is a number of constants predefined in CAN library. To be able to use the library effectively, you need to be familiar with these. You might want to check the example at the end of the chapter.

CAN_OP_MODE

CAN_OP_MODE constants define CAN operation mode. Function CANSetOperationMode expects one of these as its argument:

const _CAN_MODE_BITS    = $E0;  // Use it to access mode bits
const _CAN_MODE_NORMAL  = 0;
const _CAN_MODE_SLEEP   = $20;
const _CAN_MODE_LOOP    = $40;
const _CAN_MODE_LISTEN  = $60;
const _CAN_MODE_CONFIG  = $80;

CAN_CONFIG_FLAGS

CAN_CONFIG_FLAGS constants define flags related to CAN module configuration. Functions CANInitialize and CANSetBaudRate expect one of these (or a bitwise combination) as their argument:

const _CAN_CONFIG_DEFAULT         = $FF;  // 11111111

const _CAN_CONFIG_PHSEG2_PRG_BIT  = $01;
const _CAN_CONFIG_PHSEG2_PRG_ON   = $FF;  // XXXXXXX1
const _CAN_CONFIG_PHSEG2_PRG_OFF  = $FE;  // XXXXXXX0

const _CAN_CONFIG_LINE_FILTER_BIT = $02;
const _CAN_CONFIG_LINE_FILTER_ON  = $FF;  // XXXXXX1X
const _CAN_CONFIG_LINE_FILTER_OFF = $FD;  // XXXXXX0X

const _CAN_CONFIG_SAMPLE_BIT      = $04;
const _CAN_CONFIG_SAMPLE_ONCE     = $FF;  // XXXXX1XX
const _CAN_CONFIG_SAMPLE_THRICE   = $FB;  // XXXXX0XX

const _CAN_CONFIG_MSG_TYPE_BIT    = $08;
const _CAN_CONFIG_STD_MSG         = $FF;  // XXXX1XXX
const _CAN_CONFIG_XTD_MSG         = $F7;  // XXXX0XXX

const _CAN_CONFIG_DBL_BUFFER_BIT  = $10;
const _CAN_CONFIG_DBL_BUFFER_ON   = $FF;  // XXX1XXXX
const _CAN_CONFIG_DBL_BUFFER_OFF  = $EF;  // XXX0XXXX

const _CAN_CONFIG_MSG_BITS        = $60;
const _CAN_CONFIG_ALL_MSG         = $FF;  // X11XXXXX
const _CAN_CONFIG_VALID_XTD_MSG   = $DF;  // X10XXXXX
const _CAN_CONFIG_VALID_STD_MSG   = $BF;  // X01XXXXX
const _CAN_CONFIG_ALL_VALID_MSG   = $9F;  // X00XXXXX

You may use bitwise and to form config byte out of these values. For example:

Copy Code To Clipboard

init := _CAN_CONFIG_SAMPLE_THRICE and
        _CAN_CONFIG_PHSEG2_PRG_ON and
        _CAN_CONFIG_STD_MSG       and
        _CAN_CONFIG_DBL_BUFFER_ON and
        _CAN_CONFIG_VALID_XTD_MSG and
        _CAN_CONFIG_LINE_FILTER_OFF;
...
CANInitialize(1, 1, 3, 3, 1, init);   // Initialize CAN

CAN_TX_MSG_FLAGS

CAN_TX_MSG_FLAGS are flags related to transmission of a CAN message:

const _CAN_TX_PRIORITY_BITS  = $03;
const _CAN_TX_PRIORITY_0     = $FC;  // XXXXXX00
const _CAN_TX_PRIORITY_1     = $FD;  // XXXXXX01
const _CAN_TX_PRIORITY_2     = $FE;  // XXXXXX10
const _CAN_TX_PRIORITY_3     = $FF;  // XXXXXX11

const _CAN_TX_FRAME_BIT      = $08;
const _CAN_TX_STD_FRAME      = $FF;  // XXXXX1XX
const _CAN_TX_XTD_FRAME      = $F7;  // XXXXX0XX

const _CAN_TX_RTR_BIT        = $40;
const _CAN_TX_NO_RTR_FRAME   = $FF;  // X1XXXXXX
const _CAN_TX_RTR_FRAME      = $BF;  // X0XXXXXX

You may use bitwise and to adjust the appropriate flags. For example:

Copy Code To Clipboard

// form value to be used with CANSendMessage:
send_config := _CAN_TX_PRIORITY_0 and
               _CAN_TX_XTD_FRAME  and
               _CAN_TX_NO_RTR_FRAME;
...
CANSendMessage(id, data, 1, send_config);

CAN_RX_MSG_FLAGS

CAN_RX_MSG_FLAGS are flags related to reception of CAN message. If a particular bit is set; corresponding meaning is TRUE or else it will be FALSE.

const _CAN_RX_FILTER_BITS  = $07;  // Use it to access filter bits
const _CAN_RX_FILTER_1     = $00;
const _CAN_RX_FILTER_2     = $01;
const _CAN_RX_FILTER_3     = $02;
const _CAN_RX_FILTER_4     = $03;
const _CAN_RX_FILTER_5     = $04;
const _CAN_RX_FILTER_6     = $05;
const _CAN_RX_OVERFLOW     = $08;  // Set if Overflowed; else clear
const _CAN_RX_INVALID_MSG  = $10;  // Set if invalid; else clear
const _CAN_RX_XTD_FRAME    = $20;  // Set if XTD message; else clear
const _CAN_RX_RTR_FRAME    = $40;  // Set if RTR message; else clear
const _CAN_RX_DBL_BUFFERED = $80;  // Set if message was
                                  //   hardware double-buffered

You may use bitwise and to adjust the appropriate flags. For example:

Copy Code To Clipboard

if (MsgFlag and _CAN_RX_OVERFLOW) = 0 then
  ...
  // Receiver overflow has occurred.
  // We have lost our previous message.

CAN_MASK

CAN_MASK constants define mask codes. Function CANSetMask expects one of these as its argument:

const _CAN_MASK_B1  = 0;
const _CAN_MASK_B2  = 1;

CAN_FILTER

CAN_FILTER constants define filter codes. Function CANSetFilter expects one of these as its argument:

const _CAN_FILTER_B1_F1  = 0;
const _CAN_FILTER_B1_F2  = 1;
const _CAN_FILTER_B2_F1  = 2;
const _CAN_FILTER_B2_F2  = 3;
const _CAN_FILTER_B2_F3  = 4;
const _CAN_FILTER_B2_F4  = 5;

Library Example

This is a simple demonstration of CAN Library routines usage. First node initiates the communication with the second node by sending some data to its address. The second node responds by sending back the data incremented by 1. First node then does the same and sends incremented data back to second node, etc.

Code for the first CAN node:

Copy Code To Clipboard

program Can_1st;

var Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags, Rx_Data_Len  : byte;  // can flags
    RxTx_Data  : array[8] of byte;                                       // CAN rx/tx data buffer
    Rx_ID : longint;
    Msg_Rcvd : byte;

const ID_1st  : longint = 12111;
const ID_2nd  : longint = 3;                                  // node IDs

begin

  PORTC := 0;                                                 // clear PORTC
  TRISC := 0;                                                 // set PORTC as output

  Can_Init_Flags := 0;                                        //
  Can_Send_Flags := 0;                                        // clear flags
  Can_Rcv_Flags  := 0;                                        //

  Can_Send_Flags := _CAN_TX_PRIORITY_0 and                    // form value to be used
                   _CAN_TX_XTD_FRAME and                      //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags := _CAN_CONFIG_SAMPLE_THRICE and             // form value to be used
                   _CAN_CONFIG_PHSEG2_PRG_ON and              // with CANInit
                   _CAN_CONFIG_XTD_MSG and
                   _CAN_CONFIG_DBL_BUFFER_ON and
                   _CAN_CONFIG_VALID_XTD_MSG;
  
  CANInitialize(1,3,3,3,1,Can_Init_Flags);                    // Initialize CAN module
  CANSetOperationMode(_CAN_MODE_CONFIG,0xFF);                 // set CONFIGURATION mode
  CANSetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_XTD_MSG);            // set all mask1 bits to ones
  CANSetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_XTD_MSG);            // set all mask2 bits to ones
  CANSetFilter(_CAN_FILTER_B2_F4,ID_2nd,_CAN_CONFIG_XTD_MSG); // set id of filter B2_F4 to 2nd node ID

  CANSetOperationMode(_CAN_MODE_NORMAL,0xFF);                 // set NORMAL mode

  RxTx_Data[0] := 9;                                          // set initial data to be sent

  CANWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);             // send initial message

  while ( TRUE ) do                                           // endless loop
    begin
      Msg_Rcvd := CANRead(Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags);  // receive message
      if (((Rx_ID = ID_2nd) and Msg_Rcvd) <> 0 ) then                       // if message received check id
        begin
          PORTC := RxTx_Data[0];                                            // id correct, output data at PORTC
          Inc(RxTx_Data[0]);                                                // increment received data
          Delay_ms(10);
          CANWrite(ID_1st, RxTx_Data, 1, Can_Send_Flags);                   // send incremented data back
        end;
    end;
end.

Code for the second CAN node:

Copy Code To Clipboard

program Can_2nd;

var Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags, Rx_Data_Len  : byte;  // can flags
    RxTx_Data  : array[8] of byte;                           // can rx/tx data buffer
    Rx_ID : longint;
    Msg_Rcvd : byte;                                         // reception flag
    
const ID_1st : longint = 12111;
const ID_2nd : longint = 3;                                  // node IDs

begin
  PORTC := 0;                                                // clear PORTC
  TRISC := 0;                                                // set PORTC as output

  Can_Init_Flags := 0;                                       //
  Can_Send_Flags := 0;                                       // clear flags
  Can_Rcv_Flags  := 0;                                       //

  Can_Send_Flags := _CAN_TX_PRIORITY_0 and                   // form value to be used
                   _CAN_TX_XTD_FRAME and                     //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags := _CAN_CONFIG_SAMPLE_THRICE and            // form value to be used
                   _CAN_CONFIG_PHSEG2_PRG_ON and             // with CANInit
                   _CAN_CONFIG_XTD_MSG and
                   _CAN_CONFIG_DBL_BUFFER_ON and
                   _CAN_CONFIG_VALID_XTD_MSG and
                   _CAN_CONFIG_LINE_FILTER_OFF;

  CANInitialize(1,3,3,3,1,Can_Init_Flags);                     // initialize external CAN module
  CANSetOperationMode(_CAN_MODE_CONFIG,0xFF);                  // set CONFIGURATION mode
  CANSetMask(_CAN_MASK_B1,-1,_CAN_CONFIG_XTD_MSG);             // set all mask1 bits to ones
  CANSetMask(_CAN_MASK_B2,-1,_CAN_CONFIG_XTD_MSG);             // set all mask2 bits to ones
  CANSetFilter(_CAN_FILTER_B2_F3,ID_1st,_CAN_CONFIG_XTD_MSG);  // set id of filter B2_F3 to 1st node ID

  CANSetOperationMode(_CAN_MODE_NORMAL,0xFF);                  // set NORMAL mode

  while (TRUE) do                                                               // endless loop
    begin
      Msg_Rcvd := CANRead(Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags);      // receive message
      if (((Rx_ID = ID_1st) and Msg_Rcvd) <> 0 ) then                           // if message received check id
        begin
          PORTC := RxTx_Data[0];                                                // id correct, output data at PORTC
          inc(RxTx_Data[0]);                                                    // increment received data
          CANWrite(ID_2nd, RxTx_Data, 1, Can_Send_Flags);                       // send incremented data back
        end;
    end;
end.

HW Connection

Example of interfacing CAN transceiver with MCU and bus

Want more examples and libraries? 
Find them on