1.10.3 1.18.2 1.21.2 1.22.3 1.23.3 1.24.3 Controller Area Network (CAN)

The Controller Area Network (CAN) module supports the following key features.

Standards Compliance:

  • Full CAN 2.0B compliance

  • Programmable bit rate up to 1 Mbps Message Reception and Transmission:

  • 32/16 message FIFOs

  • Each FIFO can have up to 32 messages

  • FIFO can be a transmit message FIFO or a receive message FIFO

  • Userdefined priority levels for message FIFOs used for transmission

  • Acceptance filters for message filtering

  • Acceptance filter mask for message filtering

  • Automatic response to Remote Transmit Request (RTR)

Using The Library

The CAN library supports the CAN Normal (Classic) mode. The CAN Normal mode can transfer message in a polling or an interrupt mode.

CAN normal operation with polling

The following example shows the CAN normal mode operation with polling implementation.

void print_menu(void)

{

printf(" ------------------------------ \\r\\n");

printf(" Press '1' to Transmit message \\r\\n");

printf(" Press '2' to Receive message \\r\\n");

}

int main ( void )
{

uint32_t messageID = 0;

uint32_t rx_messageID = 0;

uint8_t message[8];

uint8_t rx_message[8];

uint32_t status = 0;

uint8_t messageLength = 0;

uint8_t rx_messageLength = 0;

uint8_t count = 0;

uint8_t user_input = 0;

CAN_MSG_RX_ATTRIBUTE msgAttr = CAN_MSG_RX_DATA_FRAME;

/* Initialize all modules */

SYS_Initialize ( NULL );

printf(" ------------------------------ \\r\\n");

printf(" CAN Demo \\r\\n");

printf(" ------------------------------ \\r\\n");

print_menu();

/* Prepare the message to send*/

messageID = 0x469;

messageLength = 8;

for (count = 8; count \>=1; count--){

message[count - 1] = count;

}

while ( true )

{

/* Maintain state machines of all polled Harmony modules. */

/* Check if there is a received character */

if(UART6_ReceiverIsReady() == true)

{

if(UART6_ErrorGet() == UART_ERROR_NONE)

{

UART6_Read((void *)&user_input, 1);

}

switch (user_input)

{

case '1':

printf(" Transmitting Message:");

if (CAN1_MessageTransmit(messageID, messageLength, message, 0,
CAN_MSG_TX_DATA_FRAME) == true)

{

printf("Success \\r\\n");

LED_Toggle();

}

else

{

printf("Failed \\r\\n");

}

break;

case '2':

printf(" Waiting for message: \\r\\n");

while (true)

{

if (CAN1_InterruptGet(1, CAN_FIFO_INTERRUPT_RXNEMPTYIF_MASK))

{

/* Check CAN Status */

status = CAN1_ErrorGet();



if (status == CAN_ERROR_NONE)

{

memset(rx_message, 0x00, sizeof(rx_message));



/* Receive New Message */

if (CAN1_MessageReceive(&rx_messageID, &rx_messageLength,
rx_message, 0, 1, &msgAttr) == true)

{

printf(" New Message Received \\r\\n");

status = CAN1_ErrorGet();

if (status == CAN_ERROR_NONE)

{

/* Print message to Console */

uint8_t length = rx_messageLength;

printf(" Message - ID : 0x%x Length : 0x%x ", (unsigned int)
rx_messageID,(unsigned int) rx_messageLength);

printf("Message : ");

while(length)

{

printf("0x%x ", rx_message[rx_messageLength - length--]);

}

printf("\\r\\n");

LED_Toggle();

break;

}

else

{

printf("Error in received message");

}

}

else

{

printf("Message Reception Failed \\r");

}

}

else

{

printf("Error in last received message");

}

}

}

break;

default:

printf(" Invalid Input \\r\\n");

break;

}

print_menu();

}

}



/* Execution should not come here during normal operation */



return ( EXIT_FAILURE );

}

CAN normal operation with interrupt

The following example shows the CAN normal mode operation with interrupt implementation.

/* Application's state machine enum */

typedef enum

{

APP_STATE_CAN_RECEIVE,

APP_STATE_CAN_TRANSMIT,

APP_STATE_CAN_IDLE,

APP_STATE_CAN_USER_INPUT,

APP_STATE_CAN_XFER_SUCCESSFUL,

APP_STATE_CAN_XFER_ERROR

} APP_STATES;



/* Variable to save application state */

static APP_STATES state = APP_STATE_CAN_USER_INPUT;



void APP_CAN_Callback(uintptr_t context)

