CAN Library

procedure CANx_EnableOperationMode(operationMode : dword);

This routine is used to enable a CAN operation mode.

operationMode: desiured operation mode. Valid values :

Value	Description
_CAN_CFG_MODE_NORMAL	Normal mode (User or Supervisor).
_CAN_CFG_MODE_LISTENONLY	Listen-Only mode.
_CAN_CFG_MODE_LOOPBACK	Loop-Back mode.
_CAN_CFG_MODE_FREEZE	Freeze mode.
_CAN_CFG_MODE_DISABLE	Module Disable mode.

Nothing.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_ExitOperationMode

function CANx_ExitOperationMode(operationMode : dword) : byte;

This routine is used to disable a CAN operation mode.

operationMode: desiured operation mode. Valid values :

Value	Description
_CAN_CFG_MODE_NORMAL	Normal mode (User or Supervisor).
_CAN_CFG_MODE_LISTENONLY	Listen-Only mode.
_CAN_CFG_MODE_LOOPBACK	Loop-Back mode.
_CAN_CFG_MODE_FREEZE	Freeze mode.
_CAN_CFG_MODE_DISABLE	Module Disable mode.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_Init

function CANx_Init(config : dword; maxMsgBuff : dword) : byte;

This routine is used to initialize CAN module. This function will enable CAN clock, reset module to the default state, set max number for message buffer and set operational mode.

config: desiured operation mode. Valid values :

Value	Description
_CAN_CFG_CLOCK_OSC	Normal mode (User or Supervisor).
_CAN_CFG_CLOCK_PERIPHERAL_CLK	Normal mode (User or Supervisor).
_CAN_CFG_MODE_NORMAL	Normal mode (User or Supervisor).
_CAN_CFG_MODE_LISTENONLY	Listen-Only mode.
_CAN_CFG_MODE_LOOPBACK	Loop-Back mode.
_CAN_CFG_MODE_FREEZE	Freeze mode.
_CAN_CFG_MODE_DISABLE	Module Disable mode.

maxMsgBuff: maximum number of message buffers.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_Init_Advanced

function CANx_Init_Advanced(config : dword; maxMsgBuff : dword; module : ^Module_Struct) : byte;

This routine is used to initialize CAN module. This function will enable CAN clock, reset module to the default state, set max number for message buffer, set operational mode and initialize it on PB19 and PB18 pins.

config: desiured operation mode. Valid values :

Value	Description
_CAN_CFG_CLOCK_OSC	Normal mode (User or Supervisor).
_CAN_CFG_CLOCK_PERIPHERAL_CLK	Normal mode (User or Supervisor).
_CAN_CFG_MODE_NORMAL	Normal mode (User or Supervisor).
_CAN_CFG_MODE_LISTENONLY	Listen-Only mode.
_CAN_CFG_MODE_LOOPBACK	Loop-Back mode.
_CAN_CFG_MODE_FREEZE	Freeze mode.
_CAN_CFG_MODE_DISABLE	Module Disable mode.

maxMsgBuff: maximum number of message buffers.
module: appropriate module pinout. Use Code Assistant to list available module pinouts by typing _GPIO_MODULE_CAN and pressing Ctrl + Space.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_SetBitRate

Prototype	procedure CANx_SetBitRate(propSeg : dword; phaseSeg2 : dword; phaseSeg1 : dword; preDivider : dword; RJW : dword);
Description	This function will set all CAN time segments which define the length of Propagation Segment in the bit time, the length of Phase Buffer Segment 2 in the bit time, the length of Phase Buffer Segment 1 in the bit time, the ratio between the PE clock frequency and the Serial Clock (Sclock) frequency, and the maximum number of time quanta that a bit time can be changed by one resynchronization. (One time quantum is equal to the Sclock period.).
Parameters	`propSeg` Propagation Segment, as defined in MCU's datasheet. `phaseSeg2` Phase Segment 2, as defined in MCU's datasheet. `phaseSeg1` Phase Segment 1, as defined in MCU's datasheet. `preDivider` Prescaler Division Factor, as defined in MCU's datasheet. `RJW` Resync Jump Width, as defined in MCU's datasheet.
Returns	Nothing.
Requires	MCU with the CAN module. MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.
Example
Notes	CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype. Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library. Valid only for Kinetis devices.

