/* * ======== USBKBD_init ======== */ void USBKBD_init(void) { Hwi_Handle hwi; Error_Block eb; Semaphore_Params semParams; Error_init(&eb); /* Install interrupt handler */ hwi = Hwi_create(INT_USB0, USBKBD_hwiHandler, NULL, &eb); if (hwi == NULL) { System_abort("Can't create USB Hwi"); } /* RTOS primitives */ Semaphore_Params_init(&semParams); semParams.mode = Semaphore_Mode_BINARY; semKeyboard = Semaphore_create(0, &semParams, &eb); if (semKeyboard == NULL) { System_abort("Can't create keyboard semaphore"); } semUSBConnected = Semaphore_create(0, &semParams, &eb); if (semUSBConnected == NULL) { System_abort("Can't create USB semaphore"); } gateKeyboard = GateMutex_create(NULL, &eb); if (gateKeyboard == NULL) { System_abort("Can't create keyboard gate"); } gateUSBWait = GateMutex_create(NULL, &eb); if (gateUSBWait == NULL) { System_abort("Could not create USB Wait gate"); } /* State specific variables */ state = USBKBD_STATE_UNCONFIGURED; kbLEDs = 0x00; /* Set the USB stack mode to Device mode with VBUS monitoring */ 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. */ if (!USBDHIDKeyboardInit(0, &keyboardDevice)) { System_abort("Error initializing the keyboard"); } }
int main (void) { SysCtlClockSet (SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // Konfiguracja GPIO // // Enable the GPIO port that is used for the on-board LED. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3); // Konfiguracja USB // Enable the GPIO peripheral used for USB, and configure the USB // pins. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeUSBAnalog(GPIO_PORTD_AHB_BASE, GPIO_PIN_4 | GPIO_PIN_5); // // Set the USB stack mode to Device mode. // USBStackModeSet(0, eUSBModeForceDevice, 0); void *pvDevice = USBDHIDKeyboardInit(0, &g_sKeyboardDevice); GPIOPinWrite (GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); if (!pvDevice) { while (1); } GPIOPinWrite (GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3); uint32_t ui32Loop; while (1) { USBDHIDKeyboardKeyStateChange (pvDevice, 0, 0x04, true); // DELAY for(ui32Loop = 0; ui32Loop < 200000; ui32Loop++) { } } }
//***************************************************************************** // // 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 USB pins // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5); // // 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_GPIOF); ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4); ROM_GPIOPadConfigSet(GPIO_PORTF_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_GPIOF); ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1); ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0); // // Not configured initially. // g_bConnected = false; g_bSuspended = false; bLastSuspend = false; // // 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; setup(); 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 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; UARTprintf(bLastSuspend ? "Bus suspended...\n" : "Host connected...\n"); } // // See if the button was just pressed. // ulButton = num; if(ulButton != ulPrevious) { // // 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 { char s[2] = {0x30+num,0}; SendString(s); } } 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) { 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) { } } } }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { uint_fast32_t ui32LastTickCount; bool bLastSuspend; 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 for this board. // PinoutSet(false, true); // // Initialize the buttons driver // ButtonsInit(); // // Enable UART0 // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0); // // Initialize the UART for console I/O. // UARTStdioConfig(0, 115200, ui32SysClock); // // 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(ui32SysClock / SYSTICKS_PER_SECOND); ROM_SysTickIntEnable(); ROM_SysTickEnable(); // // Initial Message // UARTprintf("\033[2J\033[H\n"); UARTprintf("******************************\n"); UARTprintf("* usb-dev-keyboard *\n"); UARTprintf("******************************\n"); // // 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("\nWaiting For Host...\n"); // // Wait here until USB device is connected to a host. // while(!g_bConnected) { } // // Update the status. // UARTprintf("\nHost 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. Print state to terminal. // bLastSuspend = g_bSuspended; if(bLastSuspend) { UARTprintf("\nBus Suspended ... \n"); } else { UARTprintf("\nHost Connected ... \n"); } } // // See if the button was just pressed. // ui8Buttons = ButtonsPoll(&ui8ButtonsChanged, 0); if(BUTTON_PRESSED(LEFT_BUTTON | RIGHT_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) { } } } }
//***************************************************************************** // // 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"); } } }