{

xferContext = context;



/* Check CAN Status */

status = CAN1_ErrorGet();



if ((status & (CAN_ERROR_TX_RX_WARNING_STATE |
CAN_ERROR_RX_WARNING_STATE |

CAN_ERROR_TX_WARNING_STATE | CAN_ERROR_RX_BUS_PASSIVE_STATE |

CAN_ERROR_TX_BUS_PASSIVE_STATE | CAN_ERROR_TX_BUS_OFF_STATE)) ==
CAN_ERROR_NONE)

{

switch ((APP_STATES)context)

{

case APP_STATE_CAN_RECEIVE:

case APP_STATE_CAN_TRANSMIT:

{

state = APP_STATE_CAN_XFER_SUCCESSFUL;

break;

}

default:

break;

}

}

else

{

state = APP_STATE_CAN_XFER_ERROR;

}

}



int main ( void )
{

uint8_t count = 8;

bool user_input = 0;



/* Initialize all modules */

SYS_Initialize ( NULL );



/* Prepare the message to send*/

messageID = 0x469;

messageLength = 8;

for (count = 8; count \>=1; count--){

message[count - 1] = count;

}



while ( true )

{

if (state == APP_STATE_CAN_USER_INPUT)

{

if(SWITCH_Get() == SWITCH_PRESSED_STATE)

{

while(SWITCH_Get() == SWITCH_PRESSED_STATE);



switch (user_input)

{

case 0:

CAN1_CallbackRegister( APP_CAN_Callback,
(uintptr_t)APP_STATE_CAN_TRANSMIT, 0 );

state = APP_STATE_CAN_IDLE;

CAN1_MessageTransmit(messageID, messageLength, message, 0,
CAN_MSG_TX_DATA_FRAME);

break;

case 1:

CAN1_CallbackRegister( APP_CAN_Callback,
(uintptr_t)APP_STATE_CAN_RECEIVE, 1 );

state = APP_STATE_CAN_IDLE;

memset(rx_message, 0x00, sizeof(rx_message));

/* Receive New Message */

CAN1_MessageReceive(&rx_messageID, &rx_messageLength, rx_message,
0, 1, &msgAttr);

break;

default:

break;

}

}

else

{

continue;

}

}

/* Check the application's current state. */

switch (state)

{

case APP_STATE_CAN_IDLE:

{

/* Application can do other task here */

break;

}

case APP_STATE_CAN_XFER_SUCCESSFUL:

{

if ((APP_STATES)xferContext == APP_STATE_CAN_RECEIVE)

{

}

else if ((APP_STATES)xferContext == APP_STATE_CAN_TRANSMIT)

{

}

LED_Toggle();

state = APP_STATE_CAN_USER_INPUT;

break;

}

case APP_STATE_CAN_XFER_ERROR:

{

if ((APP_STATES)xferContext == APP_STATE_CAN_RECEIVE)

{

}

else

{

}

state = APP_STATE_CAN_USER_INPUT;

break;

}

default:

break;

}



}



/* Execution should not come here during normal operation */



return ( EXIT_FAILURE );
}

Library Interface

peripheral library provides the following interfaces:

Functions

Name Description
CANx_Initialize Initializes given instance of the CAN peripheral
CANx_MessageTransmit Transmits a message into CAN bus
CANx_MessageReceive Receives a message from CAN bus
CANx_MessageAbort Abort request for a FIFO
CANx_MessageAcceptanceFilterSet Set Message acceptance filter configuration
CANx_MessageAcceptanceFilterGet Get Message acceptance filter configuration
CANx_MessageAcceptanceFilterMaskSet Set Message acceptance filter mask configuration
CANx_MessageAcceptanceFilterMaskGet Get Message acceptance filter mask configuration
CANx_ErrorGet Returns the error during transfer
CANx_ErrorCountGet Returns the transmit and receive error count during transfer
CANx_InterruptGet Returns the FIFO Interrupt status
CANx_TxFIFOIsFull Returns true if Tx FIFO is full otherwise false
CANx_AutoRTRResponseSet Set the Auto RTR response for remote transmit request
CANx_BitTimingCalculationGet Returns the bit timing information
CANx_BitTimingSet Sets the bit timing
CANx_CallbackRegister Sets the pointer to the function (and it's context) to be called when the given CAN's transfer events occur
CANx_ErrorCallbackRegister Sets the pointer to the function (and it's context) to be called when error occurs in CAN

Data types and constants

Name Type Description
CAN_MSG_TX_ATTRIBUTE Enum CAN Message TX Attribute for Data Frame and Remote Frame
CAN_MSG_RX_ATTRIBUTE Enum CAN Message RX Attribute for Data Frame and Remote Frame
CAN_FIFO_INTERRUPT_FLAG_MASK Enum CAN FIFO Interrupt Status Flag Mask
CAN_ERROR Enum CAN Transfer Error data type
CAN_CALLBACK Typedef CAN Callback Function Pointer
CAN_RX_MSG Struct CAN RX Message Buffer structure
CAN_TX_RX_MSG_BUFFER Struct CAN Message Buffer structure
CAN_NOMINAL_BIT_TIMING Struct Nominal bit timing parameters
CAN_BIT_TIMING Struct Bit timing parameters