CANx_SetRxMaskType

procedure CANx_SetRxMaskType(type : dword);

This function will set the RX masking type.

type: RX masking type. Valid values :

Value	Description
_CAN_RXMASK_GLOBAL	Global masking.
_CAN_RXMASK_INDIVIDUAL	Individual masking.

Nothing.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_SetRxIndividualMask

procedure CANx_SetRxIndividualMask(msgBuffIdType : dword; msgBuffIdx : dword; mask : dword);

This function will Set Rx individual mask as the 11-bit standard mask or the 29-bit extended mask.

msgBuffIdType: RX individual masking type. Valid values :

Value	Description
_CAN_MSGID_STD	Standard mask.
_CAN_MSGID_EXT	Extended mask.

msgBuffIdx: message buffer index.
mask: 11bit or 29bit format.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_GetReceiveStatus

Prototype	function CANx_GetReceiveStatus() : byte;
Description	This function will check if CAN is receiving message.
Parameters	None.
Returns	`0:` CAN is not receiving a message, `1:` CAN is receiving a message.
Requires	MCU with the CAN module. MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.
Example
Notes	CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype. Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library. Valid only for Kinetis devices.

CANx_SetRxMbGlobalMask

function CANx_SetRxMbGlobalMask(idType : dword; mask : dword) : byte;

This function will set Rx message buffer global mask as the 11-bit standard mask or the 29-bit extended mask.

idType: RX individual masking type. Valid values :

Value	Description
_CAN_MSGID_STD	Standard mask.
_CAN_MSGID_EXT	Extended mask.

mask: 11bit or 29bit format.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_ConfigRxMb

function CANx_ConfigRxMb(mbIndex : dword; msgIdType : dword; dataLength : dword; msgId : dword) : byte;

This function will set configure a Rx message buffer.

msgIdType: RX individual masking type. Valid values :

mbIndex: message buffer index.

Value	Description
_CAN_MSGID_STD	Standard mask.
_CAN_MSGID_EXT	Extended mask.

dataLength: length of data.
msgId: message ID.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
This function will set up the message buffer fields, configure the message buffer code for Rx message buffer as NOT_USED, enable the Message Buffer interrupt,
configure the message buffer code for Rx message buffer as INACTIVE, copy user's buffer into the message buffer data area, and configure the message buffer code for Rx message buffer as EMPTY.
Valid only for Kinetis devices.

CANx_ConfigTxMb

function CANx_ConfigTxMb(mbIndex : dword; msgIdType : dword; dataLength : dword; msgId : dword) : byte;

This function will set configure a Tx message buffer.

msgIdType: TX individual masking type. Valid values :

mbIndex: message buffer index.

Value	Description
_CAN_MSGID_STD	Standard mask.
_CAN_MSGID_EXT	Extended mask.

dataLength: length of data.
msgId: message ID.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
This function will set up the message buffer fields, configure the message buffer code for Tx buffer as INACTIVE, and enable the Message Buffer interrupt.
Valid only for Kinetis devices.

CANx_Write

function CANx_Write(mbIndex : dword; msgIdType : dword; dataLength : dword; msgId : dword; dataBuffer : ^byte) : byte;

This function will initiate (start) a transmit by beginning the process of sending data.

msgIdType: individual masking type. Valid values :

mbIndex: message buffer index.

Value	Description
_CAN_MSGID_STD	Standard mask.
_CAN_MSGID_EXT	Extended mask.

dataLength: length of data.
msgId: message ID.
dataBuffer: pointer to data.

_CAN_STATUS_OK: if operation was performed correctly,
_CAN_STATUS_INVALIDE_ARG: if argument is invalid.

MCU with the CAN module.

MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.

CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype.
Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library.
Valid only for Kinetis devices.

CANx_Read

