//*****************************************************************************
//
// Configure the USB controller and power the bus.
//
// This function configures the USB controller for host operation.
// It is assumed that the main system clock has been configured at this point.
//
// \return None.
//
//*****************************************************************************
void
ConfigureUSBInterface(void)
{
//
// Enable the uDMA controller and set up the control table base.
// This is required by usblib.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(80);
uDMAEnable();
uDMAControlBaseSet(g_sDMAControlTable);
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_GPIOPinConfigure(GPIO_PD6_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTD_BASE, GPIO_PIN_6);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Register the host class driver
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS);
//
// Open an instance of the mass storage class driver.
//
g_psMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// 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);
//
// Force the USB mode to host with no callback on mode changes since
// there should not be any.
//
USBStackModeSet(0, eUSBModeForceHost, 0);
//
// Wait 10ms for the pin to go low.
//
SysCtlDelay(g_ui32SysClock/100);
//
// Initialize the host controller.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
}
//*****************************************************************************
//
// Configure the USB controller and power the bus.
//
// This function configures the USB controller for host operation.
// It is assumed that the main system clock has been configured at this point.
//
// \return None.
//
//*****************************************************************************
void
ConfigureUSBInterface(void)
{
//
// Enable the uDMA controller and set up the control table base.
// This is required by usblib.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
uDMAEnable();
uDMAControlBaseSet(g_sDMAControlTable);
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
GPIOPinConfigure(GPIO_PH3_USB0EPEN);
GPIOPinConfigure(GPIO_PH4_USB0PFLT);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);
//
// Register the host class driver
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, NUM_CLASS_DRIVERS);
//
// Open an instance of the mass storage class driver.
//
g_ulMSCInstance = USBHMSCDriveOpen(0, MSCCallback);
//
// 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);
//
// Set the ID pin to be driven low so that OTG calls are not necessary.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_0);
GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_0, 0);
//
// Wait 10ms for the pin to go low.
//
SysCtlDelay(SysCtlClockGet()/100);
//
// Initialize the host controller.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
}
//*****************************************************************************
//
// 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_BLIZZARD && 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);
}
}
}
//*****************************************************************************
//
//! Configures the device pins for the standard usages on the EK-TM4C1294XL.
//!
//! \param bEthernet is a boolean used to determine function of Ethernet pins.
//! If true Ethernet pins are configured as Ethernet LEDs. If false GPIO are
//! available for application use.
//! \param bUSB is a boolean used to determine function of USB pins. If true USB
//! pins are configured for USB use. If false then USB pins are available for
//! application use as GPIO.
//!
//! This function enables the GPIO modules and configures the device pins for
//! the default, standard usages on the EK-TM4C1294XL. Applications that
//! require alternate configurations of the device pins can either not call
//! this function and take full responsibility for configuring all the device
//! pins, or can reconfigure the required device pins after calling this
//! function.
//!
//! \return None.
//
//*****************************************************************************
void
PinoutSet(bool bEthernet, bool bUSB)
{
//
// Enable all the GPIO peripherals.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOJ);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOK);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOP);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOQ);
//
// PA0-1 are used for UART0.
//
ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// PB0-1/PD6/PL6-7 are used for USB.
// PQ4 can be used as a power fault detect on this board but it is not
// the hardware peripheral power fault input pin.
//
if(bUSB)
{
HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0xff;
ROM_GPIOPinConfigure(GPIO_PD6_USB0EPEN);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTD_BASE, GPIO_PIN_6);
ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeGPIOInput(GPIO_PORTQ_BASE, GPIO_PIN_4);
}
else
{
//
// Keep the default config for most pins used by USB.
// Add a pull down to PD6 to turn off the TPS2052 switch
//
ROM_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_6);
MAP_GPIOPadConfigSet(GPIO_PORTD_BASE, GPIO_PIN_6, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPD);
}
//
// PF0/PF4 are used for Ethernet LEDs.
//
if(bEthernet)
{
//
// this app wants to configure for ethernet LED function.
//
ROM_GPIOPinConfigure(GPIO_PF0_EN0LED0);
ROM_GPIOPinConfigure(GPIO_PF4_EN0LED1);
GPIOPinTypeEthernetLED(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
}
else
{
//
// This app does not want Ethernet LED function so configure as
// standard outputs for LED driving.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4);
//
// Default the LEDs to OFF.
//
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4, 0);
MAP_GPIOPadConfigSet(GPIO_PORTF_BASE, GPIO_PIN_0 | GPIO_PIN_4,
GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD);
}
//
// PJ0 and J1 are used for user buttons
//
ROM_GPIOPinTypeGPIOInput(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1);
ROM_GPIOPinWrite(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1, 0);
//
// PN0 and PN1 are used for USER LEDs.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1);
MAP_GPIOPadConfigSet(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1,
GPIO_STRENGTH_12MA, GPIO_PIN_TYPE_STD);
//
// Default the LEDs to OFF.
//
ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, 0);
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
tUSBMode eLastMode;
char *pcString;
//
// 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 system clock to run at 50MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initially wait for device connection.
//
g_eUSBState = STATE_NO_DEVICE;
eLastMode = USB_MODE_OTG;
g_eCurrentUSBMode = USB_MODE_OTG;
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// 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);
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Enable clocking to the UART and associated GPIO
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open UART0 for debug output.
//
UARTStdioInit(0);
//
// 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);
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top part of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = (2 * DISPLAY_BANNER_HEIGHT) - 1;
GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);
GrRectFill(&g_sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, g_pFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb-host-", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);
GrStringDrawCentered(&g_sContext, "keyboard", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 14, 0);
//
// Calculate the number of characters that will fit on a line.
// Make sure to leave a small border for the text box.
//
g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) /
GrFontMaxWidthGet(g_pFontFixed6x8);
//
// Calculate the number of lines per usable text screen. This requires
// taking off space for the top and bottom banners and adding a small bit
// for a border.
//
g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -
(3*(DISPLAY_BANNER_HEIGHT + 1)))/
GrFontHeightGet(g_pFontFixed6x8);
//
// Open and instance of the keyboard class driver.
//
UARTprintf("Host Keyboard Application\n");
//
// Initial update of the screen.
//
UpdateStatus();
//
// The main loop for the application.
//
while(1)
{
//
// Tell the OTG library code how much time has passed in
// milliseconds since the last call.
//
USBOTGMain(GetTickms());
//
// Has the USB mode changed since last time we checked?
//
if(g_eCurrentUSBMode != eLastMode)
{
//
// Remember the new mode.
//
eLastMode = g_eCurrentUSBMode;
switch(eLastMode)
{
case USB_MODE_HOST:
pcString = "HOST";
break;
case USB_MODE_DEVICE:
pcString = "DEVICE";
break;
case USB_MODE_NONE:
pcString = "NONE";
break;
default:
pcString = "UNKNOWN";
break;
}
UARTprintf("USB mode changed to %s\n", pcString);
}
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;
//
// Update the screen now that the keyboard has been
// initialized.
//
UpdateStatus();
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)
{
tRectangle sRect;
uint_fast32_t ui32Retcode;
//
// 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);
//
// Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 ms
// tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// 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 = DISPLAY_BANNER_HEIGHT - 1;
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-msc", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 5, 0);
//
// Initialize the idle timeout and reset all flags.
//
g_ui32IdleTimeout = 0;
g_ui32Flags = 0;
//
// Initialize the state to idle.
//
g_eMSCState = MSC_DEV_DISCONNECTED;
//
// Draw the status bar and set it to idle.
//
UpdateStatus("Disconnected", 1);
//
// Enable the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Set the USB pins to be controlled by the USB controller.
//
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);
//
// 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.
//
USBDMSCInit(0, &g_sMSCDevice);
//
// Determine whether or not an SDCard is installed. If not, print a
// warning and have the user install one and restart.
//
ui32Retcode = disk_initialize(0);
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
if(ui32Retcode != RES_OK) {
GrStringDrawCentered(&g_sContext, "No SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 16, 0);
GrStringDrawCentered(&g_sContext, "Please insert",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 26, 0);
GrStringDrawCentered(&g_sContext, "a card and",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 36, 0);
GrStringDrawCentered(&g_sContext, "reset the board.",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 46, 0);
} else {
GrStringDrawCentered(&g_sContext, "SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 30, 0);
}
//
// Drop into the main loop.
//
while(1) {
switch(g_eMSCState) {
case MSC_DEV_READ: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Reading", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Writing", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_DISCONNECTED: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Disconnected", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
break;
}
case MSC_DEV_IDLE: {
break;
}
default: {
break;
}
}
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then runs a loop to
// process USB activities and operate the user interface.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32DriveTimeout;
//
// 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 system clock to run at 50MHz from the PLL.
//
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);
//
// Configure SysTick for a 100Hz interrupt.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
//
// Enable the uDMA controller and set up the control table base.
// The uDMA controller is used by the USB library.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the buttons driver.
//
ButtonsInit();
//
// Initialize two offscreen displays and assign the palette. These
// buffers are used by the slide menu widget to allow animation effects.
//
GrOffScreen4BPPInit(&g_sOffscreenDisplayA, g_pui8OffscreenBufA, 96, 64);
GrOffScreen4BPPPaletteSet(&g_sOffscreenDisplayA, g_pui32Palette, 0,
NUM_PALETTE_ENTRIES);
GrOffScreen4BPPInit(&g_sOffscreenDisplayB, g_pui8OffscreenBufB, 96, 64);
GrOffScreen4BPPPaletteSet(&g_sOffscreenDisplayB, g_pui32Palette, 0,
NUM_PALETTE_ENTRIES);
//
// Show an initial status screen
//
g_pcStatusLines[0] = "Waiting";
g_pcStatusLines[1] = "for device";
ShowStatusScreen(g_pcStatusLines, 2);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sFileMenuWidget);
//
// 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_pui8HCDPool, HCD_MEMORY_SIZE);
//
// Initialize the file system.
//
FileInit();
//
// Enter an infinite loop to run the user interface and process USB
// events.
//
while(1)
{
uint32_t ui32LastTickCount = 0;
//
// Call the USB stack to keep it running.
//
USBHCDMain();
//
// Process any messages in the widget message queue. This keeps the
// display UI running.
//
WidgetMessageQueueProcess();
//
// Take action based on the application state.
//
switch(g_eState)
{
//
// A device has enumerated.
//
case STATE_DEVICE_ENUM:
{
//
// Check to see if the device is ready. If not then stay
// in this state and we will check it again on the next pass.
//
if(USBHMSCDriveReady(g_psMSCInstance) != 0)
{
//
// Wait about 500ms before attempting to check if the
// device is ready again.
//
ROM_SysCtlDelay(ROM_SysCtlClockGet()/(3));
//
// 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_pcCwdBuf[0] = '/';
g_pcCwdBuf[1] = 0;
//
// Set the initial directory level to the root
//
g_ui32Level = 0;
//
// We need to reset the indexes of the root menu to 0, so that
// it will start at the top of the file list, and reset the
// slide menu widget to start with the root menu.
//
g_psFileMenus[g_ui32Level].ui32CenterIndex = 0;
g_psFileMenus[g_ui32Level].ui32FocusIndex = 0;
SlideMenuMenuSet(&g_sFileMenuWidget, &g_psFileMenus[g_ui32Level]);
//
// Initiate a directory change to the root. This will
// populate a menu structure representing the root directory.
//
if(ProcessDirChange("/", g_ui32Level))
{
//
// 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;
//
// Request a repaint so the file menu will be shown
//
WidgetPaint(WIDGET_ROOT);
}
break;
}
//
// If there is no device then just wait for one.
//
case STATE_NO_DEVICE:
{
if(g_ui32Flags == FLAGS_DEVICE_PRESENT)
{
//
// Show waiting message on screen
//
g_pcStatusLines[0] = "Waiting";
g_pcStatusLines[1] = "for device";
ShowStatusScreen(g_pcStatusLines, 2);
//
// 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.
//
g_pcStatusLines[0] = "Unknown";
g_pcStatusLines[1] = "device";
ShowStatusScreen(g_pcStatusLines, 2);
}
//
// 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.
//
g_pcStatusLines[0] = "Device";
g_pcStatusLines[1] = "Timeout";
ShowStatusScreen(g_pcStatusLines, 2);
}
//
// Set the Device Present flag.
//
g_ui32Flags = FLAGS_DEVICE_PRESENT;
break;
}
//
// The device is ready and in use.
//
case STATE_DEVICE_READY:
{
//
// Process occurrence of timer tick. Check for user input
// once each tick.
//
if(g_ui32SysTickCount != ui32LastTickCount)
{
uint8_t ui8ButtonState;
uint8_t ui8ButtonChanged;
ui32LastTickCount = g_ui32SysTickCount;
//
// Get the current debounced state of the buttons.
//
ui8ButtonState = ButtonsPoll(&ui8ButtonChanged, 0);
//
// If select button or right button is pressed, then we
// are trying to descend into another directory
//
if(BUTTON_PRESSED(SELECT_BUTTON,
ui8ButtonState, ui8ButtonChanged) ||
BUTTON_PRESSED(RIGHT_BUTTON,
ui8ButtonState, ui8ButtonChanged))
{
uint32_t ui32NewLevel;
uint32_t ui32ItemIdx;
char *pcItemName;
//
// Get a pointer to the current menu for this CWD.
//
tSlideMenu *psMenu = &g_psFileMenus[g_ui32Level];
//
// Get the highlighted index in the current file list.
// This is the currently highlighted file or dir
// on the display. Then get the name of the file at
// this index.
//
ui32ItemIdx = SlideMenuFocusItemGet(psMenu);
pcItemName = psMenu->psSlideMenuItems[ui32ItemIdx].pcText;
//
// Make sure we are not yet past the maximum tree
// depth.
//
if(g_ui32Level < MAX_SUBDIR_DEPTH)
{
//
// Potential new level is one greater than the
// current level.
//
ui32NewLevel = g_ui32Level + 1;
//
// Process the directory change to the new
// directory. This function will populate a menu
// structure with the files and subdirs in the new
// directory.
//
if(ProcessDirChange(pcItemName, ui32NewLevel))
{
//
// If the change was successful, then update
// the level.
//
g_ui32Level = ui32NewLevel;
//
// Now that all the prep is done, send the
// KEY_RIGHT message to the widget and it will
// "slide" from the previous file list to the
// new file list of the CWD.
//
SendWidgetKeyMessage(WIDGET_MSG_KEY_RIGHT);
}
}
}
//
// If the UP button is pressed, just pass it to the widget
// which will handle scrolling the list of files.
//
if(BUTTON_PRESSED(UP_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_UP);
}
//
// If the DOWN button is pressed, just pass it to the widget
// which will handle scrolling the list of files.
//
if(BUTTON_PRESSED(DOWN_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
SendWidgetKeyMessage(WIDGET_MSG_KEY_DOWN);
}
//
// If the LEFT button is pressed, then we are attempting
// to go up a level in the file system.
//
if(BUTTON_PRESSED(LEFT_BUTTON, ui8ButtonState, ui8ButtonChanged))
{
uint32_t ui32NewLevel;
//
// Make sure we are not already at the top of the
// directory tree (at root).
//
if(g_ui32Level)
{
//
// Potential new level is one less than the
// current level.
//
ui32NewLevel = g_ui32Level - 1;
//
// Process the directory change to the new
// directory. This function will populate a menu
// structure with the files and subdirs in the new
// directory.
//
if(ProcessDirChange("..", ui32NewLevel))
{
//
// If the change was successful, then update
// the level.
//
g_ui32Level = ui32NewLevel;
//
// Now that all the prep is done, send the
// KEY_LEFT message to the widget and it will
// "slide" from the previous file list to the
// new file list of the CWD.
//
SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT);
}
}
}
}
break;
}
//
// Something has caused a power fault.
//
case STATE_POWER_FAULT:
{
//
// Clear the screen and show a power fault indication.
//
g_pcStatusLines[0] = "Power";
g_pcStatusLines[1] = "fault";
ShowStatusScreen(g_pcStatusLines, 2);
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run from the PLL at 50MHz.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initialize the display driver.
//
CFAL96x64x16Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
//
// Fill the top part of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = (DISPLAY_BANNER_HEIGHT) - 1;
GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);
GrRectFill(&g_sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "usb-host-mouse", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);
//
// Display default information about the mouse
//
GrStringDrawCentered(&g_sContext, "Position:", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 16, 0);
GrStringDrawCentered(&g_sContext, "-,-", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 26, 1);
GrStringDrawCentered(&g_sContext, "Buttons:", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 36, 0);
GrStringDrawCentered(&g_sContext, "---", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 46, 1);
//
// Fill the bottom rows of the screen with blue to create the status area.
//
sRect.i16XMin = 0;
sRect.i16YMin = GrContextDpyHeightGet(&g_sContext) -
DISPLAY_BANNER_HEIGHT - 1;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = sRect.i16YMin + DISPLAY_BANNER_HEIGHT;
GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);
GrRectFill(&g_sContext, &sRect);
//
// Put a white box around the banner.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrRectDraw(&g_sContext, &sRect);
//
// Print a no device message a placeholder for the message printed
// during an event.
//
GrStringDrawCentered(&g_sContext, "No Device", -1,
GrContextDpyWidthGet(&g_sContext) / 2,
sRect.i16YMin + 5, 0);
//
// 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 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);
//
// Initially wait for device connection.
//
g_eUSBState = STATE_NO_DEVICE;
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, eUSBModeOTG, ModeCallback);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Initialized the cursor.
//
g_ui32Buttons = 0;
g_i32CursorX = 0;
g_i32CursorY = 0;
//
// Open an instance of the mouse driver. The mouse does not need
// to be present at this time, this just saves a place for it and allows
// the applications to be notified when a mouse is present.
//
g_psMouseInstance =
USBHMouseOpen(MouseCallback, g_pui8Buffer, MOUSE_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_pui8HCDPool, 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 the mouse is first detected.
//
case STATE_MOUSE_INIT:
{
//
// Initialize the newly connected mouse.
//
USBHMouseInit(g_psMouseInstance);
//
// Proceed to the mouse connected state.
//
g_eUSBState = STATE_MOUSE_CONNECTED;
break;
}
case STATE_MOUSE_CONNECTED:
{
//
// Nothing is currently done in the main loop when the mouse
// is connected.
//
break;
}
case STATE_NO_DEVICE:
{
//
// The mouse is not connected so nothing needs to be done here.
//
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
// Initializes the USB OTG task.
//
//*****************************************************************************
unsigned long
USBOTGTaskInit(void)
{
//
// Configure the required pins for USB operation.
//
ROM_GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, USB_MODE_OTG, ModeCallback);
//
// Initialize the host stack.
//
HostMSCInit();
//
// Initialize the device stack.
//
DeviceMSCInit();
//
// Initialize the USB controller for dual mode operation with a 2ms polling
// rate.
//
USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Set the new state so that the screen updates on the first
// pass.
//
g_ulNewState = 1;
//
// Create a queue for sending messages to the display task.
//
if(xQueueCreate((signed portCHAR *)g_pulDisplayQueueMem, DISPLAY_MEM_SIZE,
DISPLAY_QUEUE_SIZE, DISPLAY_ITEM_SIZE,
&g_pDisplayQueue) != pdPASS)
{
return(1);
}
//
// Create the display task.
//
if(xTaskCreate(USBOTGTask, (signed portCHAR *)"USB-OTG",
(signed portCHAR *)ulUSBOTGTaskStack,
sizeof(ulUSBOTGTaskStack), NULL, PRIORITY_USB_CTRL_TASK,
NULL) != pdPASS)
{
return(1);
}
TaskCreated();
//
// Success.
//
return(0);
}
void Hardware_Init(void)
{
// Initially wait for device connection.
g_eState = STATE_NO_DEVICE;
g_eUIState = STATE_NO_DEVICE;
// Set the clocking to run from the PLL at 50MHz.
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ);
// Initialize the UART.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_4 | GPIO_PIN_5);
UARTprintf("\n\nUSB Android ADK Firmware for EvalBot by [email protected]\n");
/* Configure EvalBot available Buttons (User Switch 1, 2 ...) */
// Enable the GPIO pin to read the select button.
ROM_SysCtlPeripheralEnable(USER_SW1_SYSCTL_PERIPH);
ROM_GPIODirModeSet(USER_SW1_PORT_BASE, USER_SW1_PIN, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(USER_SW1_PORT_BASE, USER_SW1_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Enable the GPIO pin to read the select button.
ROM_SysCtlPeripheralEnable(USER_SW2_SYSCTL_PERIPH);
ROM_GPIODirModeSet(USER_SW2_PORT_BASE, USER_SW2_PIN, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(USER_SW2_PORT_BASE, USER_SW2_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Enable the GPIO pin to read the select button.
// Enable the GPIO ports used for the bump sensors.
ROM_SysCtlPeripheralEnable(BUMP_L_SW3_SYSCTL_PERIPH);
ROM_GPIODirModeSet(BUMP_L_SW3_PORT_BASE, BUMP_L_SW3_PIN, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(BUMP_L_SW3_PORT_BASE, BUMP_L_SW3_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Enable the GPIO pin to read the select button.
ROM_SysCtlPeripheralEnable(BUMP_R_SW4_SYSCTL_PERIPH);
ROM_GPIODirModeSet(BUMP_R_SW4_PORT_BASE, BUMP_R_SW4_PIN, GPIO_DIR_MODE_IN);
ROM_GPIOPadConfigSet(BUMP_R_SW4_PORT_BASE, BUMP_R_SW4_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
// Enable the GPIO pin for the LED1 (PF4) & LED2 (PF5)
// Set the direction as output, and enable the GPIO pin for digital function.
ROM_SysCtlPeripheralEnable(LED1_SYSCTL_PERIPH);
GPIOPinTypeGPIOOutput(LED1_PORT_BASE, LED1_PIN);
ROM_SysCtlPeripheralEnable(LED2_SYSCTL_PERIPH);
GPIOPinTypeGPIOOutput(LED2_PORT_BASE, LED2_PIN);
// Configure SysTick for a 1KHz interrupt.
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / TICKS_PER_SECOND);
ROM_SysTickEnable();
ROM_SysTickIntEnable();
// Enable Clocking to the USB controller.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
// Set the USB pins to be controlled by the USB controller.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
GPIOPinConfigure(GPIO_PA6_USB0EPEN);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6);
// Enable the GPIO pin for the USB HOST / DEVICE Selection (PB0). Set the direction as output, and
// enable the GPIO pin for digital function.
GPIO_PORTB_DIR_R |= GPIO_PIN_0; GPIO_PORTB_DEN_R |= GPIO_PIN_0;
// PB0 = GND =USB HOST Enabled.
GPIO_PORTB_DATA_R &= ~(GPIO_PIN_0);
// Enable the uDMA controller and set up the control table base.
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_sDMAControlTable);
// 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, NUM_CLASS_DRIVERS);
// 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 250ms polling
// rate.
// Warning if this delay is higher it cannot connect correctly to Android ADK.
USBOTGModeInit(0, 250, g_pHCDPool, HCD_MEMORY_SIZE);
}
//*****************************************************************************
//
// 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;
tRectangle sRect;
tContext sContext;
int_fast32_t i32CenterX;
//
// 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);
i32CenterX = GrContextDpyWidthGet(&sContext) / 2;
//
// Fill the top part 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, "usb-dev-keyboard", -1, i32CenterX, 4, 0);
//
// Not configured initially.
//
g_bConnected = false;
g_bSuspended = false;
bLastSuspend = false;
//
// Initialize the USB stack for device mode.
//
USBStackModeSet(0, eUSBModeDevice, 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.
//
GrStringDrawCentered(&sContext, " Waiting ",
-1, i32CenterX, 22, 1);
GrStringDrawCentered(&sContext, " for host ... ", -1,
i32CenterX, 32, 1);
//
// Wait here until USB device is connected to a host.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
GrStringDrawCentered(&sContext, " Host ",
-1, i32CenterX, 22, 1);
GrStringDrawCentered(&sContext, " connected ... ",
-1, i32CenterX, 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.
//
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;
if(bLastSuspend)
{
GrStringDrawCentered(&sContext, " Bus ", -1,
i32CenterX, 22, 1);
GrStringDrawCentered(&sContext, " suspended ... ", -1,
i32CenterX, 32, 1);
}
else
{
GrStringDrawCentered(&sContext, " Host ", -1,
i32CenterX, 22, 1);
GrStringDrawCentered(&sContext, " connected ... ",
-1, i32CenterX, 32, 1);
}
}
//
// See if the button was just pressed.
//
ui8Buttons = ButtonsPoll(&ui8ButtonsChanged, 0);
if(BUTTON_PRESSED(SELECT_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)
{
}
}
}
}
//*****************************************************************************
//
// Capture one sequence of DEVCTL register values during a session request.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the pinout appropriately for this board.
//
PinoutSet();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);
//
// Fill the top 15 rows of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = 14;
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_pFontFixed6x8);
GrStringDrawCentered(&g_sContext, "OTG Example", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
#ifdef DEBUG
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open the UART for I/O
//
UARTStdioInit(0);
#endif
//
// Determine the number of SysCtlDelay loops required to delay 1mS.
//
g_ulClockMS = ROM_SysCtlClockGet() / (3 * 1000);
//
// Configure the required pins for USB operation.
//
ROM_GPIOPinTypeUSBDigital(GPIO_PORTA_BASE, GPIO_PIN_6 | GPIO_PIN_7);
ROM_GPIOPinTypeUSBDigital(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, USB_MODE_OTG, ModeCallback);
//
// Initialize the host stack.
//
HostInit();
//
// Initialize the device stack.
//
DeviceInit();
//
// Initialize the USB controller for dual mode operation with a 2ms polling
// rate.
//
USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Set the new state so that the screen updates on the first
// pass.
//
g_ulNewState = 1;
//
// Loop forever.
//
while(1)
{
//
// Tell the OTG library code how much time has passed in milliseconds
// since the last call.
//
USBOTGMain(GetTickms());
//
// Handle deferred state change.
//
if(g_ulNewState)
{
g_ulNewState =0;
//
// Update the status area of the screen.
//
ClearMainWindow();
//
// Update the status bar with the new mode.
//
switch(g_eCurrentUSBMode)
{
case USB_MODE_HOST:
{
UpdateStatus("Host Mode", 0, true);
break;
}
case USB_MODE_DEVICE:
{
UpdateStatus("Device Mode", 0, true);
break;
}
case USB_MODE_NONE:
{
UpdateStatus("Idle Mode", 0, true);
break;
}
default:
{
break;
}
}
}
if(g_eCurrentUSBMode == USB_MODE_DEVICE)
{
DeviceMain();
}
else if(g_eCurrentUSBMode == USB_MODE_HOST)
{
HostMain();
}
}
}
