//***************************************************************************** // //! Initializes HID keyboard device operation for a given USB controller. //! //! \param ui32Index is the index of the USB controller which is to be //! initialized for HID keyboard device operation. //! \param psHIDKbDevice points to a structure containing parameters //! customizing the operation of the HID keyboard device. //! //! An application wishing to offer a USB HID keyboard interface to a USB host //! must call this function to initialize the USB controller and attach the //! keyboard device to the USB bus. This function performs all required USB //! initialization. //! //! On successful completion, this function will return the \e psHIDKbDevice //! pointer passed to it. This must be passed on all future calls to the HID //! keyboard device driver. //! //! When a host connects and configures the device, the application callback //! will receive \b USB_EVENT_CONNECTED after which calls can be made to //! USBDHIDKeyboardKeyStateChange() to report key presses and releases to the //! USB host. //! //! \note The application must not make any calls to the lower level USB device //! interfaces if interacting with USB via the USB HID keyboard device class //! API. Doing so will cause unpredictable (though almost certainly //! unpleasant) behavior. //! //! \return Returns NULL on failure or the psHIDKbDevice pointer on success. // //***************************************************************************** void * USBDHIDKeyboardInit(uint32_t ui32Index, tUSBDHIDKeyboardDevice *psHIDKbDevice) { void *pvRetcode; tUSBDHIDDevice *psHIDDevice; tConfigDescriptor *pConfigDesc; // // Check parameter validity. // ASSERT(psHIDKbDevice); ASSERT(psHIDKbDevice->ppui8StringDescriptors); ASSERT(psHIDKbDevice->pfnCallback); // // Get a pointer to the HID device data. // psHIDDevice = &psHIDKbDevice->sPrivateData.sHIDDevice; // // Call the common initialization routine. // pvRetcode = USBDHIDKeyboardCompositeInit(ui32Index, psHIDKbDevice, 0); pConfigDesc = (tConfigDescriptor *)g_pui8KeybDescriptor; pConfigDesc->bmAttributes = psHIDKbDevice->ui8PwrAttributes; pConfigDesc->bMaxPower = (uint8_t)(psHIDKbDevice->ui16MaxPowermA / 2); // // If we initialized the HID layer successfully, pass our device pointer // back as the return code, otherwise return NULL to indicate an error. // if(pvRetcode) { // // Initialize the lower layer HID driver and pass it the various // structures and descriptors necessary to declare that we are a // keyboard. // pvRetcode = USBDHIDInit(ui32Index, psHIDDevice); return((void *)psHIDKbDevice); } else { return((void *)0); } }
//***************************************************************************** // // 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(); } } }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { uint32_t ui32SysClock; // // Run from the PLL at 120 MHz. // ui32SysClock = MAP_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 touch screen driver. // TouchScreenInit(ui32SysClock); // // Set the touch screen event handler. // TouchScreenCallbackSet(UITouchCallback); // // Set the system tick to fire 100 times per second. // ROM_SysTickPeriodSet(ui32SysClock / SYSTICKS_PER_SECOND); ROM_SysTickIntEnable(); ROM_SysTickEnable(); // // Initialize the USB stack for device mode. // USBStackModeSet(0, eUSBModeDevice, 0); // // Initialize the USB keyboard interface. // USBKeyboardInit(); // // Initialize the USB mouse interface. // USBMouseInit(); // // Call the composite device initialization for both the mouse and // keyboard. // USBDHIDMouseCompositeInit(0, &g_sMouseDevice, &g_psCompDevices[0]); USBDHIDKeyboardCompositeInit(0, &g_sKeyboardDevice, &g_psCompDevices[1]); // // Pass the device information to the USB library and place the device // on the bus. // USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_DATA_SIZE, g_pui8DescriptorData); // // Initialize the user interface. // UIInit(); while(1) { // // Run the main loop for the user interface. // UIMain(); } }