Prototype	function CANx_Read(msgBuffIdx : dword; msgId : ^dword; dataReceived : ^byte) : byte;
Description	This function will check for received message. If there is a message, get received data and ID.
Parameters	`msgBuffIdx:` message buffer index. `msgId:` message ID. `dataBuffer:` retrieved and stored to location pointed by this pointer.
Returns	`_CAN_STATUS_OK:` if operation was performed correctly, `_CAN_STATUS_INVALIDE_ARG:` if argument is invalid.
Requires	MCU with the CAN module. MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.
Example
Notes	CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype. Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library. Valid only for Kinetis devices.

CANx_InterruptHandler

Prototype	procedure CANx_InterruptHandler();
Description	Interrupt handler for CAN. This handler read data from MB or FIFO, and then clears the interrupt flags.
Parameters	None.
Returns	`_CAN_STATUS_OK:` if operation was performed correctly, `_CAN_STATUS_INVALIDE_ARG:` if argument is invalid.
Requires	MCU with the CAN module. MCU must be connected to the CAN transceiver (MCP2551 or similar) which is connected to the CAN bus.
Example
Notes	CAN library routine require you to specify the module you want to use. To use the desired CAN module, simply change the letter x in the routine prototype. Number of CAN modules per MCU differs from chip to chip. Please, read the appropriate datasheet before utilizing this library. Valid only for Kinetis devices.

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 Constants

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

// Stellaris Constants
// Stellaris Constants
_CAN_MODE_NORMAL
_CAN_MODE_DISABLE
_CAN_MODE_LOOP
_CAN_MODE_SILENT
_CAN_MODE_CONFIG
_CAN_MODE_BASIC
_CAN_MODE_LOOP_WITH_SILENT

// ST Constants
_CAN_OperatingMode_Initialization
_CAN_OperatingMode_Normal
_CAN_OperatingMode_Sleep

CAN_CONFIG_FLAGS Constants

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

_CAN_CONFIG_AUTO_RETRY_ENABLED
_CAN_CONFIG_AUTO_RETRY_DISABLED

CAN_TX_MSG_FLAGS Constants

CAN_TX_MSG_FLAGS are flags related to transmission of a CAN message:

_CAN_TX_STD_FRAME
_CAN_TX_XTD_FRAME
_CAN_TX_NO_RTR_FRAME
_CAN_TX_RTR_FRAME

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

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

CAN_RX_MSG_FLAGS Constants

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.

// Stellaris Constants
_CAN_RX_REMOTE_FRAME     // Set if this is a remote frame
_CAN_RX_DATA_LOST        // Set if some data is lost
_CAN_RX_NEW_DATA         // Indicate that there is new data in this message
_CAN_RX_EXTENDED_ID      // Set if extended message
_CAN_RX_USE_ID_FILTER    // Set the flag to indicate if ID masking was used
_CAN_RX_USE_EXT_FILTER   // Set if extended bit was used in filtering
_CAN_RX_USE_DIR_FILTER   // Set if direction filtering was enabled

// ST Constants
_CAN_RX_XTD_FRAME
_CAN_RX_RTR_FRAME

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

if (MsgFlag & _CAN_RX_DATA_LOST <> 0)
begin
  ...
  // We have lost our previous message.
end;

CAN_MESSAGE_OBJECT Constants

CAN_MESSAGE_OBJECT constants define CAN message object configuration. Function CANxConfigureMessage expects one of these as its argument:

  _CAN_CONFIG_TYPE_TX 
  _CAN_CONFIG_TYPE_TX_REMOTE 
  _CAN_CONFIG_TYPE_RX
  _CAN_CONFIG_TYPE_RX_REMOTE
  _CAN_CONFIG_TYPE_RXTX_REMOTE
  _CAN_CONFIG_FIFO
  _CAN_CONFIG_TX_INT_ENABLE
  _CAN_CONFIG_RX_INT_ENABLE
  _CAN_CONFIG_XTD_MSG
  _CAN_CONFIG_STD_MSG

CAN_MASK Constants

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

