TM4C1294NCPDT: CAN transceiver program not working properly

Hi Bob,

               Thanks for your suggestion as you suggested I changed the code. The transceiver code works fine when I disable either transmitter or receiver section of the code. When I try to receive something while transmitter is enabled I got only garbage value. But if I disable the transmitter section and tried to receive I got the correct output. I cant able to figure out the problem plz help me.

Transceiver code (Corrected code as you suggested)

*
 * CAN bus LED controller slave firmware
 * Written for TI Tiva TM4C123GH6PM
 */

#include <stdint.h>
#include <stdbool.h>

#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/debug.h"
#include "inc/hw_can.h"
#include "inc/hw_ints.h"
#include "driverlib/can.h"
#include "driverlib/interrupt.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/pin_map.h"
#include "utils/uartstdio.h"

//#include "drivers/rgb.h"

volatile bool rxFlag = 0; // msg recieved flag
volatile bool errFlag = 0; // error flag
unsigned int sysClock; // clockspeed in hz

volatile uint32_t g_ui32RXMsgCount = 0;
volatile uint32_t g_ui32TXMsgCount = 0;


//tCANMsgObject g_sCAN0RxMessage;
//tCANMsgObject g_sCAN0TxMessage;

//#define CAN1RXID                0
//#define RXOBJECT                1
//#define CAN1TXID                2
//#define TXOBJECT                2
// CAN interrupt handler
void delay(unsigned int milliseconds) {
   SysCtlDelay((sysClock / 3) * (milliseconds / 1000.0f));
}

void CANIntHandler(void) {

   unsigned long status = CANIntStatus(CAN1_BASE, CAN_INT_STS_CAUSE); //read interrupt status

   if(status == CAN_INT_INTID_STATUS)
  { // controller status interrupt
      status = CANStatusGet(CAN1_BASE, CAN_STS_CONTROL);
      errFlag = 1;
   }
else if(status == 2)
{ // msg object 1
      CANIntClear(CAN1_BASE, 2); // clear interrupt
    //   g_ui32RXMsgCount++;

       errFlag = 0; // clear any error flags
}

else if(status == 1)
{
  CANIntClear(CAN1_BASE, 1); // clear interrupt
   //g_ui32TXMsgCount++;
  rxFlag = 1; // set rx flag
   errFlag = 0; // clear any error flags
}


else { // should never happen
      UARTprintf("Unexpected CAN bus interrupt\n");
   }
}

int main(void)
 {

     tCANMsgObject msgR; // the CAN msg object
   //unsigned char msgData[8]; // 8 byte buffer for rx message data

     tCANMsgObject msgT; // the CAN message object
     unsigned char msgRData[8];
     unsigned int msgTData[8]; // the message data is four bytes long which we can allocate as an int32
     unsigned char *msgDataPtr = (unsigned char *)&msgTData; // make a pointer to msgData so we can access individual bytes


   // Run from crystal at 50Mhz
    sysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |SYSCTL_CFG_VCO_480), 120000000);

   // Set up debugging UART
   SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
   SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
   GPIOPinConfigure(GPIO_PA0_U0RX);
   GPIOPinConfigure(GPIO_PA1_U0TX);
   GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
   UARTStdioConfig(0, 115200, sysClock); // 115200 baud
  SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
   //GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0);


   SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // enable CAN1 GPIOperipheral
   GPIOPinConfigure(GPIO_PB0_CAN1RX);

   GPIOPinConfigure(GPIO_PB1_CAN1TX);
   GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
   SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN1);
   CANInit(CAN1_BASE);
   CANBitRateSet(CAN1_BASE, sysClock, 500000);
   CANIntRegister(CAN1_BASE, CANIntHandler); // use dynamic vector tableallocation
   CANIntEnable(CAN1_BASE, CAN_INT_MASTER | CAN_INT_ERROR |CAN_INT_STATUS);
   IntEnable(INT_CAN1);
   CANEnable(CAN1_BASE);
   IntMasterEnable();
   // Set up LED driver
