CAN Library

void CANx_EnableOperationMode(unsigned long operationMode);

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

unsigned char CANx_ExitOperationMode(unsigned long operationMode);

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

unsigned char CANx_Init(unsigned long config, unsigned long maxMsgBuff);

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

unsigned char CANx_Init_Advanced(unsigned long config, unsigned long maxMsgBuff, Module_Struct *module);

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	void CANx_SetBitRate(unsigned long propSeg, unsigned long phaseSeg2, unsigned long phaseSeg1, unsigned long preDivider, unsigned long RJW);
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

void CANx_SetRxMaskType(unsigned long type);

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

void CANx_SetRxIndividualMask(unsigned long msgBuffIdType, unsigned long msgBuffIdx, unsigned long mask);

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	unsigned char CANx_GetReceiveStatus();
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

unsigned char CANx_SetRxMbGlobalMask(unsigned long idType, unsigned long mask);

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

unsigned char CANx_ConfigRxMb(unsigned long mbIndex, unsigned long msgIdType, unsigned long dataLength, unsigned long msgId);

This function will set configure a Rx message buffer.

mbIndex: message buffer index.
msgIdType: RX individual masking type. Valid values :

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

unsigned char CANx_ConfigTxMb(unsigned long mbIndex, unsigned long msgIdType, unsigned long dataLength, unsigned long msgId);

This function will set configure a Tx message buffer.

mbIndex: message buffer index.
msgIdType: TX individual masking type. Valid values :

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

unsigned char CANx_Write(unsigned long mbIndex, unsigned long msgIdType, unsigned long dataLength, unsigned long msgId, unsigned char *dataBuffer);

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

mbIndex: message buffer index.
msgIdType: individual masking type. Valid values :

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	unsigned char CANx_Read(unsigned long msgBuffIdx, unsigned long msgId, unsigned char* *dataReceived);
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	void 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  &
              _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) {
  ...
  // We have lost our previous message.
}

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

unsigned int Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags;  // can flags
unsigned int Rx_Data_Len;                                    // received data length in bytes
char RxTx_Data[8];   
char Msg_Rcvd;                                               // reception flag
const unsigned long ID_1st = 12111, ID_2nd = 3;              // node IDs
unsigned long Rx_ID;

void main() {
  GPIO_Digital_Output(&GPIO_PORTJ, _GPIO_PINMASK_ALL);
  GPIO_PORTJ_DATA = 0;

  Can_Rcv_Flags  = 0;

  Can_Send_Flags = _CAN_TX_XTD_FRAME & _CAN_TX_NO_RTR_FRAME;  // form value to be used with CAN0Write

  Can_Init_Flags = _CAN_CONFIG_AUTO_RETRY_ENABLED;           // CAN init flags

  CAN0Initialize(1,3,3,3,1,Can_Init_Flags);                   // initialize CAN0

  CAN0SetOperationMode(_CAN_MODE_CONFIG,0xFF);                // set CONFIGURATION mode

  CAN0ConfigureMessage(1, _CAN_CONFIG_XTD_MSG & _CAN_CONFIG_TYPE_TX); // configure message object for transmitting
  CAN0ConfigureMessage(2, _CAN_CONFIG_XTD_MSG & _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] = 0xFE;
  CAN0WriteMessage(1, ID_1st, RxTx_Data, 1, Can_Send_Flags);
  
  while(1){
    Msg_Rcvd = CAN0ReadMessage(2, &Rx_ID, RxTx_Data, &Rx_Data_Len, &Can_Rcv_Flags);  // receive message
    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                   // if message received check id
      GPIO_PORTJ_DATA = RxTx_Data[0];                                      // id correct, output data at PORTJ
      RxTx_Data[0]++;                                                      // increment received data
      delay_ms(10);
      CAN0WriteMessage(1, ID_1st, RxTx_Data, 1, Can_Send_Flags);                     // send incremented data back
    }
  }

}

STM32