// Stellaris Constants
_CAN_CONFIG_XTD_MSG
_CAN_CONFIG_STD_MSG
_CAN_CONFIG_USE_DIR_FILTER

// ST Constants
_CAN_FILTER_ID_MASK_MODE
_CAN_FILTER_ID_LIST_MODE
_CAN_FILTER_USE_FIFO0
_CAN_FILTER_USE_FIFO1
_CAN_FILTER_STD_MSG
_CAN_FILTER_XTD_MSG
_CAN_FILTER_DISABLED
_CAN_FILTER_ENABLED

CAN_FILTER Constants

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

_CAN_CONFIG_XTD_MSG
_CAN_CONFIG_STD_MSG

// ST Constants
_CAN_FILTER_ID_MASK_MODE
_CAN_FILTER_ID_LIST_MODE
_CAN_FILTER_USE_FIFO1
_CAN_FILTER_DISABLED
_CAN_FILTER_ENABLED

Library Example

The example demonstrates CAN protocol. The 1st node initiates the communication with the 2nd node by sending some data to its address. The 2nd node responds by sending back the data incremented by 1. The 1st node then does the same and sends incremented data back to the 2nd node, etc.

Code for the first CAN node:

Stellaris

program CAN_1st;

var Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags, Rx_Data_Len  : dword;
    RxTx_Data  : array[8] of byte;
    Rx_ID      : longint;
    Msg_Rcvd : dword;

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

begin
  GPIO_Digital_Output(@GPIO_PORTJ, _GPIO_PINMASK_ALL);
  GPIO_PORTJ_DATA := 0;

  Can_Init_Flags   := _CAN_CONFIG_AUTO_RETRY_ENABLED;            // CAN init flags
  Can_Send_Flags   := _CAN_TX_XTD_FRAME and _CAN_TX_NO_RTR_FRAME;// form value to be used with CAN0Write
  Can_Rcv_Flags    := 0;

  CAN0Initialize(1,3,3,3,1,Can_Init_Flags);                      // initialize CAN
  CAN0SetOperationMode(_CAN_MODE_CONFIG,0xFF);                   // set CONFIGURATION mode

  CAN0ConfigureMessage(1, _CAN_CONFIG_XTD_MSG and _CAN_CONFIG_TYPE_TX); // configure message object for transmitting
  CAN0ConfigureMessage(2, _CAN_CONFIG_XTD_MSG and _CAN_CONFIG_TYPE_RX); // congigure message object for receiving

  CAN0SetMask(2, 0xFFFFFFFF, _CAN_CONFIG_XTD_MSG);                      // set all mask bits to ones
  CAN0SetFilter(2, ID_2nd, _CAN_CONFIG_XTD_MSG);                        // set filter

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

  RxTx_Data[0] := 9;
  CAN0WriteMessage(1, ID_1st, RxTx_Data, 1, Can_Send_Flags);

  while TRUE do
    begin
      Msg_Rcvd := CAN0ReadMessage(2, Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags); // receive message
      if ((Rx_ID = ID_2nd) and (Msg_Rcvd <> 0)) <> 0 then                   // if message received check id
        begin
          GPIO_PORTJ_DATA := RxTx_Data[0];                                  // id correct, output data at PORTJ
          RxTx_Data[0] := RxTx_Data[0] + 1;                                 // increment received data
          Delay_ms(10);
          CAN0WriteMessage(1, ID_1st, RxTx_Data, 1, Can_Send_Flags);       // send incremented data back
        end;
    end;
end.

STM32

program CAN1;

{ Declarations section }
var
  Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags : dword; // can flags
  Rx_Data_Len : byte;                                   // received data length in bytes
  RxTx_Data: array[8] of byte;                                           // can rx/tx data buffer
  Msg_Rcvd : byte;                                               // reception flag
  Rx_ID : dword;

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

