C28x eCAN Receive

Enhanced Controller Area Network receive mailbox

  • Library:
  • Embedded Coder Support Package for Texas Instruments C2000 Processors / C2803x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C2805x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C2806x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C280x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C281x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C2833x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / C2834x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / F2807x

    Embedded Coder Support Package for Texas Instruments C2000 Processors / F2837xD

    Embedded Coder Support Package for Texas Instruments C2000 Processors / F2837xS

    Embedded Coder Support Package for Texas Instruments C2000 Processors / F28004x

Description

The eCAN Receive block generates source code for receiving enhanced Controller Area Network (eCAN) messages through an eCAN mailbox. eCAN modules on the processor provide serial communication capability and have 32 mailboxes configurable for receive or transmit. The block supports eCAN data frames in standard or extended format.

To use the eCAN Receive block with the eCAN Pack block in the canmsglib library, set Data type to CAN_MESSAGE_TYPE.

Configure the eCAN modules for a specific hardware board by navigating to Hardware Implementation > Target hardware resources. Verify that these settings meet the requirements of your application.

Ports

Output

expand all

Connect a function call subsystem to this port. When a new message is received, the subsystem is executed.

The received data is output in the form of a vector of elements of the selected data type. The length of the vector is 8 bytes. When the block is used in polling mode, and a new message is not created between consecutive executions of the block, the existing message is repeated.

To use the eCAN Receive block with the CAN Unpack block in the canmsglib library, set Data type to CAN_MESSAGE_TYPE.

Data Types: uint8 | uint16 | uint32 | CAN_MESSAGE_TYPE

The length of output message received.

Dependencies

This port appears only if the Output message length parameter is selected.

Data Types: uint16

Parameters

expand all

Determines the eCAN module configured by the eCAN Receive block.

For standard CAN controller (SCC) mode, enter a unique number from 0 to 15. For high-end CAN controller (HECC) mode, enter a unique number from 0 to 31 . In SCC mode, transmissions from the mailbox with the highest number have the highest priority. In HECC mode, the mailbox number only determines priority if the transmit priority level (TPL) of two mailboxes is equal.

The message identifier is 11 bits long for the standard frame size or 29 bits long for the extended frame size in decimal, binary, or hex format. For binary and hex formats, use bin2dec(' ') and hex2dec(' '), respectively, to convert the entry.

The message identifier type.

A new message causes a function call to be sent from the mailbox. If you want to update the message output only when a new message arrives, the block needs to be executed asynchronously. To execute the block asynchronously, set this parameter to -1, and select the Post interrupt when message is received option.

Note

For information about setting the timing parameters of the CAN module, see Configuring Timing Parameters for CAN Blocks.

The options available are:

  • uint8: Vector length = 8 elements

  • uint16: Vector length = 4 elements

  • uint32: Vector length = 2 elements

  • CAN_MESSAGE_TYPE: Outputs data as a structure. Use the CAN Unpack block to extract the data from the structure.

The length of the vector for the received message is at most 8 bytes. If the message is less than 8 bytes, the data buffer bytes are right-aligned in the output. The data are unpacked as follows using the data buffer, which is 8 bytes.

For uint8 data, the eCAN Receive block reads each unit of 8 bytes in the registers and outputs 8-bit data to eight elements (using the lower part of the 16-bit memory).

Output[0] = data_buffer[0];
Output[1] = data_buffer[1];
Output[2] = data_buffer[2];
Output[3] = data_buffer[3];
Output[4] = data_buffer[4];
Output[5] = data_buffer[5];
Output[6] = data_buffer[6];
Output[7] = data_buffer[7];

For uint16 data, the eCAN Receive block reads each unit of 8 bytes in the registers and outputs 16-bit data to four elements.

Output[0] = data_buffer[1..0];
Output[1] = data_buffer[3..2];
Output[2] = data_buffer[5..4];
Output[3] = data_buffer[7..6];

For uint32 data, the eCAN Receive block reads each unit of 8 bytes in the registers and outputs 32-bit data to two elements.

Output[0] = data_buffer[3..0];
Output[1] = data_buffer[7..4];

For example, if the received message has two bytes:

data_buffer[0] = 0x21
data_buffer[1] = 0x43

The uint16 output is:

Output[0] = 0x4321
Output[1] = 0x0000
Output[2] = 0x0000
Output[3] = 0x0000

When you select CAN_MESSAGE_TYPE, the block outputs the following struct data (defined in can_message.h):

struct {
  
  /* Is Extended frame */
  uint8_T Extended;

  /* Length */
  uint8_T Length;

  /* RTR */
  uint8_T Remote;

  /* Error */
  uint8_T Error;

  /* CAN ID */
  uint32_T ID;
  
  /* 
  TIMESTAMP_NOT_REQUIRED is a macro that will be defined by Target teams 
  PIL, xPC if they do not require the timestamp field during code
  generation. By default, timestamp is defined. If the targets do not require
  the timestamp field, they should define the macro TIMESTAMP_NOT_REQUIRED before
  including this header file for code generation.
  */
  #ifndef TIMESTAMP_NOT_REQUIRED
    /* Timestamp */
    double Timestamp;
  #endif

  /* Data field */
  uint8_T Data[8];

};

The value of the output before receiving data.

The message length in bytes, sent to the len port. If not selected, the len port is not visible.

When selected, the block posts an asynchronous interrupt when a message is received.

The interrupt line the asynchronous interrupt uses. The value of this parameter sets bit 2 (GIL) in the global interrupt mask register (CANGIM):

  • 1 maps the global interrupts to the ECAN1INT line.

  • 0 maps the global interrupts to the ECAN0INT line.

Dependencies

This parameter appears only when you select Post interrupt when message is received.