//***************************************************************************** // // 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(); }