begin

  GPIO_Digital_Output(@GPIOE_BASE, 0xFF00);
  GPIOE_ODR  := 0;

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

  Can_Send_Flags := _CAN_TX_XTD_FRAME and                    //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags := _CAN_CONFIG_AUTOMATIC_RETRANSMISSION and            // form value to be used
                   _CAN_CONFIG_RX_FIFO_NOT_LOCKED_ON_OVERRUN and        // with CANInit
                   _CAN_CONFIG_TIME_TRIGGERED_MODE_DISABLED and
                   _CAN_CONFIG_TX_FIFO_PRIORITY_BY_IDINTIFIER and
                   _CAN_CONFIG_WAKE_UP;

  CAN1InitializeAdvanced(1,5,4,4,1,Can_Init_Flags, @_GPIO_MODULE_CAN1_PD01); // Initialize CAN module
  CAN1SetOperationMode(_CAN_OperatingMode_Initialization);                   // set CONFIGURATION mode

  CANSetFilter(0, ID_2nd,_CAN_FILTER_ENABLED and _CAN_FILTER_ID_MASK_MODE and _CAN_FILTER_XTD_MSG);
  CANSetMask(0, 0xFFFFFFFF,_CAN_FILTER_ENABLED and _CAN_FILTER_ID_MASK_MODE and _CAN_FILTER_XTD_MSG);

  CAN1SetOperationMode(_CAN_OperatingMode_Normal);           // set NORMAL mode

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

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

  while(true) do
    begin                                                                      // endless loop
      Msg_Rcvd := CAN1Read(0, Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags); // receive message
      if ((Rx_ID = ID_2nd) and (Msg_Rcvd <> 0)) then
        begin                                                                  // if message received check id
          GPIOE_ODR  := word(RxTx_Data[0]) shl 8;                              // id correct, output data at PORTE
          inc(RxTx_Data[0]) ;                                                  // increment received data
          Delay_ms(10);
          CAN1Write(ID_1st, RxTx_Data, 1, Can_Send_Flags);                     // send incremented data back
        end;
    end;
end.

Code for the second CAN node:

Stellaris

program Can_2nd;

var Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags, Rx_Data_Len : dword;
    RxTx_Data : array[8] of byte;
    Rx_ID     : longint;
    Msg_Rcvd  : dword;

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

begin
  GPIO_Digital_Output(@GPIO_PORTJ, _GPIO_PINMASK_ALL);
  GPIO_PORTJ_DATA := 0;

  Can_Init_Flags   := _CAN_CONFIG_AUTO_RETRY_ENABLED;            // CAN init flags
  Can_Send_Flags   := _CAN_TX_XTD_FRAME and _CAN_TX_NO_RTR_FRAME;// form value to be used with CAN0Write
  Can_Rcv_Flags    := 0;

  CAN0Initialize(1,3,3,3,1,Can_Init_Flags);                      // initialize CAN
  CAN0SetOperationMode(_CAN_MODE_CONFIG,0xFF);                   // set CONFIGURATION mode

  CAN0ConfigureMessage(1, _CAN_CONFIG_XTD_MSG and _CAN_CONFIG_TYPE_TX); // configure message object for transmitting
  CAN0ConfigureMessage(2, _CAN_CONFIG_XTD_MSG and _CAN_CONFIG_TYPE_RX); // congigure message object for receiving

  CAN0SetMask(2, 0xFFFFFFFF, _CAN_CONFIG_XTD_MSG);                      // set all mask bits to ones
  CAN0SetFilter(2, ID_1st, _CAN_CONFIG_XTD_MSG);                        // set filter

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

  while TRUE do
    begin
      Msg_Rcvd := CAN0ReadMessage(2, Rx_ID , RxTx_Data , Rx_Data_Len, Can_Rcv_Flags);// receive message
      if ((Rx_ID = ID_1st) and (Msg_Rcvd <> 0)) <> 0 then                  // if message received check id
        begin
          GPIO_PORTJ_DATA   := RxTx_Data[0];                               // id correct, output data at PORTJ
          RxTx_Data[0] := RxTx_Data[0] + 1;                                // increment received data
          CAN0WriteMessage(1, ID_2nd, RxTx_Data, 1, Can_Send_Flags);                 // send incremented data back
        end;
    end;
end.

STM32