//   RGBInit(1);

   // Use ID and mask 0 to recieved messages with any CAN ID
    msgR.ui32MsgID = 0;
    msgR.ui32MsgIDMask = 0;
    msgR.ui32Flags = MSG_OBJ_RX_INT_ENABLE | MSG_OBJ_USE_ID_FILTER;
   // msgR.ui32MsgLen = sizeof(msgRData); // allow up to 8 bytes
    msgR.ui32MsgLen = 8;
   // Load msg into CAN peripheral message object 1 so it can trigger interrupts on anymatched rx messages
    CANMessageSet(CAN1_BASE, 1, &msgR, MSG_OBJ_TYPE_RX);



   //msgTData = 0;
   msgT.ui32MsgID = 1;
   msgT.ui32MsgIDMask = 0;
   msgT.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
  msgT.ui32MsgLen = sizeof(msgDataPtr);
  // msgT.ui32MsgLen = 8;
   msgT.pui8MsgData = msgDataPtr;


 //  unsigned int colour[3];
//   float intensity;
 unsigned int rcvmsg[4];
 // unsigned int x,y,z;

   while(1)
 {
// IntMasterEnable();
      if(rxFlag)
      { // rx interrupt has occured


          msgR.pui8MsgData =  msgRData;
    // msgR.pui8MsgData =  (uint8_t *) & msgRData; // set pointer to rx buffer
         CANMessageGet(CAN1_BASE, 1, &msgR, 0); // read CAN messageobject 1 from CAN peripheral

         rxFlag = 0; // clear rx flag

         if(msgR.ui32Flags & MSG_OBJ_DATA_LOST)

          { // check msg flags for any lost messages

              UARTprintf("CAN message loss detected\n");


              msgR.ui32Flags &= ~MSG_OBJ_DATA_LOST;

           //
           // Set the new state of the message object.
          //
              //CANMessageSet(CAN1_BASE, 2, &msgR, MSG_OBJ_TYPE_RX);
              //colour[0] = msgData[0] * 0xFF;
              //colour[1] = msgData[1] * 0xFF;
             // colour[2] = msgData[2] * 0xFF;
              //intensity = msgData[3] / 255.0f; // scale from 0-255 to float 0-1

                       // write to UART for debugging
             // UARTprintf("Received colour\tr: %d\tg: %d\tb: %d\ti: %d\n", colour[0],colour[1], colour[2], intensity);

          //UARTprintf("Received colour\tr: %d\tg: %d\tb: %d\ti: %d\n", msgData[0],msgData[1],msgData[2], msgData[3]);
         }

         // read in colour data from rx buffer (scale from 0-255 to 0-0xFFFF for LEDdriver)
      // colour[0] = msgData[0] * 0xFF;
     //  colour[1] = msgData[1] * 0xFF;
     //  colour[2] = msgData[2] * 0xFF;
     // intensity = msgData[3] / 255.0f; // scale from 0-255 to float 0-1
      rcvmsg[0] = msgRData[0] ;
      rcvmsg[1] = msgRData[1] ;
      rcvmsg[2] = msgRData[2] ;
      rcvmsg[3] = msgRData[3] ;
      //rcvmsg[4] = msgData[4] ;
      //rcvmsg[5] = msgData[5] ;
     // rcvmsg[6] = msgData[6] ;

      //x=msgData[4];
      //y=msgData[5];

      //z=(x<<8)|y;

      // write to UART for debugging
      UARTprintf("Received message 0x%02X %02X %02X %02X\n", rcvmsg[0], rcvmsg[1],rcvmsg[2],rcvmsg[3]);
      //UARTprintf("Received message 0x%02X %02X %02X %02X\n",rcvmsg[1]);
      //UARTprintf("Analog Volatage : %d \n", z);
      //UARTprintf("Analog Volatage : %d \n", rcvmsg[6]);



         // write to UART for debugging
     // UARTprintf("Received colour\tr: %d\tg: %d\tb: %d\ti: %d\n", colour[0], colour[1], colour[2], intensity);

         // set colour and intensity
         //RGBSet(colour, intensity);
      }

     else

#if DEBUG
    if(bMsgFlag == 0)
  {
   UARTPrintf("cant able to receive message");
   bMsgFlag = 1;
   }
#endif
//UARTprintf("can't able to receive message\n");
        msgDataPtr[0] = 0x01;
      msgDataPtr[1] = 0x00;
      msgDataPtr[2] = 0x06;
      msgDataPtr[3] = 0x05;
               CANMessageSet(CAN1_BASE,1, &msgT,MSG_OBJ_TYPE_TX); // send as msg object 1
             //  UARTprintf("cant able to transmit message\n");
              UARTprintf("Sending msg: 0x%02X %02X %02X %02X\n", msgDataPtr[0], msgDataPtr[1], msgDataPtr[2], msgDataPtr[3]);
                 delay(1000); // wait 100ms
                  IntMasterEnable();

                  if(errFlag) { // check for errors
                     UARTprintf("CAN Bus Error\n");
                  }

               //   t++; // overflow is fine


      //if(GPIOPinRead(GPIO_PORTJ_BASE, GPIO_PIN_0))





          //{
        // UARTprintf("cant able to transmit message\n");
         // }

 // wait 100ms

  }
   //delay(1000); // wait 100ms
   //return 0;
}

