//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
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 device pinout appropriately for this board.
//
PinoutSet();
#ifdef DEBUG
//
// Open UART0 for debug output.
//
UARTStdioInit(0);
#endif
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);
//
// Fill the top 24 rows of the screen with blue to create the banner.
//
sRect.sXMin = 0;
sRect.sYMin = 0;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = 23;
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_pFontCm20);
GrStringDrawCentered(&g_sContext, "boot-demo-usb", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);
//
// Draw the buttons in their initial (unpressed)state.
//
UpdateDisplay(g_ucButtons, true);
//
// Initialize each of the device instances that will form our composite
// USB device.
//
g_sCompDevice.psDevices[0].pvInstance =
USBDHIDMouseCompositeInit(0, (tUSBDHIDMouseDevice *)&g_sMouseDevice);
g_sCompDevice.psDevices[1].pvInstance =
USBDDFUCompositeInit(0, (tUSBDDFUDevice *)&g_sDFUDevice);
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_BUFFER_SIZE,
g_pcDescriptorBuffer);
//
// Initialize the touch screen driver.
//
TouchScreenInit();
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(MouseTouchHandler);
//
// Drop into the main loop.
//
while(!g_bUpdateSignalled)
{
//
// Tell the user what we are doing.
//
GrContextFontSet(&g_sContext, g_pFontCmss22b);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrStringDrawCentered(&g_sContext, " Waiting for host... ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// Wait for USB configuration to complete.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
GrStringDrawCentered(&g_sContext, " Host connected... ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// Now keep processing the mouse as long as the host is connected and
// we've not been told to prepare for a firmware upgrade.
//
while(g_bConnected && !g_bUpdateSignalled)
{
//
// If it is time to check the touchscreen state then do so.
//
if(g_ulCommands & TOUCH_TICK_EVENT)
{
g_ulCommands &= ~TOUCH_TICK_EVENT;
TouchHandler();
}
}
//
// If we drop out of the previous loop, either the host has
// disconnected or a firmware upgrade has been signalled.
//
}
//
// Tell the user what's going on.
//
GrContextFontSet(&g_sContext, g_pFontCmss22b);
GrStringDrawCentered(&g_sContext, " Switching to DFU mode ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// If we get here, a firmware upgrade has been signalled so we need to get
// back into the boot loader to allow this to happen. Call the USB DFU
// device class to do this for us. Note that this function never returns.
//
USBDDFUUpdateBegin();
}
void *USBDFUTriggerDevice::compositeInit()
{
return USBDDFUCompositeInit(_controller->getNumber(), (tUSBDDFUDevice *)&_dev);
}
int main(void) {
int i;
uint8_t data[64];
// 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 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);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 + GPIO_PIN_2 + GPIO_PIN_3);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1 + GPIO_PIN_2 + GPIO_PIN_3, 0);
// Init diagnostic
diagnostic_clear_eventhistory();
// Init UART
ConfigureUART();
// Print welcome message
UARTprintf("Configuring USB\n");
//------------------------------------------------------
// // 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.
// USBDHIDInit(0, &hiddatapipe_device);
//------------------------------------------------------
USBStackModeSet(0, eUSBModeForceDevice, 0);
USBDHIDCompositeInit(0, &hiddatapipe_device, &(composite_device.psDevices[0]));
USBDDFUCompositeInit(0, &dfu_device, &(composite_device.psDevices[1]));
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
USBDCompositeInit(0, &composite_device, DESCRIPTOR_BUFFER_SIZE, composite_descriptorbuffer);
// Block until connected
while (!usbstate.connected)
;
// Configure SysTick
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 1000); // 1 ms
ROM_SysTickEnable();
ROM_SysTickIntEnable();
// enable first IN report by clearing USB tx complete
usbstate.txcomplete = 1;
while(1) {
// uncomment this if event history log is needed
// if (events.print_history == true)
// diagnostic_print_eventhistory();
// usbstate.txcomplete flag was set to 1 by txhandler after usbdhidreportwrite had succeeded
if (usbstate.txcomplete && usbstate.txdataupdated) {
// clear usbstate.txcomplete flag to indicate that usbdhidreportwrite is busy
usbstate.txcomplete = 0;
usbstate.txdataupdated = 0;
// put data (1 byte in this case) into the usb pipeline and the host will poll&read it
// the polling rate is defined in the interrupt IN endpoint descriptor
data[0] = txdata.buffer[0]; // temp buffer to avoid update change of txdata.buffer between the next 2 calls
USBDHIDReportWrite(&hiddatapipe_device, data, 1, 0);
UARTprintf("Sending irq IN to host: %d\n", data[0]);
}
if (usbstate.hostsentreport) {
// clear hostsentreport flag
usbstate.hostsentreport = 0;
for (i = 0; i < HID_REPORTOUT_SIZE; i++) {
UARTprintf("Received OUT report from host: %02x\n", rxdata.buffer[i]);
rxdata.buffer[i] = 0;
}
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Enable the USB mux GPIO.
//
SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);
//
// The LM3S3748 board uses a USB mux that must be switched to use the
// host connector and not the device connecter.
//
GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);
GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_DEVICE);
#ifdef DEBUG
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open UART0 for debug output.
//
UARTStdioInit(0);
#endif
//
// Initialize the pushbuttons.
//
ButtonsInit();
ButtonsSetAutoRepeat((LEFT_BUTTON | RIGHT_BUTTON | UP_BUTTON |
DOWN_BUTTON), 0, 2);
//
// Set the system tick to fire 100 times per second.
//
SysTickPeriodSet(SysCtlClockGet() / SYSTICKS_PER_SECOND);
SysTickIntEnable();
SysTickEnable();
//
// Initialize the display driver.
//
Formike128x128x16Init();
//
// Turn on the backlight.
//
Formike128x128x16BacklightOn();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sFormike128x128x16);
//
// 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, "boot_demo_usb", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);
//
// Initialize each of the device instances that will form our composite
// USB device.
//
g_sCompDevice.psDevices[0].pvInstance =
USBDHIDMouseCompositeInit(0, (tUSBDHIDMouseDevice *)&g_sMouseDevice);
g_sCompDevice.psDevices[1].pvInstance =
USBDDFUCompositeInit(0, (tUSBDDFUDevice *)&g_sDFUDevice);
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_BUFFER_SIZE,
g_pcDescriptorBuffer);
//
// Drop into the main loop.
//
while(!g_bUpdateSignalled)
{
//
// Fill all but the top 15 rows of the screen with black to erase the
// previous status.
//
sRect.sXMin = 0;
sRect.sYMin = 15;
sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.sYMax = GrContextDpyHeightGet(&g_sContext) - 1;
GrContextForegroundSet(&g_sContext, ClrBlack);
GrRectFill(&g_sContext, &sRect);
//
// Tell the user what we are doing.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrStringDrawCentered(&g_sContext, "Waiting for host...", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 24, true);
//
// Wait for USB configuration to complete.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
GrStringDrawCentered(&g_sContext, " Host connected... ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 24, true);
//
// Now keep processing the mouse as long as the host is connected.
//
while(g_bConnected && !g_bUpdateSignalled)
{
//
// If it is time to check the button state then do so.
//
if(g_ulCommands & BUTTON_TICK_EVENT)
{
g_ulCommands &= ~BUTTON_TICK_EVENT;
ButtonHandler();
}
}
//
// If we drop out of the previous loop, the host has disconnected so
// go back and wait for a new connection.
//
}
//
// If we drop out of the main loop, the host has signalled that it wants us
// to switch into DFU mode in preparation for a firmware upgrade. First,
// let the user know what's going on.
//
GrStringDrawCentered(&g_sContext, "Entering DFU mode...", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 24, true);
//
// Call the USB DFU device class to tidy things up and transfer control to
// the boot loader for us. Note that this function never returns.
//
USBDDFUUpdateBegin();
}
