2.1 CAN 2.0/CAN FD Driver

This example assumes that a UART is configured with STDIO enabled for the printf functions to properly work. Enable RX FIFO Not Empty Interrupt for FIFO1 using Melody Driver User interface. Also enable the global interrupts in the application code.  

#include "mcc_generated_files/system/system.h"

#define DATA_BYTE_LENGTH (16)

volatile bool msgReceivedInFIFO1 = false;
volatile struct CAN_MSG_OBJ receiveMsgObj;
void CAN1_UserFIFO1InterruptHandler(void);
 
void CANFD_Example_Receive_FIFO1_Interrupt(void)
{
    SYSTEM_Initialize();
 
    // Enable the Global Interrupts
    INTERRUPT_GlobalInterruptEnable();
 
    // Set user interrupt handler which is called whenever the Receive buffer of FIFO1 is not empty.       
    CAN1_FIFO1NotEmptyCallbackRegister(CAN1_UserFIFO1InterruptHandler);
    
    while (1)
    {
        //Checking if any message was read from FIFO1.If true, print the data bytes of message frame received in the terminal.
        if (msgReceivedInFIFO1 == true)
        {
            printf("\r\nThe data received from CAN message: \r\n");
            for (uint8_t i = 0; i < DATA_BYTE_LENGTH; i++)
            {
                printf("%d \t", receiveMsgObj.data[i]);
            }
            msgReceivedInFIFO1 = false;
        }
    }
}
 
void CAN1_UserFIFO1InterruptHandler(void)
{
    // Reads the message object from the specified CAN receive FIFO
    CAN_NODE.ReceiveMessageGet(FIFO1, &receiveMsgObj);
    msgReceivedInFIFO1 = true;
}

This example assumes that a UART is configured with STDIO enabled for the printf functions to properly work.

#include "mcc_generated_files/system/system.h"

#define DATA_BYTE_LENGTH (16)

void CANFD_Eaxmple_Receive_From_FIFO1_Polling(void)
{
    struct CAN_MSG_OBJ receiveMsgObj;
 
    SYSTEM_Initialize();
 
    while (1)
    {
        //Check if the receive FIFO (FIFO1) is not empty    
        if (CAN_RX_MSG_AVAILABLE == (CAN_NODE.ReceiveFIFOStatusGet(CAN1_FIFO_1) & CAN_RX_MSG_AVAILABLE))
        {
            //Reads the receive message object from the specified CAN Receive FIFO
            CAN_NODE.ReceiveMessageGet(CAN1_FIFO_1, &receiveMsgObj);
 
            // Read the data byte of message received and print it on terminal
            printf("\nThe data received from CAN message: \r\n");
            for (uint8_t i = 0; i < DATA_BYTE_LENGTH; i++)
            {
                printf("%d \t", receiveMsgObj.data[i]);
            }
        }
    }
}

This example assumes that a UART is configured with STDIO enabled for the printf functions to properly work.

#include "mcc_generated_files/system/system.h"

#define DATA_BYTE_LENGTH (16)

void CANFD_Example_Receive_From_Any_FIFO(void)
{
    struct CAN_MSG_OBJ receiveMsgObj;
 
    SYSTEM_Initialize();
 
    while (1)
    {
        //Checking if messages are received in any of the RX FIFO
        if (CAN_NODE.ReceivedMessageCountGet() > 0)
        {
            // Reads a receive message object from CAN RX FIFO by polling each of the RX FIFO.
            if (true == CAN_NODE.Receive(&receiveMsgObj))
            {
                // Read the data byte of message received and print it on terminal
                printf("\nThe data received from CAN message: \r\n");
                for (uint8_t i = 0; i < DATA_BYTE_LENGTH; i++)
                {
                    printf("%d \t", receiveMsgObj.data[i]);
                }
            }
            else
            {
                printf("Error : Message read from FIFO failed \r\n");
            }
        }
    }
}

This example assumes that a UART is configured with STDIO enabled for the printf functions to properly work.

#include "mcc_generated_files/system/system.h"

volatile bool busWakeUpOccured = false;
void CAN1_SleepAndWakeUpUserInterruptHandler(void);
 
void CANFD_Example_Sleep_Wakeup_Sequence(void)
{
    SYSTEM_Initialize();
 
    CAN_NODE.BusWakeUpActivityCallbackRegister(CAN1_SleepAndWakeUpUserInterruptHandler);
 
    // Enable the Global Interrupts
    INTERRUPT_GlobalInterruptEnable();
 
    /*
     * Switching CAN FD Module to disable mode. This has to be done before calling
     * SLEEP instruction. Also enable Wake up interrupt whenever bus activity is detected
     */
    CAN_NODE.SleepMode();
 
    //Checking if CAN module has entered to Disable mode
    if (CAN_DISABLE_MODE == CAN_NODE.OperationModeGet())
    {
        printf("[*] System entering into sleep.\r\n");
 
        //Once CAN module is in disable mode, the system is put to sleep after sleep mode request   
        Sleep();
        /*
         The module wakes up from sleep whenever any activity is detected on CAN receive line
         * ie when a falling edge is detected on CAN Rx line.
         * A flag is set in user interrupt handler to monitor if system woke up from sleep mode
         * due to activity in CAN Rx line
         */
        NOP();
        if (busWakeUpOccured == true)
        {
            printf("[*] System wakeup and CAN module wake-up due to activity in CAN bus\r\n");
 
            // Recover to Normal mode
            if (CAN_OP_MODE_REQUEST_SUCCESS == CAN_NODE.OperationModeSet(CAN_CONFIGURATION_MODE))
            {
                if (CAN_OP_MODE_REQUEST_SUCCESS == CAN_NODE.OperationModeSet(CAN_NORMAL_FD_MODE))
                {
                    printf("CAN module switched to Normal CAN FD mode \r\n");
                }
            }
            busWakeUpOccured = false;
        }
        else
        {
            printf("System wake up due to event other than can bus activity \r\n ");
        }
    }
}
 
void CAN1_SleepAndWakeUpUserInterruptHandler(void)
{
    busWakeUpOccured = true;
}