Transmitter code

/*
 * CAN bus LED controller master firmware
 * Written for TI Tiva TM4C1294NCPDT
 */
#include <stdbool.h>
#include <stdint.h>
#include <math.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_can.h"
#include "inc/hw_ints.h"
#include "driverlib/can.h"
#include "driverlib/interrupt.h"
#include "driverlib/sysctl.h"
#include "driverlib/gpio.h"
#include "driverlib/uart.h"
#include "driverlib/pin_map.h"
#include "utils/uartstdio.h"
#define PI 3.14159265359f
volatile bool errFlag = 0; // transmission error flag
unsigned int sysClock; // clockspeed in hz
void delay(unsigned int milliseconds) {
   SysCtlDelay((sysClock / 3) * (milliseconds / 1000.0f));
}
// CAN interrupt handler
void CANIntHandler(void) {
   unsigned long status = CANIntStatus(CAN1_BASE, CAN_INT_STS_CAUSE); // read interrupt status
   if(status == CAN_INT_INTID_STATUS) { // controller status interrupt
      status = CANStatusGet(CAN1_BASE, CAN_STS_CONTROL); // read back error bits, do something with them?
      errFlag = 1;
   } else if(status == 1) { // message object 1
      CANIntClear(CAN1_BASE, 1); // clear interrupt
      errFlag = 0; // clear any error flags
       }
   else { // should never happen
      UARTprintf("Unexpected CAN bus interrupt\n");
   }
}
int main(void) {
   tCANMsgObject msg; // the CAN message object
   unsigned int msgData; // the message data is four bytes long which we can allocate as an int32
   unsigned char *msgDataPtr = (unsigned char *)&msgData; // make a pointer to msgData so we can access individual bytes
   // Run from the PLL at 120 MHz.
   sysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000);
   // Set up debugging UART
   SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); // enable UART0 GPIO peripheral
   SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
   GPIOPinConfigure(GPIO_PA0_U0RX);
   GPIOPinConfigure(GPIO_PA1_U0TX);
   GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
   UARTStdioConfig(0, 115200, sysClock); // 115200 baud
   // Set up CAN1
   SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); // enable CAN1 GPIO peripheral
   GPIOPinConfigure(GPIO_PB0_CAN1RX);
   GPIOPinConfigure(GPIO_PB1_CAN1TX);
   GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
   SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN1);
   CANInit(CAN1_BASE);
   CANBitRateSet(CAN1_BASE, sysClock, 500000);
   CANIntRegister(CAN1_BASE, CANIntHandler); // use dynamic vector table allocation
   CANIntEnable(CAN1_BASE, CAN_INT_MASTER | CAN_INT_ERROR | CAN_INT_STATUS);
   IntEnable(INT_CAN1);
   CANEnable(CAN1_BASE);
   // Set up msg object
   msgData = 0;
   msg.ui32MsgID = 1;
   msg.ui32MsgIDMask = 0;
   msg.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
   msg.ui32MsgLen = sizeof(msgDataPtr);
   msg.pui8MsgData = msgDataPtr;
   unsigned int t = 0; // loop counter
   //float freq = 0.3; // frequency scaler
   while(1) {
      // set up next colour (scale sinf (0-1) to 0-255)
     // msgDataPtr[0] = (0.5 + 0.5*sinf(t*freq)) * 0xFF;
    //  msgDataPtr[1] = (0.5 + 0.5*sinf(t*freq + (2*PI/3))) * 0xFF; // 120 degrees out of phase
    //  msgDataPtr[2] = (0.5 + 0.5*sinf(t*freq + (4*PI/3))) * 0xFF; // 240 degrees out of phase
     // msgDataPtr[3] = 128; // 50% intensity
         msgDataPtr[0] = 0x01;
      msgDataPtr[1] = 0x02;
      msgDataPtr[2] = 0x03;
      msgDataPtr[3] = 0x04;
      UARTprintf("Sending msg: 0x%02X %02X %02X %02X\n", msgDataPtr[0], msgDataPtr[1], msgDataPtr[2], msgDataPtr[3]); // write colour to UART for debugging
IntMasterDisable();
CANMessageSet(CAN1_BASE, 1, &msg, MSG_OBJ_TYPE_TX); // send as msg object 1
      delay(1000); // wait 1000ms
      IntMasterEnable();
      if(errFlag) { // check for errors
         UARTprintf("CAN Bus Error\n");
      }
      t++; // overflow is fine
   }
   //return 0;
}

