TMS320F280037-Q1: Do we have the MCAN demo code based on sysconifg

//
// Include Files
//
#include "driverlib.h"
#include "device.h"
#include "board.h"
#include "inc/stw_types.h"
#include "inc/stw_dataTypes.h"
#include <string.h>

// Global Variables.
int32_t     error = 0;
MCAN_RxBufElement rxMsg[myMCAN0_MCAN_FIFO_1_NUM], rxMsg1;
MCAN_RxFIFOStatus RxFS;
int32_t loopCnt = 0U;

// Function Prototype.
static void MCANIntrConfig(void);
static void MCAN_ReadRxFIFO(uint32_t baseAddr, uint32_t fifoNum, MCAN_RxBufElement *rxMsg);

void main()
 {
    int i = 0;
    volatile uint32_t mode = 0U;
    uint32_t dataBytes = 64;

    //
    // Initialize device clock and peripherals
    //
    Device_init();

    //
    // Initialize GPIO and unlock the GPIO configuration registers
    //
    Device_initGPIO();

    //
    // Configure the divisor for the MCAN bit-clock
    //
    SysCtl_setMCANClk(SYSCTL_MCANCLK_DIV_3);

    //
    // ISR Configuration.
    //
    MCANIntrConfig();

    Board_init();

    //
    // Initialize receive data structure
    // (not to be confused with RX Buffer inside the MCAN module)
    //
    rxMsg[loopCnt].id = 0U;
    rxMsg[loopCnt].rtr = 0U;
    rxMsg[loopCnt].xtd = 0U;
    rxMsg[loopCnt].esi = 0U;
    rxMsg[loopCnt].rxts = 0U;
    rxMsg[loopCnt].dlc = 0U;
    rxMsg[loopCnt].brs = 0U;
    rxMsg[loopCnt].fdf = 0U;
    rxMsg[loopCnt].fidx = 0U;
    rxMsg[loopCnt].anmf = 0U;
    for(i = 0; i < dataBytes; i++)
    {
        rxMsg[loopCnt].data[i]  = 0;
    }

    while(1)
    {
        //  Adding delay of 1 second
        DEVICE_DELAY_US(1000000);

        //  Message Handling Code goes here
    }

    // Stop Application.
    asm("   ESTOP0");
}

// This function will configure X-BAR for MCAN interrupts.
static void MCANIntrConfig(void)
{
    Interrupt_initModule();
    Interrupt_initVectorTable();
    Interrupt_enableGlobal();
}

// This is Interrupt Service Routine for MCAN interrupt 1.
void INT_myMCAN0_1_ISR(void)
{
    uint32_t intrStatus;

    intrStatus = MCAN_getIntrStatus(myMCAN0_BASE);

    // Clear the interrupt Status.
    MCAN_clearIntrStatus(myMCAN0_BASE, intrStatus);

    //  Clearing the interrupt lineNum
    MCAN_clearInterrupt(myMCAN0_BASE, 0x2);

    //  Check to see if the interrupt is caused by a new message being
    //  received in RX FIFO 1
    if((MCAN_INTR_SRC_RX_FIFO1_NEW_MSG & intrStatus) == MCAN_INTR_SRC_RX_FIFO1_NEW_MSG)
    {
        MCAN_ReadRxFIFO(myMCAN0_BASE, MCAN_RX_FIFO_NUM_1, &rxMsg);
    }
    else
    {
        error++;
        //  Interrupt handling for other interrupt sources goes here
    }

    // Acknowledge this interrupt located in group 9
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);
}

#define CAN_ID_STD                        (0x0U)
#define CAN_ID_XTD                        (0x1U)
#define CAN_XTD_MSGID_MASK                ((uint32_t)0x1fffffffU)
#define CAN_STD_MSGID_MASK                ((uint32_t)0x7ffU)
#define CAN_STD_MSGID_SHIFT               ((uint32_t)18U)
#define CAN_MSG_TYPE_MASK                 ((uint32_t)0x40000000U)
#define CAN_MSG_ID_TYPE_EXT               ((uint32_t)0x80000000U)

static void MCAN_ReadRxFIFO(uint32_t baseAddr, uint32_t fifoNum, MCAN_RxBufElement *rxMsg)
{
   uint32_t fillLvl = (uint32_t)0;
   uint32_t loopCnt = (uint32_t)0;
   uint8_t canDataLength = (uint8_t)0;
   uint32_t canIdentifier = (uint32_t)0;
   uint32_t byteCnt = (uint32_t)0;
   MCAN_RxFIFOStatus fifoStatus = {0};
   MCAN_RxBufElement elem = {0};

 //  baseAddr = controllerObj->canControllerConfig.CntrAddr;
   fifoStatus.num = fifoNum;

   /* Get Rx FIFO status */
   MCAN_getRxFIFOStatus(baseAddr, &fifoStatus);
   fillLvl = fifoStatus.fillLvl;

   for (loopCnt = 0; loopCnt < fillLvl; loopCnt++)
   {
       MCAN_getRxFIFOStatus(baseAddr, &fifoStatus);
       MCAN_readMsgRam(baseAddr,
                       MCAN_MEM_TYPE_FIFO,
                       fifoStatus.getIdx, /*buff number*/
                       fifoNum,
                       &elem);

      MCAN_writeRxFIFOAck(baseAddr, fifoNum, fifoStatus.getIdx);

      canDataLength = MCAN_getMsgObjSize(elem.dlc);

      if ((uint8_t)CAN_ID_XTD == elem.xtd)
      {
         /* Received frame with Extended ID - set MSB to '1' */
         canIdentifier = ((uint32_t)elem.id | CAN_MSG_ID_TYPE_EXT);
      }
      else
      {
         /* Received frame with Standard ID */
         canIdentifier = (((uint32_t)elem.id >> CAN_STD_MSGID_SHIFT) & CAN_STD_MSGID_MASK);
      }

      /* Set CAN-FD bit (30th bit) to '1' if CAN-FD frame is received */
      canIdentifier = (canIdentifier | ((uint32_t)elem.fdf << 30U));

      for (byteCnt = 0; byteCnt < canDataLength; byteCnt++)
      {
          rxMsg[loopCnt].data[byteCnt] = (uint8_t)elem.data[byteCnt];
      }

      rxMsg[loopCnt].id = canIdentifier;
      rxMsg[loopCnt].xtd = elem.xtd;
      rxMsg[loopCnt].dlc = elem.dlc;
      rxMsg[loopCnt].fdf = elem.fdf;
   }
}