//*****************************************************************************
//
// 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.
//
//*****************************************************************************
void
DisplayStatus(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.
//
//*****************************************************************************
void
DisplayStatus(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.
//
//*****************************************************************************
int
main(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.
//
DisplayStatus(&g_sContext, "Configuring USB");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDBulkInit(0, &g_sBulkDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ui32Flags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
g_ui32Flags &= ~COMMAND_STATUS_UPDATE;
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32TxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32TxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, " %d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 48, 32, true);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32RxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32RxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, " %d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 48, 42, true);
}
}
}
//*****************************************************************************
//
//! 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 void
ContainerPaint(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;
//
// Get the position of the vertical center of the text.
//
lY = (pWidget->sPosition.sYMin +
(GrFontBaselineGet(pContainer->pFont) / 2));
//
// Set the color to draw the outline.
//
GrContextForegroundSet(&sCtx, pContainer->ulOutlineColor);
//
// Draw the outline around the container widget, leaving a gap
// where the text reside across the top of the widget.
//
GrLineDraw(&sCtx, lX1, lY, pWidget->sPosition.sXMin, lY);
GrLineDraw(&sCtx, pWidget->sPosition.sXMin, lY,
pWidget->sPosition.sXMin, pWidget->sPosition.sYMax);
GrLineDraw(&sCtx, pWidget->sPosition.sXMin,
pWidget->sPosition.sYMax, pWidget->sPosition.sXMax,
pWidget->sPosition.sYMax);
GrLineDraw(&sCtx, pWidget->sPosition.sXMax,
pWidget->sPosition.sYMax, pWidget->sPosition.sXMax, lY);
GrLineDraw(&sCtx, pWidget->sPosition.sXMax, lY, lX2, lY);
}
}
//
// Otherwise, see if the container outline style is selected.
//
else if(pContainer->ulStyle & CTR_STYLE_OUTLINE)
{
//
// Outline the container with the outline color.
//
GrContextForegroundSet(&sCtx, pContainer->ulOutlineColor);
GrRectDraw(&sCtx, &(pWidget->sPosition));
}
}
//*****************************************************************************
//
// This function updates the status area of the screen. It uses the current
// state of the application to print the status bar.
//
//*****************************************************************************
void
UpdateStatus(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.
//
//*****************************************************************************
int
main(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);
GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 160, false);
GrStringDraw(&g_sContext, "Rx buffer:", -1, 8, 185, false);
DrawBufferMeter(&g_sContext, 150, 105);
DrawBufferMeter(&g_sContext, 150, 185);
//
// Enable the UART that we will be redirecting.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Change the UART clock to the 16 MHz PIOSC.
//
UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
//
// Set the default UART configuration.
//
ROM_UARTConfigSetExpClk(UART0_BASE, UART_CLOCK,
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
ROM_UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
//
// Configure and enable UART interrupts.
//
ROM_UARTIntClear(UART0_BASE, ROM_UARTIntStatus(UART0_BASE, false));
ROM_UARTIntEnable(UART0_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring USB... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Tell the USB library the CPU clock and the PLL frequency. This is a
// new requirement for TM4C129 devices.
//
USBDCDFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
USBDCDFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDCDCInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, " Waiting for host... ");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
g_ui32UARTTxCount = 0;
g_ui32UARTRxCount = 0;
#ifdef DEBUG
g_ui32UARTRxErrors = 0;
#endif
//
// Enable interrupts now that the application is ready to start.
//
ROM_IntEnable(INT_UART0);
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE))
{
//
// Clear the command flag
//
HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 0;
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32UARTTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32UARTTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 150, 80, true);
//
// Update the RX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's receive buffer is the UART's
// transmit buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 105);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32UARTRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 150, 160, true);
//
// Update the TX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's transmit buffer is the UART's
// receive buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 185);
}
}
}
//*****************************************************************************
//
// Handles paint requests for the primitives canvas widget.
//
//*****************************************************************************
void
OnPrimitivePaint(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.
//
//*****************************************************************************
int
main(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.
//
//*****************************************************************************
int
main(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.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDMSCInit(0, &g_sMSCDevice);
//
// Determine whether or not an SDCard is installed. If not, print a
// warning and have the user install one and restart.
//
ui32Retcode = disk_initialize(0);
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
if(ui32Retcode != RES_OK) {
GrStringDrawCentered(&g_sContext, "No SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 16, 0);
GrStringDrawCentered(&g_sContext, "Please insert",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 26, 0);
GrStringDrawCentered(&g_sContext, "a card and",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 36, 0);
GrStringDrawCentered(&g_sContext, "reset the board.",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 46, 0);
} else {
GrStringDrawCentered(&g_sContext, "SDCard Found", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 30, 0);
}
//
// Drop into the main loop.
//
while(1) {
switch(g_eMSCState) {
case MSC_DEV_READ: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Reading", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_WRITE: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Writing", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
//
// If there is no activity then return to the idle state.
//
if(g_ui32IdleTimeout == 0) {
UpdateStatus("Idle", 0);
g_eMSCState = MSC_DEV_IDLE;
}
break;
}
case MSC_DEV_DISCONNECTED: {
//
// Update the screen if necessary.
//
if(g_ui32Flags & FLAG_UPDATE_STATUS) {
UpdateStatus("Disconnected", 0);
g_ui32Flags &= ~FLAG_UPDATE_STATUS;
}
break;
}
case MSC_DEV_IDLE: {
break;
}
default: {
break;
}
}
}
}
//*****************************************************************************
//
// This function updates the status area of the screen. It uses the current
// state of the application to print the status bar.
//
//*****************************************************************************
void
UpdateStatus(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);
}
}
void main(void)
{
// Stop WDT
WDTCTL = WDTPW + WDTHOLD;
// Initialize the boards
boardInit();
clockInit();
timerInit();
flashInit();
__bis_SR_register(GIE);
// Set up the LCD
LCDInit();
GrContextInit(&g_sContext, &g_sharp96x96LCD);
GrContextForegroundSet(&g_sContext, ClrBlack);
GrContextBackgroundSet(&g_sContext, ClrWhite);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
GrClearDisplay(&g_sContext);
GrFlush(&g_sContext);
// Intro Screen
GrStringDrawCentered(&g_sContext,
"How to use",
AUTO_STRING_LENGTH,
48,
15,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"the MSP430",
AUTO_STRING_LENGTH,
48,
35,
TRANSPARENT_TEXT);
GrStringDraw(&g_sContext,
"Graphics Library",
AUTO_STRING_LENGTH,
1,
51,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"Primitives",
AUTO_STRING_LENGTH,
48,
75,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
GrClearDisplay(&g_sContext);
// Draw pixels and lines on the display
GrStringDrawCentered(&g_sContext,
"Draw Pixels",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrStringDrawCentered(&g_sContext,
"& Lines",
AUTO_STRING_LENGTH,
48,
15,
TRANSPARENT_TEXT);
GrPixelDraw(&g_sContext, 30, 30);
GrPixelDraw(&g_sContext, 30, 32);
GrPixelDraw(&g_sContext, 32, 32);
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);
// Draw a Menu screen
GrStringDrawCentered(&g_sContext,
"Create a Menu",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption1);
GrStringDraw(&g_sContext,"Option #1", 10,15,15,TRANSPARENT_TEXT);
GrRectFill(&g_sContext, &myRectangleOption2);
GrStringDraw(&g_sContext,"Option #2", 10,15,25,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption3);
GrStringDraw(&g_sContext,"Option #3", 10,15,35,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption4);
GrStringDraw(&g_sContext,"Option #4", 10,15,45,TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleOption5);
GrStringDraw(&g_sContext,"Option #5", 10,15,55,TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
GrClearDisplay(&g_sContext);
// Show progress bar screen
// The following animation consist on displaying a progress bar and
// updating the progress bar in increments of 25%.
GrStringDrawCentered(&g_sContext,
"Show progress",
AUTO_STRING_LENGTH,
48,
5,
TRANSPARENT_TEXT);
GrRectDraw(&g_sContext, &myRectangleFrame);
GrStringDrawCentered(&g_sContext,
"Processing...",
AUTO_STRING_LENGTH,
48,
75,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_short();
// Update display with 25 %. Initial value of "myRectangleProgress" are set
// to update bar with a 25 % increment.
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 50 %
myRectangleProgress.sXMin = 30;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 50;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 75 %
myRectangleProgress.sXMin = 50;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 70;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrFlush(&g_sContext);
Delay_short();
// Set myRectangleProgress values to update progress bar with 100 %
myRectangleProgress.sXMin = 70;
myRectangleProgress.sYMin = 40;
myRectangleProgress.sXMax = 90;
myRectangleProgress.sYMax = 60;
GrRectFill(&g_sContext, &myRectangleProgress);
GrStringDrawCentered(&g_sContext,
"DONE!",
AUTO_STRING_LENGTH,
48,
85,
TRANSPARENT_TEXT);
GrFlush(&g_sContext);
Delay_long();
while(1);
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(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);
//
// Show the various static text elements on the color STN display.
//
GrContextFontSet(&g_sContext, TEXT_FONT);
GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 100, false);
GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 130, false);
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring USB... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit((tUSBBuffer *)&g_sTxBuffer);
USBBufferInit((tUSBBuffer *)&g_sRxBuffer);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDBulkInit(0, (tUSBDBulkDevice *)&g_sBulkDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host...");
//
// Clear our local byte counters.
//
ulRxCount = 0;
ulTxCount = 0;
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ulFlags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
g_ulFlags &= ~COMMAND_STATUS_UPDATE;
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ulTxCount != g_ulTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ulTxCount = g_ulTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, " %d ", ulTxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 120, 100, true);
}
//
// Has there been any receive traffic since we last checked?
//
if(ulRxCount != g_ulRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ulRxCount = g_ulRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, " %d ", ulRxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 120, 130, true);
}
}
}
//*****************************************************************************
//
//! Draws a slider.
//!
//! \param pWidget is a pointer to the slider widget to be drawn.
//! \param pDirty is the subrectangle of the widget which is to be redrawn.
//! This is expressed in screen coordinates.
//!
//! This function draws a slider on the display. This is called in response to
//! a \b #WIDGET_MSG_PAINT message or when the slider position changes.
//!
//! \return None.
//
//*****************************************************************************
static void
SliderPaint(tWidget *pWidget, tRectangle *pDirty)
{
tRectangle sClipRect, sValueRect, sEmptyRect, sActiveClip;
tSliderWidget *pSlider;
tContext sCtx;
long lX, lY, bIntersect;
short sPos;
//
// Check the arguments.
//
ASSERT(pWidget);
//
// Convert the generic widget pointer into a slider widget pointer.
//
pSlider = (tSliderWidget *)pWidget;
//
// Initialize a drawing context.
//
GrContextInit(&sCtx, pWidget->pDisplay);
//
// Initialize the clipping region based on the update rectangle passed.
//
bIntersect = GrRectIntersectGet(pDirty, &(pSlider->sBase.sPosition),
&sClipRect);
GrContextClipRegionSet(&sCtx, &sClipRect);
//
// Draw the control outline if necessary.
//
if(pSlider->ulStyle & SL_STYLE_OUTLINE)
{
//
// Outline the slider with the outline color.
//
GrContextForegroundSet(&sCtx, pSlider->ulOutlineColor);
GrRectDraw(&sCtx, &(pWidget->sPosition));
//
// Adjust the clipping rectangle to prevent the outline from being
// corrupted later.
//
if(sClipRect.sXMin == pWidget->sPosition.sXMin)
{
sClipRect.sXMin++;
}
if(sClipRect.sYMin == pWidget->sPosition.sYMin)
{
sClipRect.sYMin++;
}
if(sClipRect.sXMax == pWidget->sPosition.sXMax)
{
sClipRect.sXMax--;
}
if(sClipRect.sYMax == pWidget->sPosition.sYMax)
{
sClipRect.sYMax--;
}
}
//
// Determine the position associated with the current slider value.
//
sPos = SliderValueToPosition(pSlider, pSlider->lValue);
//
// Remember this so that the dirty rectangle code in the click handler
// draws the correct thing the first time it is called.
//
pSlider->sPos = sPos;
//
// Determine the rectangles for the active and empty portions of the
// widget.
//
if(pSlider->ulStyle & SL_STYLE_VERTICAL)
{
//
// Determine the rectangle corresponding to the bottom (value) portion
// of the slider.
//
sValueRect.sXMin = pWidget->sPosition.sXMin;
sValueRect.sXMax = pWidget->sPosition.sXMax;
sValueRect.sYMin = sPos;
sValueRect.sYMax = pWidget->sPosition.sYMax;
//
// Determine the rectangle corresponding to the top (empty) portion
// of the slider.
//
sEmptyRect.sXMin = pWidget->sPosition.sXMin;
sEmptyRect.sXMax = pWidget->sPosition.sXMax;
sEmptyRect.sYMin = pWidget->sPosition.sYMin;
sEmptyRect.sYMax = max(sEmptyRect.sYMin, sValueRect.sYMin - 1);
}
else
{
//
// Determine the rectangle corresponding to the bottom (value) portion
// of the slider.
//
sValueRect.sYMin = pWidget->sPosition.sYMin;
sValueRect.sYMax = pWidget->sPosition.sYMax;
sValueRect.sXMin = pWidget->sPosition.sXMin;
sValueRect.sXMax = sPos;
//
// Determine the rectangle corresponding to the top (empty) portion
// of the slider.
//
sEmptyRect.sYMin = pWidget->sPosition.sYMin;
sEmptyRect.sYMax = pWidget->sPosition.sYMax;
sEmptyRect.sXMax = pWidget->sPosition.sXMax;
sEmptyRect.sXMin = min(sEmptyRect.sXMax, sValueRect.sXMax + 1);
}
//
// Compute the center of the slider. This will be needed later if drawing
// text or an image.
//
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);
//
// Does any part of the background 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_BACKG_FILL)
{
GrContextForegroundSet(&sCtx, pSlider->ulBackgroundFillColor);
GrRectFill(&sCtx, &sEmptyRect);
}
//
// Do we need to draw an image in the active area?
//
if(pSlider->ulStyle & SL_STYLE_BACKG_IMG)
{
GrContextForegroundSet(&sCtx, pSlider->ulBackgroundTextColor);
GrContextBackgroundSet(&sCtx, pSlider->ulBackgroundFillColor);
GrImageDraw(&sCtx, pSlider->pucBackgroundImage,
lX - (GrImageWidthGet(pSlider->pucBackgroundImage) / 2),
lY - (GrImageHeightGet(pSlider->pucBackgroundImage) / 2));
}
//
// Do we need to render a text string over the top of the active area?
//
if(pSlider->ulStyle & SL_STYLE_BACKG_TEXT)
{
GrContextFontSet(&sCtx, pSlider->pFont);
GrContextForegroundSet(&sCtx, pSlider->ulBackgroundTextColor);
GrContextBackgroundSet(&sCtx, pSlider->ulBackgroundFillColor);
GrStringDrawCentered(&sCtx, pSlider->pcText, -1, lX, lY,
pSlider->ulStyle & SL_STYLE_BACKG_TEXT_OPAQUE);
}
}
}
//*****************************************************************************
//
//! 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 void
RadioButtonPaint(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)
{
//
// Shrink the clipping region by the size of the radio button so that
// it is not overwritten by further "decorative" portions of the
// widget.
//
sCtx.sClipRegion.i16XMin += pRadio->ui16CircleSize + 4;
//
// If the radio button outline style is selected then shrink the
// clipping region by one pixel on each side so that the outline is not
// overwritten by the text or image.
//
if(pRadio->ui16Style & RB_STYLE_OUTLINE)
{
sCtx.sClipRegion.i16YMin++;
sCtx.sClipRegion.i16XMax--;
sCtx.sClipRegion.i16YMax--;
}
//
// See if the radio button image style is selected.
//
if(pRadio->ui16Style & RB_STYLE_IMG)
{
//
// Determine where along the Y extent of the widget to draw the
// image. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrImageHeightGet(pRadio->pui8Image) >
(sCtx.sClipRegion.i16YMax - sCtx.sClipRegion.i16YMin))
{
i32Y = sCtx.sClipRegion.i16YMin;
}
else
{
i32Y = (sCtx.sClipRegion.i16YMin +
((sCtx.sClipRegion.i16YMax - sCtx.sClipRegion.i16YMin -
GrImageHeightGet(pRadio->pui8Image) + 1) / 2));
}
//
// Set the foreground and background colors to use for 1 BPP
// images.
//
GrContextForegroundSet(&sCtx, pRadio->ui32TextColor);
GrContextBackgroundSet(&sCtx, pRadio->ui32FillColor);
//
// Draw the image next to the radio button.
//
GrImageDraw(&sCtx, pRadio->pui8Image, sCtx.sClipRegion.i16XMin,
i32Y);
}
//
// See if the radio button text style is selected.
//
if(pRadio->ui16Style & RB_STYLE_TEXT)
{
//
// Determine where along the Y extent of the widget to draw the
// string. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrFontHeightGet(pRadio->psFont) >
(sCtx.sClipRegion.i16YMax - sCtx.sClipRegion.i16YMin))
{
i32Y = sCtx.sClipRegion.i16YMin;
}
else
{
i32Y = (sCtx.sClipRegion.i16YMin +
((sCtx.sClipRegion.i16YMax - sCtx.sClipRegion.i16YMin -
GrFontHeightGet(pRadio->psFont) + 1) / 2));
}
//
// Draw the text next to the radio button.
//
GrContextFontSet(&sCtx, pRadio->psFont);
GrContextForegroundSet(&sCtx, pRadio->ui32TextColor);
GrContextBackgroundSet(&sCtx, pRadio->ui32FillColor);
GrStringDraw(&sCtx, pRadio->pcText, -1, sCtx.sClipRegion.i16XMin,
i32Y, pRadio->ui16Style & RB_STYLE_TEXT_OPAQUE);
}
}
}
//*****************************************************************************
//
//! 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 void
CheckBoxPaint(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,
sRect.sYMin + 1);
//
// See if the check box text or image style is selected.
//
if((pCheck->usStyle & (CB_STYLE_TEXT | CB_STYLE_IMG)) && !bClick)
{
//
// Shrink the clipping region by the size of the check box so that it
// is not overwritten by further "decorative" portions of the widget.
//
sCtx.sClipRegion.sXMin += pCheck->usBoxSize + 4;
//
// If the check box outline style is selected then shrink the clipping
// region by one pixel on each side so that the outline is not
// overwritten by the text or image.
//
if(pCheck->usStyle & CB_STYLE_OUTLINE)
{
sCtx.sClipRegion.sYMin++;
sCtx.sClipRegion.sXMax--;
sCtx.sClipRegion.sYMax--;
}
//
// See if the check box image style is selected.
//
if(pCheck->usStyle & CB_STYLE_IMG)
{
//
// Determine where along the Y extent of the widget to draw the
// image. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrImageHeightGet(pCheck->pucImage) >
(sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin))
{
lY = sCtx.sClipRegion.sYMin;
}
else
{
lY = (sCtx.sClipRegion.sYMin +
((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin -
GrImageHeightGet(pCheck->pucImage) + 1) / 2));
}
//
// Set the foreground and background colors to use for 1 BPP
// images.
//
GrContextForegroundSet(&sCtx, pCheck->ulTextColor);
GrContextBackgroundSet(&sCtx, pCheck->ulFillColor);
//
// Draw the image next to the check box.
//
GrImageDraw(&sCtx, pCheck->pucImage, sCtx.sClipRegion.sXMin, lY);
}
//
// See if the check box text style is selected.
//
if(pCheck->usStyle & CB_STYLE_TEXT)
{
//
// Determine where along the Y extent of the widget to draw the
// string. It is drawn at the top if it takes all (or more than
// all) of the Y extent of the widget, and it is drawn centered if
// it takes less than the Y extent.
//
if(GrFontHeightGet(pCheck->pFont) >
(sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin))
{
lY = sCtx.sClipRegion.sYMin;
}
else
{
lY = (sCtx.sClipRegion.sYMin +
((sCtx.sClipRegion.sYMax - sCtx.sClipRegion.sYMin -
GrFontHeightGet(pCheck->pFont) + 1) / 2));
}
//
// Draw the text next to the check box.
//
GrContextFontSet(&sCtx, pCheck->pFont);
GrContextForegroundSet(&sCtx, pCheck->ulTextColor);
GrContextBackgroundSet(&sCtx, pCheck->ulFillColor);
GrStringDraw(&sCtx, pCheck->pcText, -1, sCtx.sClipRegion.sXMin,
lY, pCheck->usStyle & CB_STYLE_TEXT_OPAQUE);
}
}
}
//*****************************************************************************
//
// 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.
//
//*****************************************************************************
void
PrintChar(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.
//
//*****************************************************************************
int
main(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.
//
DEBUG_PRINT("\nStellaris USB bulk device example\n");
DEBUG_PRINT("---------------------------------\n\n");
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, "Configuring USB...");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit((tUSBBuffer *)&g_sTxBuffer);
USBBufferInit((tUSBBuffer *)&g_sRxBuffer);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDBulkInit(0, (tUSBDBulkDevice *)&g_sBulkDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host...");
//
// Clear our local byte counters.
//
ulRxCount = 0;
ulTxCount = 0;
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ulFlags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
g_ulFlags &= ~COMMAND_STATUS_UPDATE;
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ulTxCount != g_ulTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ulTxCount = g_ulTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d", ulTxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 70, 70, true);
}
//
// Has there been any receive traffic since we last checked?
//
if(ulRxCount != g_ulRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ulRxCount = g_ulRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d", ulRxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 70, 90, true);
}
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_8MHZ);
//
// Enable the 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.
//
g_ulLinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -
(2*(DISPLAY_BANNER_HEIGHT + 1)))/
GrFontHeightGet(g_pFontFixed6x8);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers);
//
// Open and instance of the keyboard class driver.
//
UARTprintf("Host Keyboard Application\n");
//
// Open an instance of the keyboard driver. The keyboard does not need
// to be present at this time, this just save a place for it and allows
// the applications to be notified when a keyboard is present.
//
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);
//
// Initialize the host controller stack.
//
USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);
//
// Call the main loop for the Host controller driver.
//
USBHCDMain();
//
// Initial update of the screen.
//
UpdateStatus();
//
// The main loop for the application.
//
while(1)
{
switch(g_eUSBState)
{
//
// This state is entered when they keyboard is first detected.
//
case STATE_KEYBOARD_INIT:
{
//
// Initialized the newly connected keyboard.
//
USBHKeyboardInit(g_ulKeyboardInstance);
//
// Proceed to the keyboard connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
//
// Update the screen now that the keyboard has been
// initialized.
//
UpdateStatus();
break;
}
case STATE_KEYBOARD_UPDATE:
{
//
// If the application detected a change that required an
// update to be sent to the keyboard to change the modifier
// state then call it and return to the connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
break;
}
case STATE_KEYBOARD_CONNECTED:
{
//
// Nothing is currently done in the main loop when the keyboard
// is connected.
//
break;
}
case STATE_UNKNOWN_DEVICE:
{
//
// Nothing to do as the device is unknown.
//
break;
}
case STATE_NO_DEVICE:
{
//
// Nothing is currently done in the main loop when the keyboard
// is not connected.
//
break;
}
default:
{
break;
}
}
//
// Periodic call the main loop for the Host controller driver.
//
USBHCDMain();
}
}
//*****************************************************************************
//
// Performs calibration of the touch screen.
//
//*****************************************************************************
int
main(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)
{
//
// Grab the current raw touch screen position.
//
i32X2 = g_i16TouchX;
i32Y2 = g_i16TouchY;
//
// See if the pen is up or down.
//
if((i32X2 < g_i16TouchMin) || (i32Y2 < g_i16TouchMin))
{
//
// The pen is up, so see if any samples have been accumulated.
//
if(i32Count > 0)
{
//
// The pen has just been lifted from the screen, so break
// out of the controlling while loop.
//
break;
}
//
// Reset the accumulators and sample count.
//
i32X1 = 0;
i32Y1 = 0;
i32Count = -5;
//
// Grab the next sample.
//
continue;
}
//
// Increment the count of samples.
//
i32Count++;
//
// If the sample count is greater than zero, add this sample to the
// accumulators.
//
if(i32Count > 0)
{
i32X1 += i32X2;
i32Y1 += i32Y2;
}
}
//
// Save the averaged raw ADC reading for this calibration point.
//
ppi32Points[i32Idx][2] = i32X1 / i32Count;
ppi32Points[i32Idx][3] = i32Y1 / i32Count;
//
// Erase the box around this calibration point.
//
GrContextForegroundSet(&sContext, ClrBlack);
GrRectFill(&sContext, &sRect);
}
//
// Clear the screen.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&sContext) - 1;
sRect.i16YMax = GrContextDpyHeightGet(&sContext) - 1;
GrRectFill(&sContext, &sRect);
//
// Indicate that the calibration data is being displayed.
//
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDraw(&sContext, "Calibration data:", -1, 16, 32, 0);
//
// Compute and display the M0 calibration value.
//
usprintf(pcBuffer, "M0 = %d",
(((ppi32Points[0][0] - ppi32Points[2][0]) *
(ppi32Points[1][3] - ppi32Points[2][3])) -
((ppi32Points[1][0] - ppi32Points[2][0]) *
(ppi32Points[0][3] - ppi32Points[2][3]))));
GrStringDraw(&sContext, pcBuffer, -1, 16, 72, 0);
//
// Compute and display the M1 calibration value.
//
usprintf(pcBuffer, "M1 = %d",
(((ppi32Points[0][2] - ppi32Points[2][2]) *
(ppi32Points[1][0] - ppi32Points[2][0])) -
((ppi32Points[0][0] - ppi32Points[2][0]) *
(ppi32Points[1][2] - ppi32Points[2][2]))));
GrStringDraw(&sContext, pcBuffer, -1, 16, 92, 0);
//
// Compute and display the M2 calibration value.
//
usprintf(pcBuffer, "M2 = %d",
((((ppi32Points[2][2] * ppi32Points[1][0]) -
(ppi32Points[1][2] * ppi32Points[2][0])) * ppi32Points[0][3]) +
(((ppi32Points[0][2] * ppi32Points[2][0]) -
(ppi32Points[2][2] * ppi32Points[0][0])) * ppi32Points[1][3]) +
(((ppi32Points[1][2] * ppi32Points[0][0]) -
(ppi32Points[0][2] * ppi32Points[1][0])) * ppi32Points[2][3])));
GrStringDraw(&sContext, pcBuffer, -1, 16, 112, 0);
//
// Compute and display the M3 calibration value.
//
usprintf(pcBuffer, "M3 = %d",
(((ppi32Points[0][1] - ppi32Points[2][1]) *
(ppi32Points[1][3] - ppi32Points[2][3])) -
((ppi32Points[1][1] - ppi32Points[2][1]) *
(ppi32Points[0][3] - ppi32Points[2][3]))));
GrStringDraw(&sContext, pcBuffer, -1, 16, 132, 0);
//
// Compute and display the M4 calibration value.
//
usprintf(pcBuffer, "M4 = %d",
(((ppi32Points[0][2] - ppi32Points[2][2]) *
(ppi32Points[1][1] - ppi32Points[2][1])) -
((ppi32Points[0][1] - ppi32Points[2][1]) *
(ppi32Points[1][2] - ppi32Points[2][2]))));
GrStringDraw(&sContext, pcBuffer, -1, 16, 152, 0);
//
// Compute and display the M5 calibration value.
//
usprintf(pcBuffer, "M5 = %d",
((((ppi32Points[2][2] * ppi32Points[1][1]) -
(ppi32Points[1][2] * ppi32Points[2][1])) * ppi32Points[0][3]) +
(((ppi32Points[0][2] * ppi32Points[2][1]) -
(ppi32Points[2][2] * ppi32Points[0][1])) * ppi32Points[1][3]) +
(((ppi32Points[1][2] * ppi32Points[0][1]) -
(ppi32Points[0][2] * ppi32Points[1][1])) * ppi32Points[2][3])));
GrStringDraw(&sContext, pcBuffer, -1, 16, 172, 0);
//
// Compute and display the M6 calibration value.
//
usprintf(pcBuffer, "M6 = %d",
(((ppi32Points[0][2] - ppi32Points[2][2]) *
(ppi32Points[1][3] - ppi32Points[2][3])) -
((ppi32Points[1][2] - ppi32Points[2][2]) *
(ppi32Points[0][3] - ppi32Points[2][3]))));
GrStringDraw(&sContext, pcBuffer, -1, 16, 192, 0);
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// The calibration is complete. Sit around and wait for a reset.
//
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.
//
//*****************************************************************************
int
main(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.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Initialize the CPU usage measurement routine.
//
CPUUsageInit(SysCtlClockGet(), SYSTICKS_PER_SECOND, 2);
//
// Enable the uDMA controller at the system level. Enable it to continue
// to run while the processor is in sleep.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UDMA);
//
// Enable the uDMA controller error interrupt. This interrupt will occur
// if there is a bus error during a transfer.
//
ROM_IntEnable(INT_UDMAERR);
//
// Enable the uDMA controller.
//
ROM_uDMAEnable();
//
// Point at the control table to use for channel control structures.
//
ROM_uDMAControlBaseSet(ucControlTable);
//
// Initialize the uDMA memory to memory transfers.
//
InitSWTransfer();
//
// Initialize the uDMA UART transfers.
//
InitUART0Transfer();
//
// Remember the current SysTick seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Remember the current count of memory buffer transfers.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Loop until the button is pressed. The processor is put to sleep
// in this loop so that CPU utilization can be measured.
//
while(1)
{
//
// Check to see if one second has elapsed. If so, the make some
// updates.
//
if(g_ulSeconds != ulPrevSeconds)
{
//
// Print a message to the display showing the CPU usage percent.
// The fractional part of the percent value is ignored.
//
usnprintf(cStrBuf, sizeof(cStrBuf), "CPU utilization %2u%%",
g_ulCPUUsage >> 16);
GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 160, 1);
//
// Tell the user how many seconds we have to go before ending.
//
usnprintf(cStrBuf, sizeof(cStrBuf), " Test ends in %d seconds ",
10 - g_ulSeconds);
GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 120, 1);
//
// Remember the new seconds count.
//
ulPrevSeconds = g_ulSeconds;
//
// Calculate how many memory transfers have occurred since the last
// second.
//
ulXfersCompleted = g_ulMemXferCount - ulPrevXferCount;
//
// Remember the new transfer count.
//
ulPrevXferCount = g_ulMemXferCount;
//
// Compute how many bytes were transferred in the memory transfer
// since the last second.
//
ulBytesTransferred = ulXfersCompleted * MEM_BUFFER_SIZE * 4;
//
// Print a message to the display showing the memory transfer rate.
//
usnprintf(cStrBuf, sizeof(cStrBuf), " %8u Bytes/Sec ",
ulBytesTransferred);
GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 182, 1);
//
// Calculate how many UART transfers have occurred since the last
// second.
//
ulXfersCompleted = (g_ulRxBufACount + g_ulRxBufBCount -
ulPrevUARTCount);
//
// Remember the new UART transfer count.
//
ulPrevUARTCount = g_ulRxBufACount + g_ulRxBufBCount;
//
// Compute how many bytes were transferred by the UART. The number
// of bytes received is multiplied by 2 so that the TX bytes
// transferred are also accounted for.
//
ulBytesTransferred = ulXfersCompleted * UART_RXBUF_SIZE * 2;
//
// Print a message to the display showing the UART transfer rate.
//
usnprintf(cStrBuf, sizeof(cStrBuf), " %8u Bytes/Sec ",
ulBytesTransferred);
GrStringDrawCentered(&g_sContext, cStrBuf, -1, ulCenterX, 204, 1);
}
//
// Put the processor to sleep if there is nothing to do. This allows
// the CPU usage routine to measure the number of free CPU cycles.
// If the processor is sleeping a lot, it can be hard to connect to
// the target with the debugger.
//
SysCtlSleep();
//
// See if we have run long enough and exit the loop if so.
//
if(g_ulSeconds >= 10)
{
break;
}
}
//*****************************************************************************
//
// 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.
//
//*****************************************************************************
void
PrintChar(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);
}
return;
}
}
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;
}
}
}
//*****************************************************************************
//
// Demonstrate the use of the USB stick update example.
//
//*****************************************************************************
int
main(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)
{
//
// See if the button is pressed.
//
if(ROM_GPIOPinRead(GPIO_PORTM_BASE, GPIO_PIN_4) == 0)
{
//
// Increment the count since the button is pressed.
//
ulCount++;
//
// If the count has reached 4, then the button has been debounced
// as being pressed.
//
if(ulCount == 4)
{
break;
}
}
else
{
//
// Reset the count since the button is not pressed.
//
ulCount = 0;
}
//
// Delay for approximately 10ms.
//
SysCtlDelay(16000000 / (3 * 100));
}
//
// Wait until the select button has been released for ~40ms (in order to
// debounce the release).
//
ulCount = 0;
while(1)
{
//
// See if the button is pressed.
//
if(ROM_GPIOPinRead(GPIO_PORTM_BASE, GPIO_PIN_4) != 0)
{
//
// Increment the count since the button is released.
//
ulCount++;
//
// If the count has reached 4, then the button has been debounced
// as being released.
//
if(ulCount == 4)
{
break;
}
}
else
{
//
// Reset the count since the button is pressed.
//
ulCount = 0;
}
//
// Delay for approximately 10ms.
//
SysCtlDelay(16000000 / (3 * 100));
}
//
// Indicate that the updater is being called.
//
GrStringDrawCentered(&sContext, "The USB stick", -1,
GrContextDpyWidthGet(&sContext) / 2, 20, true);
GrStringDrawCentered(&sContext, "updater is now", -1,
GrContextDpyWidthGet(&sContext) / 2, 30, true);
GrStringDrawCentered(&sContext, "waiting for a", -1,
GrContextDpyWidthGet(&sContext) / 2, 40, true);
GrStringDrawCentered(&sContext, "USB stick.", -1,
GrContextDpyWidthGet(&sContext) / 2, 50, true);
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// Call the updater so that it will search for an update on a memory stick.
//
(*((void (*)(void))(*(unsigned long *)0x2c)))();
//
// The updater should take control, so this should never be reached.
// Just in case, loop forever.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
tUSBMode eLastMode;
char *pcString;
//
// 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);
//
// Initially wait for device connection.
//
g_eUSBState = STATE_NO_DEVICE;
eLastMode = USB_MODE_OTG;
g_eCurrentUSBMode = USB_MODE_OTG;
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// 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 Interrupts
//
ROM_IntMasterEnable();
//
// Enable clocking to the UART and associated GPIO
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open UART0 for debug output.
//
UARTStdioInit(0);
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, USB_MODE_OTG, ModeCallback);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ulNumHostClassDrivers);
//
// Open an instance of the keyboard driver. The keyboard does not need
// to be present at this time, this just save a place for it and allows
// the applications to be notified when a keyboard is present.
//
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);
//
// Open and instance of the keyboard class driver.
//
UARTprintf("Host Keyboard Application\n");
//
// Initial update of the screen.
//
UpdateStatus();
//
// The main loop for the application.
//
while(1)
{
//
// Tell the OTG library code how much time has passed in
// milliseconds since the last call.
//
USBOTGMain(GetTickms());
//
// Has the USB mode changed since last time we checked?
//
if(g_eCurrentUSBMode != eLastMode)
{
//
// Remember the new mode.
//
eLastMode = g_eCurrentUSBMode;
switch(eLastMode)
{
case USB_MODE_HOST:
pcString = "HOST";
break;
case USB_MODE_DEVICE:
pcString = "DEVICE";
break;
case USB_MODE_NONE:
pcString = "NONE";
break;
default:
pcString = "UNKNOWN";
break;
}
UARTprintf("USB mode changed to %s\n", pcString);
}
switch(g_eUSBState)
{
//
// This state is entered when they keyboard is first detected.
//
case STATE_KEYBOARD_INIT:
{
//
// Initialized the newly connected keyboard.
//
USBHKeyboardInit(g_ulKeyboardInstance);
//
// Proceed to the keyboard connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
//
// Update the screen now that the keyboard has been
// initialized.
//
UpdateStatus();
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
break;
}
case STATE_KEYBOARD_UPDATE:
{
//
// If the application detected a change that required an
// update to be sent to the keyboard to change the modifier
// state then call it and return to the connected state.
//
g_eUSBState = STATE_KEYBOARD_CONNECTED;
USBHKeyboardModifierSet(g_ulKeyboardInstance, g_ulModifiers);
break;
}
case STATE_KEYBOARD_CONNECTED:
{
//
// Nothing is currently done in the main loop when the keyboard
// is connected.
//
break;
}
case STATE_UNKNOWN_DEVICE:
{
//
// Nothing to do as the device is unknown.
//
break;
}
case STATE_NO_DEVICE:
{
//
// Nothing is currently done in the main loop when the keyboard
// is not connected.
//
break;
}
default:
{
break;
}
}
}
}
//*****************************************************************************
//
//! 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 void
ClockSetPaint(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.
//
i32Width = 1 + (sRect.i16XMax - sRect.i16XMin);
i32Height = 1 + (sRect.i16YMax - sRect.i16YMin);
//
// Compute the X and Y starting point for the row that will show the
// date.
//
i32X = sRect.i16XMin + (i32Width - (ui32FontWidth * 10)) / 2;
i32Y = sRect.i16YMin + ((i32Height * 1) / 6) - (ui32FontHeight / 2);
//
// Draw the date field separators on the date row.
//
GrStringDraw(&sContext, "/", -1, i32X + (ui32FontWidth * 4), i32Y, 0);
GrStringDraw(&sContext, "/", -1, i32X + (ui32FontWidth * 7), i32Y, 0);
//
// Compute the X and Y starting point for the row that will show the
// time.
//
i32X = sRect.i16XMin + (i32Width - (ui32FontWidth * 5)) / 2;
i32Y = sRect.i16YMin + ((i32Height * 3) / 6) - (ui32FontHeight / 2);
//
// Draw the time field separators on the time row.
//
GrStringDraw(&sContext, ":", -1, i32X + (ui32FontWidth * 2), i32Y, 0);
//
// Process each of the fields to be shown on the widget
//
for(ui32Idx = 0; ui32Idx < NUM_FIELDS; ui32Idx++)
{
//
// Compute the X and Y for the text for each field, and print the
// text into a buffer.
//
switch(ui32Idx)
{
//
// Year
//
case FIELD_YEAR:
{
usnprintf(pcBuf, sizeof(pcBuf), "%4u", psTime->tm_year+1900);
i32X = sRect.i16XMin + (i32Width - (ui32FontWidth * 10)) / 2;
i32Y = sRect.i16YMin + ((i32Height * 1) / 6) -
(ui32FontHeight / 2);
ui32SelWidth = 4;
break;
}
//
// Month
//
case FIELD_MONTH:
{
usnprintf(pcBuf, sizeof(pcBuf), "%02u", psTime->tm_mon + 1);
i32X += ui32FontWidth * 5;
ui32SelWidth = 2;
break;
}
//
// Day
//
case FIELD_DAY:
{
usnprintf(pcBuf, sizeof(pcBuf), "%02u", psTime->tm_mday);
i32X += ui32FontWidth * 3;
ui32SelWidth = 2;
break;
}
//
// Hour
//
case FIELD_HOUR:
{
usnprintf(pcBuf, sizeof(pcBuf), "%02u", psTime->tm_hour);
i32X = sRect.i16XMin + (i32Width - (ui32FontWidth * 5)) / 2;
i32Y = sRect.i16YMin + ((i32Height * 3) / 6) -
(ui32FontHeight / 2);
ui32SelWidth = 2;
break;
}
//
// Minute
//
case FIELD_MINUTE:
{
usnprintf(pcBuf, sizeof(pcBuf), "%02u", psTime->tm_min);
i32X += ui32FontWidth * 3;
ui32SelWidth = 2;
break;
}
//
// OK
//
case FIELD_OK:
{
usnprintf(pcBuf, sizeof(pcBuf), "OK");
i32X = (i32Width - (ui32FontWidth * 9)) / 2;
i32X += sRect.i16XMin;
i32Y = ((i32Height * 5) / 6) - (ui32FontHeight / 2);
i32Y += sRect.i16YMin;
ui32SelWidth = 2;
break;
}
//
// CANCEL (default case is purely to keep the compiler from
// issuing a warning that ui32SelWidth may be used ininitialized).
//
case FIELD_CANCEL:
default:
{
usnprintf(pcBuf, sizeof(pcBuf), "CANCEL");
i32X += ui32FontWidth * 3;
ui32SelWidth = 6;
break;
}
}
//
// If the current field index is the highlighted field, then this
// text field will be drawn with highlighting.
//
if(ui32Idx == psClockWidget->ui32Highlight)
{
//
// Compute a rectangle for the highlight area.
//
sRectSel.i16XMin = i32X;
sRectSel.i16XMax = (ui32SelWidth * ui32FontWidth) + i32X;
sRectSel.i16YMin = i32Y - 2;
sRectSel.i16YMax = ui32FontHeight + i32Y + 2;
//
// Set the foreground color to the text color, and then fill the
// highlight rectangle. The text field will be highlighted by
// inverting the normal colors.
// Then draw the highlighting rectangle.
//
GrContextForegroundSet(&sContext,
psClockWidget->ui32ForegroundColor);
GrRectFill(&sContext, &sRectSel);
//
// Change the foreground color to the normal background color.
// This will be used for drawing the text for the highlighted
// field, which has the colors inverted (FG <--> BG)
//
GrContextForegroundSet(&sContext,
psClockWidget->ui32BackgroundColor);
}
else
{
//
// This text field is not highlighted so just set the normal
// foreground color.
//
GrContextForegroundSet(&sContext,
psClockWidget->ui32ForegroundColor);
}
//
// Print the text from the buffer to the display at the computed
// location.
//
GrStringDraw(&sContext, pcBuf, -1, i32X, i32Y, 0);
}
}
//*****************************************************************************
//
// This is the main application entry function.
//
//*****************************************************************************
int
main(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);
//
// Enable and configure the UART RX and TX pins
//
ROM_SysCtlPeripheralEnable(TX_GPIO_PERIPH);
ROM_SysCtlPeripheralEnable(RX_GPIO_PERIPH);
ROM_GPIOPinTypeUART(TX_GPIO_BASE, TX_GPIO_PIN);
ROM_GPIOPinTypeUART(RX_GPIO_BASE, RX_GPIO_PIN);
//
// TODO: Add code to configure handshake GPIOs if required.
//
//
// Set the default UART configuration.
//
ROM_UARTConfigSetExpClk(USB_UART_BASE, ROM_SysCtlClockGet(),
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
ROM_UARTFIFOLevelSet(USB_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
//
// Configure and enable UART interrupts.
//
ROM_UARTIntClear(USB_UART_BASE, ROM_UARTIntStatus(USB_UART_BASE, false));
ROM_UARTIntEnable(USB_UART_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
//
// Enable the system tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Tell the user what we are up to.
//
DisplayStatus(&g_sContext, " Configuring... ");
//
// Initialize the transmit and receive buffers.
//
USBBufferInit(&g_sTxBuffer);
USBBufferInit(&g_sRxBuffer);
//
// Set the USB stack mode to Device mode with VBUS monitoring.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass our device information to the USB library and place the device
// on the bus.
//
USBDCDCInit(0, &g_sCDCDevice);
//
// Wait for initial configuration to complete.
//
DisplayStatus(&g_sContext, "Waiting for host");
//
// Clear our local byte counters.
//
ui32RxCount = 0;
ui32TxCount = 0;
//
// Enable interrupts now that the application is ready to start.
//
ROM_IntEnable(USB_UART_INT);
//
// Main application loop.
//
while(1)
{
//
// Have we been asked to update the status display?
//
if(g_ui32Flags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
ROM_IntMasterDisable();
g_ui32Flags &= ~COMMAND_STATUS_UPDATE;
ROM_IntMasterEnable();
DisplayStatus(&g_sContext, g_pcStatus);
}
//
// Has there been any transmit traffic since we last checked?
//
if(ui32TxCount != g_ui32UARTTxCount)
{
//
// Take a snapshot of the latest transmit count.
//
ui32TxCount = g_ui32UARTTxCount;
//
// Update the display of bytes transmitted by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 12, true);
//
// Update the RX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's receive buffer is the UART's
// transmit buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 22);
}
//
// Has there been any receive traffic since we last checked?
//
if(ui32RxCount != g_ui32UARTRxCount)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the display of bytes received by the UART.
//
usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
GrStringDraw(&g_sContext, pcBuffer, -1, 40, 32, true);
//
// Update the TX buffer fullness. Remember that the buffers are
// named relative to the USB whereas the status display is from
// the UART's perspective. The USB's transmit buffer is the UART's
// receive buffer.
//
ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
UART_BUFFER_SIZE);
UpdateBufferMeter(&g_sContext, ui32Fullness, 40, 42);
}
}
}
//*****************************************************************************
//
//! 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 void
ImageButtonPaint(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);
//
// If there is a keycap image and it is not disabled, center this on the
// top of the button, applying any offset defined if the button is
// currently pressed.
//
if(pPush->pucKeycapImage && !(pPush->ulStyle & IB_STYLE_KEYCAP_OFF))
{
//
// Draw the keycap image.
//
GrImageDraw(&sCtx, pPush->pucKeycapImage,
lX - (GrImageWidthGet(pPush->pucKeycapImage) / 2),
lY - (GrImageHeightGet(pPush->pucKeycapImage) / 2));
}
//
// See if the button text style is selected.
//
if(pPush->ulStyle & IB_STYLE_TEXT)
{
//
// Draw the text centered in the middle of the button with offset
// applied if the button is currently pressed.
//
GrContextFontSet(&sCtx, pPush->pFont);
GrStringDrawCentered(&sCtx, pPush->pcText, -1, lX, lY, 0);
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(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.
//
UARTSend((uint8_t *)"Enter text: ", 12);
//
// Loop forever echoing data through the UART.
//
while(1)
{
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(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.
//
ROM_IntPrioritySet(INT_GPIOA, 0x00);
ROM_IntPrioritySet(INT_TIMER0B, 0x40);
ROM_IntPrioritySet(INT_TIMER0A, 0x80);
//
// Enable the interrupts associated with the SoftUART.
//
ROM_IntEnable(INT_TIMER0A);
ROM_IntEnable(INT_TIMER0B);
ROM_IntEnable(INT_GPIOA);
//
// Prompt for text to be entered.
//
UARTSend((unsigned char *)"\033[2JEnter text: ", 16);
//
// Enable the SoftUART interrupt.
//
SoftUARTIntEnable(&g_sUART, SOFTUART_INT_RX | SOFTUART_INT_RT);
//
// Loop forever echoing data through the UART.
//
while(1)
{
//
// Wait until there are characters available in the receive buffer.
//
while(g_ulFlag == 0)
{
}
g_ulFlag = 0;
//
// Loop while there are characters in the receive buffer.
//
while(SoftUARTCharsAvail(&g_sUART))
{
//
// Read the next character from the UART and write it back to the
// UART.
//
SoftUARTCharPutNonBlocking(&g_sUART,
SoftUARTCharGetNonBlocking(&g_sUART));
}
}
}