Try changing the message ID of the second transmitter. You have both nodes transmitting with msg.ui32MsgID = 1. That should be avoided.

Hi Bob,

Staff notes your FAR, 'Above & Beyond' (i.e. very deep dive) support - such 'Attention to Detail' should be adopted by the poster - as well.

Staff senses that  the insertion of 'Key Breakpoints' - in which all 'key/critical CAN Registers' are carefully checked - may enable, 'Faster & Easier' detection of a flawed code block.

Poster may significantly benefit from the 'Careful examination of (unmodified) vendor example code' (especially simpler CAN code) - following Staff's recommendation above, ("Halt the code at Key Points - & then carefully examine CAN Registers") prior to  'doing battle' w/the 'far more complex & lengthy' code - poster submitted for analysis here...

Improved Code Analysis METHODS as well as heightened CAN understanding (i.e. details) appears a 'valid prescription.'     (such 'spectacular' support (may not always) be available!)      The suggestions herein aim to create, 'Greater Poster Understanding, Capability, & Independence!'

Hi Bob,

           I even changed the message ID of the transmitter code to 3 but still I am getting the same output. Help me

Please post your modified transmit project and I will take a look at it.

Sorry, I accidentally clicked "TI thinks resolved". Please reject that, unless you have actually resolved the issue.

I did not see any obvious issues with the transmitter code. Can you tell me again which errors you are now getting? If it is the "Unexpected CAN bus interrupt" message, what value was returned from CANIntStatus? If it is "CAN Bus Error", what is the value returned from CANStatusGet? 

I have not heard back from you. Did you resolve the issue?

Hi Bob,

sorry for the delayed response. with this I attached the interrupt status of the both transmitter and transceiver code for your perusal.

interrupt status of transmitter code

interrupt status of CAN transceiver code

I am out of the office and will return on Wednesday October 16. I have asked a colleague to look into your issue while I am gone. 

The status of the receiver does not show any message being received. Have you looked at the CAN bus with an oscilloscope and logic analyzer?