//*****************************************************************************
//
// Main application entry function.
//
//*****************************************************************************
int
main(void)
{
tBoolean bRetcode;
smplStatus_t eRetcode;
ioctlToken_t eToken;
//
// Set the system clock to run at 50MHz from the PLL
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// NB: We don't call PinoutSet() in this testcase since the EM header
// expansion board doesn't currently have an I2C ID EEPROM. If we did
// call PinoutSet() this would configure all the EPI pins for SDRAM and
// we don't want to do this.
//
g_eDaughterType = DAUGHTER_NONE;
//
// Enable peripherals required to drive the LCD.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
//
// Configure SysTick for a 10Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the touch screen driver.
//
TouchScreenInit();
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sHeading);
//
// Initialize the status string.
//
UpdateStatus("Initializing...");
//
// Paint the widget tree to make sure they all appear on the display.
//
WidgetPaint(WIDGET_ROOT);
//
// Initialize the SimpliciTI BSP.
//
BSP_Init();
//
// Set the SimpliciTI device address using the current Ethernet MAC address
// to ensure something like uniqueness.
//
bRetcode = SetSimpliciTIAddress();
//
// Did we have a problem with the address?
//
if(!bRetcode)
{
//
// Yes - make sure the display is updated then hang the app.
//
WidgetMessageQueueProcess();
while(1)
{
//
// MAC address is not set so hang the app.
//
}
}
//
// Turn on both our LEDs
//
SetLED(1, true);
SetLED(2, true);
UpdateStatus("Waiting...");
//
// Initialize the SimpliciTI stack but don't set any receive callback.
//
while(1)
{
eRetcode = SMPL_Init((uint8_t (*)(linkID_t))0);
if(eRetcode == SMPL_SUCCESS)
{
break;
}
ToggleLED(1);
ToggleLED(2);
SPIN_ABOUT_A_SECOND;
}
// This code example changes the Link token to be distributed to those who
// Join. For the example here this should be done before anyone joins so
// the Join context is defaulted to OFF for this scenario. See the
// smpl_config.dat file. After the link token is set the Join context must
// be enabled.
//
// NOTE that this is done after initialization. For APs the init sequence
// consists of a step in which a link token is generated. The sequence here
// overrides that setting. It can be used to distribute different link
// tokens to different devices. The sequence here is a simple example of
// how to use the IOCTL interface to set the Link token for subsequent
// Joiners.
//
// You might want to be careful about following this particular example if
// you are restoring from NV unless you are setting a fixed value as is
// done here. Unconditionally setting a random value will make it
// essentially impossible for newly joining devices to link to devices that
// joined before the AP was reset since they will have different link
// tokens.
//
eToken.tokenType = TT_LINK;
eToken.token.linkToken = 0x78563412;
SMPL_Ioctl(IOCTL_OBJ_TOKEN, IOCTL_ACT_SET, &eToken);
//
// Enable join context.
//
SMPL_Ioctl(IOCTL_OBJ_AP_JOIN, IOCTL_ACT_ON, 0);
//
// Tell the user what's up.
//
UpdateStatus("Access point active.");
//
// Do nothing after this - the SimpliciTI stack code handles all the
// access point function required.
//
while(1)
{
//
// Process the widget message queue.
//
WidgetMessageQueueProcess();
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
unsigned long ulButton, ulPrevious, ulLastTickCount;
tBoolean bLastSuspend;
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTprintf("\033[2JKeyboard device application\n");
//
// Enable the GPIO that is used for the on-board push button.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4);
ROM_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
//
// Enable the GPIO that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 0);
//
// Not configured initially.
//
g_bConnected = false;
g_bSuspended = false;
bLastSuspend = false;
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass our device information to the USB HID device class driver,
// initialize the USB
// controller and connect the device to the bus.
//
USBDHIDKeyboardInit(0, &g_sKeyboardDevice);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// The main loop starts here. We begin by waiting for a host connection
// then drop into the main keyboard handling section. If the host
// disconnects, we return to the top and wait for a new connection.
//
ulPrevious = 1;
while(1)
{
//
// Tell the user what we are doing and provide some basic instructions.
//
UARTprintf("Waiting for host...\n");
//
// Wait for USB configuration to complete.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
UARTprintf("Host connected...\n");
//
// Enter the idle state.
//
g_eKeyboardState = STATE_IDLE;
//
// Assume that the bus is not currently suspended if we have just been
// configured.
//
bLastSuspend = false;
//
// Keep transfering characters from the UART to the USB host for as
// long as we are connected to the host.
//
while(g_bConnected)
{
//
// Remember the current time.
//
ulLastTickCount = g_ulSysTickCount;
//
// Has the suspend state changed since last time we checked?
//
if(bLastSuspend != g_bSuspended)
{
//
// Yes - the state changed so update the display.
//
bLastSuspend = g_bSuspended;
UARTprintf(bLastSuspend ? "Bus suspended...\n" :
"Host connected...\n");
}
//
// See if the button was just pressed.
//
ulButton = ROM_GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_4);
if((ulButton == 0) && (ulPrevious != 0))
{
//
// If the bus is suspended then resume it. Otherwise, type
// some "random" characters.
//
if(g_bSuspended)
{
//
// We are suspended so request a remote wakeup.
//
USBDHIDKeyboardRemoteWakeupRequest(
(void *)&g_sKeyboardDevice);
}
else
{
SendString("Make the Switch to TI Microcontrollers!");
}
}
ulPrevious = ulButton;
//
// Wait for at least 1 system tick to have gone by before we poll
// the buttons again.
//
while(g_ulSysTickCount == ulLastTickCount)
{
//
// Hang around doing nothing.
//
}
}
//
// Dropping out of the previous loop indicates that the host has
// disconnected so go back and wait for reconnection.
//
if(g_bConnected == false)
{
UARTprintf("Host disconnected...\n");
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
//
// Turn on stacking of FPU registers if FPU is used in the ISR.
//
FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 40MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Enable the Debug UART.
//
ConfigureUART();
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JAir Mouse Application\n");
//
// Configure desired interrupt priorities. This makes certain that the DCM
// is fed data at a consistent rate. Lower numbers equal higher priority.
//
ROM_IntPrioritySet(INT_I2C3, 0x00);
ROM_IntPrioritySet(INT_GPIOB, 0x10);
ROM_IntPrioritySet(FAULT_SYSTICK, 0x20);
ROM_IntPrioritySet(INT_UART1, 0x60);
ROM_IntPrioritySet(INT_UART0, 0x70);
ROM_IntPrioritySet(INT_WTIMER5B, 0x80);
//
// Configure the USB D+ and D- pins.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_5 | GPIO_PIN_4);
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
USBDHIDMouseCompositeInit(0, &g_sMouseDevice, &g_psCompDevices[0]);
USBDHIDKeyboardCompositeInit(0, &g_sKeyboardDevice, &g_psCompDevices[1]);
//
// Set the USB stack mode to Force Device mode.
//
USBStackModeSet(0, eUSBModeForceDevice, 0);
//
// Pass the device information to the USB library and place the device
// on the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE,
g_pui8DescriptorData);
//
// User Interface Init
//
ButtonsInit();
RGBInit(0);
RGBEnable();
//
// Initialize the motion sub system.
//
MotionInit();
//
// Initialize the Radio Systems.
//
LPRFInit();
//
// Drop into the main loop.
//
while(1)
{
//
// Check for and handle timer tick events.
//
if(HWREGBITW(&g_ui32Events, USB_TICK_EVENT) == 1)
{
//
// Clear the Tick event flag. Set in SysTick interrupt handler.
//
HWREGBITW(&g_ui32Events, USB_TICK_EVENT) = 0;
//
// Each tick period handle wired mouse and keyboard.
//
if(HWREGBITW(&g_ui32USBFlags, FLAG_CONNECTED) == 1)
{
MouseMoveHandler();
KeyboardMain();
}
}
//
// Check for LPRF tick events. LPRF Ticks are slower since UART to
// RNP is much slower data connection than the USB.
//
if(HWREGBITW(&g_ui32Events, LPRF_TICK_EVENT) == 1)
{
//
// Clear the event flag.
//
HWREGBITW(&g_ui32Events, LPRF_TICK_EVENT) = 0;
//
// Perform the LPRF Main task handling
//
LPRFMain();
}
//
// Check for and handle motion events.
//
if((HWREGBITW(&g_ui32Events, MOTION_EVENT) == 1) ||
(HWREGBITW(&g_ui32Events, MOTION_ERROR_EVENT) == 1))
{
//
// Clear the motion event flag. Set in the Motion I2C interrupt
// handler when an I2C transaction to get sensor data is complete.
//
HWREGBITW(&g_ui32Events, MOTION_EVENT) = 0;
//
// Process the motion data that has been captured
//
MotionMain();
}
}
}
int
main(void)
{
unsigned long ulPHYMR0;
tBoolean bButtonWasPressed = false;
tMotorState sMotorState=STATE_STOPPED;
tWaveHeader sWaveHeader;
unsigned long ulWaveIndex = 1;
int losL,losH;
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH);
ulPHYMR0 = ROM_EthernetPHYRead(ETH_BASE, PHY_MR0);
ROM_EthernetPHYWrite(ETH_BASE, PHY_MR0, ulPHYMR0 | PHY_MR0_PWRDN);
// Display96x16x1Init(true);
// Display96x16x1StringDraw("MOTOR", 29, 0);
// Display96x16x1StringDraw("DEMO", 31, 1);
LEDsInit();
LED_On(LED_1);
PushButtonsInit();
BumpSensorsInit();
MotorsInit();
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
SoundInit();
// WaveOpen((unsigned long *) sWaveClips[ulWaveIndex].pucWav, &sWaveHeader);
//mozliwe ze trzeba przed kazdym odtworzeniem ;/
// while(WaveOpen((unsigned long *)
// sWaveClips[ulWaveIndex].pucWav,
// &sWaveHeader) != WAVE_OK);//do zablokowania w razie bledu
for(;;)
{
tBoolean bButtonIsPressed;
tBoolean bBumperIsPressed[2];
bButtonIsPressed = !PushButtonGetDebounced((tButton)1);
bBumperIsPressed[0] = !BumpSensorGetDebounced((tBumper)0);
bBumperIsPressed[1] = !BumpSensorGetDebounced((tBumper)1);
switch(sMotorState)
{
case STATE_STOPPED:
{
if(bButtonIsPressed && !bButtonWasPressed)
{
sterowanie(0,50,50);
sMotorState = STATE_RUNNING;
}
break;
}
case STATE_RUNNING:
{
if(bButtonIsPressed && !bButtonWasPressed)
{
MotorStop((tSide)0);
MotorStop((tSide)1);
sMotorState = STATE_STOPPED;
}
else if(bBumperIsPressed[0])
{
MotorStop((tSide)0);
MotorStop((tSide)1);
// WavePlayStart(&sWaveHeader); mozliwe ze tu
losL =10+ g_ulTickCount % 20;//i dać los zamiast 15,mamy losowe skrecanie(10-30)
losH =40+ g_ulTickCount % 30;//i dać los zamiast 60,mamy losowe skrecanie(40-70)
sterowanie(1,losL,losH);
sMotorState = STATE_TYL;
}
else if(bBumperIsPressed[1]){
MotorStop((tSide)0);
MotorStop((tSide)1);
losL =10+ g_ulTickCount % 20;//i dać los zamiast 15,mamy losowe skrecanie(10-30)
losH =40+ g_ulTickCount % 30;//i dać los zamiast 60,mamy losowe skrecanie(40-70)
sterowanie(1,losH,losL);
// WavePlayStart(&sWaveHeader); mozliwe ze tu
sMotorState = STATE_TYL;
}
break;
}
case STATE_TYL:
{//cofanie tez moze byc losowe np losH+losL(50-100)+160=(210-260)
while(cofanie<250);
MotorStop((tSide)0);
MotorStop((tSide)1);
sterowanie(0,50,50);
sMotorState = STATE_RUNNING;
break;
}
default:
{
MotorStop((tSide)1);
MotorStop((tSide)0);
sMotorState = STATE_STOPPED;
break;
}
}
bButtonWasPressed = bButtonIsPressed;
}
}
//*****************************************************************************
//
// Main application entry function.
//
//*****************************************************************************
int
main(void)
{
tBoolean bRetcode;
//
// Set the system clock to run at 50MHz from the PLL
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// NB: We don't call PinoutSet() in this testcase since the EM header
// expansion board doesn't currently have an I2C ID EEPROM. If we did
// call PinoutSet() this would configure all the EPI pins for SDRAM and
// we don't want to do this.
//
g_eDaughterType = DAUGHTER_NONE;
//
// Enable peripherals required to drive the LCD.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
//
// Configure SysTick for a 10Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the touch screen driver.
//
TouchScreenInit();
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sHeading);
//
// Initialize the status string.
//
UpdateStatus(true, "Joining network...");
//
// Paint the widget tree to make sure they all appear on the display.
//
WidgetPaint(WIDGET_ROOT);
//
// Initialize the SimpliciTI BSP.
//
BSP_Init();
//
// Set the SimpliciTI device address using the current Ethernet MAC address
// to ensure something like uniqueness.
//
bRetcode = SetSimpliciTIAddress();
//
// Did we have a problem with the address?
//
if(!bRetcode)
{
//
// Yes - make sure the display is updated then hang the app.
//
WidgetMessageQueueProcess();
while(1)
{
//
// MAC address is not set so hang the app.
//
}
}
//
// Turn both "LEDs" off.
//
SetLED(1, false);
SetLED(2, false);
//
// Keep trying to join (a side effect of successful initialization) until
// successful. Toggle LEDS to indicate that joining has not occurred.
//
while(SMPL_SUCCESS != SMPL_Init(0))
{
ToggleLED(1);
ToggleLED(2);
SPIN_ABOUT_A_SECOND;
}
//
// We have joined the network so turn on both "LEDs" to indicate this.
//
SetLED(1, true);
SetLED(2, true);
UpdateStatus(true, "Joined network");
//
// Link to the access point which is now listening for us and continue
// processing. This function does not return.
//
LinkTo();
}
//*****************************************************************************
//
// The main application. It configures the board and then enters a loop
// to show messages on the display and blink the LEDs.
//
//*****************************************************************************
int
main(void)
{
unsigned long ulPHYMR0;
unsigned long ulNextTickLED = 0;
unsigned long ulNextTickDisplay = 0;
unsigned long ulDisplayState = 0;
//
// Set the clocking to directly from the crystal
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Since the Ethernet is not used, power down the PHY to save battery.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH);
ulPHYMR0 = ROM_EthernetPHYRead(ETH_BASE, PHY_MR0);
ROM_EthernetPHYWrite(ETH_BASE, PHY_MR0, ulPHYMR0 | PHY_MR0_PWRDN);
//
// Initialize the board display
//
Display96x16x1Init(true);
//
// Initialize the GPIO used for the LEDs, and then turn one LED on
// and the other off
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_5);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4, 0);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_5, GPIO_PIN_5);
//
// Set up and enable the SysTick timer to use as a time reference.
// It will be set up for a 100 ms tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 10);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enter loop to run forever, blinking LEDs and printing messages to
// the display
//
for(;;)
{
//
// If LED blink period has timed out, then toggle LEDs.
//
if(g_ulTickCount >= ulNextTickLED)
{
//
// Set next LED toggle timeout for 1 second
//
ulNextTickLED += 10;
//
// Toggle the state of each LED
//
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_5,
~ROM_GPIOPinRead(GPIO_PORTF_BASE,
GPIO_PIN_4 | GPIO_PIN_5));
}
//
// If display interval has elapsed, then update display state
//
if(g_ulTickCount >= ulNextTickDisplay)
{
//
// Process the display state. Each state, the display does
// something different.
//
// Odd time intervals are used, like 5.3 seconds, to keep the
// display updates out of sync with the LED blinking which is
// happening on a 1 second interval. This is just for cosmetic
// effect, there is no technical reason it needs to be that way.
//
switch(ulDisplayState)
{
//
// Initial state, show TEXAS INSTRUMENTS for 5.3 seconds
//
case 0:
{
Display96x16x1StringDraw("TEXAS", 29, 0);
Display96x16x1StringDraw("INSTRUMENTS", 11, 1);
ulNextTickDisplay += 53;
ulDisplayState = 1;
break;
}
//
// Next, clear display for 1.3 seconds
//
case 1:
{
Display96x16x1Clear();
ulNextTickDisplay += 13;
ulDisplayState = 2;
break;
}
//
// Show STELLARIS for 5.3 seconds
//
case 2:
{
Display96x16x1StringDraw("STELLARIS", 21, 0);
ulNextTickDisplay += 53;
ulDisplayState = 3;
break;
}
//
// Clear the previous message and then show EVALBOT on
// the second line for 5.3 seconds
//
case 3:
{
Display96x16x1Clear();
Display96x16x1StringDraw("EVALBOT", 27, 1);
ulNextTickDisplay += 53;
ulDisplayState = 4;
break;
}
//
// Clear display for 1.3 seconds, then go back to start
//
case 4:
{
Display96x16x1Clear();
ulNextTickDisplay += 13;
ulDisplayState = 0;
break;
}
//
// Default state. Should never get here, but if so just
// go back to starting state.
//
default:
{
ulDisplayState = 0;
break;
}
} // end switch
} // end if
} // end for(;;)
}
int main_simple(void)
{
static uint32_t g_ui32SrcBuf[MEM_BUFFER_SIZE];
static uint32_t g_ui32DstBuf[MEM_BUFFER_SIZE];
/* Set up clock for 120MHz */
MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
/* Set up SysTick timer */
ROM_SysTickPeriodSet(0xffffffff);
ROM_SysTickEnable();
/* Enable interrupts */
ROM_IntMasterEnable();
init_dma_memcpy(UDMA_CHANNEL_SW);
{ /* Scope out the counter */
uint_fast16_t ui16Idx;
/* Fill source buffer with varying numbers */
for(ui16Idx = 0; ui16Idx < MEM_BUFFER_SIZE; ui16Idx++)
{
g_ui32SrcBuf[ui16Idx] = ui16Idx;
}
}
void *cbfn_ptr[2] = {&set_udma_txfer_done, NULL};
volatile unsigned int t0 = (ROM_SysTickValueGet());
dma_memcpy(
g_ui32DstBuf,
g_ui32SrcBuf,
MEM_BUFFER_SIZE,
UDMA_CHANNEL_SW,
cbfn_ptr[0]
);
/* Wait for udma txfer to complete */
while (!udma_txfer_done);
volatile unsigned int t1 = (ROM_SysTickValueGet());
memcpy(g_ui32DstBuf, g_ui32SrcBuf, MEM_BUFFER_SIZE);
volatile unsigned int t2 = (ROM_SysTickValueGet());
t2 = t1 - t2; /* Calc time taken for memcpy */
t1 = t0 - t1; /* Calc time taken for dma_memcpy */
volatile uint32_t count_past_dma = 0;
/* Wait around compare txfer times */
while (1){
count_past_dma++;
}
return 0;
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32TxCount;
uint32_t ui32RxCount;
tRectangle sRect;
char pcBuffer[16];
uint32_t ui32Fullness;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Configure the required pins for USB operation.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Erratum workaround for silicon revision A1. VBUS must have pull-down.
//
if(CLASS_IS_TM4C123 && REVISION_IS_A1)
{
HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;
}
//
// Not configured initially.
//
g_bUSBConfigured = false;
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = 9;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb-dev-serial", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);
//
// Show the various static text elements on the color STN display.
//
GrStringDraw(&g_sContext, "Tx #",-1, 0, 12, false);
GrStringDraw(&g_sContext, "Tx buf", -1, 0, 22, false);
GrStringDraw(&g_sContext, "Rx #", -1, 0, 32, false);
GrStringDraw(&g_sContext, "Rx buf", -1, 0, 42, false);
DrawBufferMeter(&g_sContext, 40, 22);
DrawBufferMeter(&g_sContext, 40, 42);
//
// Enable the UART that we will be redirecting.
//
ROM_SysCtlPeripheralEnable(USB_UART_PERIPH);
//
// Enable and configure the UART RX and TX pins
//
ROM_SysCtlPeripheralEnable(TX_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(RX_GPIO_PERIPH);
ROM_GPIOPinTypeUART(TX_GPIO_BASE, TX_GPIO_PIN);
ROM_GPIOPinTypeUART(RX_GPIO_BASE, RX_GPIO_PIN);
//
// TODO: Add code to configure handshake GPIOs if required.
//
//
// Set the default UART configuration.
//
ROM_UARTConfigSetExpClk(USB_UART_BASE, ROM_SysCtlClockGet(),
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
ROM_UARTFIFOLevelSet(USB_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
//
// Configure and enable UART interrupts.
//
ROM_UARTIntClear(USB_UART_BASE, ROM_UARTIntStatus(USB_UART_BASE, false));
ROM_UARTIntEnable(USB_UART_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
//
// Enable the system tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDCDCInit(0, &g_sCDCDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
//
// Enable interrupts now that the application is ready to start.
//
ROM_IntEnable(USB_UART_INT);
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ui32Flags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
ROM_IntMasterDisable();
g_ui32Flags &= ~COMMAND_STATUS_UPDATE;
ROM_IntMasterEnable();
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32UARTTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32UARTTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 12, true);
//
// Update the RX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's receive buffer is the UART's
// transmit buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 22);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32UARTRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 32, true);
//
// Update the TX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's transmit buffer is the UART's
// receive buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 42);
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
//
// Enable the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTprintf("\033[2JHost Keyboard Application\n");
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Configure the power pins for host controller.
//
GPIOPinConfigure(GPIO_PH3_USB0EPEN);
GPIOPinConfigure(GPIO_PH4_USB0PFLT);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);
//
// Initially wait for device connection.
//
g_eUSBState = STATE_NO_DEVICE;
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, USB_MODE_OTG, ModeCallback);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers);
//
// Open an instance of the keyboard driver. The keyboard does not need
// to be present at this time, this just save a place for it and allows
// the applications to be notified when a keyboard is present.
//
g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer,
KEYBOARD_MEMORY_SIZE);
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Initialize the USB controller for OTG operation with a 2ms polling
// rate.
//
USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE);
//
// The main loop for the application.
//
while(1)
{
//
// Tell the OTG state machine how much time has passed in
// milliseconds since the last call.
//
USBOTGMain(GetTickms());
switch(g_eUSBState)
{
//
// This state is entered when they keyboard is first detected.
//
case STATE_KEYBOARD_INIT:
{
//
// Initialized the newly connected keyboard.
//
USBHKeyboardInit(g_ulKeyboardInstance);
//
// Proceed to the keyboard connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
break;
}
case STATE_KEYBOARD_UPDATE:
{
//
// If the application detected a change that required an
// update to be sent to the keyboard to change the modifier
// state then call it and return to the connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
break;
}
case STATE_KEYBOARD_CONNECTED:
{
//
// Nothing is currently done in the main loop when the keyboard
// is connected.
//
break;
}
case STATE_UNKNOWN_DEVICE:
{
//
// Nothing to do as the device is unknown.
//
break;
}
case STATE_NO_DEVICE:
{
//
// Nothing is currently done in the main loop when the keyboard
// is not connected.
//
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
uint_fast32_t ui32LastTickCount;
bool bLastSuspend;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//
// Enable the GPIO pin for the Blue LED (PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
//
// Enable the UART.
//
ConfigureUART();
UARTprintf("Keyboard device application\n");
// Configure USB0DM & USB0DP (PD4 & PD5)
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_AHB_BASE, GPIO_PIN_4 | GPIO_PIN_5);
//Configure USB0ID & USB0VBUS (PB0 & PB1)
// ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
// ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Erratum workaround for silicon revision A1. VBUS must have pull-down.
//
if(CLASS_IS_TM4C123 && REVISION_IS_A1)
{
HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;
}
//
// Initialize the buttons driver
//
ButtonsInit();
//
// Not configured initially.
//
g_bConnected = false;
g_bSuspended = false;
bLastSuspend = false;
//
// Initialize the USB stack for device mode.
//
//USBStackModeSet(0, eUSBModeDevice, 0);
USBStackModeSet(0, eUSBModeForceDevice, 0);
//
// Pass our device information to the USB HID device class driver,
// initialize the USB
// controller and connect the device to the bus.
//
USBDHIDKeyboardInit(0, &g_sKeyboardDevice);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// The main loop starts here. We begin by waiting for a host connection
// then drop into the main keyboard handling section. If the host
// disconnects, we return to the top and wait for a new connection.
//
while(1)
{
uint8_t ui8Buttons;
uint8_t ui8ButtonsChanged;
//
// Tell the user what we are doing and provide some basic instructions.
//
UARTprintf("Waiting for host...\n");
//
// Wait here until USB device is connected to a host.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
UARTprintf("Host connected...\n");
//
// Enter the idle state.
//
g_eKeyboardState = STATE_IDLE;
//
// Assume that the bus is not currently suspended if we have just been
// configured.
//
bLastSuspend = false;
//
// Keep transferring characters from the UART to the USB host for as
// long as we are connected to the host.
//
while(g_bConnected)
{
//
// Remember the current time.
//
ui32LastTickCount = g_ui32SysTickCount;
//
// Has the suspend state changed since last time we checked?
//
if(bLastSuspend != g_bSuspended)
{
//
// Yes - the state changed so update the display.
//
bLastSuspend = g_bSuspended;
UARTprintf(bLastSuspend ? "Bus suspended...\n" :"Host connected...\n");
}
//
// See if the button was just pressed.
//
ui8Buttons = ButtonsPoll(&ui8ButtonsChanged, 0);
if(BUTTON_PRESSED(LEFT_BUTTON, ui8Buttons, ui8ButtonsChanged))
{
//
// If the bus is suspended then resume it. Otherwise, type
// some "random" characters.
//
if(g_bSuspended)
{
USBDHIDKeyboardRemoteWakeupRequest(
(void *)&g_sKeyboardDevice);
}
else
{
SendString("Make the Switch to TI Microcontrollers!");
}
}
//
// Wait for at least 1 system tick to have gone by before we poll
// the buttons again.
//
while(g_ui32SysTickCount == ui32LastTickCount)
{
}
}
//
// Dropping out of the previous loop indicates that the host has
// disconnected so go back and wait for reconnection.
//
if(g_bConnected == false)
{
UARTprintf("Host disconnected...\n");
}
}
}
//*****************************************************************************
//
// This example demonstrates how to use the uDMA controller to transfer data
// between memory buffers and to and from a peripheral, in this case a UART.
// The uDMA controller is configured to repeatedly transfer a block of data
// from one memory buffer to another. It is also set up to repeatedly copy a
// block of data from a buffer to the UART output. The UART data is looped
// back so the same data is received, and the uDMA controlled is configured to
// continuously receive the UART data using ping-pong buffers.
//
// The processor is put to sleep when it is not doing anything, and this allows
// collection of CPU usage data to see how much CPU is being used while the
// data transfers are ongoing.
//
//*****************************************************************************
int
main(void)
{
static unsigned long ulPrevSeconds;
static unsigned long ulPrevXferCount;
static unsigned long ulPrevUARTCount = 0;
unsigned long ulXfersCompleted;
unsigned long ulBytesTransferred;
volatile unsigned long ulLoop;
//
g_uiSsiTxBufA=&g_u16PixelData[0][0];
g_uiSsiTxBufB=g_uiSsiTxBufA+SSI_TXBUF_SIZE;
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50 MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable peripherals to operate when CPU is in sleep.
//
ROM_SysCtlPeripheralClockGating(true);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
//
// Enable the GPIO pins for the LED (PF2).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_2);
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
// Reset Pin
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5);
//Blank Pin
//ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_5);
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTprintf("\033[2JuDMA Example\n");
//
// Show the clock frequency on the display.
//
UARTprintf("Stellaris @ %u MHz\n\n", ROM_SysCtlClockGet() / 1000000);
//
// Show statistics headings.
//
UARTprintf("CPU Memory UART Remaining\n");
UARTprintf("Usage Transfers Transfers Time\n");
//
// Configure SysTick to occur 100 times per second, to use as a time
// reference. Enable SysTick to generate interrupts.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Initialize the CPU usage measurement routine.
//
CPUUsageInit(ROM_SysCtlClockGet(), SYSTICKS_PER_SECOND, 2);
//
// Enable the uDMA controller at the system level. Enable it to continue
// to run while the processor is in sleep.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UDMA);
//
// Enable the uDMA controller error interrupt. This interrupt will occur
// if there is a bus error during a transfer.
//
ROM_IntEnable(INT_UDMAERR);
//
// Enable the uDMA controller.
//
ROM_uDMAEnable();
//
// Point at the control table to use for channel control structures.
//
ROM_uDMAControlBaseSet(ucControlTable);
//
// Initialize the uDMA memory to memory transfers.
//
InitSWTransfer();
//Reset Set BLAK HIGH and reset MSP430
GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, GPIO_PIN_5);
GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_4, GPIO_PIN_4);
//
// Initialize the uDMA UART transfers.
//
InitSSI2Transfer();
//InitUART1Transfer();
// Release Blank Pin
SysCtlDelay(SysCtlClockGet() / 20 / 3);
GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_5, 0);
//
// Remember the current SysTick seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Remember the current count of memory buffer transfers.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Loop until the button is pressed. The processor is put to sleep
// in this loop so that CPU utilization can be measured.
//
while(1)
{
//
// Check to see if one second has elapsed. If so, the make some
// updates.
//
if(g_ulSeconds != ulPrevSeconds)
{
//
// Turn on the LED as a heartbeat
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
//
// Print a message to the display showing the CPU usage percent.
// The fractional part of the percent value is ignored.
//
UARTprintf("\r%3d%% ", g_ulCPUUsage >> 16);
//
// Remember the new seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Calculate how many memory transfers have occurred since the last
// second.
//
ulXfersCompleted = g_ulMemXferCount - ulPrevXferCount;
//
// Remember the new transfer count.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Compute how many bytes were transferred in the memory transfer
// since the last second.
//
ulBytesTransferred = ulXfersCompleted * MEM_BUFFER_SIZE * 4;
//
// Print a message showing the memory transfer rate.
//
if(ulBytesTransferred >= 100000000)
{
UARTprintf("%3d MB/s ", ulBytesTransferred / 1000000);
}
else if(ulBytesTransferred >= 10000000)
{
UARTprintf("%2d.%01d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 100000);
}
else if(ulBytesTransferred >= 1000000)
{
UARTprintf("%1d.%02d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 10000);
}
else if(ulBytesTransferred >= 100000)
{
UARTprintf("%3d KB/s ", ulBytesTransferred / 1000);
}
else if(ulBytesTransferred >= 10000)
{
UARTprintf("%2d.%01d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 100);
}
else if(ulBytesTransferred >= 1000)
{
UARTprintf("%1d.%02d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 10);
}
else if(ulBytesTransferred >= 100)
{
UARTprintf("%3d B/s ", ulBytesTransferred);
}
else if(ulBytesTransferred >= 10)
{
UARTprintf("%2d B/s ", ulBytesTransferred);
}
else
{
UARTprintf("%1d B/s ", ulBytesTransferred);
}
//
// Calculate how many UART transfers have occurred since the last
// second.
//
ulXfersCompleted = (g_ulRxBufACount + g_ulRxBufBCount -
ulPrevUARTCount);
//
// Remember the new UART transfer count.
//
ulPrevUARTCount = g_ulRxBufACount + g_ulRxBufBCount;
//
// Compute how many bytes were transferred by the UART. The number
// of bytes received is multiplied by 2 so that the TX bytes
// transferred are also accounted for.
//
ulBytesTransferred = ulXfersCompleted * SSI_RXBUF_SIZE * 2;
//
// Print a message showing the UART transfer rate.
//
if(ulBytesTransferred >= 1000000)
{
UARTprintf("%1d.%02d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 10000);
}
else if(ulBytesTransferred >= 100000)
{
UARTprintf("%3d KB/s ", ulBytesTransferred / 1000);
}
else if(ulBytesTransferred >= 10000)
{
UARTprintf("%2d.%01d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 100);
}
else if(ulBytesTransferred >= 1000)
{
UARTprintf("%1d.%02d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 10);
}
else if(ulBytesTransferred >= 100)
{
UARTprintf("%3d B/s ", ulBytesTransferred);
}
else if(ulBytesTransferred >= 10)
{
UARTprintf("%2d B/s ", ulBytesTransferred);
}
else
{
UARTprintf("%1d B/s ", ulBytesTransferred);
}
//
// Print a spinning line to make it more apparent that there is
// something happening.
//
UARTprintf("%2ds", TEST_TIME - ulPrevSeconds);
//
// Turn off the LED.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
}
//
// Put the processor to sleep if there is nothing to do. This allows
// the CPU usage routine to measure the number of free CPU cycles.
// If the processor is sleeping a lot, it can be hard to connect to
// the target with the debugger.
//
ROM_SysCtlSleep();
//
// See if we have run long enough and exit the loop if so.
//
if(g_ulSeconds >= TEST_TIME)
{
break;
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
ROM_FPULazyStackingEnable();
// Set the clocking to run from the PLL at 50MHz.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
// Configure USB pins
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5);
// Set the system tick to fire 100 times per second.
ROM_SysTickEnable();
ROM_SysTickIntEnable();
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
// Initialize the on board buttons
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
// Right button is muxed so you need to unlock and configure
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY_DD;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) |= 0x01;
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = 0;
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4 |GPIO_PIN_0);
ROM_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_4 |GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
// Enable Output Status Light
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
// Set initial LED Status to RED to indicate not connected
ROM_GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 2);
// Set the USB stack mode to Device mode with VBUS monitoring.
USBStackModeSet(0, USB_MODE_DEVICE, 0);
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
USBDHIDCustomHidInit(0, (tUSBDHIDCustomHidDevice *)&g_sCustomHidDevice);
// Drop into the main loop.
while(1)
{
// Wait for USB configuration to complete.
while(!g_bConnected)
{
ROM_GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 2);
}
// Update the status to green when connected.
ROM_GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 8);
// Now keep processing the customhid as long as the host is connected.
while(g_bConnected)
{
// If it is time to check the buttons and send a customhid report then do so.
if(HWREGBITW(&g_ulCommands, TICK_EVENT) == 1)
{
HWREGBITW(&g_ulCommands, TICK_EVENT) = 0;
CustomHidChangeHandler();
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
unsigned long ulLastTickCount;
tBoolean bLastSuspend;
tRectangle sRect;
tContext sContext;
long lCenterX;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Configure the required pins for USB operation.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinConfigure(GPIO_PG4_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Erratum workaround for silicon revision A1. VBUS must have pull-down.
//
if(CLASS_IS_BLIZZARD && REVISION_IS_A1)
{
HWREG(GPIO_PORTB_BASE + GPIO_O_PDR) |= GPIO_PIN_1;
}
//
// Enable the GPIO that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2);
ROM_GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_2, 0);
//
// Initialize the buttons driver
//
ButtonsInit();
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context and find the middle X coordinate.
//
GrContextInit(&sContext, &g_sCFAL96x64x16);
lCenterX = GrContextDpyWidthGet(&sContext) / 2;
//
// Fill the top part of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&sContext) - 1;
sRect.sYMax = 9;
GrContextForegroundSet(&sContext, ClrDarkBlue);
GrRectFill(&sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&sContext, ClrWhite);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&sContext, g_pFontFixed6x8);
GrStringDrawCentered(&sContext, "usb-dev-keyboard", -1, lCenterX, 4, 0);
//
// Not configured initially.
//
g_bConnected = false;
g_bSuspended = false;
bLastSuspend = false;
//
// Initialize the USB stack for device mode.
//
USBStackModeSet(0, USB_MODE_DEVICE, 0);
//
// Pass our device information to the USB HID device class driver,
// initialize the USB
// controller and connect the device to the bus.
//
USBDHIDKeyboardInit(0, &g_sKeyboardDevice);
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// The main loop starts here. We begin by waiting for a host connection
// then drop into the main keyboard handling section. If the host
// disconnects, we return to the top and wait for a new connection.
//
while(1)
{
unsigned char ucButtons;
unsigned char ucButtonsChanged;
//
// Tell the user what we are doing and provide some basic instructions.
//
GrStringDrawCentered(&sContext, " Waiting ", -1, lCenterX, 22, 1);
GrStringDrawCentered(&sContext, " for host ... ", -1, lCenterX, 32, 1);
//
// Wait here until USB device is connected to a host.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
GrStringDrawCentered(&sContext, " Host ", -1, lCenterX, 22, 1);
GrStringDrawCentered(&sContext, " connected ... ", -1, lCenterX, 32, 1);
//
// Enter the idle state.
//
g_eKeyboardState = STATE_IDLE;
//
// Assume that the bus is not currently suspended if we have just been
// configured.
//
bLastSuspend = false;
//
// Keep transferring characters from the UART to the USB host for as
// long as we are connected to the host.
//
while(g_bConnected)
{
//
// Remember the current time.
//
ulLastTickCount = g_ulSysTickCount;
//
// Has the suspend state changed since last time we checked?
//
if(bLastSuspend != g_bSuspended)
{
//
// Yes - the state changed so update the display.
//
bLastSuspend = g_bSuspended;
if(bLastSuspend)
{
GrStringDrawCentered(&sContext, " Bus ", -1,
lCenterX, 22, 1);
GrStringDrawCentered(&sContext, " suspended ... ", -1,
lCenterX, 32, 1);
}
else
{
GrStringDrawCentered(&sContext, " Host ", -1,
lCenterX, 22, 1);
GrStringDrawCentered(&sContext, " connected ... ",
-1, lCenterX, 32, 1);
}
}
//
// See if the button was just pressed.
//
ucButtons = ButtonsPoll(&ucButtonsChanged, 0);
if(BUTTON_PRESSED(SELECT_BUTTON, ucButtons, ucButtonsChanged))
{
//
// If the bus is suspended then resume it. Otherwise, type
// some "random" characters.
//
if(g_bSuspended)
{
USBDHIDKeyboardRemoteWakeupRequest(
(void *)&g_sKeyboardDevice);
}
else
{
SendString("Make the Switch to TI Microcontrollers!");
}
}
//
// Wait for at least 1 system tick to have gone by before we poll
// the buttons again.
//
while(g_ulSysTickCount == ulLastTickCount)
{
}
}
}
}
//*****************************************************************************
//
// Run the hibernate example. Use a loop to put the microcontroller into
// hibernate mode, and to wake up based on time. Also allow the user to cause
// it to hibernate and/or wake up based on button presses.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32Idx;
uint32_t ui32Status = 0;
uint32_t ui32HibernateCount = 0;
tContext sContext;
tRectangle sRect;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initialize the UART.
//
ConfigureUART();
//
// Initialize the OLED display
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sCFAL96x64x16);
//
// Fill the top 24 rows of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1;
sRect.i16YMax = 9;
GrContextForegroundSet(&sContext, ClrDarkBlue);
GrRectFill(&sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&sContext, ClrWhite);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&sContext, g_psFontFixed6x8);
GrStringDrawCentered(&sContext, "hibernate", -1,
GrContextDpyWidthGet(&sContext) / 2, 4, 0);
//
// Initialize the buttons driver
//
ButtonsInit();
//
// Set up systick to generate interrupts at 100 Hz.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Enable the Hibernation module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE);
//
// Print wake cause message on display.
//
GrStringDrawCentered(&sContext, "Wake due to:", -1,
GrContextDpyWidthGet(&sContext) / 2, Row(2) + 4,
true);
//
// Check to see if Hibernation module is already active, which could mean
// that the processor is waking from a hibernation.
//
if(HibernateIsActive())
{
//
// Read the status bits to see what caused the wake.
//
ui32Status = HibernateIntStatus(0);
HibernateIntClear(ui32Status);
//
// Wake was due to the push button.
//
if(ui32Status & HIBERNATE_INT_PIN_WAKE)
{
GrStringDrawCentered(&sContext, "BUTTON", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(3) + 4, true);
}
//
// Wake was due to RTC match
//
else if(ui32Status & HIBERNATE_INT_RTC_MATCH_0)
{
GrStringDrawCentered(&sContext, "TIMEOUT", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(3) + 4, true);
}
//
// Wake is due to neither button nor RTC, so it must have been a hard
// reset.
//
else
{
GrStringDrawCentered(&sContext, "RESET", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(3) + 4, true);
}
//
// If the wake is due to button or RTC, then read the first location
// from the battery backed memory, as the hibernation count.
//
if(ui32Status & (HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_RTC_MATCH_0))
{
HibernateDataGet(&ui32HibernateCount, 1);
}
}
//
// Enable the Hibernation module. This should always be called, even if
// the module was already enabled, because this function also initializes
// some timing parameters.
//
HibernateEnableExpClk(ROM_SysCtlClockGet());
//
// If the wake was not due to button or RTC match, then it was a reset.
//
if(!(ui32Status & (HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_RTC_MATCH_0)))
{
//
// Configure the module clock source.
//
HibernateClockConfig(HIBERNATE_OSC_LOWDRIVE);
//
// Finish the wake cause message.
//
GrStringDrawCentered(&sContext, "RESET", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(3) + 4, true);
//
// Wait a couple of seconds in case we need to break in with the
// debugger.
//
SysTickWait(3 * 100);
//
// Allow time for the crystal to power up. This line is separated from
// the above to make it clear this is still needed, even if the above
// delay is removed.
//
SysTickWait(15);
}
//
// Print the count of times that hibernate has occurred.
//
usnprintf(g_pcBuf, sizeof(g_pcBuf), "Hib count=%4u", ui32HibernateCount);
GrStringDrawCentered(&sContext, g_pcBuf, -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(1) + 4, true);
//
// Print messages on the screen about hibernation.
//
GrStringDrawCentered(&sContext, "Select to Hib", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(4) + 4, true);
GrStringDrawCentered(&sContext, "Wake in 5 s,", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(5) + 4, true);
GrStringDrawCentered(&sContext, "or press Select", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(6) + 4, true);
GrStringDrawCentered(&sContext, "for immed. wake.", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(7) + 4, true);
//
// Clear the button pressed flag, in case it was held down at the
// beginning.
//
bSelectPressed = 0;
//
// Wait for user to press the button.
//
while(!bSelectPressed)
{
//
// Wait a bit before looping again.
//
SysTickWait(10);
}
//
// Tell user to release the button.
//
GrStringDrawCentered(&sContext, " ", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(4) + 4, true);
GrStringDrawCentered(&sContext, " Release the ", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(5) + 4, true);
GrStringDrawCentered(&sContext, " button. ", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(6) + 4, true);
GrStringDrawCentered(&sContext, " ", -1,
GrContextDpyWidthGet(&sContext) / 2,
Row(7) + 4, true);
//
// Wait for user to release the button.
//
while(bSelectPressed)
{
}
//
// If hibernation count is very large, it may be that there was already
// a value in the hibernate memory, so reset the count.
//
ui32HibernateCount = (ui32HibernateCount > 10000) ? 0 : ui32HibernateCount;
//
// Increment the hibernation count, and store it in the battery backed
// memory.
//
ui32HibernateCount++;
HibernateDataSet(&ui32HibernateCount, 1);
//
// Clear and enable the RTC and set the match registers to 5 seconds in the
// future. Set both to same, though they could be set differently, the
// first to match will cause a wake.
//
HibernateRTCSet(0);
HibernateRTCEnable();
HibernateRTCMatchSet(0, 5);
//
// Set wake condition on pin or RTC match. Board will wake when 5 seconds
// elapses, or when the button is pressed.
//
HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC);
//
// Request hibernation.
//
HibernateRequest();
//
// Give it time to activate, it should never get past this wait.
//
SysTickWait(100);
//
// Should not have got here, something is wrong. Print an error message to
// the user.
//
sRect.i16XMin = 0;
sRect.i16XMax = 95;
sRect.i16YMin = 0;
sRect.i16YMax = 63;
GrContextForegroundSet(&sContext, ClrBlack);
GrRectFill(&sContext, &sRect);
GrContextForegroundSet(&sContext, ClrWhite);
ui32Idx = 0;
while(g_pcErrorText[ui32Idx])
{
GrStringDraw(&sContext, g_pcErrorText[ui32Idx], -1, Col(0),
Row(ui32Idx), true);
ui32Idx++;
}
//
// Wait for the user to press the button, then restart the app.
//
bSelectPressed = 0;
while(!bSelectPressed)
{
}
//
// Reset the processor.
//
ROM_SysCtlReset();
//
// Finished.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(void)
{
volatile uint32_t ui32Loop;
uint32_t ui32TxCount;
uint32_t ui32RxCount;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run from the PLL at 50MHz
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the GPIO port that is used for the on-board LED.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
// Enable the GPIO pins for the LED (PF2 & PF3).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2);
//
// Open UART0 and show the application name on the UART.
//
ConfigureUART();
UARTprintf("\033[2JTiva C Series USB bulk device example\n");
UARTprintf("---------------------------------\n\n");
//
// Not configured initially.
//
g_bUSBConfigured = false;
//
// Enable the GPIO peripheral used for USB, and configure the USB
// pins.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5);
//
// Enable the system tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Tell the user what we are up to.
//
UARTprintf("Configuring USB\n");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeForceDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDBulkInit(0, &g_sBulkDevice);
//
// Wait for initial configuration to complete.
//
UARTprintf("Waiting for host...\n");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
//
// Main application loop.
//
while(1)
{
//
// See if any data has been transferred.
//
if((ui32TxCount != g_ui32TxCount) || (ui32RxCount != g_ui32RxCount))
{
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32TxCount)
{
//
// Turn on the Green LED.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3);
//
// Delay for a bit.
//
for(ui32Loop = 0; ui32Loop < 150000; ui32Loop++)
{
}
//
// Turn off the Green LED.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32TxCount;
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32RxCount)
{
//
// Turn on the Blue LED.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);
//
// Delay for a bit.
//
for(ui32Loop = 0; ui32Loop < 150000; ui32Loop++)
{
}
//
// Turn off the Blue LED.
//
GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32RxCount;
}
//
// Update the display of bytes transferred.
//
UARTprintf("\rTx: %d Rx: %d", ui32TxCount, ui32RxCount);
}
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then runs
// a command processing loop to read commands from the console.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32DriveTimeout;
uint32_t ui32SysClock;
tContext sContext;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "usb-host-msc");
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable the uDMA controller and set up the control table base.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_sDMAControlTable);
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sBackground);
//
// Set some initial strings.
//
ListBoxTextAdd(&g_sDirList, "Waiting for device...");
//
// Issue the initial paint request to the widgets then immediately call
// the widget manager to process the paint message. This ensures that the
// display is drawn as quickly as possible and saves the delay we would
// otherwise experience if we processed the paint message after mounting
// and reading the SD card.
//
WidgetPaint(WIDGET_ROOT);
WidgetMessageQueueProcess();
//
// Initially wait for device connection.
//
g_eState = STATE_NO_DEVICE;
//
// Initialize the USB stack for host mode.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// Initialize the drive timeout.
//
ui32DriveTimeout = USBMSC_DRIVE_RETRY;
//
// Initialize the power configuration. This sets the power enable signal
// to be active high and does not enable the power fault.
//
USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
//
// Initialize the USB controller for host operation.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Initialize the file system.
//
FileInit();
//
// Enter an (almost) infinite loop for reading and processing commands from
// the user.
//
while(1)
{
//
// Call the USB stack to keep it running.
//
USBHCDMain();
//
// Process any messages in the widget message queue. This keeps the
// display UI running.
//
WidgetMessageQueueProcess();
switch(g_eState)
{
case STATE_DEVICE_ENUM:
{
//
// Take it easy on the Mass storage device if it is slow to
// start up after connecting.
//
if(USBHMSCDriveReady(g_psMSCInstance) != 0)
{
//
// Wait about 500ms before attempting to check if the
// device is ready again.
//
ROM_SysCtlDelay(ui32SysClock / (3 * 2));
//
// Decrement the retry count.
//
ui32DriveTimeout--;
//
// If the timeout is hit then go to the
// STATE_TIMEOUT_DEVICE state.
//
if(ui32DriveTimeout == 0)
{
g_eState = STATE_TIMEOUT_DEVICE;
}
break;
}
//
// Getting here means the device is ready.
// Reset the CWD to the root directory.
//
g_cCwdBuf[0] = '/';
g_cCwdBuf[1] = 0;
//
// Set the initial directory level to the root
//
g_ui32Level = 0;
//
// Fill the list box with the files and directories found.
//
if(!PopulateFileListBox(true))
{
//
// If there were no errors reported, we are ready for
// MSC operation.
//
g_eState = STATE_DEVICE_READY;
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// If there is no device then just wait for one.
//
case STATE_NO_DEVICE:
{
if(g_ui32Flags == FLAGS_DEVICE_PRESENT)
{
//
// Empty the list box on the display.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Waiting for device...");
WidgetPaint((tWidget *)&g_sDirList);
//
// Clear the Device Present flag.
//
g_ui32Flags &= ~FLAGS_DEVICE_PRESENT;
}
break;
}
//
// An unknown device was connected.
//
case STATE_UNKNOWN_DEVICE:
{
//
// If this is a new device then change the status.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device
// is present.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Unknown device.");
WidgetPaint((tWidget *)&g_sDirList);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// The connected mass storage device is not reporting ready.
//
case STATE_TIMEOUT_DEVICE:
{
//
// If this is the first time in this state then print a
// message.
//
if((g_ui32Flags & FLAGS_DEVICE_PRESENT) == 0)
{
//
// Clear the screen and indicate that an unknown device
// is present.
//
ListBoxClear(&g_sDirList);
ListBoxTextAdd(&g_sDirList, "Device Timeout.");
WidgetPaint((tWidget *)&g_sDirList);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// Something has caused a power fault.
//
case STATE_POWER_FAULT:
{
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This example demonstrates how to use the uDMA controller to transfer data
// between memory buffers and to and from a peripheral, in this case a UART.
// The uDMA controller is configured to repeatedly transfer a block of data
// from one memory buffer to another. It is also set up to repeatedly copy a
// block of data from a buffer to the UART output. The UART data is looped
// back so the same data is received, and the uDMA controlled is configured to
// continuously receive the UART data using ping-pong buffers.
//
// The processor is put to sleep when it is not doing anything, and this allows
// collection of CPU usage data to see how much CPU is being used while the
// data transfers are ongoing.
//
//*****************************************************************************
int
main(void)
{
static unsigned long ulPrevSeconds;
static unsigned long ulPrevXferCount;
static unsigned long ulPrevUARTCount = 0;
unsigned long ulXfersCompleted;
unsigned long ulBytesTransferred;
unsigned long ulButton;
//
// Set the clocking to run from the PLL at 50 MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable peripherals to operate when CPU is in sleep.
//
ROM_SysCtlPeripheralClockGating(true);
//
// Set the push button as an input with a pull-up.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_4,
GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
//
// Initialize the UART.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTprintf("\033[2JuDMA Example\n");
//
// Show the clock frequency and exit instructions.
//
UARTprintf("Stellaris @ %u MHz\n", ROM_SysCtlClockGet() / 1000000);
UARTprintf("Press button to use debugger.\n\n");
//
// Show statistics headings.
//
UARTprintf("CPU Memory UART\n");
UARTprintf("Usage Transfers Transfers\n");
//
// Configure SysTick to occur 100 times per second, to use as a time
// reference. Enable SysTick to generate interrupts.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Initialize the CPU usage measurement routine.
//
CPUUsageInit(ROM_SysCtlClockGet(), SYSTICKS_PER_SECOND, 2);
//
// Enable the uDMA controller at the system level. Enable it to continue
// to run while the processor is in sleep.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UDMA);
//
// Enable the uDMA controller error interrupt. This interrupt will occur
// if there is a bus error during a transfer.
//
ROM_IntEnable(INT_UDMAERR);
//
// Enable the uDMA controller.
//
ROM_uDMAEnable();
//
// Point at the control table to use for channel control structures.
//
ROM_uDMAControlBaseSet(ucControlTable);
//
// Initialize the uDMA memory to memory transfers.
//
InitSWTransfer();
//
// Initialize the uDMA UART transfers.
//
InitUART1Transfer();
//
// Remember the current SysTick seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Remember the current count of memory buffer transfers.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Loop until the button is pressed. The processor is put to sleep
// in this loop so that CPU utilization can be measured. When the
// processor is sleeping a lot, it can be hard to connect to the target
// with the debugger. Pressing the button will cause this loop to exit
// and the processor will no longer sleep.
//
while(1)
{
//
// Check for the select button press. If the button is pressed,
// then exit this loop.
//
ulButton = ROM_GPIOPinRead(GPIO_PORTB_BASE, GPIO_PIN_4);
if(!ulButton)
{
break;
}
//
// Check to see if one second has elapsed. If so, the make some
// updates.
//
if(g_ulSeconds != ulPrevSeconds)
{
//
// Print a message to the display showing the CPU usage percent.
// The fractional part of the percent value is ignored.
//
UARTprintf("\r%3d%% ", g_ulCPUUsage >> 16);
//
// Remember the new seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Calculate how many memory transfers have occurred since the last
// second.
//
ulXfersCompleted = g_ulMemXferCount - ulPrevXferCount;
//
// Remember the new transfer count.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Compute how many bytes were transferred in the memory transfer
// since the last second.
//
ulBytesTransferred = ulXfersCompleted * MEM_BUFFER_SIZE * 4;
//
// Print a message showing the memory transfer rate.
//
if(ulBytesTransferred >= 100000000)
{
UARTprintf("%3d MB/s ", ulBytesTransferred / 1000000);
}
else if(ulBytesTransferred >= 10000000)
{
UARTprintf("%2d.%01d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 100000);
}
else if(ulBytesTransferred >= 1000000)
{
UARTprintf("%1d.%02d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 10000);
}
else if(ulBytesTransferred >= 100000)
{
UARTprintf("%3d KB/s ", ulBytesTransferred / 1000);
}
else if(ulBytesTransferred >= 10000)
{
UARTprintf("%2d.%01d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 100);
}
else if(ulBytesTransferred >= 1000)
{
UARTprintf("%1d.%02d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 10);
}
else if(ulBytesTransferred >= 100)
{
UARTprintf("%3d B/s ", ulBytesTransferred);
}
else if(ulBytesTransferred >= 10)
{
UARTprintf("%2d B/s ", ulBytesTransferred);
}
else
{
UARTprintf("%1d B/s ", ulBytesTransferred);
}
//
// Calculate how many UART transfers have occurred since the last
// second.
//
ulXfersCompleted = (g_ulRxBufACount + g_ulRxBufBCount -
ulPrevUARTCount);
//
// Remember the new UART transfer count.
//
ulPrevUARTCount = g_ulRxBufACount + g_ulRxBufBCount;
//
// Compute how many bytes were transferred by the UART. The number
// of bytes received is multiplied by 2 so that the TX bytes
// transferred are also accounted for.
//
ulBytesTransferred = ulXfersCompleted * UART_RXBUF_SIZE * 2;
//
// Print a message showing the UART transfer rate.
//
if(ulBytesTransferred >= 1000000)
{
UARTprintf("%1d.%02d MB/s ", ulBytesTransferred / 1000000,
(ulBytesTransferred % 1000000) / 10000);
}
else if(ulBytesTransferred >= 100000)
{
UARTprintf("%3d KB/s ", ulBytesTransferred / 1000);
}
else if(ulBytesTransferred >= 10000)
{
UARTprintf("%2d.%01d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 100);
}
else if(ulBytesTransferred >= 1000)
{
UARTprintf("%1d.%02d KB/s ", ulBytesTransferred / 1000,
(ulBytesTransferred % 1000) / 10);
}
else if(ulBytesTransferred >= 100)
{
UARTprintf("%3d B/s ", ulBytesTransferred);
}
else if(ulBytesTransferred >= 10)
{
UARTprintf("%2d B/s ", ulBytesTransferred);
}
else
{
UARTprintf("%1d B/s ", ulBytesTransferred);
}
//
// Print a spinning line to make it more apparent that there is
// something happening.
//
UARTprintf("%c", g_pcTwirl[ulPrevSeconds % 4]);
}
//
// Put the processor to sleep if there is nothing to do. This allows
// the CPU usage routine to measure the number of free CPU cycles.
// If the processor is sleeping a lot, it can be hard to connect to
// the target with the debugger.
//
ROM_SysCtlSleep();
}