TiVA TM4C129X CAN controller problem

messori marco

Prodigy 130 points

Other Parts Discussed in Thread: ISO1050

Dear all

I'm trying to use CAN controller on demo board DK-TM4C129X.

I wont ti use CAN controller CAN0 to send massage and CAN1 to read message.

CAN0 have PA0= CAN0RX and PA1=CAN0TX.

CAN1 have PB0= CAN1RX and PB1=CAN1TX.

I wired on the demoboard PA0= CAN0_RX with PB1=CAN1_TX and PA1= CAN0_TX with PB0=CAN1_RX to

emulete a transmission.

But when i debug the code I see that the esecution dont run and the debugger still fixed after the system clock initialization.

In the following my code:

//*****************************************************************************
// interrupt handler for the CAN0 peripheral.
//*****************************************************************************

void CANIntHandler(void)
{
    uint32_t ui32Status;

    // 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.
        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 message object 1, which what we are using for
    // sending messages.
    //
    else if(ui32Status == 1)
    {

        // Getting to this point means that the TX interrupt occurred on
        // message object 1, and the message TX is complete. Clear the
        // message object interrupt.

        CANIntClear(CAN0_BASE, 1);


        // Increment a counter to keep track of how many messages have been
        // sent. In a real application this could be used to set flags to
        // indicate when a message is sent.

        g_ui32MsgCount++;


        // Since the message was sent, clear any error flags.

        g_bErrFlag = 0;
    }

    //
    // Otherwise, something unexpected caused the interrupt. This should
    // never happen.
    //
    else
    {
        //
        // Spurious interrupt handling can go here.
        //
    }
}

//*****************************************************************************
// main
//*****************************************************************************
int main(void)
{

   ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |                                   // Run from the PLL at 120 MHz.
                                           SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
                                           SYSCTL_CFG_VCO_480), 120000000);

    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA|SYSCTL_PERIPH_GPIOB );


    // Configure the GPIO pin muxing to select CAN0 and CAN1 functions for these pins.

    GPIOPinConfigure(GPIO_PA0_CAN0RX);   // firmware stall here
    GPIOPinConfigure(GPIO_PA1_CAN0TX);

    GPIOPinConfigure(GPIO_PB0_CAN1RX);
    GPIOPinConfigure(GPIO_PB1_CAN1TX);

    // Enable the alternate function on the GPIO pins.

    GPIOPinTypeCAN(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
    GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);

    // Enable CAN0 e CAN1 peripheral

    SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);
   SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN1);

    // Initialize the CAN0 e CAN1 controller

    CANInit(CAN0_BASE);
   CANInit(CAN1_BASE);

    // Set up the bit rate for the CAN0 and CAN1 to 500KHz

    CANBitRateSet(CAN0_BASE, ui32SysClock, 500000);
    CANBitRateSet(CAN1_BASE, ui32SysClock, 500000);

//-- Enable interrupts on the CAN0 peripheral ---------------------------------

    CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS);

    // Enable the CAN0 interrupt on the processor (NVIC).
    IntEnable(INT_CAN0);

    // Enable the CAN0 for operation.
    CANEnable(CAN0_BASE);

   // Initialize the message object that will be used for sending CAN
    // messages. The message will be 4 bytes that will contain an incrementing
    // value. Initially it will be set to 0.

    ui32MsgData = 0;
    sCANMessageTX.ui32MsgID = 1;
    sCANMessageTX.ui32MsgIDMask = 0;
    sCANMessageTX.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
    sCANMessageTX.ui32MsgLen = sizeof(pui8MsgData);
    sCANMessageTX.pui8MsgData = pui8MsgData;

    // Enable the CAN1 for operation.
    CANEnable(CAN1_BASE);


    // Initialize a message object to be used for receiving CAN messages with
    // any CAN ID. In order to receive any CAN ID, the ID and mask must both
    // be set to 0, and the ID filter enabled.

    sCANMessageRX.ui32MsgID = 0;
    sCANMessageRX.ui32MsgIDMask = 0;
    sCANMessageRX.ui32Flags = MSG_OBJ_RX_INT_ENABLE | MSG_OBJ_USE_ID_FILTER;
    sCANMessageRX.ui32MsgLen = 8;

    // Enter loop to send messages. A new message will be sent once per
    // second. The 4 bytes of message content will be treated as an uint32_t
    // and incremented by one each time.

    while(1)
    {

        // Send the CAN message
        CANMessageSet(CAN0_BASE, 1, &sCANMessageTX, MSG_OBJ_TYPE_TX);   // CAN0 trasmit message object

              while((CANStatusGet(CAN1_BASE, CAN_STS_NEWDAT)&1)== 0)
               {

                   CANMessageGet(CAN1_BASE, 1, &sCANMessageRX, 0);
               }

        // Increment the value in the message data.
        ui32MsgData++;
    }

    //
    // Return no errors
    //
    return(0);
}

