void init_clk_system(void)
/*****************************************************************************
* Input : -
* Output : -
* Function :
*****************************************************************************/
{
// Init clock settings according to datasheet
// Set Clock speed to 50 Mhz.
// Step 1
// Set BYPASS bit
SYSCTL_RCC_R |= SYSCTL_RCC_BYPASS;
// Clear USESYS bits
SYSCTL_RCC_R &= ~(SYSCTL_RCC_USESYSDIV);
// Enable Main osc.
SYSCTL_RCC_R &= ~(SYSCTL_RCC_MOSCDIS);
// Step 2
// Clear PLL lock flag
//SYSCTL_RIS_R = ~(SYSCTL_RIS_PLLLRIS);
SYSCTL_MISC_R |= SYSCTL_RIS_PLLLRIS;
// Set XTAL value, first clear bits then set
SYSCTL_RCC_R &= ~(SYSCTL_RCC_XTAL_M);
SYSCTL_RCC_R |= SYSCTL_RCC_XTAL_16MHZ;
// delay
SimpleDelay();
// Set OSCSRC, first clear bits then set
SYSCTL_RCC_R &= ~(SYSCTL_RCC_OSCSRC_M);
SYSCTL_RCC_R |= SYSCTL_RCC_OSCSRC_MAIN;
// Clear PWRDN
SYSCTL_RCC_R &= ~(SYSCTL_RCC_PWRDN);
// delay
SimpleDelay();
// Step 3
// Set SYSDIV, first clear bits then set
// Set to 50 Mhz.
SYSCTL_RCC_R &= ~(SYSCTL_RCC_SYSDIV_M);
SYSCTL_RCC_R |= SYSCTL_RCC_SYSDIV_4;
// Set USESYS bit
SYSCTL_RCC_R |= SYSCTL_RCC_USESYSDIV;
// Step 4
// wait for PLL lock
while(!(SYSCTL_RIS_R & SYSCTL_RIS_PLLLRIS));
// Step 5
// Clear BYPASS bit
SYSCTL_RCC_R &= ~(SYSCTL_RCC_BYPASS);
// delay
SimpleDelay();
}
/***************************** Functions *******************************/
void initHW(void)
{
volatile INT16U event;
volatile INT32U ulLoop;
volatile INT8S dummy;
// Enable the GPIO port that is used for the on-board.
SYSCTL_RCGC2_R = SYSCTL_RCGC2_GPIOB | SYSCTL_RCGC2_GPIOD;
// Do a dummy read to insert a few cycles after enabling the peripheral.
dummy = SYSCTL_RCGC2_R;
// Outputs:
// Set the direction as output (PD0).
// PD0 : Status LED intern USR_LED
GPIO_PORTD_DIR_R = 0x01;
// inputs :
// Enable internal pull-up (PB4).
// PB4 : Select button SW2
GPIO_PORTB_PUR_R = 0x08;
// Enable the GPIO pins for digital function (PD6, PF0, PF1, PG0 and PG1).
// PD0 +PB4 : intern USR_LED + SW2
GPIO_PORTB_DEN_R = 0x08;
GPIO_PORTD_DEN_R = 0x01;
// a short delay to ensure stable IO before running the rest of the program
SimpleDelay();
}
void initHW(void)
{
volatile INT16U event;
volatile INT32U ulLoop;
//SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);//set to use osc its better for pwm
//! Enable the ports
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
// Inputs :
// PF1 : Select button
// PE0 : Up button
// PE1 : Down button
// PE2 : Left button
// PE3 : Right button
GPIODirModeSet( GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_DIR_MODE_IN);
GPIOPadConfigSet( GPIO_PORTF_BASE, GPIO_PIN_1, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIODirModeSet( GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, GPIO_DIR_MODE_IN);
GPIOPadConfigSet( GPIO_PORTE_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Outputs:
// PF0 : Status LED
GPIODirModeSet( GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_DIR_MODE_OUT);
GPIOPadConfigSet( GPIO_PORTF_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD);
GPIOPinWrite( GPIO_PORTF_BASE, GPIO_PIN_0, false);
//! PD6 : LED1 RED
// Set the direction as output (PF0).
GPIO_PORTD_DIR_R = 0x40;
// Enable the GPIO pins for digital function (PF0 and PF1).
GPIO_PORTD_DEN_R = 0x40;
//! PG0 : LED2 YELLOW
//! PG1 : LED3 GREEN
GPIO_PORTG_DIR_R = 0x03;
// Enable the GPIO pins for digital function (PF0 and PF1).
GPIO_PORTG_DEN_R = 0x03;
//off
//! PD6 : LED1 RED
GPIO_PORTD_DATA_R |= 0x40;
//! PG0+PG1 : LED2 YELLOW + LED3 GREEN
GPIO_PORTG_DATA_R |= 0x03;
// a short delay to ensure stable IO before running the rest of the program
SimpleDelay(5);
}
//*****************************************************************************
//
// Configure the CAN and enter a loop to transmit periodic CAN messages.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the external crystal/oscillator.
// TODO: The SYSCTL_XTAL_ value must be changed to match the value of the
// crystal on your board.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for CAN operation.
//
InitConsole();
//
// For this example CAN0 is used with RX and TX pins on port B4 and B5.
// The actual port and pins used may be different on your part, consult
// the data sheet for more information.
// GPIO port B needs to be enabled so these pins can be used.
// TODO: change this to whichever GPIO port you are using
//
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);
//
// Enable the alternate function on the GPIO pins. The above step selects
// which alternate function is available. This step actually enables the
// alternate function instead of GPIO for these pins.
// TODO: change this to match the port/pin you are using
//
GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5);
//
// The GPIO port and pins have been set up for CAN. The CAN peripheral
// must be enabled.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);
//
// Initialize the CAN controller
//
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 on the CAN peripheral. This example uses static
// allocation of interrupt handlers which means the name of the handler
// is in the vector table of startup code. If you want to use dynamic
// allocation of the vector table, then you must also call CANIntRegister()
// here.
//
// CANIntRegister(CAN0_BASE, CANIntHandler); // if using dynamic vectors
//
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 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.
//
//
// 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.ui32MsgID = 0x1001;
g_sCANMsgObject1.ui32MsgIDMask = 0;
g_sCANMsgObject1.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
g_sCANMsgObject1.ui32MsgLen = sizeof(g_pui8Msg1);
g_sCANMsgObject1.pui8MsgData = g_pui8Msg1;
//
// 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.ui32MsgID = 0x2001;
g_sCANMsgObject2.ui32MsgIDMask = 0;
g_sCANMsgObject2.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
g_sCANMsgObject2.ui32MsgLen = sizeof(g_pui8Msg2);
g_sCANMsgObject2.pui8MsgData = g_pui8Msg2;
//
// Enter loop to send messages. Four messages will be sent once per
// second. The contents of each message will be changed each time.
//
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.ui32MsgID = 0x3001;
g_sCANMsgObject3.ui32MsgIDMask = 0;
g_sCANMsgObject3.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
g_sCANMsgObject3.ui32MsgLen = sizeof(g_pui8Msg3);
g_sCANMsgObject3.pui8MsgData = g_pui8Msg3;
//
// 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.ui32MsgID = 0x3002;
g_sCANMsgObject3.ui32MsgIDMask = 0;
g_sCANMsgObject3.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
g_sCANMsgObject3.ui32MsgLen = sizeof(g_pui8Msg4);
g_sCANMsgObject3.pui8MsgData = g_pui8Msg4;
//
// 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_ui32Msg1Count + g_ui32Msg2Count + g_ui32Msg3Count);
}
//
// Change the value in the message data for each of the messages.
//
(*(uint32_t *)g_pui8Msg1)++;
(*(uint32_t *)g_pui8Msg2)++;
(*(uint32_t *)g_pui8Msg3)++;
(*(uint32_t *)&g_pui8Msg4[0])++;
(*(uint32_t *)&g_pui8Msg4[4])--;
}
//
// Return no errors
//
return(0);
}
//*****************************************************************************
//
// Configure the CAN and enter a loop to transmit periodic CAN messages.
//
//*****************************************************************************
int
main(void)
{
tCANMsgObject sCANMessage;
uint32_t ui32MsgData;
uint8_t *pui8MsgData;
pui8MsgData = (uint8_t *)&ui32MsgData;
//
// Set the clocking to run directly from the external crystal/oscillator.
// TODO: The SYSCTL_XTAL_ value must be changed to match the value of the
// crystal on your board.
//
SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set up the serial console to use for displaying messages. This is
// just for this example program and is not needed for CAN operation.
//
InitConsole();
//
// For this example CAN0 is used with RX and TX pins on port B4 and B5.
// The actual port and pins used may be different on your part, consult
// the data sheet for more information.
// GPIO port B needs to be enabled so these pins can be used.
// TODO: change this to whichever GPIO port you are using
//
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);
//
// Enable the alternate function on the GPIO pins. The above step selects
// which alternate function is available. This step actually enables the
// alternate function instead of GPIO for these pins.
// TODO: change this to match the port/pin you are using
//
GPIOPinTypeCAN(GPIO_PORTB_BASE, GPIO_PIN_4 | GPIO_PIN_5);
//
// The GPIO port and pins have been set up for CAN. The CAN peripheral
// must be enabled.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_CAN0);
//
// Initialize the CAN controller
//
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 on the CAN peripheral. This example uses static
// allocation of interrupt handlers which means the name of the handler
// is in the vector table of startup code. If you want to use dynamic
// allocation of the vector table, then you must also call CANIntRegister()
// here.
//
// CANIntRegister(CAN0_BASE, CAN0_IRQHandler); // if using dynamic vectors
//
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 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;
sCANMessage.ui32MsgID = 1;
sCANMessage.ui32MsgIDMask = 0;
sCANMessage.ui32Flags = MSG_OBJ_TX_INT_ENABLE;
sCANMessage.ui32MsgLen = sizeof(pui8MsgData);
sCANMessage.pui8MsgData = pui8MsgData;
//
// 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)
{
//
// Print a message to the console showing the message count and the
// contents of the message being sent.
//
UARTprintf("Sending msg: 0x%02X %02X %02X %02X",
pui8MsgData[0], pui8MsgData[1], pui8MsgData[2],
pui8MsgData[3]);
//
// Send the CAN message using object number 1 (not the same thing as
// CAN ID, which is also 1 in this example). This function will cause
// the message to be transmitted right away.
//
CANMessageSet(CAN0_BASE, 1, &sCANMessage, MSG_OBJ_TYPE_TX);
//
// Now 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_ui32MsgCount);
}
//
// Increment the value in the message data.
//
ui32MsgData++;
}
//
// Return no errors
//
return(0);
}
