自学教程：C++ GrRectFill函数代码示例

//*****************************************************************************//// Shows the status string on the color STN display.//// /param psContext is a pointer to the graphics context representing the// display.// /param pcStatus is a pointer to the string to be shown.////*****************************************************************************voidDisplayStatus(tContext *psContext, char *pcStatus){    tRectangle rectLine;    long lY;    //    // Calculate the Y coordinate of the top left of the character cell    // for our line of text.    //    lY = (GrContextDpyHeightGet(psContext) / 4) -         (GrFontHeightGet(TEXT_FONT) / 2);    //    // Determine the bounding rectangle for this line of text.    //    rectLine.sXMin = 0;    rectLine.sXMax = GrContextDpyWidthGet(psContext) - 1;    rectLine.sYMin = lY;    rectLine.sYMax = lY + GrFontHeightGet(TEXT_FONT) - 1;    //    // Clear the line with black.    //    GrContextForegroundSet(&g_sContext, ClrBlack);    GrRectFill(psContext, &rectLine);    //    // Draw the new status string    //    DEBUG_PRINT("%s/n", pcStatus);    GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(psContext, pcStatus, -1,                         GrContextDpyWidthGet(psContext) / 2,                         GrContextDpyHeightGet(psContext) / 4 , false);}

/** * Show the Text for the Bootscreen */void vShowBootText(char* text){	/* Header Rectangle */	tRectangle sRect;	if (g_sContext.pDisplay == 0)	{		GrContextInit(&g_sContext, DISPLAY_DRIVER);	}	//	// Fill the top 24 rows of the screen with blue to create the banner.	//	sRect.sXMin = 0;	sRect.sYMin = 0;	sRect.sXMax = GrContextDpyWidthGet(&g_sContext);	sRect.sYMax = GrContextDpyHeightGet(&g_sContext);	GrContextForegroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_BACKGROUND_COLOR);	GrContextBackgroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_BACKGROUND_COLOR);	GrRectFill(&g_sContext, &sRect);	//	// Put a white box around the banner.	//	GrRectDraw(&g_sContext, &sRect);	GrContextForegroundSet(&g_sContext, DISPLAY_BOOT_SCREEN_COLOR);	//	// Put the application name in the middle of the banner.	//	GrContextFontSet(&g_sContext, DISPLAY_BOOT_SCREEN_FONT);	GrStringDrawCentered(&g_sContext, text, -1,			GrContextDpyWidthGet(&g_sContext) / 2, GrContextDpyHeightGet(&g_sContext) / 2, 0);}

//*****************************************************************************//// Shows the status string on the display.//// /param psContext is a pointer to the graphics context representing the// display.// /param pcStatus is a pointer to the string to be shown.////*****************************************************************************voidDisplayStatus(tContext *psContext, char *pcStatus){    tRectangle sRectLine;    int32_t i32Y;    //    // Calculate the Y coordinate of the top left of the character cell    // for our line of text.    //    i32Y = GrContextDpyHeightGet(psContext) - GrFontHeightGet(TEXT_FONT) - 10;    //    // Determine the bounding rectangle for this line of text. We add 4 pixels    // to the height just to ensure that we clear a couple of pixels above and    // below the line of text.    //    sRectLine.i16XMin = 0;    sRectLine.i16XMax = GrContextDpyWidthGet(psContext) - 1;    sRectLine.i16YMin = i32Y - GrFontHeightGet(TEXT_FONT);    sRectLine.i16YMax = i32Y + GrFontHeightGet(TEXT_FONT) + 3;    //    // Clear the line with black.    //    GrContextForegroundSet(&g_sContext, ClrBlack);    GrRectFill(psContext, &sRectLine);    //    // Draw the new status string    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrStringDrawCentered(psContext, pcStatus, -1,                         GrContextDpyWidthGet(psContext) / 2,                         i32Y, false);}

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    uint_fast32_t ui32TxCount;    uint_fast32_t ui32RxCount;    tRectangle sRect;    char pcBuffer[16];    //    // 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);#ifdef DEBUG    //    // Configure the UART for debug output.    //    ConfigureUART();#endif    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // 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, "usb-dev-bulk", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    //    // Show the various static text elements on the color STN display.    //    GrStringDraw(&g_sContext, "Tx bytes:", -1, 0, 32, false);    GrStringDraw(&g_sContext, "Rx bytes:", -1, 0, 42, false);    //    // Enable the GPIO peripheral used for USB, and configure the USB    // pins.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOL);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTL_BASE, GPIO_PIN_6 | GPIO_PIN_7);    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Show the application name on the display and UART output.    //    DEBUG_PRINT("/nTiva C Series USB bulk device example/n");    DEBUG_PRINT("---------------------------------/n/n");    //    // Tell the user what we are up to.//.........这里部分代码省略.........

//*****************************************************************************////! Draws a container widget.//!//! /param pWidget is a pointer to the container widget to be drawn.//!//! This function draws a container widget on the display.  This is called in//! response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidContainerPaint(tWidget *pWidget){    tContainerWidget *pContainer;    long lX1, lX2, lY;    tContext sCtx;    //    // Check the arguments.    //    ASSERT(pWidget);    //    // Convert the generic widget pointer into a container widget pointer.    //    pContainer = (tContainerWidget *)pWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, pWidget->pDisplay);    //    // Initialize the clipping region based on the extents of this container.    //    GrContextClipRegionSet(&sCtx, &(pWidget->sPosition));    //    // See if the container fill style is selected.    //    if(pContainer->ulStyle & CTR_STYLE_FILL)    {        //        // Fill the container with the fill color.        //        GrContextForegroundSet(&sCtx, pContainer->ulFillColor);        GrRectFill(&sCtx, &(pWidget->sPosition));    }    //    // See if the container text style is selected.    //    if(pContainer->ulStyle & CTR_STYLE_TEXT)    {        //        // Set the font and colors used to draw the container text.        //        GrContextFontSet(&sCtx, pContainer->pFont);        GrContextForegroundSet(&sCtx, pContainer->ulTextColor);        GrContextBackgroundSet(&sCtx, pContainer->ulFillColor);        //        // Get the width of the container text.        //        lX2 = GrStringWidthGet(&sCtx, pContainer->pcText, -1);        //        // Determine the position of the text.  The position depends on the        // the width of the string and if centering is enabled.        //        if(pContainer->ulStyle & CTR_STYLE_TEXT_CENTER)        {            lX1 = (pWidget->sPosition.sXMin +                   ((pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1 -                     lX2 - 8) / 2));        }        else        {            lX1 = pWidget->sPosition.sXMin + 4;        }        //        // Draw the container text.        //        GrStringDraw(&sCtx, pContainer->pcText, -1, lX1 + 4,                     pWidget->sPosition.sYMin,                     pContainer->ulStyle & CTR_STYLE_TEXT_OPAQUE);        //        // See if the container outline style is selected.        //        if(pContainer->ulStyle & CTR_STYLE_OUTLINE)        {            //            // Get the position of the right side of the string.            //            lX2 = lX1 + lX2 + 8;//.........这里部分代码省略.........

//*****************************************************************************//// This function updates the status area of the screen.  It uses the current// state of the application to print the status bar.////*****************************************************************************voidUpdateStatus(void){    tRectangle sRect;    //    // Fill the bottom rows of the screen with blue to create the status area.    //    sRect.sXMin = 0;    sRect.sYMin = GrContextDpyHeightGet(&g_sContext) -                  DISPLAY_BANNER_HEIGHT - 1;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = sRect.sYMin + DISPLAY_BANNER_HEIGHT;    GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    //    // Update the status on the screen.    //    if(g_eUSBState == STATE_NO_DEVICE)    {        //        // Keyboard is currently disconnected.        //        GrStringDrawCentered(&g_sContext, "no device", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if(g_eUSBState == STATE_UNKNOWN_DEVICE)    {        //        // Unknown device is currently connected.        //        GrStringDrawCentered(&g_sContext, "unknown device", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if(g_eUSBState == STATE_POWER_FAULT)    {        //        // Something caused a power fault.        //        GrStringDrawCentered(&g_sContext, "power fault", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);    }    else if((g_eUSBState == STATE_KEYBOARD_CONNECTED) ||            (g_eUSBState == STATE_KEYBOARD_UPDATE))    {        //        // Keyboard is connected.        //        GrStringDrawCentered(&g_sContext, "connected", -1,                              GrContextDpyWidthGet(&g_sContext) / 2,                              sRect.sYMin + 5, 0);        //        // Update the CAPS Lock status.        //        if(g_ulModifiers & HID_KEYB_CAPS_LOCK)        {            GrStringDrawCentered(&g_sContext, "C",                                  GrContextDpyWidthGet(&g_sContext) / 2,                                  sRect.sXMax - 10,                                 sRect.sYMin + 5, 0);        }    }}

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    uint32_t ui32TxCount, ui32RxCount, ui32Fullness, ui32SysClock, ui32PLLRate;    tRectangle sRect;    char pcBuffer[16];#ifdef USE_ULPI    uint32_t ui32Setting;#endif    //    // Set the system clock to run at 120MHz from the PLL.    //    ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |                                           SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |                                           SYSCTL_CFG_VCO_480), 120000000);    //    // Configure the device pins.    //    PinoutSet();#ifdef USE_ULPI    //    // Switch the USB ULPI Pins over.    //    USBULPIPinoutSet();    //    // Enable USB ULPI with high speed support.    //    ui32Setting = USBLIB_FEATURE_ULPI_HS;    USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);    //    // Setting the PLL frequency to zero tells the USB library to use the    // external USB clock.    //    ui32PLLRate = 0;#else    //    // Save the PLL rate used by this application.    //    ui32PLLRate = 480000000;#endif    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Not configured initially.    //    g_ui32Flags = 0;    //    // 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-serial");    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Show the various static text elements on the color STN display.    //    GrContextFontSet(&g_sContext, TEXT_FONT);    GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 80, false);    GrStringDraw(&g_sContext, "Tx buffer:", -1, 8, 105, false);//.........这里部分代码省略.........

//*****************************************************************************//// Handles paint requests for the primitives canvas widget.////*****************************************************************************voidOnPrimitivePaint(tWidget *pWidget, tContext *pContext){    unsigned int ulIdx;    tRectangle sRect;    //    // Draw a vertical sweep of lines from red to green.    //    for(ulIdx = 0; ulIdx <= 8; ulIdx++)    {        GrContextForegroundSet(pContext,                               (((((10 - ulIdx) * 255) / 10) << ClrRedShift) |                                (((ulIdx * 255) / 10) << ClrGreenShift)));        GrLineDraw(pContext, 115+X_OFFSET, 120+Y_OFFSET, 5+X_OFFSET, 120+Y_OFFSET - (11 * ulIdx));    }    //    // Draw a horizontal sweep of lines from green to blue.    //    for(ulIdx = 1; ulIdx <= 10; ulIdx++)    {        GrContextForegroundSet(pContext,                               (((((10 - ulIdx) * 255) / 10) <<                                 ClrGreenShift) |                                (((ulIdx * 255) / 10) << ClrBlueShift)));        GrLineDraw(pContext, 115+X_OFFSET, 120+Y_OFFSET, 5 + (ulIdx * 11)+X_OFFSET, 29+Y_OFFSET);    }    //    // Draw a filled circle with an overlapping circle.    //    GrContextForegroundSet(pContext, ClrBrown);    GrCircleFill(pContext, 185+X_OFFSET, 69+Y_OFFSET, 40);    GrContextForegroundSet(pContext, ClrSkyBlue);    GrCircleDraw(pContext, 205+X_OFFSET, 99+Y_OFFSET, 30);    //    // Draw a filled rectangle with an overlapping rectangle.    //    GrContextForegroundSet(pContext, ClrSlateGray);    sRect.sXMin = 20+X_OFFSET;    sRect.sYMin = 100+Y_OFFSET;    sRect.sXMax = 75+X_OFFSET;    sRect.sYMax = 160+Y_OFFSET;    GrRectFill(pContext, &sRect);    GrContextForegroundSet(pContext, ClrSlateBlue);    sRect.sXMin += 40;    sRect.sYMin += 40;    sRect.sXMax += 30;    sRect.sYMax += 28;    GrRectDraw(pContext, &sRect);    //    // Draw a piece of text in fonts of increasing size.    //    GrContextForegroundSet(pContext, ClrSilver);    GrContextFontSet(pContext, &g_sFontCm14);    GrStringDraw(pContext, "Strings", -1, 125+X_OFFSET, 110+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm18);    GrStringDraw(pContext, "Strings", -1, 145+X_OFFSET, 124+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm22);    GrStringDraw(pContext, "Strings", -1, 165+X_OFFSET, 142+Y_OFFSET, 0);    GrContextFontSet(pContext, &g_sFontCm24);    GrStringDraw(pContext, "Strings", -1, 185+X_OFFSET, 162+Y_OFFSET, 0);    //    // Draw an image.    //    GrImageDraw(pContext, g_TILogo, 240+X_OFFSET, 60+Y_OFFSET);}

//*****************************************************************************//// Print "Hello World!" to the display.////*****************************************************************************intmain(void){    tContext sContext;    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_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |                       SYSCTL_OSC_MAIN);    //    // Initialize the UART.    //    ConfigureUART();    UARTprintf("Hello, world!/n");    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sCFAL96x64x16);    //    // Fill the top 24 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1;    sRect.i16YMax = 23;    GrContextForegroundSet(&sContext, ClrDarkBlue);    GrRectFill(&sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&sContext, ClrWhite);    GrRectDraw(&sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&sContext, g_psFontCm12);    GrStringDrawCentered(&sContext, "hello", -1,                         GrContextDpyWidthGet(&sContext) / 2, 10, 0);    //    // Say hello using the Computer Modern 40 point font.    //    GrContextFontSet(&sContext, g_psFontCm12/*g_psFontFixed6x8*/);    GrStringDrawCentered(&sContext, "Hello World!", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         ((GrContextDpyHeightGet(&sContext) - 24) / 2) + 24,                         0);    //    // Flush any cached drawing operations.    //    GrFlush(&sContext);    //    // We are finished. Hang around doing nothing.    //    while(1) {    }}

uint8_t sportswatch_process(uint8_t event, uint16_t lparam, void* rparam){  UNUSED_VAR(lparam);  switch(event)  {  case EVENT_WINDOW_CREATED:    {      if (rparam == (void*)0)      {          //running          sports_type = SPORTS_DATA_FLAG_RUN;          set_mode(DATA_MODE_RUNNING);        //ant_init(MODE_HRM);      }      else      {          //cycling          sports_type = SPORTS_DATA_FLAG_BIKE;          set_mode(DATA_MODE_BIKING);        //ant_init(MODE_CBSC);      }      rtc_enablechange(SECOND_CHANGE);      cleanUpSportsWatchData();      ui_config* config = window_readconfig();      sportnum = config->sports_grid + 4;      add_watch_status(WS_SPORTS);      ble_start_sync(2, get_mode());      return 0x80; // disable status    }  case EVENT_SPORT_DATA:    {      //printf("got a sport data /n");      updateData(lparam, (uint32_t)rparam);      break;    }  case EVENT_TIME_CHANGED:    {      workout_time++;      updateData(SPORTS_TIME, workout_time);      if (upload_data_interval > 0 &&          workout_time % upload_data_interval == 0)      {        ui_config* config = window_readconfig();        sportnum = config->sports_grid + 4;        //STLV over RFCOMM        send_sports_data(0,           sports_type | SPORTS_DATA_FLAG_START,           config->sports_grid_data, grid_data, sportnum);        //BLE        ble_send_sports_data(grid_data, 5);      }      if (workout_time % save_data_interval == 0 &&       (get_mode() & DATA_MODE_PAUSED) != 0)      {        saveSportsData();      }      break;    }  case EVENT_WINDOW_PAINT:    {      tContext *pContext = (tContext*)rparam;      GrContextForegroundSet(pContext, ClrBlack);      GrRectFill(pContext, &fullscreen_clip);      GrContextForegroundSet(pContext, ClrWhite);      onDraw(pContext);      break;    }  case EVENT_WINDOW_CLOSING:    {      rtc_enablechange(0);#if PRODUCT_W001      ant_shutdown();#endif            uint8_t dummy_stlv_meta = 0;      uint32_t dummy_stlv_data = 0;      send_sports_data(0, sports_type | SPORTS_DATA_FLAG_STOP, &dummy_stlv_meta, &dummy_stlv_data, 1);      saveSportsData();      ble_stop_sync();      set_mode(DATA_MODE_NORMAL);      del_watch_status(WS_SPORTS);      break;    }  default:    return 0;  }  return 1;}

//*****************************************************************************//// This is the main loop that runs the application.////*****************************************************************************intmain(void){    tRectangle sRect;    uint_fast32_t ui32Retcode;    //    // 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 SysTick for a 100Hz interrupt.  The FatFs driver wants a 10 ms    // tick.    //    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);    ROM_SysTickEnable();    ROM_SysTickIntEnable();    //    // Configure and enable uDMA    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);    SysCtlDelay(10);    ROM_uDMAControlBaseSet(&sDMAControlTable[0]);    ROM_uDMAEnable();    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.i16XMin = 0;    sRect.i16YMin = 0;    sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.i16YMax = DISPLAY_BANNER_HEIGHT - 1;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb-dev-msc", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 5, 0);    //    // Initialize the idle timeout and reset all flags.    //    g_ui32IdleTimeout = 0;    g_ui32Flags = 0;    //    // Initialize the state to idle.    //    g_eMSCState = MSC_DEV_DISCONNECTED;    //    // Draw the status bar and set it to idle.    //    UpdateStatus("Disconnected", 1);    //    // Enable the USB controller.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);    //    // Set the USB pins to be controlled by the USB controller.    //    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);    //    // Set the USB stack mode to Device mode with VBUS monitoring.//.........这里部分代码省略.........

//*****************************************************************************//// This function updates the status area of the screen.  It uses the current// state of the application to print the status bar.////*****************************************************************************voidUpdateStatus(char *pcString, bool bClrBackground){    tRectangle sRect;    //    //    //    GrContextBackgroundSet(&g_sContext, DISPLAY_BANNER_BG);    if(bClrBackground) {        //        // Fill the bottom rows of the screen with blue to create the status area.        //        sRect.i16XMin = 0;        sRect.i16YMin = GrContextDpyHeightGet(&g_sContext) -                        DISPLAY_BANNER_HEIGHT;        sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;        sRect.i16YMax = sRect.i16YMin + DISPLAY_BANNER_HEIGHT - 1;        //        // Draw the background of the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);        GrRectFill(&g_sContext, &sRect);        //        // Put a white box around the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_FG);        GrRectDraw(&g_sContext, &sRect);    } else {        //        // Fill the bottom rows of the screen with blue to create the status area.        //        sRect.i16XMin = 1;        sRect.i16YMin = GrContextDpyHeightGet(&g_sContext) -                        DISPLAY_BANNER_HEIGHT + 1;        sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 2;        sRect.i16YMax = sRect.i16YMin + DISPLAY_BANNER_HEIGHT - 3;        //        // Draw the background of the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);        GrRectFill(&g_sContext, &sRect);        //        // White text in the banner.        //        GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_FG);    }    //    // Write the current state to the left of the status area.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    //    // Update the status on the screen.    //    if(pcString != 0) {        GrStringDrawCentered(&g_sContext, pcString,                             -1, GrContextDpyWidthGet(&g_sContext) / 2,                             58, 1);    }}

//.........这里部分代码省略.........    GrPixelDraw(&g_sContext, 32, 30);    GrLineDraw(&g_sContext, 35, 35, 90, 90);    GrLineDraw(&g_sContext, 5, 80, 80, 20);    GrLineDraw(&g_sContext,                0,                GrContextDpyHeightGet(&g_sContext) - 1,                GrContextDpyWidthGet(&g_sContext) - 1,                GrContextDpyHeightGet(&g_sContext) - 1);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Draw circles on the display    GrStringDraw(&g_sContext,                  "Draw Circles",                  AUTO_STRING_LENGTH,                  10,                  5,                  TRANSPARENT_TEXT);    GrCircleDraw(&g_sContext, 30, 70, 20);    GrCircleFill(&g_sContext, 60, 50, 30);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Draw rectangles on the display    GrStringDrawCentered(&g_sContext,                          "Draw Rectangles",                          AUTO_STRING_LENGTH,                          48,                          5,                          TRANSPARENT_TEXT);    GrRectDraw(&g_sContext, &myRectangle1);    GrRectFill(&g_sContext, &myRectangle2);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);    // Combining Primitive screen    GrStringDrawCentered(&g_sContext,                          "Combining",                          AUTO_STRING_LENGTH,                          48,                          15,                          TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "Primitives to",                          AUTO_STRING_LENGTH,                          48,                          35,                          TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "create menus",                          AUTO_STRING_LENGTH,                          48,                          51,                          TRANSPARENT_TEXT);    GrStringDrawCentered(&g_sContext,                          "and animations",                          AUTO_STRING_LENGTH,                          48,                          75,                          TRANSPARENT_TEXT);    GrFlush(&g_sContext);    Delay_long();    GrClearDisplay(&g_sContext);

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    unsigned int ulTxCount;    unsigned int ulRxCount;	tRectangle sRect;	char pcBuffer[16];	unsigned int i;	unsigned char *src, *dest;	    MMUConfigAndEnable();			//	// USB module clock enable	//	USB0ModuleClkConfig();	//	//USB interrupt enable	//		USBInterruptEnable();	//	//LCD back light enable	//	LCDBackLightEnable();	// UPD Pin setup	//	//	UPDNPinControl();	//	//Delay timer setup	//	DelayTimerSetup();	//	//Configures raster to display image 	//	SetUpLCD();	    RasterDMAFBConfig(SOC_LCDC_0_REGS, 					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET),					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 -					  PALETTE_OFFSET, FRAME_BUFFER_0);	RasterDMAFBConfig(SOC_LCDC_0_REGS, 					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET),					  (unsigned int)(g_pucBuffer+PALETTE_OFFSET) + sizeof(g_pucBuffer) - 2 - 					  PALETTE_OFFSET, FRAME_BUFFER_1);	src = (unsigned char *) palette_32b;	dest = (unsigned char *) (g_pucBuffer+PALETTE_OFFSET);	// Copy palette info into buffer	for( i = PALETTE_OFFSET; i < (PALETTE_SIZE+PALETTE_OFFSET); i++)	{		*dest++ = *src++;	}			GrOffScreen24BPPInit(&g_s35_800x480x24Display, g_pucBuffer, LCD_WIDTH, LCD_HEIGHT);		// Initialize a drawing context.	GrContextInit(&g_sContext, &g_s35_800x480x24Display);	/* enable End of frame interrupt */	RasterEndOfFrameIntEnable(SOC_LCDC_0_REGS);	/* enable raster */	RasterEnable(SOC_LCDC_0_REGS);		 //    // Fill the top 15 rows of the screen with blue to create the banner.    //  	sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //  	GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, &g_sFontCm20);    GrStringDrawCentered(&g_sContext, "usb-dev-bulk", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);//.........这里部分代码省略.........

//.........这里部分代码省略.........    //    lX = (pWidget->sPosition.sXMin +          ((pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1) / 2));    lY = (pWidget->sPosition.sYMin +          ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin + 1) / 2));    //    // Get the required clipping rectangle for the active/value part of    // the slider.    //    bIntersect = GrRectIntersectGet(&sClipRect, &sValueRect, &sActiveClip);    //    // Does any part of the value rectangle intersect with the region we are    // supposed to be redrawing?    //    if(bIntersect)    {        //        // Yes - we have something to draw.        //        //        // Set the new clipping rectangle.        //        GrContextClipRegionSet(&sCtx, &sActiveClip);        //        // Do we need to fill the active area with a color?        //        if(pSlider->ulStyle & SL_STYLE_FILL)        {            GrContextForegroundSet(&sCtx, pSlider->ulFillColor);            GrRectFill(&sCtx, &sValueRect);        }        //        // Do we need to draw an image in the active area?        //        if(pSlider->ulStyle & SL_STYLE_IMG)        {            GrContextForegroundSet(&sCtx, pSlider->ulTextColor);            GrContextBackgroundSet(&sCtx, pSlider->ulFillColor);            GrImageDraw(&sCtx, pSlider->pucImage,                        lX - (GrImageWidthGet(pSlider->pucImage) / 2),                        lY - (GrImageHeightGet(pSlider->pucImage) / 2));        }        //        // Do we need to render a text string over the top of the active area?        //        if(pSlider->ulStyle & SL_STYLE_TEXT)        {            GrContextFontSet(&sCtx, pSlider->pFont);            GrContextForegroundSet(&sCtx, pSlider->ulTextColor);            GrContextBackgroundSet(&sCtx, pSlider->ulFillColor);            GrStringDrawCentered(&sCtx, pSlider->pcText, -1, lX, lY,                                 pSlider->ulStyle & SL_STYLE_TEXT_OPAQUE);        }    }    //    // Now get the required clipping rectangle for the background portion of    // the slider.    //    bIntersect = GrRectIntersectGet(&sClipRect, &sEmptyRect, &sActiveClip);

//*****************************************************************************////! Draws a radio button widget.//!//! /param psWidget is a pointer to the radio button widget to be drawn.//! /param bClick is a boolean that is /b true if the paint request is a result//! of a pointer click and /b false if not.//!//! This function draws a radio button widget on the display.  This is called//! in response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidRadioButtonPaint(tWidget *psWidget, uint32_t bClick){    tRadioButtonWidget *pRadio;    tContext sCtx;    int32_t i32X, i32Y;    //    // Check the arguments.    //    ASSERT(psWidget);    //    // Convert the generic widget pointer into a radio button widget pointer.    //    pRadio = (tRadioButtonWidget *)psWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, psWidget->psDisplay);    //    // Initialize the clipping region based on the extents of this radio    // button.    //    GrContextClipRegionSet(&sCtx, &(psWidget->sPosition));    //    // See if the radio button fill style is selected.    //    if((pRadio->ui16Style & RB_STYLE_FILL) && !bClick)    {        //        // Fill the radio button with the fill color.        //        GrContextForegroundSet(&sCtx, pRadio->ui32FillColor);        GrRectFill(&sCtx, &(psWidget->sPosition));    }    //    // See if the radio button outline style is selected.    //    if((pRadio->ui16Style & RB_STYLE_OUTLINE) && !bClick)    {        //        // Outline the radio button with the outline color.        //        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);        GrRectDraw(&sCtx, &(psWidget->sPosition));    }    //    // Draw the radio button.    //    i32X = psWidget->sPosition.i16XMin + (pRadio->ui16CircleSize / 2) + 2;    i32Y = (psWidget->sPosition.i16YMin +            ((psWidget->sPosition.i16YMax - psWidget->sPosition.i16YMin) / 2));    if(!bClick)    {        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);        GrCircleDraw(&sCtx, i32X, i32Y, pRadio->ui16CircleSize / 2);    }    //    // Select the foreground color based on whether or not the radio button is    // selected.    //    if(pRadio->ui16Style & RB_STYLE_SELECTED)    {        GrContextForegroundSet(&sCtx, pRadio->ui32OutlineColor);    }    else    {        GrContextForegroundSet(&sCtx, pRadio->ui32FillColor);    }    //    // Fill in the radio button.    //    GrCircleFill(&sCtx, i32X, i32Y, (pRadio->ui16CircleSize / 2) - 2);    //    // See if the radio button text or image style is selected.    //    if((pRadio->ui16Style & (RB_STYLE_TEXT | RB_STYLE_IMG)) && !bClick)//.........这里部分代码省略.........

//*****************************************************************************////! Draws a check box widget.//!//! /param pWidget is a pointer to the check box widget to be drawn.//! /param bClick is a boolean that is /b true if the paint request is a result//! of a pointer click and /b false if not.//!//! This function draws a check box widget on the display.  This is called in//! response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidCheckBoxPaint(tWidget *pWidget, unsigned long bClick){    tCheckBoxWidget *pCheck;    tRectangle sRect;    tContext sCtx;    long lY;    //    // Check the arguments.    //    ASSERT(pWidget);    //    // Convert the generic widget pointer into a check box widget pointer.    //    pCheck = (tCheckBoxWidget *)pWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, pWidget->pDisplay);    //    // Initialize the clipping region based on the extents of this check box.    //    GrContextClipRegionSet(&sCtx, &(pWidget->sPosition));    //    // See if the check box fill style is selected.    //    if((pCheck->usStyle & CB_STYLE_FILL) && !bClick)    {        //        // Fill the check box with the fill color.        //        GrContextForegroundSet(&sCtx, pCheck->ulFillColor);        GrRectFill(&sCtx, &(pWidget->sPosition));    }    //    // See if the check box outline style is selected.    //    if((pCheck->usStyle & CB_STYLE_OUTLINE) && !bClick)    {        //        // Outline the check box with the outline color.        //        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);        GrRectDraw(&sCtx, &(pWidget->sPosition));    }    //    // Draw the check box.    //    sRect.sXMin = pWidget->sPosition.sXMin + 2;    sRect.sYMin = (pWidget->sPosition.sYMin +                   ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin -                     pCheck->usBoxSize + 1) / 2));    sRect.sXMax = sRect.sXMin + pCheck->usBoxSize - 1;    sRect.sYMax = sRect.sYMin + pCheck->usBoxSize - 1;    if(!bClick)    {        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);        GrRectDraw(&sCtx, &sRect);    }    //    // Select the foreground color based on whether or not the check box is    // selected.    //    if(pCheck->usStyle & CB_STYLE_SELECTED)    {        GrContextForegroundSet(&sCtx, pCheck->ulOutlineColor);    }    else    {        GrContextForegroundSet(&sCtx, pCheck->ulFillColor);    }    //    // Draw an "X" in the check box.    //    GrLineDraw(&sCtx, sRect.sXMin + 1, sRect.sYMin + 1, sRect.sXMax - 1,               sRect.sYMax - 1);    GrLineDraw(&sCtx, sRect.sXMin + 1, sRect.sYMax - 1, sRect.sXMax - 1,//.........这里部分代码省略.........

//*****************************************************************************//// This function prints the character out the UART and into the text area of// the screen.//// /param ucChar is the character to print out.//// This function handles all of the detail of printing a character to both the// UART and to the text area of the screen on the evaluation board.  The text// area of the screen will be cleared any time the text goes beyond the end// of the text area.//// /return None.////*****************************************************************************voidPrintChar(const char ucChar){    tRectangle sRect;    //    // If both the line and column have gone to zero then clear the screen.    //    if((g_ulLine == 0) && (g_ulColumn == 0))    {        //        // Form the rectangle that makes up the text box.        //        sRect.sXMin = 0;        sRect.sYMin = DISPLAY_BANNER_HEIGHT + DISPLAY_TEXT_BORDER;        sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - DISPLAY_TEXT_BORDER;        sRect.sYMax = GrContextDpyHeightGet(&g_sContext) -                      DISPLAY_BANNER_HEIGHT - DISPLAY_TEXT_BORDER;        //        // Change the foreground color to black and draw black rectangle to        // clear the screen.        //        GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_BG);        GrRectFill(&g_sContext, &sRect);        //        // Reset the foreground color to the text color.        //        GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG);    }    //    // Send the character to the UART.    //    UARTprintf("%c", ucChar);    //    // Allow new lines to cause the column to go back to zero.    //    if(ucChar != '/n')    {        //        // Print the character to the screen.        //        GrStringDraw(&g_sContext, &ucChar, 1,                     GrFontMaxWidthGet(g_pFontFixed6x8) * g_ulColumn,                     DISPLAY_BANNER_HEIGHT + DISPLAY_TEXT_BORDER +                     (g_ulLine * GrFontHeightGet(g_pFontFixed6x8)), 0);    }    else    {        //        // This will allow the code below to properly handle the new line.        //        g_ulColumn = g_ulCharsPerLine;    }    //    // Update the text row and column that the next character will use.    //    if(g_ulColumn < g_ulCharsPerLine)    {        //        // No line wrap yet so move one column over.        //        g_ulColumn++;    }    else    {        //        // Line wrapped so go back to the first column and update the line.        //        g_ulColumn = 0;        g_ulLine++;        //        // The line has gone past the end so go back to the first line.        //        if(g_ulLine >= g_ulLinesPerScreen)        {            g_ulLine = 0;        }    }}

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    unsigned long ulTxCount;    unsigned long ulRxCount;    tRectangle sRect;    char pcBuffer[16];    //    // Set the clocking to run from the PLL at 50MHz    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_8MHZ);#ifdef DEBUG    //    // Configure the relevant pins such that UART0 owns them.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Open UART0 for debug output.    //    UARTStdioInit(0);#endif    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Initialize the display driver.    //    Formike128x128x16Init();    //    // Turn on the backlight.    //    Formike128x128x16BacklightOn();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sFormike128x128x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 14;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb_dev_bulk", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);    //    // Show the various static text elements on the color STN display.    //    GrContextFontSet(&g_sContext, TEXT_FONT);    GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 70, false);    GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 90, false);    //    // Configure the USB mux on the board to put us in device mode.  We pull    // the relevant pin high to do this.    //    ROM_SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);    ROM_GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);    ROM_GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_DEVICE);    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(SysCtlClockGet() / SYSTICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Show the application name on the display and UART output.    ////.........这里部分代码省略.........

//*****************************************************************************//// This is the main loop that runs the application.////*****************************************************************************intmain(void){    tRectangle sRect;    //    // Set the clocking to run directly from the crystal.    //    SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                   SYSCTL_XTAL_8MHZ);    //    // Enable the peripherals used by this example.    //    SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);    //    // Configure the relevant pins such that UART0 owns them.    //    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Open UART0 for debug output.    //    UARTStdioInit(0);    //    // Enable the USB mux GPIO.    //    SysCtlPeripheralEnable(USB_MUX_GPIO_PERIPH);    //    // The LM3S3748 board uses a USB mux that must be switched to use the    // host connector and not the device connector.    //    GPIOPinTypeGPIOOutput(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN);    GPIOPinWrite(USB_MUX_GPIO_BASE, USB_MUX_GPIO_PIN, USB_MUX_SEL_HOST);    //    // Configure the power pins for host controller.    //    GPIOPinTypeUSBDigital(GPIO_PORTH_BASE, GPIO_PIN_3 | GPIO_PIN_4);    //    // Initialize the display driver.    //    Formike128x128x16Init();    //    // Turn on the backlight.    //    Formike128x128x16BacklightOn();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sFormike128x128x16);    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = DISPLAY_BANNER_HEIGHT;    GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb_host_keyboard", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 7, 0);    //    // Calculate the number of characters that will fit on a line.    // Make sure to leave a small border for the text box.    //    g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) /                        GrFontMaxWidthGet(g_pFontFixed6x8);    //    // Calculate the number of lines per usable text screen.  This requires    // taking off space for the top and bottom banners and adding a small bit    // for a border.    ////.........这里部分代码省略.........

//*****************************************************************************//// Performs calibration of the touch screen.////*****************************************************************************intmain(void){    int32_t i32Idx, i32X1, i32Y1, i32X2, i32Y2, i32Count, ppi32Points[3][4];    uint32_t ui32SysClock;    char pcBuffer[32];    tContext sContext;    tRectangle sRect;    //    // 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 graphics context.    //    GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);    //    // Draw the application frame.    //    FrameDraw(&sContext, "calibrate");    //    // Print the instructions across the middle of the screen in white with a    // 20 point small-caps font.    //    GrContextForegroundSet(&sContext, ClrWhite);    GrContextFontSet(&sContext, g_psFontCmsc20);    GrStringDrawCentered(&sContext, "Touch the box", -1,                         GrContextDpyWidthGet(&sContext) / 2,                         (GrContextDpyHeightGet(&sContext) / 2) - 10, 0);    //    // Set the points used for calibration based on the size of the screen.    //    ppi32Points[0][0] = GrContextDpyWidthGet(&sContext) / 10;    ppi32Points[0][1] = (GrContextDpyHeightGet(&sContext) * 2) / 10;    ppi32Points[1][0] = GrContextDpyWidthGet(&sContext) / 2;    ppi32Points[1][1] = (GrContextDpyHeightGet(&sContext) * 9) / 10;    ppi32Points[2][0] = (GrContextDpyWidthGet(&sContext) * 9) / 10;    ppi32Points[2][1] = GrContextDpyHeightGet(&sContext) / 2;    //    // Initialize the touch screen driver.    //    TouchScreenInit(ui32SysClock);    //    // Loop through the calibration points.    //    for(i32Idx = 0; i32Idx < 3; i32Idx++)    {        //        // Fill a white box around the calibration point.        //        GrContextForegroundSet(&sContext, ClrWhite);        sRect.i16XMin = ppi32Points[i32Idx][0] - 5;        sRect.i16YMin = ppi32Points[i32Idx][1] - 5;        sRect.i16XMax = ppi32Points[i32Idx][0] + 5;        sRect.i16YMax = ppi32Points[i32Idx][1] + 5;        GrRectFill(&sContext, &sRect);        //        // Flush any cached drawing operations.        //        GrFlush(&sContext);        //        // Initialize the raw sample accumulators and the sample count.        //        i32X1 = 0;        i32Y1 = 0;        i32Count = -5;        //        // Loop forever.  This loop is explicitly broken out of when the pen is        // lifted.        //        while(1)        {            ////.........这里部分代码省略.........

//*****************************************************************************//// This example demonstrates how to use the uDMA controller to transfer data// between memory buffers and to and from a peripheral, in this case a UART.// The uDMA controller is configured to repeatedly transfer a block of data// from one memory buffer to another.  It is also set up to repeatedly copy a// block of data from a buffer to the UART output.  The UART data is looped// back so the same data is received, and the uDMA controlled is configured to// continuously receive the UART data using ping-pong buffers.//// The processor is put to sleep when it is not doing anything, and this allows// collection of CPU usage data to see how much CPU is being used while the// data transfers are ongoing.////*****************************************************************************intmain(void){    static unsigned long ulPrevSeconds;    static unsigned long ulPrevXferCount;    static unsigned long ulPrevUARTCount = 0;    static char cStrBuf[40];    tRectangle sRect;    unsigned long ulCenterX;    unsigned long ulXfersCompleted;    unsigned long ulBytesTransferred;    //    // Set the clocking to run from the PLL at 50 MHz.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Set the device pinout appropriately for this board.    //    PinoutSet();    //    // Enable peripherals to operate when CPU is in sleep.    //    ROM_SysCtlPeripheralClockGating(true);    //    // Initialize the display driver.    //    Kitronix320x240x16_SSD2119Init();    //    // Initialize the graphics context and find the middle X coordinate.    //    GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);    //    // Get the center X coordinate of the screen, since it is used a lot.    //    ulCenterX = GrContextDpyWidthGet(&g_sContext) / 2;    //    // Fill the top 15 rows of the screen with blue to create the banner.    //    sRect.sXMin = 0;    sRect.sYMin = 0;    sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - 1;    sRect.sYMax = 23;    GrContextForegroundSet(&g_sContext, ClrDarkBlue);    GrRectFill(&g_sContext, &sRect);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontCm20);    GrStringDrawCentered(&g_sContext, "udma-demo", -1, ulCenterX, 11, 0);    //    // Show the clock frequency on the display.    //    GrContextFontSet(&g_sContext, g_pFontCmss18b);    usnprintf(cStrBuf, sizeof(cStrBuf), "Stellaris @ %u MHz",              SysCtlClockGet() / 1000000);    GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 40, 0);    //    // Show static text and field labels on the display.    //    GrStringDrawCentered(&g_sContext, "uDMA Mem Transfers", -1,                         ulCenterX, 62, 0);    GrStringDrawCentered(&g_sContext, "uDMA UART Transfers", -1,                         ulCenterX, 84, 0);    //    // Configure SysTick to occur 100 times per second, to use as a time    // reference.  Enable SysTick to generate interrupts.    ////.........这里部分代码省略.........

//*****************************************************************************//// This function prints the character out the UART and into the text area of// the screen.//// /param ucChar is the character to print out.//// This function handles all of the detail of printing a character to both the// UART and to the text area of the screen on the evaluation board.  The text// area of the screen will be cleared any time the text goes beyond the end// of the text area.//// /return None.////*****************************************************************************voidPrintChar(const char ucChar){    tRectangle sRect;    //    // If both the line and column have gone to zero then clear the screen.    //    if((g_ulLine == 0) && (g_ulColumn == 0))    {        //        // Form the rectangle that makes up the text box.        //        sRect.sXMin = 0;        sRect.sYMin = (2 * DISPLAY_BANNER_HEIGHT) + DISPLAY_TEXT_BORDER;        sRect.sXMax = GrContextDpyWidthGet(&g_sContext) - DISPLAY_TEXT_BORDER;        sRect.sYMax = GrContextDpyHeightGet(&g_sContext) -                      DISPLAY_BANNER_HEIGHT - DISPLAY_TEXT_BORDER;        //        // Change the foreground color to black and draw black rectangle to        // clear the screen.        //        GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_BG);        GrRectFill(&g_sContext, &sRect);        //        // Reset the foreground color to the text color.        //        GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG);    }    //    // Send the character to the UART.    //    UARTprintf("%c", ucChar);    //    // Allow new lines to cause the column to go back to zero.    //    if(ucChar != '/n')    {        //        // Did we get a backspace character?        //        if(ucChar != ASCII_BACKSPACE)        {            //            // This is not a backspace so print the character to the screen.            //            GrStringDraw(&g_sContext, &ucChar, 1,                         GrFontMaxWidthGet(g_pFontFixed6x8) * g_ulColumn,                         (2 * DISPLAY_BANNER_HEIGHT) + DISPLAY_TEXT_BORDER +                         (g_ulLine * GrFontHeightGet(g_pFontFixed6x8)), 0);        }        else        {            //            // We got a backspace.  If we are at the top left of the screen,            // return since we don't need to do anything.            //            if(g_ulColumn || g_ulLine)            {                //                // Adjust the cursor position to erase the last character.                //                if(g_ulColumn)                {                    g_ulColumn--;                }                else                {                    g_ulColumn = g_ulCharsPerLine;                    g_ulLine--;                }                //                // Print a space at this position then return without fixing up                // the cursor again.                //                GrStringDraw(&g_sContext, " ", 1,                             GrFontMaxWidthGet(g_pFontFixed6x8) * g_ulColumn,                             (2 * DISPLAY_BANNER_HEIGHT) + DISPLAY_TEXT_BORDER +                             (g_ulLine * GrFontHeightGet(g_pFontFixed6x8)),                             true);//.........这里部分代码省略.........

//*****************************************************************************//// Demonstrate the use of the USB stick update example.////*****************************************************************************intmain(void){    unsigned long ulCount;    tContext sContext;    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 system clock to run at 50MHz from the PLL.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sCFAL96x64x16);    //    // Fill the top 24 rows 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);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&sContext, ClrWhite);    GrRectDraw(&sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&sContext, g_pFontFixed6x8);    GrStringDrawCentered(&sContext, "usb-stick-demo", -1,                         GrContextDpyWidthGet(&sContext) / 2, 4, 0);    //    // Indicate what is happening.    //    GrStringDrawCentered(&sContext, "Press the", -1,                         GrContextDpyWidthGet(&sContext) / 2, 20, 0);    GrStringDrawCentered(&sContext, "select button to", -1,                         GrContextDpyWidthGet(&sContext) / 2, 30, 0);    GrStringDrawCentered(&sContext, "start the USB", -1,                         GrContextDpyWidthGet(&sContext) / 2, 40, 0);    GrStringDrawCentered(&sContext, "stick updater.", -1,                         GrContextDpyWidthGet(&sContext) / 2, 50, 0);    //    // Flush any cached drawing operations.    //    GrFlush(&sContext);    //    // Enable the GPIO module which the select button is attached to.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOM);    //    // Enable the GPIO pin to read the user button.    //    ROM_GPIODirModeSet(GPIO_PORTM_BASE, GPIO_PIN_4, GPIO_DIR_MODE_IN);    ROM_GPIOPadConfigSet(GPIO_PORTM_BASE, GPIO_PIN_4, GPIO_STRENGTH_2MA,                         GPIO_PIN_TYPE_STD_WPU);    //    // Wait for the pullup to take effect or the next loop will exist too soon.    //    SysCtlDelay(1000);    //    // Wait until the select button has been pressed for ~40ms (in order to    // debounce the press).    //    ulCount = 0;    while(1)    {        ////.........这里部分代码省略.........

//.........这里部分代码省略.........    g_ulKeyboardInstance = USBHKeyboardOpen(KeyboardCallback, g_pucBuffer,                                            KEYBOARD_MEMORY_SIZE);    //    // 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 OTG operation with a 2ms polling    // rate.    //    USBOTGModeInit(0, 2000, g_pHCDPool, HCD_MEMORY_SIZE);    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_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(&g_sContext) - 1;    sRect.sYMax = (2 * DISPLAY_BANNER_HEIGHT) - 1;    GrContextForegroundSet(&g_sContext, DISPLAY_BANNER_BG);    GrRectFill(&g_sContext, &sRect);    //    // Change foreground for white text.    //    GrContextForegroundSet(&g_sContext, DISPLAY_TEXT_FG);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_pFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb-host-", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    GrStringDrawCentered(&g_sContext, "keyboard", -1,                             GrContextDpyWidthGet(&g_sContext) / 2, 14, 0);    //    // Calculate the number of characters that will fit on a line.    // Make sure to leave a small border for the text box.    //    g_ulCharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 4) /                        GrFontMaxWidthGet(g_pFontFixed6x8);    //    // Calculate the number of lines per usable text screen.  This requires    // taking off space for the top and bottom banners and adding a small bit    // for a border.    //    g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -                          (3*(DISPLAY_BANNER_HEIGHT + 1)))/                          GrFontHeightGet(g_pFontFixed6x8);

//*****************************************************************************////! Paints the clock set widget on the display.//!//! /param psWidget is a pointer to the clock setting widget to be drawn.//!//! This function draws the date and time fields of the clock setting widget//! onto the display.  One of the fields can be highlighted.  This is//! called in response to a /b WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidClockSetPaint(tWidget *psWidget){    tClockSetWidget *psClockWidget;    tContext sContext;    tRectangle sRect, sRectSel;    struct tm *psTime;    char pcBuf[8];    int32_t i32X, i32Y, i32Width, i32Height;    uint32_t ui32Idx, ui32FontHeight, ui32FontWidth, ui32SelWidth;    //    // Check the arguments.    //    ASSERT(psWidget);    ASSERT(psWidget->psDisplay);    //    // Convert the generic widget pointer into a clock set widget pointer.    //    psClockWidget = (tClockSetWidget *)psWidget;    ASSERT(psClockWidget->psTime);    //    // Get pointer to the time structure    //    psTime = psClockWidget->psTime;    //    // Initialize a drawing context.    //    GrContextInit(&sContext, psWidget->psDisplay);    //    // Initialize the clipping region based on the extents of this widget.    //    GrContextClipRegionSet(&sContext, &(psWidget->sPosition));    //    // Set the font for the context, and get font height and width - they    // are used a lot later.    //    GrContextFontSet(&sContext, psClockWidget->psFont);    ui32FontHeight = GrFontHeightGet(psClockWidget->psFont);    ui32FontWidth = GrFontMaxWidthGet(psClockWidget->psFont);    //    // Fill the widget with the background color.    //    GrContextForegroundSet(&sContext, psClockWidget->ui32BackgroundColor);    GrRectFill(&sContext, &sContext.sClipRegion);    //    // Draw a border around the widget    //    GrContextForegroundSet(&sContext, psClockWidget->ui32ForegroundColor);    GrContextBackgroundSet(&sContext, psClockWidget->ui32BackgroundColor);    GrRectDraw(&sContext, &sContext.sClipRegion);    //    // Compute a rectangle for the screen title.  Put it at the top of    // the widget display, and sized to be the height of the font, plus    // a few pixels of space.    //    sRect.i16XMin = sContext.sClipRegion.i16XMin;    sRect.i16XMax = sContext.sClipRegion.i16XMax;    sRect.i16YMin = sContext.sClipRegion.i16YMin;    sRect.i16YMax = ui32FontHeight * 2;    GrRectDraw(&sContext, &sRect);    //    // Print a title for the widget    //    GrContextFontSet(&sContext, psClockWidget->psFont);    GrStringDrawCentered(&sContext, "CLOCK SET", -1,                         (1 + sRect.i16XMax - sRect.i16XMin) / 2,                         (1 + sRect.i16YMax - sRect.i16YMin) / 2, 1);    //    // Reset the rectangle to cover the non-title area of the display    //    sRect.i16YMin = sRect.i16YMax + 1;    sRect.i16YMax = sContext.sClipRegion.i16YMax;    //    // Compute the width and height of the area remaining for showing the    // clock fields.//.........这里部分代码省略.........

//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void){    uint32_t ui32TxCount;    uint32_t ui32RxCount;    tRectangle sRect;    char pcBuffer[16];    uint32_t ui32Fullness;    //    // 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;    }    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Initialize the display driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&g_sContext, &g_sCFAL96x64x16);    //    // Fill the top 15 rows 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);    //    // Put a white box around the banner.    //    GrContextForegroundSet(&g_sContext, ClrWhite);    GrRectDraw(&g_sContext, &sRect);    //    // Put the application name in the middle of the banner.    //    GrContextFontSet(&g_sContext, g_psFontFixed6x8);    GrStringDrawCentered(&g_sContext, "usb-dev-serial", -1,                         GrContextDpyWidthGet(&g_sContext) / 2, 4, 0);    //    // Show the various static text elements on the color STN display.    //    GrStringDraw(&g_sContext, "Tx #",-1, 0, 12, false);    GrStringDraw(&g_sContext, "Tx buf", -1, 0, 22, false);    GrStringDraw(&g_sContext, "Rx #", -1, 0, 32, false);    GrStringDraw(&g_sContext, "Rx buf", -1, 0, 42, false);    DrawBufferMeter(&g_sContext, 40, 22);    DrawBufferMeter(&g_sContext, 40, 42);    //    // Enable the UART that we will be redirecting.    //    ROM_SysCtlPeripheralEnable(USB_UART_PERIPH);    ////.........这里部分代码省略.........

//*****************************************************************************////! Draws an image button.//!//! /param pWidget is a pointer to the image button widget to be drawn.//!//! This function draws a rectangular image button on the display.  This is//! called in response to a /b #WIDGET_MSG_PAINT message.//!//! /return None.////*****************************************************************************static voidImageButtonPaint(tWidget *pWidget){    const unsigned char *pucImage;    tImageButtonWidget *pPush;    tContext sCtx;    long lX, lY;    //    // Check the arguments.    //    ASSERT(pWidget);    //    // Convert the generic widget pointer into a image button widget pointer.    //    pPush = (tImageButtonWidget *)pWidget;    //    // Initialize a drawing context.    //    GrContextInit(&sCtx, pWidget->pDisplay);    //    // Initialize the clipping region based on the extents of this rectangular    // image button.    //    GrContextClipRegionSet(&sCtx, &(pWidget->sPosition));    //    // Compute the center of the image button.    //    lX = (pWidget->sPosition.sXMin +          ((pWidget->sPosition.sXMax - pWidget->sPosition.sXMin + 1) / 2));    lY = (pWidget->sPosition.sYMin +          ((pWidget->sPosition.sYMax - pWidget->sPosition.sYMin + 1) / 2));    //    // Do we need to fill the widget background with a color?    //    if(pPush->ulStyle & IB_STYLE_FILL)    {        //        // Yes. Set the appropriate color depending upon whether or not        // the widget is currently pressed.        //        GrContextForegroundSet(&sCtx,                               ((pPush->ulStyle & IB_STYLE_PRESSED) ?                                pPush->ulPressedColor :                                pPush->ulBackgroundColor));        GrRectFill(&sCtx, &(pWidget->sPosition));    }    //    // Set the foreground and background colors to use for 1 BPP    // images and text    //    GrContextForegroundSet(&sCtx, pPush->ulForegroundColor);    GrContextBackgroundSet(&sCtx,                           ((pPush->ulStyle & IB_STYLE_PRESSED) ?                            pPush->ulPressedColor :                            pPush->ulBackgroundColor));    //    // Do we need to draw the background image?    //    if(!(pPush->ulStyle & IB_STYLE_IMAGE_OFF))    {        //        // Get the background image to be drawn.        //        pucImage = ((pPush->ulStyle & IB_STYLE_PRESSED) ?                    pPush->pucPressImage : pPush->pucImage);        //        // Draw the image centered in the image button.        //        GrImageDraw(&sCtx, pucImage, lX - (GrImageWidthGet(pucImage) / 2),                    lY - (GrImageHeightGet(pucImage) / 2));    }    //    // Adjust the drawing position if the button is pressed.    //    lX += ((pPush->ulStyle & IB_STYLE_PRESSED) ? pPush->sXOffset : 0);    lY += ((pPush->ulStyle & IB_STYLE_PRESSED) ? pPush->sYOffset : 0);    ////.........这里部分代码省略.........

//*****************************************************************************//// This example demonstrates how to send a string of data to the UART.////*****************************************************************************intmain(void){    tRectangle sRect;    tContext sContext;    //    // 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 driver.    //    CFAL96x64x16Init();    //    // Initialize the graphics context.    //    GrContextInit(&sContext, &g_sCFAL96x64x16);    //    // 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, "uart-echo", -1,                         GrContextDpyWidthGet(&sContext) / 2, 4, 0);    //    // Initialize the display and write some instructions.    //    GrStringDrawCentered(&sContext, "Connect a", -1,                         GrContextDpyWidthGet(&sContext) / 2, 20, false);    GrStringDrawCentered(&sContext, "terminal", -1,                         GrContextDpyWidthGet(&sContext) / 2, 30, false);    GrStringDrawCentered(&sContext, "to UART0.", -1,                         GrContextDpyWidthGet(&sContext) / 2, 40, false);    GrStringDrawCentered(&sContext, "115000,N,8,1", -1,                         GrContextDpyWidthGet(&sContext) / 2, 50, false);    //    // Enable the peripherals used by this example.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);    //    // Enable processor interrupts.    //    ROM_IntMasterEnable();    //    // Set GPIO A0 and A1 as UART pins.    //    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Configure the UART for 115,200, 8-N-1 operation.    //    ROM_UARTConfigSetExpClk(UART0_BASE, ROM_SysCtlClockGet(), 115200,                            (UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |                             UART_CONFIG_PAR_NONE));    //    // Enable the UART interrupt.    //    ROM_IntEnable(INT_UART0);    ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);    //    // Prompt for text to be entered.    ////.........这里部分代码省略.........

//*****************************************************************************//// This example demonstrates how to send a string of data to the UART.////*****************************************************************************intmain(void){    tRectangle sRect;    tContext sContext;    //    // Set the clocking to run at 50 MHz from the PLL.    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);        //    // 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, "softuart-echo", -1,                         GrContextDpyWidthGet(&sContext) / 2, 4, 0);        //    // Initialize the display and write some instructions.    //    GrStringDrawCentered(&sContext, "Connect a", -1,                         GrContextDpyWidthGet(&sContext) / 2, 20, false);    GrStringDrawCentered(&sContext, "terminal", -1,                         GrContextDpyWidthGet(&sContext) / 2, 30, false);    GrStringDrawCentered(&sContext, "to UART0.", -1,                         GrContextDpyWidthGet(&sContext) / 2, 40, false);    GrStringDrawCentered(&sContext, "115000,N,8,1", -1,                         GrContextDpyWidthGet(&sContext) / 2, 50, false);    //    // Enable the peripherals used by this example.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);    //    // Compute the bit time for 115,200 baud.    //    g_ulBitTime = (ROM_SysCtlClockGet() / 115200) - 1;    //    // Configure the SoftUART for 8-N-1 operation.    //    SoftUARTInit(&g_sUART);    SoftUARTRxGPIOSet(&g_sUART, GPIO_PORTA_BASE, GPIO_PIN_0);    SoftUARTTxGPIOSet(&g_sUART, GPIO_PORTA_BASE, GPIO_PIN_1);    SoftUARTRxBufferSet(&g_sUART, g_pusRxBuffer,                        sizeof(g_pusRxBuffer) / sizeof(g_pusRxBuffer[0]));    SoftUARTTxBufferSet(&g_sUART, g_pucTxBuffer, sizeof(g_pucTxBuffer));    SoftUARTCallbackSet(&g_sUART, SoftUARTIntHandler);    SoftUARTConfigSet(&g_sUART,                      (SOFTUART_CONFIG_WLEN_8 | SOFTUART_CONFIG_STOP_ONE |                       SOFTUART_CONFIG_PAR_NONE));    //    // Configure the timer for the SoftUART transmitter.    //    ROM_TimerConfigure(TIMER0_BASE,                       (TIMER_CFG_SPLIT_PAIR | TIMER_CFG_A_PERIODIC |                        TIMER_CFG_B_PERIODIC));    ROM_TimerLoadSet(TIMER0_BASE, TIMER_A, g_ulBitTime);    ROM_TimerIntEnable(TIMER0_BASE, TIMER_TIMA_TIMEOUT | TIMER_TIMB_TIMEOUT);    ROM_TimerEnable(TIMER0_BASE, TIMER_A);    //    // Set the priorities of the interrupts associated with the SoftUART.  The    // receiver is higher priority than the transmitter, and the receiver edge    // interrupt is higher priority than the receiver timer interrupt.//.........这里部分代码省略.........