TM4C123GH6PM: CAN using FIFO

Sorry, I just looked at that example in section 6.4 of the Driver Library User's Guide. There are several issues with that example. I need to take some time to correct it and then I will post a better example. To be more specific, the function CANMessageGet() will only read the data received in one of the message objects. When using FIFO mode, you must cycle through the message objects that are part of the FIFO and read each one that has new data in it. The example code clearly does not do that.

Yes, among other problems, this example is missing the assignment of the input buffer to the receive CAN message object structure. It needs a line like:

    sMsgObjectRx.pui8MsgData = pui8BufferIn;

Here is the interrupt routine that I wrote and tested which reads the values out of a 4 message buffer FIFO. The routine reads from the CAN message mailboxes and stores the data into a circular buffer.

// Circular buffer for receive CAN frames
#define BUFFER_SIZE 1024
volatile uint64_t    g_pui64Array[BUFFER_SIZE];
volatile bool        g_bErrFlag;
volatile bool        g_bTxFlag;
volatile bool        g_bRXFlag;
volatile uint32_t    g_ui32MsgCount;
volatile uint32_t    g_ui32RxMsgCount;
volatile uint32_t    g_ui32ArrayHead;
static   uint32_t    g_ui32ArrayTail;

void CAN0IntHandler(void)
{
    uint32_t ui32Status, i;
    tCANMsgObject sMsgObjectRx;

    GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_7, GPIO_PIN_7);

    //
    // Read the CAN interrupt status to find the cause of the interrupt
    //
    ui32Status = CANIntStatus(CAN0_BASE, CAN_INT_STS_CAUSE);

    //
    // If the cause is a controller status interrupt, then get the status
    //
    if(ui32Status == CAN_INT_INTID_STATUS)
    {
        //
        // Read the controller status.  This will return a field of status
        // error bits that can indicate various errors.  Error processing
        // is not done in this example for simplicity.  Refer to the
        // API documentation for details about the error status bits.
        // The act of reading this status will clear the interrupt.  If the
        // CAN peripheral is not connected to a CAN bus with other CAN devices
        // present, then errors will occur and will be indicated in the
        // controller status.
        //
        ui32Status = CANStatusGet(CAN0_BASE, CAN_STS_CONTROL);
        //
        // Set a flag to indicate some errors may have occurred.
        //
        g_bErrFlag = 1;
    }

    //
    // Check if the cause is a receive message object
    //
    else if((ui32Status > 0) & (ui32Status < 5))
    {
        for(i = ui32Status; i < 5; i++)
        {
            //
            // Getting to this point means that the RX interrupt occurred.
            // Read the message, clear the interrupt
            sMsgObjectRx.ui32Flags = MSG_OBJ_NO_FLAGS;
            sMsgObjectRx.pui8MsgData = (void *)&(g_pui64Array[g_ui32ArrayHead]);
            CANMessageGet(CAN0_BASE, i, &sMsgObjectRx, true);
            if((sMsgObjectRx.ui32Flags & MSG_OBJ_NEW_DATA) == MSG_OBJ_NEW_DATA)
            {
                // Increment head of circular buffer
                g_ui32ArrayHead++;
                g_ui32ArrayHead = g_ui32ArrayHead % BUFFER_SIZE;
                //
                // Increment a counter to keep track of how many messages have been
                // received.  In a real application this could be used to set flags to
                // indicate when a message is received.
                //
                g_ui32RxMsgCount++;
            }
            else
            {
                break;
            }
        }
    }
    //
    // Otherwise, something unexpected caused the interrupt.  This should
    // never happen.
    //
    else
    {
        //
        // Spurious interrupt handling can go here.
        //
    }
}