int
main(void)
{

      // Set the clocking to run directly from the PLL.
      //
    SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);


      //
      // Configure CAN 0 Pins.
      //
      SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);


      // Configure the GPIO pin muxing to select CAN0 functions for these pins.
      // This step selects which alternate function is available for these pins.
      // This is necessary if your part supports GPIO pin function muxing.
      // Consult the data sheet to see which functions are allocated per pin.
      // TODO: change this to select the port/pin you are using
      //
      GPIOPinConfigure(GPIO_PB4_CAN0RX);
      GPIOPinConfigure(GPIO_PB5_CAN0TX);

//      GPIOPinConfigure(GPIO_PF0_CAN1RX);
//      GPIOPinConfigure(GPIO_PF1_CAN1TX);

      GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5);


      //
      // Enable the CAN controller.
      //
      SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);

      //
      // Reset the state of all the message object and the state of the CAN
      // module to a known state.
      //
      CANInit(CAN0_BASE);

      //
      // Set up the bit rate for the CAN bus.  This function sets up the CAN
      // bus timing for a nominal configuration.  You can achieve more control
      // over the CAN bus timing by using the function CANBitTimingSet() instead
      // of this one, if needed.
      // In this example, the CAN bus is set to 500 kHz.  In the function below,
      // the call to SysCtlClockGet() is used to determine the clock rate that
      // is used for clocking the CAN peripheral.  This can be replaced with a
      // fixed value if you know the value of the system clock, saving the extra
      // function call.  For some parts, the CAN peripheral is clocked by a fixed
      // 8 MHz regardless of the system clock in which case the call to
      // SysCtlClockGet() should be replaced with 8000000.  Consult the data
      // sheet for more information about CAN peripheral clocking.
      //
      CANBitRateSet(CAN0_BASE, SysCtlClockGet(), 500000);
                //


      //
      // Enable interrupts from CAN controller.
      //
      CANIntEnable(CAN0_BASE, CAN_INT_MASTER | CAN_INT_ERROR);// | CAN_INT_STATUS

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

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

      // Initialize message object 1 to be able to send CAN message 1.  This
      // message object is not shared so it only needs to be initialized one
      // time, and can be used for repeatedly sending the same message ID.

      g_sCANMsgObject1.ulMsgID = 0x100;
      g_sCANMsgObject1.ulMsgIDMask = 0;
      g_sCANMsgObject1.ulFlags = MSG_OBJ_TX_INT_ENABLE;
      g_sCANMsgObject1.ulMsgLen = sizeof(g_ucMsg1);
      g_sCANMsgObject1.pucMsgData = g_ucMsg1;

      // Initialize message object 2 to be able to send CAN message 2.  This
      // message object is not shared so it only needs to be initialized one
      // time, and can be used for repeatedly sending the same message ID.
      //
      g_sCANMsgObject2.ulMsgID = 0x200;
      g_sCANMsgObject2.ulMsgIDMask = 0;
      g_sCANMsgObject2.ulFlags = MSG_OBJ_TX_INT_ENABLE;
      g_sCANMsgObject2.ulMsgLen = sizeof(g_ucMsg2);
      g_sCANMsgObject2.pucMsgData = g_ucMsg2;

      for(;;)
          {
              //
              // Send message 1 using CAN controller message object 1.  This is
              // the only message sent using this message object.  The
              // CANMessageSet() function will cause the message to be sent right
              // away.
              //
              //PrintCANMessageInfo(&g_sCANMsgObject1, 1);
              CANMessageSet(CAN0_BASE, 1, &g_sCANMsgObject1, MSG_OBJ_TYPE_TX);

              //
              // Send message 2 using CAN controller message object 2.  This is
              // the only message sent using this message object.  The
              // CANMessageSet() function will cause the message to be sent right
              // away.
              //
             // PrintCANMessageInfo(&g_sCANMsgObject2, 2);
              CANMessageSet(CAN0_BASE, 2, &g_sCANMsgObject2, MSG_OBJ_TYPE_TX);

              //
              // Load message object 3 with message 3.  This is needs to be done each
              // time because message object 3 is being shared for two different
              // messages.
              //
              g_sCANMsgObject3.ulMsgID = 0x300;
              g_sCANMsgObject3.ulMsgIDMask = 0;
              g_sCANMsgObject3.ulFlags = MSG_OBJ_TX_INT_ENABLE;
              g_sCANMsgObject3.ulMsgLen = sizeof(g_ucMsg3);
              g_sCANMsgObject3.pucMsgData = g_ucMsg3;

              //
              // Clear the flag that indicates that message 3 has been sent.  This
              // flag will be set in the interrupt handler when a message has been
              // sent using message object 3.
              //
              g_bMsgObj3Sent = 0;

              //
              // Now send message 3 using CAN controller message object 3.  This is
              // the first message sent using this message object.  The
              // CANMessageSet() function will cause the message to be sent right
              // away.
              //
              PrintCANMessageInfo(&g_sCANMsgObject3, 3);
              CANMessageSet(CAN0_BASE, 3, &g_sCANMsgObject3, MSG_OBJ_TYPE_TX);

              //
              // Wait for the indication from the interrupt handler that message
              // object 3 is done, because we are re-using it for another message.
              //
//              while(!g_bMsgObj3Sent)
//              {
//              }

              //
              // Load message object 3 with message 4.  This is needed because
              // message object 3 is being shared for two different messages.
              //
              g_sCANMsgObject3.ulMsgID = 0x300;
              g_sCANMsgObject3.ulMsgIDMask = 0;
              g_sCANMsgObject3.ulFlags = MSG_OBJ_TX_INT_ENABLE;
              g_sCANMsgObject3.ulMsgLen = sizeof(g_ucMsg4);
              g_sCANMsgObject3.pucMsgData = g_ucMsg4;

              //
              // Now send message 4 using CAN controller message object 3.  This is
              // the second message sent using this message object.  The
              // CANMessageSet() function will cause the message to be sent right
              // away.
              //
              //PrintCANMessageInfo(&g_sCANMsgObject3, 3);
              CANMessageSet(CAN0_BASE, 3, &g_sCANMsgObject3, MSG_OBJ_TYPE_TX);

              //
              // Wait 1 second before continuing
              //
              SimpleDelay();

              //
              // Check the error flag to see if errors occurred
              //
              if(g_bErrFlag)
              {
                  UARTprintf(" error - cable connected?\n");
              }
              else
              {
                  //
                  // If no errors then print the count of message sent
                  //
                  UARTprintf(" total count = %u\n",
                             g_ulMsg1Count + g_ulMsg2Count + g_ulMsg3Count);
              }

              //
              // Change the value in the message data for each of the messages.
              //
              (*(unsigned long *)g_ucMsg1)++;
              (*(unsigned long *)g_ucMsg2)++;
              (*(unsigned long *)g_ucMsg3)++;
              (*(unsigned long *)&g_ucMsg4[0])++;
              (*(unsigned long *)&g_ucMsg4[4])--;
          }

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