Many thanks for the support

best regards

Marco

over 11 years ago

0 Amit Ashara over 11 years ago

TI__Guru**** 244400 points

Hello Marco,

Enabling the clock to the peripheral cannot be combined

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA|SYSCTL_PERIPH_GPIOB );

Replace with

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);

Regards

Amit

0 messori marco over 11 years ago in reply to Amit Ashara

Prodigy 130 points

Many thanks Amit

Now the loop start but it stay froze here :

while((CANStatusGet(CAN1_BASE, CAN_STS_NEWDAT)&1)== 0)
               {

                   CANMessageGet(CAN1_BASE, 1, &sCANMessageRX, 0);      // firmware stay here
               }

Seems that the CAN1 controller do nor receive the bit trasmitted by CAN0 controller.

Have you same suggestion for me?

Thanks again Amit

0 Amit Ashara over 11 years ago in reply to messori marco

TI__Guru**** 244400 points

Hello Messori,

Can you check if the CAN TX is occurring correctly at the IO boundary?

Secondly, the loop should be such that you wait for the message to be written in the FIFO buffer before reading it.

while((CANStatusGet(CAN1_BASE, CAN_STS_NEWDAT)&0x1)== 0x1);

CANMessageGet(CAN1_BASE, 1, &sCANMessageRX, 0);

Regards

Amit

0 INTEGRIS Dexter over 11 years ago in reply to Amit Ashara

Intellectual 905 points

I don't believe that you can physically connect the CAN0 and CAN1 like this without CAN transceiver PHY chips in the middle. The CAN physical layer has an ACK bit. The receiver will listen for its address and ack the transmission by driving the signal at the correct bit. This won't work correctly if you directly connect TX and RX pins.

It is a differential pair network I don't think you can hook it up directly as if it were a UART.

0 Bill McMahon over 10 years ago in reply to INTEGRIS Dexter

Prodigy 10 points

TivaWare Peripheral Driver Library (spmu298a), there is a CAN example in section 6.4 on page 89
where CAN0/CAN1 talk to each other via direct wire connection. However, I've never tried it.

Bill

0 cb1 over 10 years ago in reply to INTEGRIS Dexter

Guru 47900 points

Kindly let this serve as, "Vote #2" for Dexter's analysis. Upon poster Petrei's note/arrival - surely Vote #3 will land.

It should be stated that 2 CAN transceivers are required (fronting each CAN instantiation) - even if this "unverified or inexactly verified" App note claims direct connect "may", "work." (unlikely - this planet...)

Vendor's apparent "blessing" of this direct connect suggests too many sips - vendor's "Kool Aid." (tasty but sometimes toxic...)

0 Robert Adsett over 10 years ago in reply to Bill McMahon

Guru 27665 points

Vote #3

Bill McMahon said:

TivaWare Peripheral Driver Library (spmu298a), there is a CAN example in section 6.4 on page 89
where CAN0/CAN1 talk to each other via direct wire connection. However, I've never tried it.

From the documenation in question

This example code sends out data from CAN controller 0 to be received by CAN controller 1. In order to actually receive the data, an external cable must be connected between the two ports.

While that paragraph is not clearly written and I understand why you are interpreting it that way I do not believe that is what is meant. (I actually suspect they have some particulary eval board with populated transcievers in mind when they wrote that paragraph)

I know of no CAN peripherals that can be connected directly. I've seen nothing to indicate the TI peripherals are any different.

Robert

0 Roberto Romano over 10 years ago in reply to Robert Adsett

Guru 27285 points

Robert Adsett said:

While that paragraph is not clearly written and I understand why you are interpreting it that way I do not believe that is what is meant. (I actually suspect they have some particulary eval board with populated transcievers in mind when they wrote that paragraph)

I know of no CAN peripherals that can be connected directly. I've seen nothing to indicate the TI peripherals are any different.

Hi Robert, that document as you interpret is written to experiment on CAN ready board like http://www.ti.com/tool/dk-tm4c123g, document is not TIVA part related so it can be used across all family.

Thank pointing me to this new version.

To do test of dual channel I got a on semi dual CANPHY to check compatibility with other vendor. This chip is price competitor : http://www.onsemi.com/PowerSolutions/product.do?id=NCV7441 as recovery from when I bought DK board preceding version that has no on board CANPHY.

On all my board I am using isolated version ISO1050.

Arm-based microcontrollers

Arm-based microcontrollers forum

TiVA TM4C129X CAN controller problem