unsigned long Can_Init_Flags;
unsigned char Can_Send_Flags, Can_Rcv_Flags; // can flags
unsigned char Rx_Data_Len;                                   // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const long ID_1st = 12111, ID_2nd = 3;                       // node IDs
long Rx_ID;

void main() {

  GPIO_Digital_Output(&GPIOE_BASE, 0xFF00);
  GPIOE_ODR  = 0;
    DMA1_CCR1bits.

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

  Can_Send_Flags = _CAN_TX_XTD_FRAME &                      //     with CANWrite
                   _CAN_TX_NO_RTR_FRAME;

  Can_Init_Flags = _CAN_CONFIG_AUTOMATIC_RETRANSMISSION &              // form value to be used
                   _CAN_CONFIG_RX_FIFO_NOT_LOCKED_ON_OVERRUN &         // with CANInit
                   _CAN_CONFIG_TIME_TRIGGERED_MODE_DISABLED &
                   _CAN_CONFIG_TX_FIFO_PRIORITY_BY_IDINTIFIER &
                   _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

  CANSetFilterScale32(0, _CAN_FILTER_ENABLED & _CAN_FILTER_ID_MASK_MODE & _CAN_FILTER_XTD_MSG, ID_2nd, -1);

  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(1) {  // endless loop
    Msg_Rcvd = CAN1Read(0, &Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags);  // receive message
    if ((Rx_ID == ID_2nd) && Msg_Rcvd) {                                        // if message received check id
      GPIOE_ODR  = RxTx_Data[0] << 8;                                           // id correct, output data at PORTE
      RxTx_Data[0]++ ;                                                          // increment received data
      Delay_ms(10);
      CAN1Write(ID_1st, RxTx_Data, 1, Can_Send_Flags);                          // send incremented data back
    }
  }
}

Code for the second CAN node:

Stellaris

unsigned int Can_Init_Flags, Can_Send_Flags, Can_Rcv_Flags;  // can flags
unsigned int Rx_Data_Len;                                    // received data length in bytes
char RxTx_Data[8];                                           // can rx/tx data buffer
char Msg_Rcvd;                                               // reception flag
const unsigned long ID_1st = 12111, ID_2nd = 3;              // node IDs
unsigned long Rx_ID;

void main() {
  GPIO_Digital_Output(&GPIO_PORTJ, _GPIO_PINMASK_ALL);
  GPIO_PORTJ_DATA = 0;

  Can_Rcv_Flags  = 0;

  Can_Send_Flags = _CAN_TX_XTD_FRAME & _CAN_TX_NO_RTR_FRAME;  // form value to be used with CAN0Write

  Can_Init_Flags = _CAN_CONFIG_AUTO_RETRY_ENABLED;           // CAN init flags

//  CAN0Initialize(1,3,3,3,1,Can_Init_Flags);                   // initialize CAN0
  CAN0InitializeAdvanced(1,3,3,3,1,Can_Init_Flags,&_GPIO_MODULE_CAN0_D01);                   // initialize CAN0

  CAN0SetOperationMode(_CAN_MODE_CONFIG,0xFF);                // set CONFIGURATION mode

  CAN0ConfigureMessage(1, _CAN_CONFIG_XTD_MSG & _CAN_CONFIG_TYPE_TX); // configure message object for transmitting
  CAN0ConfigureMessage(2, _CAN_CONFIG_XTD_MSG & _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
  RxTx_Data[0] = 0;

  while(1) {
    Msg_Rcvd = CAN0ReadMessage(2, &Rx_ID , RxTx_Data , &Rx_Data_Len, &Can_Rcv_Flags); // receive message
    if ((Rx_ID == ID_1st) && Msg_Rcvd) {                                              // if message received check id
      GPIO_PORTJ_DATA = RxTx_Data[0];                                                 // id correct, output data at PORTJ
      RxTx_Data[0]++;                                                                 // increment received data
      CAN0WriteMessage(1, ID_2nd, RxTx_Data, 1, Can_Send_Flags);                      // send incremented data back
    }
  }

}

STM32