int main(void) { uint8_t ucState; uint8_t ucDelta; uint8_t ui8LedData=2; SysCtlClockSet(SYSCTL_SYSDIV_5|SYSCTL_USE_PLL|SYSCTL_XTAL_16MHZ|SYSCTL_OSC_MAIN); ButtonsInit(); SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE,GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3); while(1){ ucState = ButtonsPoll(&ucDelta,0); if(BUTTON_PRESSED(LEFT_BUTTON,ucState,ucDelta)){ GPIOPinWrite(GPIO_PORTF_BASE,GPIO_PIN_1,ui8LedData); ui8LedData^=1<<1; } } return 0; }
//***************************************************************************** // // Called by the NVIC as a result of SysTick Timer rollover interrupt flag // // Checks buttons and calls AppButtonHandler to manage button events. // Tracks time and auto mode color stepping. Calls AppRainbow to implement // RGB color changes. // //***************************************************************************** void SysTickIntHandler(void) { static float x; g_sAppState.ui32Buttons = ButtonsPoll(0,0); AppButtonHandler(); // // Auto increment the color wheel if in the AUTO mode. AUTO mode is when // device is active but user interaction has timed out. // if(g_sAppState.ui32Mode == APP_MODE_AUTO) { g_sAppState.fColorWheelPos += APP_AUTO_COLOR_STEP; } // // Provide wrap around of the control variable from 0 to 1.5 times PI // if(g_sAppState.fColorWheelPos > (APP_PI * 1.5f)) { g_sAppState.fColorWheelPos = 0.0f; } if(x < 0.0f) { g_sAppState.fColorWheelPos = APP_PI * 1.5f; } // // Set the RGB Color based on current control variable value. // AppRainbow(0); }
int main(void) { // TivaC application specific code MAP_FPUEnable(); MAP_FPULazyStackingEnable(); // TivaC system clock configuration. Set to 80MHz. MAP_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); uint8_t button_debounced_delta; uint8_t button_raw_state; ButtonsInit(); // ROS nodehandle initialization and topic registration nh.initNode(); nh.advertise(button_publisher); while (1) { uint8_t button_debounced_state = ButtonsPoll(&button_debounced_delta, &button_raw_state); // Publish message to be transmitted. button_msg.sw1.data = button_debounced_state & LEFT_BUTTON; button_msg.sw2.data = button_debounced_state & RIGHT_BUTTON; button_publisher.publish(&button_msg); // Handle all communications and callbacks. nh.spinOnce(); // Delay for a bit. nh.getHardware()->delay(100); } }
//***************************************************************************** // // This is the interrupt handler for the SysTick interrupt. It is called // periodically and updates a global tick counter then sets a flag to tell the // main loop to move the mouse. // //***************************************************************************** void SysTickIntHandler(void) { g_ui32SysTickCount++; HWREGBITW(&g_ui32Events, USB_TICK_EVENT) = 1; HWREGBITW(&g_ui32Events, LPRF_TICK_EVENT) = 1; g_ui8Buttons = ButtonsPoll(0, 0); }
void SysTickIntHandler(void) { g_sAppState.ulButtons = ButtonsPoll(0,0); AppButtonHandler(); }
void checkButtons(void) { uint8_t button_state = 0; uint8_t button_changed = 0; button_state = ButtonsPoll(&button_changed,0); switch (button_changed & ALL_BUTTONS) { case LEFT_BUTTON: if (button_state & LEFT_BUTTON) { iniciaLeituraSonar(sonar_select); } break; case RIGHT_BUTTON: if (button_state & RIGHT_BUTTON) { iniciaLeituraMPU6050(); } break; } }
int main (void) { SysCtlClockSet (SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_25MHZ); configureUART (); printf ("cpu-gauge.\r\n"); // 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); // // USB config : 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); // ButtonsInit(); // printf ("Buttons OK.\r\n"); motorInit (); printf ("Motor initialized.\r\n"); printf ("Test sequence : +40 steps.\r\n"); motorRun (40); printf ("Test sequence : -40 steps.\r\n"); motorRun (-40); printf ("Test sequence : OK.\r\n"); SysCtlDelay (DELAY_COEFFICIENT_SCD / 10); uint8_t ui8ButtonsChanged, ui8Buttons; while (1) { ButtonsPoll(&ui8ButtonsChanged, &ui8Buttons); if (ui8ButtonsChanged) { if(ui8Buttons & LEFT_BUTTON) { printf ("pressed\r\n"); } else { printf ("released\r\n"); } } } }
//***************************************************************************** // // The SysTick handler. Increments a tick counter and debounces the push // button. // //***************************************************************************** void SysTickHandler(void) { uint8_t ui8Data, ui8Delta; // // Increment the tick counter. // g_ui32SysTickCount++; // // Get buttons status using button debouncer driver // ui8Data = ButtonsPoll(&ui8Delta, 0); // // See if the select button was just pressed. // if(BUTTON_PRESSED(SELECT_BUTTON, ui8Data, ui8Delta)) { // // Set a flag to indicate that the select button was just pressed. // bSelectPressed = 1; } // // Else, see if the select button was just released. // if(BUTTON_RELEASED(SELECT_BUTTON, ui8Data, ui8Delta)) { // // Clear the button pressed flag. // bSelectPressed = 0; } }
//***************************************************************************** // // Initialize and operate the data logger. // //***************************************************************************** int main(void) { tContext sDisplayContext, sBufferContext; uint32_t ui32HibIntStatus, ui32SysClock, ui32LastTickCount; bool bSkipSplash; uint8_t ui8ButtonState, ui8ButtonChanged; uint_fast8_t ui8X, ui8Y; // // 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. // MAP_FPULazyStackingEnable(); // // Set the clocking to run at 50 MHz. // MAP_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); ui32SysClock = MAP_SysCtlClockGet(); // // Initialize locals. // bSkipSplash = false; ui32LastTickCount = 0; // // Initialize the data acquisition module. This initializes the ADC // hardware. // AcquireInit(); // // Enable access to the hibernate peripheral. If the hibernate peripheral // was already running then this will have no effect. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_HIBERNATE); // // Check to see if the hiberate module is already active and if so then // read the saved configuration state. If both are okay, then proceed // to check and see if we are logging data using sleep mode. // if(HibernateIsActive() && !GetSavedState(&g_sConfigState)) { // // Read the status of the hibernate module. // ui32HibIntStatus = HibernateIntStatus(1); // // If this is a pin wake, that means the user pressed the select // button and we should terminate the sleep logging. In this case // we will fall out of this conditional section, and go through the // normal startup below, but skipping the splash screen so the user // gets immediate response. // if(ui32HibIntStatus & HIBERNATE_INT_PIN_WAKE) { // // Clear the interrupt flag so it is not seen again until another // wake. // HibernateIntClear(HIBERNATE_INT_PIN_WAKE); bSkipSplash = true; } // // Otherwise if we are waking from hibernate and it was not a pin // wake, then it must be from RTC match. Check to see if we are // sleep logging and if so then go through an abbreviated startup // in order to collect the data and go back to sleep. // else if(g_sConfigState.ui32SleepLogging && (ui32HibIntStatus & HIBERNATE_INT_RTC_MATCH_0)) { // // Start logger and pass the configuration. The logger should // configure itself to take one sample. // AcquireStart(&g_sConfigState); g_iLoggerState = eSTATE_LOGGING; // // Enter a forever loop to run the acquisition. This will run // until a new sample has been taken and stored. // while(!AcquireRun()) { } // // Getting here means that a data acquisition was performed and we // can now go back to sleep. Save the configuration and then // activate the hibernate. // SetSavedState(&g_sConfigState); // // Set wake condition on pin-wake or RTC match. Then put the // processor in hibernation. // HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC); HibernateRequest(); // // Hibernating takes a finite amount of time to occur, so wait // here forever until hibernate activates and the processor // power is removed. // for(;;) { } } // // Otherwise, this was not a pin wake, and we were not sleep logging, // so just fall out of this conditional and go through the normal // startup below. // } else { // // In this case, either the hibernate module was not already active, or // the saved configuration was not valid. Initialize the configuration // to the default state and then go through the normal startup below. // GetDefaultState(&g_sConfigState); } // // Enable the Hibernate module to run. // HibernateEnableExpClk(SysCtlClockGet()); // // The hibernate peripheral trim register must be set per silicon // erratum 2.1 // HibernateRTCTrimSet(0x7FFF); // // Start the RTC running. If it was already running then this will have // no effect. // HibernateRTCEnable(); // // In case we were sleep logging and are now finished (due to user // pressing select button), then disable sleep logging so it doesnt // try to start up again. // g_sConfigState.ui32SleepLogging = 0; SetSavedState(&g_sConfigState); // // Initialize the display driver. // CFAL96x64x16Init(); // // Initialize the buttons driver. // ButtonsInit(); // // Pass the restored state to the menu system. // MenuSetState(&g_sConfigState); // // Enable the USB peripheral // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0); // // Configure the required pins for USB operation. // MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); MAP_GPIOPinConfigure(GPIO_PG4_USB0EPEN); MAP_GPIOPinTypeUSBDigital(GPIO_PORTG_BASE, GPIO_PIN_4); MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL); MAP_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7); MAP_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; } // // Initialize the USB stack mode and pass in a mode callback. // USBStackModeSet(0, eUSBModeOTG, ModeCallback); // // Initialize the stack to be used with USB stick. // USBStickInit(); // // Initialize the stack to be used as a serial device. // USBSerialInit(); // // Initialize the USB controller for dual mode operation with a 2ms polling // rate. // USBOTGModeInit(0, 2000, g_pui8HCDPool, HCD_MEMORY_SIZE); // // Initialize the menus module. This module will control the user // interface menuing system. // MenuInit(WidgetActivated); // // Configure SysTick to periodically interrupt. // g_ui32TickCount = 0; MAP_SysTickPeriodSet(ui32SysClock / CLOCK_RATE); MAP_SysTickIntEnable(); MAP_SysTickEnable(); // // Initialize the display context and another context that is used // as an offscreen drawing buffer for display animation effect // GrContextInit(&sDisplayContext, &g_sCFAL96x64x16); GrContextInit(&sBufferContext, &g_sOffscreenDisplayA); // // Show the splash screen if we are not skipping it. The only reason to // skip it is if the application was in sleep-logging mode and the user // just waked it up with the select button. // if(!bSkipSplash) { const uint8_t *pui8SplashLogo = g_pui8Image_TI_Black; // // Draw the TI logo on the display. Use an animation effect where the // logo will "slide" onto the screen. Allow select button to break // out of animation. // for(ui8X = 0; ui8X < 96; ui8X++) { if(ButtonsPoll(0, 0) & SELECT_BUTTON) { break; } GrImageDraw(&sDisplayContext, pui8SplashLogo, 95 - ui8X, 0); } // // Leave the logo on the screen for a long duration. Monitor the // buttons so that if the user presses the select button, the logo // display is terminated and the application starts immediately. // while(g_ui32TickCount < 400) { if(ButtonsPoll(0, 0) & SELECT_BUTTON) { break; } } // // Extended splash sequence // if(ButtonsPoll(0, 0) & UP_BUTTON) { for(ui8X = 0; ui8X < 96; ui8X += 4) { GrImageDraw(&sDisplayContext, g_ppui8Image_Splash[(ui8X / 4) & 3], (int32_t)ui8X - 96L, 0); GrImageDraw(&sDisplayContext, pui8SplashLogo, ui8X, 0); MAP_SysCtlDelay(ui32SysClock / 12); } MAP_SysCtlDelay(ui32SysClock / 3); pui8SplashLogo = g_ppui8Image_Splash[4]; GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, 0); MAP_SysCtlDelay(ui32SysClock / 12); } // // Draw the initial menu into the offscreen buffer. // SlideMenuDraw(&g_sMenuWidget, &sBufferContext, 0); // // Now, draw both the TI logo splash screen (from above) and the initial // menu on the screen at the same time, moving the coordinates so that // the logo "slides" off the display and the menu "slides" onto the // display. // for(ui8Y = 0; ui8Y < 64; ui8Y++) { GrImageDraw(&sDisplayContext, pui8SplashLogo, 0, -ui8Y); GrImageDraw(&sDisplayContext, g_pui8OffscreenBufA, 0, 63 - ui8Y); } } // // Add the menu widget to the widget tree and send an initial paint // request. // WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sMenuWidget); WidgetPaint(WIDGET_ROOT); // // Set the focus handle to the menu widget. Any button events will be // sent to this widget // g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget; // // Forever loop to run the application // while(1) { // // Each time the timer tick occurs, process any button events. // if(g_ui32TickCount != ui32LastTickCount) { // // Remember last tick count // ui32LastTickCount = g_ui32TickCount; // // Read the debounced state of the buttons. // ui8ButtonState = ButtonsPoll(&ui8ButtonChanged, 0); // // Pass any button presses through to the widget message // processing mechanism. The widget that has the button event // focus (probably the menu widget) will catch these button events. // if(BUTTON_PRESSED(SELECT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_SELECT); } if(BUTTON_PRESSED(UP_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_UP); } if(BUTTON_PRESSED(DOWN_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_DOWN); } if(BUTTON_PRESSED(LEFT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT); } if(BUTTON_PRESSED(RIGHT_BUTTON, ui8ButtonState, ui8ButtonChanged)) { SendWidgetKeyMessage(WIDGET_MSG_KEY_RIGHT); } } // // Tell the OTG library code how much time has passed in milliseconds // since the last call. // USBOTGMain(GetTickms()); // // Call functions as needed to keep the host or device mode running. // if(g_iCurrentUSBMode == eUSBModeDevice) { USBSerialRun(); } else if(g_iCurrentUSBMode == eUSBModeHost) { USBStickRun(); } // // If in the logging state, then call the logger run function. This // keeps the data acquisition running. // if((g_iLoggerState == eSTATE_LOGGING) || (g_iLoggerState == eSTATE_VIEWING)) { if(AcquireRun() && g_sConfigState.ui32SleepLogging) { // // If sleep logging is enabled, then at this point we have // stored the first data item, now save the state and start // hibernation. Wait for the power to be cut. // SetSavedState(&g_sConfigState); HibernateWakeSet(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC); HibernateRequest(); for(;;) { } } // // If viewing instead of logging then request a repaint to keep // the viewing window updated. // if(g_iLoggerState == eSTATE_VIEWING) { WidgetPaint(WIDGET_ROOT); } } // // If in the saving state, then save data from flash storage to // USB stick. // if(g_iLoggerState == eSTATE_SAVING) { // // Save data from flash to USB // FlashStoreSave(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If in the erasing state, then erase the data stored in flash. // if(g_iLoggerState == eSTATE_ERASING) { // // Save data from flash to USB // FlashStoreErase(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If in the flash reporting state, then show the report of the amount // of used and free flash memory. // if(g_iLoggerState == eSTATE_FREEFLASH) { // // Report free flash space // FlashStoreReport(); // // Return to idle state // g_iLoggerState = eSTATE_IDLE; } // // If we are exiting the clock setting widget, that means that control // needs to be given back to the menu system. // if(g_iLoggerState == eSTATE_CLOCKEXIT) { // // Give the button event focus back to the menu system // g_ui32KeyFocusWidgetHandle = (uint32_t)&g_sMenuWidget; // // Send a button event to the menu widget that means the left // key was pressed. This signals the menu widget to deactivate // the current child widget (which was the clock setting wigdet). // This will cause the menu widget to slide the clock set widget // off the screen and resume control of the display. // SendWidgetKeyMessage(WIDGET_MSG_KEY_LEFT); g_iLoggerState = eSTATE_IDLE; } // // Process any new messages that are in the widget queue. This keeps // the user interface running. // WidgetMessageQueueProcess(); } }
//***************************************************************************** // // 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"); } } }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { uint8_t ui8ButtonsChanged, ui8Buttons; uint32_t ui32SysClock; // // Set the clocking to run from the PLL at 120MHz // ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_25MHZ | SYSCTL_CFG_VCO_480), 120000000); // // Configure the device pins. // PinoutSet(); // // Configure the buttons driver. // ButtonsInit(ALL_BUTTONS); // // Initialize the display driver. // Kentec320x240x16_SSD2119Init(ui32SysClock); // // Initialize the graphics context. // GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119); // // Draw the application frame. // FrameDraw(&g_sContext, "usb-dev-gamepad"); // // Default status is disconnected. // DisplayStatus(&g_sContext, "Disconnected"); // // Not configured initially. // g_iGamepadState = eStateNotConfigured; // // Initialize the USB stack for device mode. // USBStackModeSet(0, eUSBModeDevice, 0); // // Pass the device information to the USB library and place the device // on the bus. // USBDHIDGamepadInit(0, &g_sGamepadDevice); // // Zero out the initial report. // g_sReport.ui8Buttons = 0; g_sReport.i8XPos = 0; g_sReport.i8YPos = 0; // // Initialize the touch screen driver. // TouchScreenInit(ui32SysClock); // // Set the touch screen event handler. // TouchScreenCallbackSet(TSHandler); // // The main loop starts here. We begin by waiting for a host connection // then drop into the main gamepad handling section. If the host // disconnects, we return to the top and wait for a new connection. // while(1) { // // Wait here until USB device is connected to a host. // if(g_iGamepadState == eStateIdle) { // // See if the buttons updated. // ButtonsPoll(&ui8ButtonsChanged, &ui8Buttons); g_sReport.ui8Buttons = 0; // // Set button 1 if up button pressed. // if(ui8Buttons & UP_BUTTON) { g_sReport.ui8Buttons |= 0x01; } // // Set button 2 if down button pressed. // if(ui8Buttons & DOWN_BUTTON) { g_sReport.ui8Buttons |= 0x02; } // // Set button 3 if select button pressed. // if(ui8Buttons & SELECT_BUTTON) { g_sReport.ui8Buttons |= 0x04; } if(ui8ButtonsChanged) { g_bUpdate = true; } // // Send the report if there was an update. // if(g_bUpdate) { g_bUpdate = false; USBDHIDGamepadSendReport(&g_sGamepadDevice, &g_sReport, sizeof(g_sReport)); // // Now sending data but protect this from an interrupt since // it can change in interrupt context as well. // IntMasterDisable(); g_iGamepadState = eStateSending; IntMasterEnable(); } } } }
//***************************************************************************** // // This function handles updates due to the buttons. // // This function is called from the main loop each time the buttons need to // be checked. If it detects an update it will schedule an transfer to the // host. // // Returns Returns \b true on success or \b false if an error is detected. // //***************************************************************************** tBoolean ButtonHandler(void) { unsigned char ucButtons, ucChanged, ucRepeat; unsigned long ulRetcode; char cDeltaX, cDeltaY; tBoolean bSuccess; // // Determine the state of the pushbuttons. // ucButtons = ButtonsPoll(&ucChanged, &ucRepeat); // // Update the display to show which buttons are currently pressed. // UpdateDisplay(ucButtons); // // If we are connected to the host and the select button changed state or // we see a repeat message from any of the direction buttons, go ahead and // send a mouse state change to the host. // if((ucChanged & SELECT_BUTTON) || (ucRepeat & ~SELECT_BUTTON)) { // // Assume no change in the position until we determine otherwise. // cDeltaX = 0; cDeltaY = 0; // // Up button is held down // if(BUTTON_REPEAT(UP_BUTTON, ucRepeat)) { cDeltaY = MOUSE_MOVE_DEC; } // // Down button is held down. // if(BUTTON_REPEAT(DOWN_BUTTON, ucRepeat)) { cDeltaY = MOUSE_MOVE_INC; } // // Left button is held down. // if(BUTTON_REPEAT(LEFT_BUTTON, ucRepeat)) { cDeltaX = MOUSE_MOVE_DEC; } // // Right button is held down // if(BUTTON_REPEAT(RIGHT_BUTTON, ucRepeat)) { cDeltaX = MOUSE_MOVE_INC; } // // Tell the HID driver to send this new report for us. Note that a 0 // in ucButtons indicates that the relevant button is pressed so we // set the MOUSE_REPORT_BUTTON_1 bit if SELECT_BUTTON is clear in // ucButtons. // DEBUG_PRINT("Sending (0x%02x, 0x%02x), button %s.\n", cDeltaX, cDeltaY, ((ucButtons & SELECT_BUTTON) ? "released" : "pressed")); g_eMouseState = MOUSE_STATE_SENDING; ulRetcode = USBDHIDMouseStateChange((void *)&g_sMouseDevice, cDeltaX, cDeltaY, ((ucButtons & SELECT_BUTTON) ? 0 : MOUSE_REPORT_BUTTON_1)); // // Did we schedule the report for transmission? // if(ulRetcode == MOUSE_SUCCESS) { // // Wait for the host to acknowledge the transmission if all went // well. // bSuccess = WaitForSendIdle(MAX_SEND_DELAY); // // Did we time out waiting for the packet to be sent? // if (!bSuccess) { // // Yes - assume the host disconnected and go back to // waiting for a new connection. // DEBUG_PRINT("Send timed out!\n"); g_bConnected = 0; } } else { // // An error was reported when trying to send the report. This may // be due to host disconnection but could also be due to a clash // between our attempt to send a report and the driver sending the // last report in response to an idle timer timeout so we don't // jump to the conclusion that we were disconnected in this case. // DEBUG_PRINT("Can't send report.\n"); bSuccess = false; } } else { // // There was no change in the state of the buttons so we have nothing // to do. // bSuccess = true; } return(bSuccess); }
int main(void) { // Enable FPU for interrupt routines // ROM_FPULazyStackingEnable(); // ROM_FPUEnable(); // Set clock to 80MHz SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // Turn off LEDs 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_2|GPIO_PIN_3, 0); // Setup buttons ButtonsInit(); // Initialize the UART. ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); ROM_GPIOPinConfigure(GPIO_PA0_U0RX); ROM_GPIOPinConfigure(GPIO_PA1_U0TX); ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1); UARTStdioInit(0); // Setup servos and start the timer for them setupServos(); uint16_t servoPosition = SERVO_MIN_PULSE; // Continually check which button is pressed and move the servo position that direction while(1) { switch(ButtonsPoll(0, 0) & ALL_BUTTONS) { case LEFT_BUTTON: servoPosition -= 10; if(servoPosition < SERVO_MIN_PULSE) { servoPosition = SERVO_MIN_PULSE; // Too far, blink red ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_1); } else { // Valid position, blink green ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_2); } break; case RIGHT_BUTTON: servoPosition += 10; if(servoPosition > SERVO_MAX_PULSE) { servoPosition = SERVO_MAX_PULSE; // Too far, blink red ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_1); } else { // Valid position, blink blue ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, GPIO_PIN_3); } break; } // Update servo positions servoSet(servo, servoPosition); servoSet(servo2, servoPosition); // Wait .002s SysCtlDelay((SysCtlClockGet() / 3) / 500); // Turn off all LEDs ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, 0); } }
//***************************************************************************** // // 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) { } } } }
//***************************************************************************** // // 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; } } } }
//***************************************************************************** // // The interrupt handler for the PB4 pin interrupt. When triggered, this will // toggle the JTAG pins between JTAG and GPIO mode. // //***************************************************************************** void SysTickIntHandler(void) { uint8_t ui8Buttons; uint8_t ui8ButtonsChanged; // // Grab the current, debounced state of the buttons. // ui8Buttons = ButtonsPoll(&ui8ButtonsChanged, 0); // // If the USR_SW1 button has been pressed, and was previously not pressed, // start the process of changing the behavior of the JTAG pins. // if(BUTTON_PRESSED(USR_SW1, ui8Buttons, ui8ButtonsChanged)) { // // Toggle the pin mode. // g_ui32Mode ^= 1; // // See if the pins should be in JTAG or GPIO mode. // if(g_ui32Mode == 0) { // // Change PC0-3 into hardware (i.e. JTAG) pins. // HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x01; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) |= 0x01; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x02; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) |= 0x02; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x04; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) |= 0x04; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x08; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) |= 0x08; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x00; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = 0; // // Turn on the LED to indicate that the pins are in JTAG mode. // ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_PIN_0); } else { // // Change PC0-3 into GPIO inputs. // HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x01; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) &= 0xfe; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x02; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) &= 0xfd; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x04; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) &= 0xfb; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x08; HWREG(GPIO_PORTC_BASE + GPIO_O_AFSEL) &= 0xf7; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY; HWREG(GPIO_PORTC_BASE + GPIO_O_CR) = 0x00; HWREG(GPIO_PORTC_BASE + GPIO_O_LOCK) = 0; ROM_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, (GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3)); // // Turn off the LED to indicate that the pins are in GPIO mode. // ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0 | GPIO_PIN_1, GPIO_PIN_1); } } }
//***************************************************************************** // // This example demonstrates the use of the watchdog timer. // //***************************************************************************** int main(void) { int_fast32_t i32CenterX; tRectangle sRect; // // 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 directly from the crystal. // ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Initialize the display and buttons drivers. // CFAL96x64x16Init(); ButtonsInit(); // // Initialize the graphics context and find the middle X coordinate. // GrContextInit(&g_sContext, &g_sCFAL96x64x16); i32CenterX = GrContextDpyWidthGet(&g_sContext) / 2; // // 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 = 9; GrContextForegroundSet(&g_sContext, ClrDarkBlue); GrRectFill(&g_sContext, &sRect); // // Change foreground for white text. // GrContextForegroundSet(&g_sContext, ClrWhite); // // Put the application name in the middle of the banner. // GrContextFontSet(&g_sContext, g_psFontFixed6x8); GrStringDrawCentered(&g_sContext, "watchdog", -1, i32CenterX, 4, 0); // // Show the state and offer some instructions to the user. // GrContextFontSet(&g_sContext, g_psFontFixed6x8); GrStringDrawCentered(&g_sContext, "Feeding", -1, i32CenterX, 14, 1); GrStringDrawCentered(&g_sContext, "Watchdog", -1, i32CenterX, 24, 1); GrStringDrawCentered(&g_sContext, "Press", -1, i32CenterX, 36, 1); GrStringDrawCentered(&g_sContext, "Select", -1, i32CenterX, 46, 1); GrStringDrawCentered(&g_sContext, "to stop", -1, i32CenterX, 56, 1); // // Enable the peripherals used by this example. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG); // // Enable processor interrupts. // ROM_IntMasterEnable(); // // Set GPIO PG2 as an output. This drives an LED on the board that will // toggle when a watchdog interrupt is processed. // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2); ROM_GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_2, 0); // // Enable the watchdog interrupt. // ROM_IntEnable(INT_WATCHDOG); // // Set the period of the watchdog timer. // ROM_WatchdogReloadSet(WATCHDOG0_BASE, ROM_SysCtlClockGet()); // // Enable reset generation from the watchdog timer. // ROM_WatchdogResetEnable(WATCHDOG0_BASE); // // Enable the watchdog timer. // ROM_WatchdogEnable(WATCHDOG0_BASE); // // Loop forever while the LED winks as watchdog interrupts are handled. // while(1) { // // Poll for the select button pressed // uint8_t ui8Buttons = ButtonsPoll(0, 0); if(ui8Buttons & SELECT_BUTTON) { SelectButtonPressed(); while(1) { } } } }
//***************************************************************************** // // This example demonstrates the use of the watchdog timer. // //***************************************************************************** int main(void) { // // Set the clocking to run directly from the crystal at 120MHz. // g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ | SYSCTL_OSC_MAIN | SYSCTL_USE_PLL | SYSCTL_CFG_VCO_480), 120000000); // // Initialize the buttons driver. // ButtonsInit(); // // Enable the peripherals used by this example. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0); ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION); // // Enable processor interrupts. // ROM_IntMasterEnable(); // // Set GPIO PN0 as an output. This drives an LED on the board that will // toggle when a watchdog interrupt is processed. // ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0); ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0); // // Enable the watchdog interrupt. // ROM_IntEnable(INT_WATCHDOG); // // Set the period of the watchdog timer to 1 second. // ROM_WatchdogReloadSet(WATCHDOG0_BASE, g_ui32SysClock); // // Enable reset generation from the watchdog timer. // ROM_WatchdogResetEnable(WATCHDOG0_BASE); // // Enable the watchdog timer. // ROM_WatchdogEnable(WATCHDOG0_BASE); // // Loop forever while the LED winks as watchdog interrupts are handled. // while(1) { // // Poll for the select button pressed // uint8_t ui8Buttons = ButtonsPoll(0, 0); if(ui8Buttons & USR_SW1) { SW1ButtonPressed(); while(1) { } } } }
//***************************************************************************** // // This is interrupt handler for the systick interrupt. // // This function handles the interrupts generated by the system tick. These // are used for button debouncing and updating the state of the buttons. // The buttons are stored in a bitmask indicating which buttons have been // release. If a button is pressed twice, only one press will be seen. There // is no press and hold detection. // // \return None. // //***************************************************************************** void SysTickHandler(void) { unsigned char ucButtons; unsigned char ucChanged; unsigned char ucRepeat; // // Determine the state of the pushbuttons. // ucButtons = ButtonsPoll(&ucChanged, &ucRepeat); // // Up button has been released. // if(BUTTON_RELEASED(UP_BUTTON, ucButtons, ucChanged)) { g_ulButtons |= BUTTON_UP_CLICK; } // // Up button has been held. // if(BUTTON_REPEAT(UP_BUTTON, ucRepeat)) { g_ulButtons |= BUTTON_UP_CLICK; } // // Down button has been released. // if(BUTTON_RELEASED(DOWN_BUTTON, ucButtons, ucChanged)) { g_ulButtons |= BUTTON_DOWN_CLICK; } // // Down button has been held. // if(BUTTON_REPEAT(DOWN_BUTTON, ucRepeat)) { g_ulButtons |= BUTTON_DOWN_CLICK; } // // Left button has been released. // if(BUTTON_RELEASED(LEFT_BUTTON, ucButtons, ucChanged)) { g_ulButtons |= BUTTON_LEFT_CLICK; } // // Right button has been released. // if(BUTTON_RELEASED(RIGHT_BUTTON, ucButtons, ucChanged)) { g_ulButtons |= BUTTON_RIGHT_CLICK; } // // Select button has been released. // if(BUTTON_RELEASED(SELECT_BUTTON, ucButtons, ucChanged)) { g_ulButtons |= BUTTON_SELECT_CLICK; } }
int main(void) { unsigned char button_val; unsigned char Delta; unsigned char Rawstate; // // Setup the system clock to run at 80 Mhz from PLL with crystal reference // SysCtlClockSet( SYSCTL_SYSDIV_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_16MHZ); // // Enable and configure the GPIO port for the LED operation. // SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); GPIOPinTypeGPIOOutput(LED, RED_LED | BLUE_LED | GREEN_LED); GPIOPinWrite(LED, RED_LED | BLUE_LED | GREEN_LED, 0x00); Blink(GREEN_LED | BLUE_LED, 5, 50); ButtonsInit(); UARTInit(); while (1) { SysCtlDelay(100000); button_val = ButtonsPoll(&Delta, &Rawstate); if (BUTTON_PRESSED(LEFT_BUTTON,button_val,Delta)) { if (SendAndCheck("AT", 1)) { Blink(BLUE_LED, 1, 300); } else { Blink(RED_LED, 1, 300); } } if (BUTTON_PRESSED(RIGHT_BUTTON,button_val,Delta)) { break; } } Blink(GREEN_LED, 1, 1000); ADCInit(); InitSonar(); SimInit(); Blink(BLUE_LED, 1, 1000); // // Loop Forever // while (1) { SysCtlDelay(100000); button_val = ButtonsPoll(&Delta, &Rawstate); if (BUTTON_PRESSED(LEFT_BUTTON,button_val,Delta)) { GPIOPinWrite(LED, RED_LED | BLUE_LED | GREEN_LED, GREEN_LED); max_distance = GetDistanceSonar(); GPIOPinWrite(LED, RED_LED | BLUE_LED | GREEN_LED, 0x00); if (SendAndCheck("AT", 1)) { Blink(BLUE_LED, 1, 300); } else { Blink(RED_LED, 1, 300); } } if (BUTTON_PRESSED(RIGHT_BUTTON,button_val,Delta)) { isRunning = !isRunning; } if (isRunning) { tempC = GetTemperature(); if (tempC > 70) { SendData(DATA_TEMP, tempC); Blink(RED_LED, 3, 100); } distance = GetDistanceSonar(); percentage = (int) floor( ((max_distance - distance) * 100.0) / max_distance); if ((percentage >= 0) && (percentage <= 100) && abs(percentage - oldPercentage) > 10) { SendData(DATA_TRASH, percentage); oldPercentage = percentage; } Blink(GREEN_LED, 1, 10); } } }
//***************************************************************************** // // This task reads the buttons' state and passes this information to LEDTask. // //***************************************************************************** static void SwitchTask(void *pvParameters) { portTickType ui16LastTime; uint32_t ui32SwitchDelay = 25; uint8_t ui8CurButtonState, ui8PrevButtonState; uint8_t ui8Message; ui8CurButtonState = ui8PrevButtonState = 0; // // Get the current tick count. // ui16LastTime = xTaskGetTickCount(); // // Loop forever. // while(1) { // // Poll the debounced state of the buttons. // ui8CurButtonState = ButtonsPoll(0, 0); // // Check if previous debounced state is equal to the current state. // if(ui8CurButtonState != ui8PrevButtonState) { ui8PrevButtonState = ui8CurButtonState; // // Check to make sure the change in state is due to button press // and not due to button release. // if((ui8CurButtonState & ALL_BUTTONS) != 0) { if((ui8CurButtonState & ALL_BUTTONS) == LEFT_BUTTON) { ui8Message = LEFT_BUTTON; // // Guard UART from concurrent access. // xSemaphoreTake(g_pUARTSemaphore, portMAX_DELAY); UARTprintf("Left Button is pressed.\n"); xSemaphoreGive(g_pUARTSemaphore); } else if((ui8CurButtonState & ALL_BUTTONS) == RIGHT_BUTTON) { ui8Message = RIGHT_BUTTON; // // Guard UART from concurrent access. // xSemaphoreTake(g_pUARTSemaphore, portMAX_DELAY); UARTprintf("Right Button is pressed.\n"); xSemaphoreGive(g_pUARTSemaphore); } // // Pass the value of the button pressed to LEDTask. // if(xQueueSend(g_pLEDQueue, &ui8Message, portMAX_DELAY) != pdPASS) { // // Error. The queue should never be full. If so print the // error message on UART and wait for ever. // UARTprintf("\nQueue full. This should never happen.\n"); while(1) { } } } } // // Wait for the required amount of time to check back. // vTaskDelayUntil(&ui16LastTime, ui32SwitchDelay / portTICK_RATE_MS); } }
//***************************************************************************** // // This is the main loop that runs the application. // //***************************************************************************** int main(void) { uint8_t ui8ButtonsChanged, ui8Buttons; bool bUpdate; // // 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_2); // // Open UART0 and show the application name on the UART. // ConfigureUART(); UARTprintf("\033[2JTiva C Series USB gamepad device example\n"); UARTprintf("---------------------------------\n\n"); // // Not configured initially. // g_iGamepadState = eStateNotConfigured; // // Enable the GPIO peripheral used for USB, and configure the USB // pins. // ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD); SysCtlGPIOAHBEnable(SYSCTL_PERIPH_GPIOD); ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_AHB_BASE, GPIO_PIN_4 | GPIO_PIN_5); // // Configure the GPIOS for the buttons. // ButtonsInit(); // // Initialize the ADC channels. // ADCInit(); // // Tell the user what we are up to. // UARTprintf("Configuring USB\n"); // // Set the USB stack mode to Device mode. // USBStackModeSet(0, eUSBModeForceDevice, 0); // // Pass the device information to the USB library and place the device // on the bus. // USBDHIDGamepadInit(0, &g_sGamepadDevice); // // Zero out the initial report. // sReport.ui8Buttons = 0; sReport.i8XPos = 0; sReport.i8YPos = 0; sReport.i8ZPos = 0; // // Tell the user what we are doing and provide some basic instructions. // UARTprintf("\nWaiting For Host...\n"); // // Trigger an initial ADC sequence. // ADCProcessorTrigger(ADC0_BASE, 0); // // The main loop starts here. We begin by waiting for a host connection // then drop into the main gamepad handling section. If the host // disconnects, we return to the top and wait for a new connection. // while(1) { // // Wait here until USB device is connected to a host. // if(g_iGamepadState == eStateIdle) { // // No update by default. // bUpdate = false; // // See if the buttons updated. // ButtonsPoll(&ui8ButtonsChanged, &ui8Buttons); sReport.ui8Buttons = 0; // // Set button 1 if left pressed. // if(ui8Buttons & LEFT_BUTTON) { sReport.ui8Buttons |= 0x01; } // // Set button 2 if right pressed. // if(ui8Buttons & RIGHT_BUTTON) { sReport.ui8Buttons |= 0x02; } if(ui8ButtonsChanged) { bUpdate = true; } // // See if the ADC updated. // if(ADCIntStatus(ADC0_BASE, 0, false) != 0) { // // Clear the ADC interrupt. // ADCIntClear(ADC0_BASE, 0); // // Read the data and trigger a new sample request. // ADCSequenceDataGet(ADC0_BASE, 0, &g_pui32ADCData[0]); ADCProcessorTrigger(ADC0_BASE, 0); // // Update the report. // sReport.i8XPos = Convert8Bit(g_pui32ADCData[0]); sReport.i8YPos = Convert8Bit(g_pui32ADCData[1]); sReport.i8ZPos = Convert8Bit(g_pui32ADCData[2]); bUpdate = true; } // // Send the report if there was an update. // if(bUpdate) { USBDHIDGamepadSendReport(&g_sGamepadDevice, &sReport, sizeof(sReport)); // // Now sending data but protect this from an interrupt since // it can change in interrupt context as well. // IntMasterDisable(); g_iGamepadState = eStateSending; IntMasterEnable(); // // Limit the blink rate of the LED. // if(g_ui32Updates++ == 40) { // // Turn on the blue LED. // ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2); // // Reset the update count. // g_ui32Updates = 0; } } } } }
//***************************************************************************** // // A simple application demonstrating use of the boot loader, // //***************************************************************************** int main(void) { tRectangle sRect; tContext sContext; unsigned long ulSysClock; // // 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_XTAL_16MHZ | SYSCTL_OSC_MAIN); ulSysClock = ROM_SysCtlClockGet(); // // Initialize the peripherals that each of the boot loader flavors // supports. Since this example is intended for use with any of the // boot loaders and we don't know which is actually in use, we cover all // bases and initialize for serial, Ethernet and USB use here. // SetupForUART(); SetupForUSB(); // // Initialize the buttons driver. // ButtonsInit(); // // Initialize the display driver. // CFAL96x64x16Init(); // // Initialize the graphics context. // GrContextInit(&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(&sContext) - 1; sRect.sYMax = 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_pFontFixed6x8); GrStringDrawCentered(&sContext, "boot-demo2", -1, GrContextDpyWidthGet(&sContext) / 2, 4, 0); GrStringDrawCentered(&sContext, "Press select", -1, GrContextDpyWidthGet(&sContext) / 2, 20, false); GrStringDrawCentered(&sContext, "button to", -1, GrContextDpyWidthGet(&sContext) / 2, 30, false); GrStringDrawCentered(&sContext, "update.", -1, GrContextDpyWidthGet(&sContext) / 2, 40, false); // // Wait for select button to be pressed. // while ((ButtonsPoll(0, 0) & SELECT_BUTTON) == 0) { ROM_SysCtlDelay(ulSysClock / 1000); } GrStringDrawCentered(&sContext, " ", -1, GrContextDpyWidthGet(&sContext) / 2, 20, true); GrStringDrawCentered(&sContext, " Updating... ", -1, GrContextDpyWidthGet(&sContext) / 2, 30, true); GrStringDrawCentered(&sContext, " ", -1, GrContextDpyWidthGet(&sContext) / 2, 40, true); // // Transfer control to the boot loader. // JumpToBootLoader(); // // The previous function never returns but we need to stick in a return // code here to keep the compiler from generating a warning. // return(0); }
//***************************************************************************** // // 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) { } } } }