//*****************************************************************************
//
// Print "Hello World!" to the UART on the Intelligent UART Module.
//
//*****************************************************************************
int
main(void)
{
//
// Run from the PLL at 120 MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet(false, false);
//
// Enable the GPIO pins for the LED D1 (PN1).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
//
// Initialize the UART.
//
ConfigureUART();
//
// Hello!
//
UARTprintf("Hello, world!\n");
//
// We are finished. Hang around flashing D1.
//
while(1)
{
//
// Turn on D1.
//
LEDWrite(CLP_D1, 1);
//
// Delay for a bit.
//
SysCtlDelay(g_ui32SysClock / 10 / 3);
//
// Turn off D1.
//
LEDWrite(CLP_D1, 0);
//
// Delay for a bit.
//
SysCtlDelay(g_ui32SysClock / 10 / 3);
}
}
//*****************************************************************************
//
// Print "Hello World!" to the display on the Intelligent Display Module.
//
//*****************************************************************************
int
main(void)
{
tContext sContext;
uint32_t ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "hello");
//
// Say hello using the Computer Modern 40 point font.
//
GrContextFontSet(&sContext, g_psFontCm40);
GrStringDrawCentered(&sContext, "Hello World!", -1,
GrContextDpyWidthGet(&sContext) / 2,
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24,
0);
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// We are finished. Hang around doing nothing.
//
while(1)
{
}
}
//*****************************************************************************
//
// A simple application demonstrating use of the boot loader,
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
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, "boot-demo-uart");
//
// Print instructions on the screen.
//
GrStringDrawCentered(&sContext, "Press the screen to start", -1, 160, 108,
false);
GrStringDrawCentered(&sContext, "the update process", -1, 160, 128, false);
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(TSHandler);
//
// Enable the UART that will be used for the firmware update.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Configure the UART for 115200, 8-N-1.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 115200,
(UART_CONFIG_PAR_NONE | UART_CONFIG_STOP_ONE |
UART_CONFIG_WLEN_8));
//
// Enable the UART operation.
//
ROM_UARTEnable(UART0_BASE);
//
// Wait until the screen has been pressed, indicating that the firwmare
// update should begin.
//
while(!g_bFirmwareUpdate)
{
}
//
// Clear the screen.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = 319;
sRect.i16YMax = 239;
GrContextForegroundSet(&sContext, ClrBlack);
GrRectFill(&sContext, &sRect);
//
// Indicate that the firmware update is about to start.
//
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDrawCentered(&sContext, "Update process started...", -1, 160, 98,
false);
GrStringDrawCentered(&sContext, "Using UART0 with", -1, 160, 138, false);
GrStringDrawCentered(&sContext, "115,200 baud, 8-N-1.", -1, 160, 158,
false);
//
// Disable all processor interrupts. Instead of disabling them one at a
// time, a direct write to NVIC is done to disable all peripheral
// interrupts.
//
HWREG(NVIC_DIS0) = 0xffffffff;
HWREG(NVIC_DIS1) = 0xffffffff;
HWREG(NVIC_DIS2) = 0xffffffff;
HWREG(NVIC_DIS3) = 0xffffffff;
HWREG(NVIC_DIS4) = 0xffffffff;
//
// Call the ROM UART boot loader.
//
ROM_UpdateUART();
//
// The boot loader should not return. In the off chance that it does,
// enter a dead loop.
//
while(1)
{
}
}
//*****************************************************************************
//
// This example demonstrates the use of both watchdog timers.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = 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(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "watchdog");
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
TouchScreenCallbackSet(WatchdogTouchCallback);
//
// Reconfigure PF1 as a GPIO output so that it can be directly driven
// (instead of being an Ethernet LED).
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, 0);
//
// Show the state and offer some instructions to the user.
//
GrContextFontSet(&g_sContext, g_psFontCmss20);
GrStringDrawCentered(&g_sContext, "Watchdog 0:", -1, 80, 80, 0);
GrStringDrawCentered(&g_sContext, "Watchdog 1:", -1, 240, 80, 0);
GrContextFontSet(&g_sContext, g_psFontCmss14);
GrStringDrawCentered(&g_sContext,
"Tap the left screen to starve the watchdog 0",
-1, GrContextDpyWidthGet(&g_sContext) / 2 ,
(GrContextDpyHeightGet(&g_sContext) / 2) + 40, 1);
GrStringDrawCentered(&g_sContext,
"Tap the right screen to starve the watchdog 1",
-1, GrContextDpyWidthGet(&g_sContext) / 2 ,
(GrContextDpyHeightGet(&g_sContext) / 2) + 60, 1);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG1);
//
// Enable the watchdog interrupt.
//
ROM_IntEnable(INT_WATCHDOG);
//
// Set the period of the watchdog timer.
//
ROM_WatchdogReloadSet(WATCHDOG0_BASE, ui32SysClock);
ROM_WatchdogReloadSet(WATCHDOG1_BASE, 16000000);
//
// Enable reset generation from the watchdog timer.
//
ROM_WatchdogResetEnable(WATCHDOG0_BASE);
ROM_WatchdogResetEnable(WATCHDOG1_BASE);
//
// Enable the watchdog timer.
//
ROM_WatchdogEnable(WATCHDOG0_BASE);
ROM_WatchdogEnable(WATCHDOG1_BASE);
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(1)
{
}
}
//*****************************************************************************
//
// 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 is the main example program. It checks to see that the interrupts are
// processed in the correct order when they have identical priorities,
// increasing priorities, and decreasing priorities. This exercises interrupt
// preemption and tail chaining.
//
//*****************************************************************************
int
main(void)
{
uint_fast8_t ui8Error;
uint32_t ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "interrupts");
//
// Put the status header text on the display.
//
GrContextFontSet(&g_sContext, g_psFontCm20);
GrStringDrawCentered(&g_sContext, "Active: Pending: ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 150, 0);
//
// Configure the B3, L1 and L0 to be outputs to indicate entry/exit of one
// of the interrupt handlers.
//
GPIOPinTypeGPIOOutput(GPIO_A_BASE, GPIO_A_PIN);
GPIOPinTypeGPIOOutput(GPIO_B_BASE, GPIO_B_PIN);
GPIOPinTypeGPIOOutput(GPIO_C_BASE, GPIO_C_PIN);
GPIOPinWrite(GPIO_A_BASE, GPIO_A_PIN, 0);
GPIOPinWrite(GPIO_B_BASE, GPIO_B_PIN, 0);
GPIOPinWrite(GPIO_C_BASE, GPIO_C_PIN, 0);
//
// Set up and enable the SysTick timer. It will be used as a reference
// for delay loops in the interrupt handlers. The SysTick timer period
// will be set up for 100 times per second.
//
ROM_SysTickPeriodSet(ui32SysClock / 100);
ROM_SysTickEnable();
//
// Reset the error indicator.
//
ui8Error = 0;
//
// Enable interrupts to the processor.
//
ROM_IntMasterEnable();
//
// Enable the interrupts.
//
ROM_IntEnable(INT_GPIOA);
ROM_IntEnable(INT_GPIOB);
ROM_IntEnable(INT_GPIOC);
//
// Indicate that the equal interrupt priority test is beginning.
//
GrStringDrawCentered(&g_sContext, "Equal Priority", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 60, 1);
//
// Set the interrupt priorities so they are all equal.
//
ROM_IntPrioritySet(INT_GPIOA, 0x00);
ROM_IntPrioritySet(INT_GPIOB, 0x00);
ROM_IntPrioritySet(INT_GPIOC, 0x00);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the LCD.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 3) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 1))
{
ui8Error |= 1;
}
//
// Wait two seconds.
//
Delay(2);
//
// Indicate that the decreasing interrupt priority test is beginning.
//
GrStringDrawCentered(&g_sContext, " Decreasing Priority ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 60, 1);
//
// Set the interrupt priorities so that they are decreasing (i.e. C > B >
// A).
//
ROM_IntPrioritySet(INT_GPIOA, 0x80);
ROM_IntPrioritySet(INT_GPIOB, 0x40);
ROM_IntPrioritySet(INT_GPIOC, 0x00);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the display.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 3) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 1))
{
ui8Error |= 2;
}
//
// Wait two seconds.
//
Delay(2);
//
// Indicate that the increasing interrupt priority test is beginning.
//
GrStringDrawCentered(&g_sContext, " Increasing Priority ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 60, 1);
//
// Set the interrupt priorities so that they are increasing (i.e. C < B <
// A).
//
ROM_IntPrioritySet(INT_GPIOA, 0x00);
ROM_IntPrioritySet(INT_GPIOB, 0x40);
ROM_IntPrioritySet(INT_GPIOC, 0x80);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the display.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 1) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 3))
{
ui8Error |= 4;
}
//
// Wait two seconds.
//
Delay(2);
//
// Disable the interrupts.
//
ROM_IntDisable(INT_GPIOA);
ROM_IntDisable(INT_GPIOB);
ROM_IntDisable(INT_GPIOC);
//
// Disable interrupts to the processor.
//
ROM_IntMasterDisable();
//
// Print out the test results.
//
GrStringDrawCentered(&g_sContext, " Interrupt Priority ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 60, 1);
if(ui8Error)
{
GrStringDrawCentered(&g_sContext, " Equal: P Inc: P Dec: P ",
-1, GrContextDpyWidthGet(&g_sContext) / 2, 150, 1);
if(ui8Error & 1)
{
GrStringDrawCentered(&g_sContext, " F ", -1, 113, 150, 1);
}
if(ui8Error & 2)
{
GrStringDrawCentered(&g_sContext, " F ", -1, 187, 150, 1);
}
if(ui8Error & 4)
{
GrStringDrawCentered(&g_sContext, " F ", -1, 272, 150, 1);
}
}
else
{
GrStringDrawCentered(&g_sContext, " Success! ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 150, 1);
}
//
// Flush the display.
//
GrFlush(&g_sContext);
//
// Loop forever.
//
while(1)
{
}
}
//*****************************************************************************
//
// The program main function. It performs initialization, then handles wav
// file playback.
//
//*****************************************************************************
int
main(void)
{
int nStatus;
//
// Set the system clock to run at 80MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Give bget some memory to work with.
//
bpool(g_pulHeap, sizeof(g_pulHeap));
//
// Set the device pin out appropriately for this board.
//
PinoutSet();
//
// Configure the relevant pins such that UART0 owns them.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
//
// Open the UART for I/O
//
UARTStdioInit(0);
UARTprintf("i2s_speex_enc\n");
//
// Configure and enable uDMA
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
SysCtlDelay(10);
ROM_uDMAControlBaseSet(&sDMAControlTable[0]);
ROM_uDMAEnable();
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Configure the I2S peripheral.
//
SoundInit(1);
//
// Set the format of the play back in the sound driver.
//
SoundSetFormat(AUDIO_RATE, AUDIO_BITS, AUDIO_CHANNELS);
//
// Print out some header information to the serial console.
//
UARTprintf("\ni2s_speex_enc Stellaris Example\n");
UARTprintf("Streaming at %d %d bit ",SoundSampleRateGet(), AUDIO_BITS);
if(AUDIO_CHANNELS == 2)
{
UARTprintf("Stereo\n");
}
else
{
UARTprintf("Mono\n");
}
//
// Set the initial volume.
//
SoundVolumeSet(INITIAL_VOLUME_PERCENT);
//
// Initialize the Speex decoder.
//
SpeexDecodeInit();
//
// Set the default quality to 2.
//
g_iQuality = 2;
//
// Initialize the Speex encoder to Complexity of 1 and Quality 2.
//
SpeexEncodeInit(AUDIO_RATE, 1, g_iQuality);
//
// Initialize the audio buffers.
//
InitBuffers();
//
// Initialize the applications global state flags.
//
g_ulFlags = 0;
//
// Kick off a request for a buffer play back and advance the encoder
// pointer.
//
SoundBufferRead(g_pucRecBuffer, RECORD_BUFFER_INC,
RecordBufferCallback);
g_pucEncode += RECORD_BUFFER_INC;
//
// Kick off a second request for a buffer play back and advance the encode
// pointer.
//
SoundBufferRead(&g_pucRecBuffer[RECORD_BUFFER_INC], RECORD_BUFFER_INC,
RecordBufferCallback);
g_pucEncode += RECORD_BUFFER_INC;
//
// The rest of the handling occurs at interrupt time so the main loop will
// simply stall here.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
UARTprintf("\n> ");
//
// Get a line of text from the user.
//
UARTgets(g_cCmdBuf, sizeof(g_cCmdBuf));
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
nStatus = CmdLineProcess(g_cCmdBuf);
//
// Handle the case of bad command.
//
if(nStatus == CMDLINE_BAD_CMD)
{
UARTprintf("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(nStatus == CMDLINE_TOO_MANY_ARGS)
{
UARTprintf("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(nStatus != 0)
{
UARTprintf("Command returned error code \n");
}
}
}
//*****************************************************************************
//
// 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;
}
}
//*****************************************************************************
//
// The main application loop.
//
//*****************************************************************************
int
main(void)
{
int32_t i32Status, i32Idx;
uint32_t ui32SysClock, ui32PLLRate;
#ifdef USE_ULPI
uint32_t ui32Setting;
#endif
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Set the part pin out appropriately for this device.
//
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
//
// Initialize the hub port status.
//
for(i32Idx = 0; i32Idx < NUM_HUB_STATUS; i32Idx++)
{
g_psHubStatus[i32Idx].bConnected = false;
}
//
// Enable Clocking to the USB controller.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_USB0);
//
// Enable Interrupts
//
ROM_IntMasterEnable();
//
// Initialize the USB stack mode and pass in a mode callback.
//
USBStackModeSet(0, eUSBModeHost, 0);
//
// Register the host class drivers.
//
USBHCDRegisterDrivers(0, g_ppHostClassDrivers, g_ui32NumHostClassDrivers);
//
// Open the Keyboard interface.
//
KeyboardOpen();
MSCOpen(ui32SysClock);
//
// Open a hub instance and provide it with the memory required to hold
// configuration descriptors for each attached device.
//
USBHHubOpen(HubCallback);
//
// 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);
//
// Tell the USB library the CPU clock and the PLL frequency.
//
USBOTGFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
USBOTGFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
//
// Initialize the USB controller for Host mode.
//
USBHCDInit(0, g_pui8HCDPool, sizeof(g_pui8HCDPool));
//
// 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-host-hub");
//
// Calculate the number of characters that will fit on a line.
// Make sure to leave a small border for the text box.
//
g_ui32CharsPerLine = (GrContextDpyWidthGet(&g_sContext) - 16) /
GrFontMaxWidthGet(g_psFontFixed6x8);
//
// 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_ui32LinesPerScreen = (GrContextDpyHeightGet(&g_sContext) -
(2*(DISPLAY_BANNER_HEIGHT + 1)))/
GrFontHeightGet(g_psFontFixed6x8);
//
// Initial update of the screen.
//
UpdateStatus(0);
UpdateStatus(1);
UpdateStatus(2);
UpdateStatus(3);
g_ui32CmdIdx = 0;
g_ui32CurrentLine = 0;
//
// Initialize the file system.
//
FileInit();
//
// The main loop for the application.
//
while(1)
{
//
// Print a prompt to the console. Show the CWD.
//
WriteString("> ");
//
// Is there a command waiting to be processed?
//
while((g_ui32Flags & FLAG_CMD_READY) == 0)
{
//
// Call the YSB library to let non-interrupt code run.
//
USBHCDMain();
//
// Call the keyboard and mass storage main routines.
//
KeyboardMain();
MSCMain();
}
//
// Pass the line from the user to the command processor.
// It will be parsed and valid commands executed.
//
i32Status = CmdLineProcess(g_pcCmdBuf);
//
// Handle the case of bad command.
//
if(i32Status == CMDLINE_BAD_CMD)
{
WriteString("Bad command!\n");
}
//
// Handle the case of too many arguments.
//
else if(i32Status == CMDLINE_TOO_MANY_ARGS)
{
WriteString("Too many arguments for command processor!\n");
}
//
// Otherwise the command was executed. Print the error
// code if one was returned.
//
else if(i32Status != 0)
{
WriteString("Command returned error code\n");
WriteString((char *)StringFromFresult((FRESULT)i32Status));
WriteString("\n");
}
//
// Reset the command flag and the command index.
//
g_ui32Flags &= ~FLAG_CMD_READY;
g_ui32CmdIdx = 0;
}
}
//*****************************************************************************
//
// Main application entry point.
//
//*****************************************************************************
int
main(void)
{
int_fast32_t i32IPart[16], i32FPart[16];
uint_fast32_t ui32Idx, ui32CompDCMStarted;
float pfData[16];
float *pfAccel, *pfGyro, *pfMag, *pfEulers, *pfQuaternion;
//
// Initialize convenience pointers that clean up and clarify the code
// meaning. We want all the data in a single contiguous array so that
// we can make our pretty printing easier later.
//
pfAccel = pfData;
pfGyro = pfData + 3;
pfMag = pfData + 6;
pfEulers = pfData + 9;
pfQuaternion = pfData + 12;
//
// Configure the system frequency.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins for this board.
//
PinoutSet(false, false);
//
// Initialize the UART.
//
ConfigureUART();
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JMPU9150 Complimentary DCM Example\n");
//
// The I2C7 peripheral must be enabled before use.
//
// For BoosterPack 2 interface use I2C8.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C7);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Configure the pin muxing for I2C7 functions on port D0 and D1.
// This step is not necessary if your part does not support pin muxing.
//
// For BoosterPack 2 interface use PA2 and PA3.
//
ROM_GPIOPinConfigure(GPIO_PD0_I2C7SCL);
ROM_GPIOPinConfigure(GPIO_PD1_I2C7SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
// For BoosterPack 2 interface use PA2 and PA3.
//
GPIOPinTypeI2CSCL(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinTypeI2C(GPIO_PORTD_BASE, GPIO_PIN_1);
//
// Configure and Enable the GPIO interrupt. Used for INT signal from the
// MPU9150.
//
// For BoosterPack 2 interface change this to PM7.
//
ROM_GPIOPinTypeGPIOInput(GPIO_PORTM_BASE, GPIO_PIN_3);
GPIOIntEnable(GPIO_PORTM_BASE, GPIO_PIN_3);
ROM_GPIOIntTypeSet(GPIO_PORTM_BASE, GPIO_PIN_3, GPIO_FALLING_EDGE);
ROM_IntEnable(INT_GPIOM);
//
// Keep only some parts of the systems running while in sleep mode.
// GPIOM is for the MPU9150 interrupt pin.
// UART0 is the virtual serial port
// I2C7 is the I2C interface to the ISL29023
//
// For BoosterPack 2 Interface change this to I2C8.
//
ROM_SysCtlPeripheralClockGating(true);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOM);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_I2C7);
//
// Enable interrupts to the processor.
//
ROM_IntMasterEnable();
//
// Initialize I2C7 peripheral.
//
// For BoosterPack 2 use I2C8.
//
I2CMInit(&g_sI2CInst, I2C7_BASE, INT_I2C7, 0xff, 0xff, g_ui32SysClock);
//
// Turn on the LED to show a transaction is starting.
//
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
//
// Initialize the MPU9150 Driver.
//
MPU9150Init(&g_sMPU9150Inst, &g_sI2CInst, MPU9150_I2C_ADDRESS,
MPU9150AppCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MPU9150AppI2CWait(__FILE__, __LINE__);
//
// Turn on the LED to show a transaction is starting.
//
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
//
// Write application specifice sensor configuration such as filter settings
// and sensor range settings.
//
g_sMPU9150Inst.pui8Data[0] = MPU9150_CONFIG_DLPF_CFG_94_98;
g_sMPU9150Inst.pui8Data[1] = MPU9150_GYRO_CONFIG_FS_SEL_250;
g_sMPU9150Inst.pui8Data[2] = (MPU9150_ACCEL_CONFIG_ACCEL_HPF_5HZ |
MPU9150_ACCEL_CONFIG_AFS_SEL_2G);
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_CONFIG, g_sMPU9150Inst.pui8Data, 3,
MPU9150AppCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MPU9150AppI2CWait(__FILE__, __LINE__);
//
// Turn on the LED to show a transaction is starting.
//
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
//
// Configure the data ready interrupt pin output of the MPU9150.
//
g_sMPU9150Inst.pui8Data[0] = MPU9150_INT_PIN_CFG_INT_LEVEL |
MPU9150_INT_PIN_CFG_INT_RD_CLEAR |
MPU9150_INT_PIN_CFG_LATCH_INT_EN;
g_sMPU9150Inst.pui8Data[1] = MPU9150_INT_ENABLE_DATA_RDY_EN;
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_INT_PIN_CFG,
g_sMPU9150Inst.pui8Data, 2, MPU9150AppCallback,
&g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MPU9150AppI2CWait(__FILE__, __LINE__);
//
// Initialize the DCM system. 50 hz sample rate.
// accel weight = .2, gyro weight = .8, mag weight = .2
//
CompDCMInit(&g_sCompDCMInst, 1.0f / 50.0f, 0.2f, 0.6f, 0.2f);
//
// Print the basic outline of our data table. Done once and then kept as we
// print only the data.
//
UARTprintf("\033[2J\033[H");
UARTprintf("MPU9150 9-Axis Simple Data Application Example\n\n");
UARTprintf("\033[20GX\033[31G|\033[43GY\033[54G|\033[66GZ\n\n");
UARTprintf("Accel\033[8G|\033[31G|\033[54G|\n\n");
UARTprintf("Gyro\033[8G|\033[31G|\033[54G|\n\n");
UARTprintf("Mag\033[8G|\033[31G|\033[54G|\n\n");
UARTprintf("\n\033[20GRoll\033[31G|\033[43GPitch\033[54G|\033[66GYaw\n\n");
UARTprintf("Eulers\033[8G|\033[31G|\033[54G|\n\n");
UARTprintf("\n\033[17GQ1\033[26G|\033[35GQ2\033[44G|\033[53GQ3\033[62G|"
"\033[71GQ4\n\n");
UARTprintf("Q\033[8G|\033[26G|\033[44G|\033[62G|\n\n");
ui32CompDCMStarted = 0;
while(1) {
//
// Go to sleep mode while waiting for data ready.
//
while(!g_vui8I2CDoneFlag) {
ROM_SysCtlSleep();
}
//
// Clear the flag
//
g_vui8I2CDoneFlag = 0;
//
// Get floating point version of the Accel Data in m/s^2.
//
MPU9150DataAccelGetFloat(&g_sMPU9150Inst, pfAccel, pfAccel + 1,
pfAccel + 2);
//
// Get floating point version of angular velocities in rad/sec
//
MPU9150DataGyroGetFloat(&g_sMPU9150Inst, pfGyro, pfGyro + 1,
pfGyro + 2);
//
// Get floating point version of magnetic fields strength in tesla
//
MPU9150DataMagnetoGetFloat(&g_sMPU9150Inst, pfMag, pfMag + 1,
pfMag + 2);
//
// Check if this is our first data ever.
//
if(ui32CompDCMStarted == 0) {
//
// Set flag indicating that DCM is started.
// Perform the seeding of the DCM with the first data set.
//
ui32CompDCMStarted = 1;
CompDCMMagnetoUpdate(&g_sCompDCMInst, pfMag[0], pfMag[1],
pfMag[2]);
CompDCMAccelUpdate(&g_sCompDCMInst, pfAccel[0], pfAccel[1],
pfAccel[2]);
CompDCMGyroUpdate(&g_sCompDCMInst, pfGyro[0], pfGyro[1],
pfGyro[2]);
CompDCMStart(&g_sCompDCMInst);
} else {
//
// DCM Is already started. Perform the incremental update.
//
CompDCMMagnetoUpdate(&g_sCompDCMInst, pfMag[0], pfMag[1],
pfMag[2]);
CompDCMAccelUpdate(&g_sCompDCMInst, pfAccel[0], pfAccel[1],
pfAccel[2]);
CompDCMGyroUpdate(&g_sCompDCMInst, -pfGyro[0], -pfGyro[1],
-pfGyro[2]);
CompDCMUpdate(&g_sCompDCMInst);
}
//
// Increment the skip counter. Skip counter is used so we do not
// overflow the UART with data.
//
g_ui32PrintSkipCounter++;
if(g_ui32PrintSkipCounter >= PRINT_SKIP_COUNT) {
//
// Reset skip counter.
//
g_ui32PrintSkipCounter = 0;
//
// Get Euler data. (Roll Pitch Yaw)
//
CompDCMComputeEulers(&g_sCompDCMInst, pfEulers, pfEulers + 1,
pfEulers + 2);
//
// Get Quaternions.
//
CompDCMComputeQuaternion(&g_sCompDCMInst, pfQuaternion);
//
// convert mag data to micro-tesla for better human interpretation.
//
pfMag[0] *= 1e6;
pfMag[1] *= 1e6;
pfMag[2] *= 1e6;
//
// Convert Eulers to degrees. 180/PI = 57.29...
// Convert Yaw to 0 to 360 to approximate compass headings.
//
pfEulers[0] *= 57.295779513082320876798154814105f;
pfEulers[1] *= 57.295779513082320876798154814105f;
pfEulers[2] *= 57.295779513082320876798154814105f;
if(pfEulers[2] < 0) {
pfEulers[2] += 360.0f;
}
//
// Now drop back to using the data as a single array for the
// purpose of decomposing the float into a integer part and a
// fraction (decimal) part.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++) {
//
// Conver float value to a integer truncating the decimal part.
//
i32IPart[ui32Idx] = (int32_t) pfData[ui32Idx];
//
// Multiply by 1000 to preserve first three decimal values.
// Truncates at the 3rd decimal place.
//
i32FPart[ui32Idx] = (int32_t) (pfData[ui32Idx] * 1000.0f);
//
// Subtract off the integer part from this newly formed decimal
// part.
//
i32FPart[ui32Idx] = i32FPart[ui32Idx] -
(i32IPart[ui32Idx] * 1000);
//
// make the decimal part a positive number for display.
//
if(i32FPart[ui32Idx] < 0) {
i32FPart[ui32Idx] *= -1;
}
}
//
// Print the acceleration numbers in the table.
//
UARTprintf("\033[5;17H%3d.%03d", i32IPart[0], i32FPart[0]);
UARTprintf("\033[5;40H%3d.%03d", i32IPart[1], i32FPart[1]);
UARTprintf("\033[5;63H%3d.%03d", i32IPart[2], i32FPart[2]);
//
// Print the angular velocities in the table.
//
UARTprintf("\033[7;17H%3d.%03d", i32IPart[3], i32FPart[3]);
UARTprintf("\033[7;40H%3d.%03d", i32IPart[4], i32FPart[4]);
UARTprintf("\033[7;63H%3d.%03d", i32IPart[5], i32FPart[5]);
//
// Print the magnetic data in the table.
//
UARTprintf("\033[9;17H%3d.%03d", i32IPart[6], i32FPart[6]);
UARTprintf("\033[9;40H%3d.%03d", i32IPart[7], i32FPart[7]);
UARTprintf("\033[9;63H%3d.%03d", i32IPart[8], i32FPart[8]);
//
// Print the Eulers in a table.
//
UARTprintf("\033[14;17H%3d.%03d", i32IPart[9], i32FPart[9]);
UARTprintf("\033[14;40H%3d.%03d", i32IPart[10], i32FPart[10]);
UARTprintf("\033[14;63H%3d.%03d", i32IPart[11], i32FPart[11]);
//
// Print the quaternions in a table format.
//
UARTprintf("\033[19;14H%3d.%03d", i32IPart[12], i32FPart[12]);
UARTprintf("\033[19;32H%3d.%03d", i32IPart[13], i32FPart[13]);
UARTprintf("\033[19;50H%3d.%03d", i32IPart[14], i32FPart[14]);
UARTprintf("\033[19;68H%3d.%03d", i32IPart[15], i32FPart[15]);
}
}
}
//*****************************************************************************
//
// Initialize SafeRTOS and start the initial set of tasks.
//
//*****************************************************************************
int
main(void)
{
tContext sContext;
tRectangle sRect;
//
// Set the clocking to run at 80 MHz from the PLL.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ |
SYSCTL_OSC_MAIN);
//
// Initialize the device pinout appropriately for this board.
//
PinoutSet();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119);
//
// 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 = 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_pFontCm20);
GrStringDrawCentered(&sContext, "safertos-demo", -1,
GrContextDpyWidthGet(&sContext) / 2, 10, 0);
//
// Set the location and size of the system stack.
//
g_sSafeRTOSPortInit.pulSystemStackLocation =
(unsigned portLONG *)(*(unsigned long *)0);
g_sSafeRTOSPortInit.ulSystemStackSizeBytes = 128 * 4;
//
// Set the location of the vector table.
//
g_sSafeRTOSPortInit.pulVectorTableBase =
(unsigned portLONG *)HWREG(NVIC_VTABLE);
//
// Initialize the SafeRTOS kernel.
//
vTaskInitializeScheduler((signed portCHAR *)g_pulIdleTaskStack,
sizeof(g_pulIdleTaskStack), 0,
&g_sSafeRTOSPortInit);
//
// Create the display task.
//
if(DisplayTaskInit() != 0)
{
GrContextForegroundSet(&sContext, ClrRed);
GrStringDrawCentered(&sContext, "Failed to create display task!", -1,
GrContextDpyWidthGet(&sContext) / 2,
(((GrContextDpyHeightGet(&sContext) - 24) / 2) +
24), 0);
while(1)
{
}
}
//
// Create the spider task.
//
if(SpiderTaskInit() != 0)
{
GrContextForegroundSet(&sContext, ClrRed);
GrStringDrawCentered(&sContext, "Failed to create spider task!", -1,
GrContextDpyWidthGet(&sContext) / 2,
(((GrContextDpyHeightGet(&sContext) - 24) / 2) +
24), 0);
while(1)
{
}
}
//
// Create the LED task.
//
if(LEDTaskInit() != 0)
{
GrContextForegroundSet(&sContext, ClrRed);
GrStringDrawCentered(&sContext, "Failed to create LED task!", -1,
GrContextDpyWidthGet(&sContext) / 2,
(((GrContextDpyHeightGet(&sContext) - 24) / 2) +
24), 0);
while(1)
{
}
}
//
// Create the lwIP tasks.
//
if(lwIPTaskInit() != 0)
{
GrContextForegroundSet(&sContext, ClrRed);
GrStringDrawCentered(&sContext, "Failed to create lwIP tasks!", -1,
GrContextDpyWidthGet(&sContext) / 2,
(((GrContextDpyHeightGet(&sContext) - 24) / 2) +
24), 0);
while(1)
{
}
}
//
// Start the scheduler. This should not return.
//
xTaskStartScheduler(pdTRUE);
//
// In case the scheduler returns for some reason, print an error and loop
// forever.
//
GrContextForegroundSet(&sContext, ClrRed);
GrStringDrawCentered(&sContext, "Failed to start scheduler!", -1,
GrContextDpyWidthGet(&sContext) / 2,
(((GrContextDpyHeightGet(&sContext) - 24) / 2) + 24),
0);
while(1)
{
}
}
//*****************************************************************************
//
// Provides a scribble pad using the display on the Intelligent Display Module.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "scribble");
//
// Print the instructions across the top of the screen in white with a 20
// point san-serif font.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
GrContextFontSet(&g_sContext, g_psFontCmss20);
GrStringDrawCentered(&g_sContext, "Touch the screen to draw", -1,
GrContextDpyWidthGet(&g_sContext) / 2,
((GrContextDpyHeightGet(&g_sContext) - 32) / 2) + 14,
0);
//
// Flush any cached drawing operations.
//
GrFlush(&g_sContext);
//
// Set the color index to zero.
//
g_ui32ColorIdx = 0;
//
// Initialize the message queue we use to pass messages from the touch
// interrupt handler context to the main loop for processing.
//
RingBufInit(&g_sMsgQueue, (uint8_t *)g_psMsgQueueBuffer,
(MSG_QUEUE_SIZE * sizeof(tScribbleMessage)));
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(TSHandler);
//
// Loop forever. All the drawing is done in the touch screen event
// handler.
//
while(1)
{
//
// Process any new touchscreen messages.
//
ProcessTouchMessages();
}
}
/*
* main.c
*/
int main(void) {
float fTemperature, fHumidity;
int32_t i32IntegerPart;
int32_t i32FractionPart;
g_ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//confiugre the GPIO pins
PinoutSet(false,false);
ConfigureUART();
//configure I2C pins
SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C8);
GPIOPinConfigure(GPIO_PA2_I2C8SCL);
GPIOPinConfigure(GPIO_PA3_I2C8SDA);
GPIOPinTypeI2C(GPIO_PORTA_BASE,GPIO_PIN_2);
GPIOPinTypeI2C(GPIO_PORTA_BASE,GPIO_PIN_3);
//enable interrupts
IntMasterEnable();
//initialize I2C
I2CMInit(&g_sI2CInst,I2C8_BASE,INT_I2C8,0xff,0xff,g_ui32SysClock);
IntPrioritySet(INT_I2C7,0xE0);
//initialize the sensors
SHT21Init(&g_sSHT21Inst, &g_sI2CInst, SHT21_I2C_ADDRESS,
SHT21AppCallback,&g_sSHT21Inst);
//delay for 20 ms
SysCtlDelay(g_ui32SysClock / (50 * 3));
while(1){
//
// Turn on D2 to show we are starting a transaction with the sensor.
// This is turned off in the application callback.
//
LEDWrite(CLP_D1 | CLP_D2 , CLP_D2);
//
// Write the command to start a humidity measurement.
//
SHT21Write(&g_sSHT21Inst, SHT21_CMD_MEAS_RH, g_sSHT21Inst.pui8Data, 0,
SHT21AppCallback, &g_sSHT21Inst);
//
// Wait for the I2C transactions to complete before moving forward.
//
SHT21AppI2CWait(__FILE__, __LINE__);
//
// Wait 33 milliseconds before attempting to get the result. Datasheet
// claims this can take as long as 29 milliseconds.
//
SysCtlDelay(g_ui32SysClock / (30 * 3));
//
// Turn on D2 to show we are starting a transaction with the sensor.
// This is turned off in the application callback.
//
LEDWrite(CLP_D1 | CLP_D2 , CLP_D2);
//
// Get the raw data from the sensor over the I2C bus.
//
SHT21DataRead(&g_sSHT21Inst, SHT21AppCallback, &g_sSHT21Inst);
//
// Wait for the I2C transactions to complete before moving forward.
//
SHT21AppI2CWait(__FILE__, __LINE__);
//
// Get a copy of the most recent raw data in floating point format.
//
SHT21DataHumidityGetFloat(&g_sSHT21Inst, &fHumidity);
//
// Turn on D2 to show we are starting a transaction with the sensor.
// This is turned off in the application callback.
//
LEDWrite(CLP_D1 | CLP_D2 , CLP_D2);
//
// Write the command to start a temperature measurement.
//
SHT21Write(&g_sSHT21Inst, SHT21_CMD_MEAS_T, g_sSHT21Inst.pui8Data, 0,
SHT21AppCallback, &g_sSHT21Inst);
//
// Wait for the I2C transactions to complete before moving forward.
//
SHT21AppI2CWait(__FILE__, __LINE__);
//
// Wait 100 milliseconds before attempting to get the result. Datasheet
// claims this can take as long as 85 milliseconds.
//
SysCtlDelay(g_ui32SysClock / (10 * 3));
//
// Turn on D2 to show we are starting a transaction with the sensor.
// This is turned off in the application callback.
//
LEDWrite(CLP_D1 | CLP_D2 , CLP_D2);
//
// Read the conversion data from the sensor over I2C.
//
SHT21DataRead(&g_sSHT21Inst, SHT21AppCallback, &g_sSHT21Inst);
//
// Wait for the I2C transactions to complete before moving forward.
//
SHT21AppI2CWait(__FILE__, __LINE__);
//
// Get the most recent temperature result as a float in celcius.
//
SHT21DataTemperatureGetFloat(&g_sSHT21Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print. Humidity is returned as 0.0 to 1.0 so multiply by 100 to get
// percent humidity.
//
fHumidity *= 100.0f;
i32IntegerPart = (int32_t) fHumidity;
i32FractionPart = (int32_t) (fHumidity * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print the humidity value using the integers we just created.
//
UARTprintf("Humidity %3d.%03d\t", i32IntegerPart, i32FractionPart);
//
// Perform the conversion from float to a printable set of integers.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart = (int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print the temperature as integer and fraction parts.
//
UARTprintf("Temperature %3d.%03d\n", i32IntegerPart, i32FractionPart);
//
// Delay for one second. This is to keep sensor duty cycle
// to about 10% as suggested in the datasheet, section 2.4.
// This minimizes self heating effects and keeps reading more accurate.
//
SysCtlDelay(g_ui32SysClock / 3);
}
return 0;
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
tContext sContext;
//
// 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, "uart-echo");
//
// Display UART configuration on the display.
//
GrStringDraw(&sContext, "Port:", -1, 70, 70, 0);
GrStringDraw(&sContext, "Baud:", -1, 70, 95, 0);
GrStringDraw(&sContext, "Data:", -1, 70, 120, 0);
GrStringDraw(&sContext, "Parity:", -1, 70, 145, 0);
GrStringDraw(&sContext, "Stop:", -1, 70, 170, 0);
GrStringDraw(&sContext, "Uart 0", -1, 150, 70, 0);
GrStringDraw(&sContext, "115,200 bps", -1, 150, 95, 0);
GrStringDraw(&sContext, "8 Bit", -1, 150, 120, 0);
GrStringDraw(&sContext, "None", -1, 150, 145, 0);
GrStringDraw(&sContext, "1 Bit", -1, 150, 170, 0);
//
// Enable the (non-GPIO) peripherals used by this example. PinoutSet()
// already enabled GPIO Port A.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Configure the UART for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 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)
{
}
}
int main()
{
//
// Make sure the main oscillator is enabled because this is required by
// the PHY. The system must have a 25MHz crystal attached to the OSC
// pins. The SYSCTL_MOSC_HIGHFREQ parameter is used when the crystal
// frequency is 10MHz or higher.
//
SysCtlMOSCConfigSet(SYSCTL_MOSC_HIGHFREQ);
//
// Run from the PLL at 120 MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
// Configure the device pins.
//
PinoutSet(true, false);
//
// Configure UART.
//
//UARTStdioConfig(0, 115200, g_ui32SysClock);
//
// Clear the terminal and print banner.
//
//UARTprintf("\033[2J\033[H");
//UARTprintf("Ethernet lwIP example\n\n");
//
// Configure Port N1 for as an output for the animation LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_1);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1);
//
// Initialize LED to OFF (0)
//
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1, ~GPIO_PIN_1);
//
// Configure SysTick for a periodic interrupt.
//
MAP_SysTickPeriodSet(g_ui32SysClock / SYSTICKHZ);
MAP_SysTickEnable();
MAP_SysTickIntEnable();
// Init Onion Client
client = new OnionClient("o8Ik6DuC","NfyGRECh3WSZw9xn");
client->registerFunction("/on",ledOn,0,0);
client->registerFunction("/off",ledOff,0,0);
char *params[1] = {"data"};
client->registerFunction("/pubTest",pubTest,params,1);
client->init(g_ui32SysClock);
//
// Setup Onion Client
//
//httpd_init();
//client->begin();
//
// Set the interrupt priorities. We set the SysTick interrupt to a higher
// priority than the Ethernet interrupt to ensure that the file system
// tick is processed if SysTick occurs while the Ethernet handler is being
// processed. This is very likely since all the TCP/IP and HTTP work is
// done in the context of the Ethernet interrupt.
//
MAP_IntPrioritySet(INT_EMAC0, ETHERNET_INT_PRIORITY);
MAP_IntPrioritySet(FAULT_SYSTICK, SYSTICK_INT_PRIORITY);
//
// Loop forever. All the work is done in interrupt handlers.
//
uint32_t last_time = g_millis;
bool led = false;
while(1)
{
if ((g_millis - last_time) > 500) {
if (led) {
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, ~GPIO_PIN_0);
led = false;
} else {
MAP_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, GPIO_PIN_0);
led = true;
}
last_time = g_millis;
}
client->loop();
}
return 0;
}
//*****************************************************************************
//
// Run the AES encryption/decryption example
//
//*****************************************************************************
int
main(void)
{
unsigned char ucBlockBuf[17];
const unsigned *puKey;
unsigned char ucTempIV[16];
tContext sContext;
tRectangle sRect;
long lCenterX;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the pinout appropriately for this board.
//
PinoutSet();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context and find the middle X coordinate.
//
GrContextInit(&sContext, &g_sKitronix320x240x16_SSD2119);
lCenterX = GrContextDpyWidthGet(&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(&sContext) - 1;
sRect.sYMax = 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_pFontCm20);
GrStringDrawCentered(&sContext, "aes-expanded-key", -1, lCenterX, 8, 0);
//
// Print the plain text title
//
GrContextFontSet(&sContext, g_pFontCmss22b);
GrStringDrawCentered(&sContext, "Plain Text:", -1, lCenterX, 60, 0);
GrStringDrawCentered(&sContext, g_cPlainText, -1, lCenterX, 85, 0);
//
// Get the expanded key to use for encryption
//
puKey = AESExpandedEncryptKeyData();
//
// Generate the initialization vector needed for CBC mode.
// A temporary copy is made that will be used with the crypt
// function because the crypt function will modify the IV that is passed.
//
AESGenerateIV(g_ucIV, 1);
memcpy(ucTempIV, g_ucIV, 16);
//
// Encrypt the plaintext message using CBC mode
//
aes_crypt_cbc(puKey, AES_ENCRYPT, 16, ucTempIV,
(unsigned char *)g_cPlainText, ucBlockBuf);
//
// Print the encrypted block to the display. Note that it will
// appear as nonsense data. The block needs to be null terminated
// so that the StringDraw function will work correctly.
//
ucBlockBuf[16] = 0;
GrStringDrawCentered(&sContext, "Encrypted:", -1, lCenterX, 120, 0);
GrStringDrawCentered(&sContext, (char *)ucBlockBuf, -1, lCenterX, 145, 0);
//
// Get the expanded key to use for decryption
//
puKey = AESExpandedDecryptKeyData();
//
// Decrypt the message using CBC mode
//
memcpy(ucTempIV, g_ucIV, 16);
aes_crypt_cbc(puKey, AES_DECRYPT, 16, ucTempIV, ucBlockBuf, ucBlockBuf);
//
// Print the decrypted block to the display. It should be the same text
// as the original message.
//
GrStringDrawCentered(&sContext, "Decrypted:", -1, lCenterX, 180, 0);
GrStringDrawCentered(&sContext, (char *)ucBlockBuf, -1, lCenterX, 205, 0);
//
// Finished.
//
while(1)
{
}
}
//*****************************************************************************
//
// A simple demonstration of the features of the TivaWare Graphics Library.
//
//*****************************************************************************
int
main(void)
{
tContext sContext;
uint32_t ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Set graphics library text rendering defaults.
//
GrLibInit(&GRLIB_INIT_STRUCT);
//
// Set the string table and the default language.
//
GrStringTableSet(STRING_TABLE);
//
// Set the default language.
//
ChangeLanguage(GrLangEnUS);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "lang-demo");
//
// Load the static strings from the string table. These strings are
// independent of the language in use but we store them in the string
// table nonetheless since (a) we may be using codepage remapping in
// which case it would be difficult to hardcode them into the app source
// anyway (ASCII or ISO8859-1 text would not render properly with the
// remapped custom font) and (b) even if we're not using codepage remapping,
// we may have generated a custom font from the string table output and
// we want to make sure that all glyphs required by the application are
// present in that font. If we hardcode some text in the application
// source and don't put it in the string table, we run the risk of having
// characters missing in the font.
//
GrStringGet(STR_ENGLISH, g_pcEnglish, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_DEUTSCH, g_pcDeutsch, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_ESPANOL, g_pcEspanol, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_ITALIANO, g_pcItaliano, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_CHINESE, g_pcChinese, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_KOREAN, g_pcKorean, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_JAPANESE, g_pcJapanese, MAX_LANGUAGE_NAME_LEN);
GrStringGet(STR_PLUS, g_pcPlus, 2);
GrStringGet(STR_MINUS, g_pcMinus, 2);
//
// Initialize the touch screen driver and have it route its messages to the
// widget tree.
//
TouchScreenInit(ui32SysClock);
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the title block and the previous and next buttons to the widget
// tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sPrevious);
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sTitle);
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sNext);
//
// Add the first panel to the widget tree.
//
g_ui32Panel = 0;
WidgetAdd(WIDGET_ROOT, (tWidget *)g_psPanels);
//
// Set the string for the title.
//
CanvasTextSet(&g_sTitle, g_pcTitle);
//
// Issue the initial paint request to the widgets.
//
WidgetPaint(WIDGET_ROOT);
//
// Loop forever, processing widget messages.
//
while(1)
{
//
// Process any messages in the widget message queue.
//
WidgetMessageQueueProcess();
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the device pinout appropriately for this board.
//
PinoutSet();
#ifdef DEBUG
//
// Open UART0 for debug output.
//
UARTStdioInit(0);
#endif
//
// Set the system tick to fire 100 times per second.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);
ROM_SysTickIntEnable();
ROM_SysTickEnable();
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);
//
// 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) - 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, "boot-demo-usb", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 10, 0);
//
// Draw the buttons in their initial (unpressed)state.
//
UpdateDisplay(g_ucButtons, true);
//
// Initialize each of the device instances that will form our composite
// USB device.
//
g_sCompDevice.psDevices[0].pvInstance =
USBDHIDMouseCompositeInit(0, (tUSBDHIDMouseDevice *)&g_sMouseDevice);
g_sCompDevice.psDevices[1].pvInstance =
USBDDFUCompositeInit(0, (tUSBDDFUDevice *)&g_sDFUDevice);
//
// Pass the USB library our device information, initialize the USB
// controller and connect the device to the bus.
//
USBDCompositeInit(0, &g_sCompDevice, DESCRIPTOR_BUFFER_SIZE,
g_pcDescriptorBuffer);
//
// Initialize the touch screen driver.
//
TouchScreenInit();
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(MouseTouchHandler);
//
// Drop into the main loop.
//
while(!g_bUpdateSignalled)
{
//
// Tell the user what we are doing.
//
GrContextFontSet(&g_sContext, g_pFontCmss22b);
GrContextForegroundSet(&g_sContext, ClrWhite);
GrStringDrawCentered(&g_sContext, " Waiting for host... ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// Wait for USB configuration to complete.
//
while(!g_bConnected)
{
}
//
// Update the status.
//
GrStringDrawCentered(&g_sContext, " Host connected... ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// Now keep processing the mouse as long as the host is connected and
// we've not been told to prepare for a firmware upgrade.
//
while(g_bConnected && !g_bUpdateSignalled)
{
//
// If it is time to check the touchscreen state then do so.
//
if(g_ulCommands & TOUCH_TICK_EVENT)
{
g_ulCommands &= ~TOUCH_TICK_EVENT;
TouchHandler();
}
}
//
// If we drop out of the previous loop, either the host has
// disconnected or a firmware upgrade has been signalled.
//
}
//
// Tell the user what's going on.
//
GrContextFontSet(&g_sContext, g_pFontCmss22b);
GrStringDrawCentered(&g_sContext, " Switching to DFU mode ", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 40, true);
//
// If we get here, a firmware upgrade has been signalled so we need to get
// back into the boot loader to allow this to happen. Call the USB DFU
// device class to do this for us. Note that this function never returns.
//
USBDDFUUpdateBegin();
}
//*****************************************************************************
//
// This example encrypts blocks of plaintext using TDES in CBC mode. It
// does the encryption first without uDMA and then with uDMA. The results
// are checked after each operation.
//
//*****************************************************************************
int
main(void)
{
uint32_t pui32CipherText[16], ui32Errors, ui32Idx, ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet(false, false);
//
// Initialize local variables.
//
ui32Errors = 0;
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32CipherText[ui32Idx] = 0;
}
//
// Enable stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPUStackingEnable();
//
// Enable DES interrupts.
//
ROM_IntEnable(INT_DES0);
//
// Enable debug output on UART0 and print a welcome message.
//
ConfigureUART();
UARTprintf("Starting TDES CBC encryption demo.\n");
//
// Enable the uDMA module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
//
// Setup the control table.
//
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initialize the CCM and DES modules.
//
if(!DESInit())
{
UARTprintf("Initialization of the DES module failed.\n");
ui32Errors |= 0x00000001;
}
//
// Perform the encryption without uDMA.
//
UARTprintf("Performing encryption without uDMA.\n");
TDESCBCEncrypt(g_pui32TDESPlainText, pui32CipherText, g_pui32TDESKey,
64, g_pui32TDESIV, false);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
if(pui32CipherText[ui32Idx] != g_pui32TDESCipherText[ui32Idx])
{
UARTprintf("Ciphertext mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, g_pui32TDESCipherText[ui32Idx],
pui32CipherText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
//
// Clear the array containing the ciphertext.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32CipherText[ui32Idx] = 0;
}
//
// Perform the encryption with uDMA.
//
UARTprintf("Performing encryption with uDMA.\n");
TDESCBCEncrypt(g_pui32TDESPlainText, pui32CipherText, g_pui32TDESKey,
64, g_pui32TDESIV, true);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
if(pui32CipherText[ui32Idx] != g_pui32TDESCipherText[ui32Idx])
{
UARTprintf("Ciphertext mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, g_pui32TDESCipherText[ui32Idx],
pui32CipherText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000004;
}
}
//
// Finished.
//
if(ui32Errors)
{
UARTprintf("Demo failed with error code 0x%x.\n", ui32Errors);
LEDWrite(CLP_D3 | CLP_D4, CLP_D4);
}
else
{
UARTprintf("Demo completed successfully.\n");
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
}
while(1)
{
}
}
//*****************************************************************************
//
// Main 'C' Language entry point.
//
//*****************************************************************************
int
main(void)
{
float fTemperature, fPressure, fAltitude;
int32_t i32IntegerPart;
int32_t i32FractionPart;
tContext sContext;
uint32_t ui32SysClock;
char pcBuf[15];
//
// Setup the system clock to run at 40 Mhz from PLL with crystal reference
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 40000000);
//
// 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, "bmp180");
//
// Flush any cached drawing operations.
//
GrFlush(&sContext);
//
// Enable UART0
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
//
// Initialize the UART for console I/O.
//
UARTStdioConfig(0, 115200, ui32SysClock);
//
// Print the welcome message to the terminal.
//
UARTprintf("\033[2JBMP180 Example\n");
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
// This step is not necessary if your part does not support pin muxing.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
ui32SysClock);
//
// Initialize the BMP180
//
BMP180Init(&g_sBMP180Inst, &g_sI2CInst, BMP180_I2C_ADDRESS,
BMP180AppCallback, &g_sBMP180Inst);
//
// Wait for initialization callback to indicate reset request is complete.
//
while(g_vui8DataFlag == 0)
{
//
// Wait for I2C Transactions to complete.
//
}
//
// Reset the data ready flag
//
g_vui8DataFlag = 0;
//
// Enable the system ticks at 10 hz.
//
MAP_SysTickPeriodSet(ui32SysClock / (10 * 3));
MAP_SysTickIntEnable();
MAP_SysTickEnable();
//
// Configure PQ4 to control the blue LED.
//
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4);
//
// Print temperature, pressure and altitude labels once on the LCD.
//
GrStringDraw(&sContext, "Temperature", 11,
((GrContextDpyWidthGet(&sContext) / 2) - 96),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
GrStringDraw(&sContext, "Pressure", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 63),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
GrStringDraw(&sContext, "Altitude", 8,
((GrContextDpyWidthGet(&sContext) / 2) - 59),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
//
// Begin the data collection and printing. Loop Forever.
//
while(1)
{
//
// Read the data from the BMP180 over I2C. This command starts a
// temperature measurement. Then polls until temperature is ready.
// Then automatically starts a pressure measurement and polls for that
// to complete. When both measurement are complete and in the local
// buffer then the application callback is called from the I2C
// interrupt context. Polling is done on I2C interrupts allowing
// processor to continue doing other tasks as needed.
//
BMP180DataRead(&g_sBMP180Inst, BMP180AppCallback, &g_sBMP180Inst);
while(g_vui8DataFlag == 0)
{
//
// Wait for the new data set to be available.
//
}
//
// Reset the data ready flag.
//
g_vui8DataFlag = 0;
//
// Get a local copy of the latest temperature data in float format.
//
BMP180DataTemperatureGetFloat(&g_sBMP180Inst, &fTemperature);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fTemperature;
i32FractionPart =(int32_t) (fTemperature * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print temperature with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%03d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) - 24, 1);
UARTprintf("Temperature %3d.%03d\t\t", i32IntegerPart,
i32FractionPart);
//
// Get a local copy of the latest air pressure data in float format.
//
BMP180DataPressureGetFloat(&g_sBMP180Inst, &fPressure);
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fPressure;
i32FractionPart =(int32_t) (fPressure * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print Pressure with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, -1,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
(GrContextDpyHeightGet(&sContext) - 32) / 2, 1);
UARTprintf("Pressure %3d.%03d\t\t", i32IntegerPart, i32FractionPart);
//
// Calculate the altitude.
//
fAltitude = 44330.0f * (1.0f - powf(fPressure / 101325.0f,
1.0f / 5.255f));
//
// Convert the floats to an integer part and fraction part for easy
// print.
//
i32IntegerPart = (int32_t) fAltitude;
i32FractionPart =(int32_t) (fAltitude * 1000.0f);
i32FractionPart = i32FractionPart - (i32IntegerPart * 1000);
if(i32FractionPart < 0)
{
i32FractionPart *= -1;
}
//
// Print altitude with three digits of decimal precision to LCD and
// terminal.
//
usnprintf(pcBuf, sizeof(pcBuf), "%3d.%03d ", i32IntegerPart,
i32FractionPart);
GrStringDraw(&sContext, pcBuf, 8,
((GrContextDpyWidthGet(&sContext) / 2) + 16),
((GrContextDpyHeightGet(&sContext) - 32) / 2) + 24, 1);
UARTprintf("Altitude %3d.%03d", i32IntegerPart, i32FractionPart);
//
// Print new line.
//
UARTprintf("\n");
//
// Delay to keep printing speed reasonable. About 100 milliseconds.
//
MAP_SysCtlDelay(ui32SysClock / (10 * 3));
}
}
//*****************************************************************************
//
// This is the main loop that runs the application.
//
//*****************************************************************************
int
main(void)
{
uint8_t ui8ButtonsChanged, ui8Buttons;
uint32_t ui32SysClock;
//
// Set the clocking to run from the PLL at 120MHz
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_25MHZ |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet();
//
// Configure the buttons driver.
//
ButtonsInit(ALL_BUTTONS);
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&g_sContext, "usb-dev-gamepad");
//
// Default status is disconnected.
//
DisplayStatus(&g_sContext, "Disconnected");
//
// Not configured initially.
//
g_iGamepadState = eStateNotConfigured;
//
// Initialize the USB stack for device mode.
//
USBStackModeSet(0, eUSBModeDevice, 0);
//
// Pass the device information to the USB library and place the device
// on the bus.
//
USBDHIDGamepadInit(0, &g_sGamepadDevice);
//
// Zero out the initial report.
//
g_sReport.ui8Buttons = 0;
g_sReport.i8XPos = 0;
g_sReport.i8YPos = 0;
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(TSHandler);
//
// The main loop starts here. We begin by waiting for a host connection
// then drop into the main gamepad handling section. If the host
// disconnects, we return to the top and wait for a new connection.
//
while(1)
{
//
// Wait here until USB device is connected to a host.
//
if(g_iGamepadState == eStateIdle)
{
//
// See if the buttons updated.
//
ButtonsPoll(&ui8ButtonsChanged, &ui8Buttons);
g_sReport.ui8Buttons = 0;
//
// Set button 1 if up button pressed.
//
if(ui8Buttons & UP_BUTTON)
{
g_sReport.ui8Buttons |= 0x01;
}
//
// Set button 2 if down button pressed.
//
if(ui8Buttons & DOWN_BUTTON)
{
g_sReport.ui8Buttons |= 0x02;
}
//
// Set button 3 if select button pressed.
//
if(ui8Buttons & SELECT_BUTTON)
{
g_sReport.ui8Buttons |= 0x04;
}
if(ui8ButtonsChanged)
{
g_bUpdate = true;
}
//
// Send the report if there was an update.
//
if(g_bUpdate)
{
g_bUpdate = false;
USBDHIDGamepadSendReport(&g_sGamepadDevice, &g_sReport,
sizeof(g_sReport));
//
// Now sending data but protect this from an interrupt since
// it can change in interrupt context as well.
//
IntMasterDisable();
g_iGamepadState = eStateSending;
IntMasterEnable();
}
}
}
}
//*****************************************************************************
//
// This example generates hashes from a random block of data and empty block.
//
//*****************************************************************************
int
main(void)
{
uint32_t pui32HashResult[5], ui32Errors, ui32Vector, ui32Idx, ui32SysClock;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet(false, false);
//
// Initialize local variables.
//
ui32Errors = 0;
//
// Enable SHA interrupts.
//
ROM_IntEnable(INT_SHA0);
//
// Enable debug output on UART0 and print a welcome message.
//
ConfigureUART();
UARTprintf("Starting SHA1 hash encryption demo.\n");
//
// Enable the uDMA module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
//
// Setup the control table.
//
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initialize the CCM and SHAMD5 modules.
//
if(!SHAMD5Init())
{
UARTprintf("Initialization of the SHA module failed.\n");
ui32Errors |= 0x00000001;
}
//
// Run tests without uDMA.
//
for(ui32Vector = 0; ui32Vector < 3; ui32Vector++)
{
UARTprintf("Running test #%d without uDMA\n", ui32Vector);
//
// Generate the hash.
//
SHA1HashGenerate(g_pui32RandomData,
g_psSHA1TestVectors[ui32Vector].ui32DataLength,
pui32HashResult, false);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 5; ui32Idx++)
{
if(pui32HashResult[ui32Idx] !=
g_psSHA1TestVectors[ui32Vector].pui32HashResult[ui32Idx])
{
UARTprintf("Hash result mismatch - Exp: 0x%x, Act: 0x%x\n",
g_psSHA1TestVectors[ui32Vector].
pui32HashResult[ui32Idx], pui32HashResult[0]);
ui32Errors |= ((ui32Idx << 16) | 0x2);
}
}
}
//
// Run tests with uDMA.
//
for(ui32Vector = 0; ui32Vector < 3; ui32Vector++)
{
UARTprintf("Running test #%d with uDMA\n", ui32Vector);
//
// Generate the hash.
//
SHA1HashGenerate(g_pui32RandomData,
g_psSHA1TestVectors[ui32Vector].ui32DataLength,
pui32HashResult, true);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 5; ui32Idx++)
{
if(pui32HashResult[ui32Idx] !=
g_psSHA1TestVectors[ui32Vector].pui32HashResult[ui32Idx])
{
UARTprintf("Hash result mismatch - Exp: 0x%x, Act: 0x%x\n",
g_psSHA1TestVectors[ui32Vector].
pui32HashResult[ui32Idx], pui32HashResult[0]);
ui32Errors |= ((ui32Idx << 16) | 0x3);
}
}
}
//
// Finished.
//
if(ui32Errors)
{
UARTprintf("Demo failed with error code 0x%x.\n", ui32Errors);
LEDWrite(CLP_D3 | CLP_D4, CLP_D4);
}
else
{
UARTprintf("Demo completed successfully.\n");
LEDWrite(CLP_D3 | CLP_D4, CLP_D3);
}
while(1)
{
}
}
//*****************************************************************************
//
// This example decrypts a block of payload using AES128 in CCM mode. It
// does the decryption first without uDMA and then with uDMA. The results
// are checked after each operation.
//
//*****************************************************************************
int
main(void)
{
uint32_t pui32Payload[16], pui32Tag[4], ui32Errors, ui32Idx;
uint32_t ui32PayloadLength, ui32TagLength;
uint32_t ui32NonceLength, ui32AuthDataLength;
uint32_t *pui32Nonce, *pui32AuthData, ui32SysClock;
uint32_t *pui32Key, *pui32ExpPayload, *pui32CipherText;
uint8_t ui8Vector;
uint8_t *pui8ExpTag, *pui8Tag;
tContext sContext;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = 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, "aes128-ccm-decrypt");
//
// Show some instructions on the display
//
GrContextFontSet(&sContext, g_psFontCm20);
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDrawCentered(&sContext, "Connect a terminal to", -1,
GrContextDpyWidthGet(&sContext) / 2, 60, false);
GrStringDrawCentered(&sContext, "UART0 (115200,N,8,1)", -1,
GrContextDpyWidthGet(&sContext) / 2, 80, false);
GrStringDrawCentered(&sContext, "for more information.", -1,
GrContextDpyWidthGet(&sContext) / 2, 100, false);
//
// Initialize local variables.
//
ui32Errors = 0;
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32Payload[ui32Idx] = 0;
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
pui32Tag[ui32Idx] = 0;
}
pui8Tag = (uint8_t *)pui32Tag;
//
// Enable stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPUStackingEnable();
//
// Configure the system clock to run off the internal 16MHz oscillator.
//
ROM_SysCtlClockFreqSet(SYSCTL_OSC_INT | SYSCTL_USE_OSC, 16000000);
//
// Enable AES interrupts.
//
ROM_IntEnable(INT_AES0);
//
// Enable debug output on UART0 and print a welcome message.
//
ConfigureUART();
UARTprintf("Starting AES128 CCM decryption demo.\n");
GrStringDrawCentered(&sContext, "Starting demo...", -1,
GrContextDpyWidthGet(&sContext) / 2, 140, false);
//
// Enable the uDMA module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
//
// Setup the control table.
//
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initialize the CCM and AES modules.
//
if(!AESInit())
{
UARTprintf("Initialization of the AES module failed.\n");
ui32Errors |= 0x00000001;
}
//
// Loop through all the given vectors.
//
for(ui8Vector = 0;
(ui8Vector <
(sizeof(g_psAESCCMTestVectors) / sizeof(g_psAESCCMTestVectors[0]))) &&
(ui32Errors == 0);
ui8Vector++)
{
UARTprintf("Starting vector #%d\n", ui8Vector);
//
// Get the current vector's data members.
//
pui32Key = g_psAESCCMTestVectors[ui8Vector].pui32Key;
pui32ExpPayload = g_psAESCCMTestVectors[ui8Vector].pui32Payload;
ui32PayloadLength =
g_psAESCCMTestVectors[ui8Vector].ui32PayloadLength;
pui32AuthData = g_psAESCCMTestVectors[ui8Vector].pui32AuthData;
ui32AuthDataLength =
g_psAESCCMTestVectors[ui8Vector].ui32AuthDataLength;
pui32CipherText =
g_psAESCCMTestVectors[ui8Vector].pui32CipherText;
pui8ExpTag = (uint8_t *)g_psAESCCMTestVectors[ui8Vector].pui32Tag;
ui32TagLength = g_psAESCCMTestVectors[ui8Vector].ui32TagLength;
pui32Nonce = g_psAESCCMTestVectors[ui8Vector].pui32Nonce;
ui32NonceLength =
g_psAESCCMTestVectors[ui8Vector].ui32NonceLength;
//
// Perform the decryption without uDMA.
//
UARTprintf("Performing decryption without uDMA.\n");
AES128CCMDecrypt(pui32Key, pui32CipherText, pui32Payload,
ui32PayloadLength, pui32Nonce, ui32NonceLength,
pui32AuthData, ui32AuthDataLength, pui32Tag,
ui32TagLength, false);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < (ui32PayloadLength / 4); ui32Idx++)
{
if(pui32Payload[ui32Idx] != pui32ExpPayload[ui32Idx])
{
UARTprintf("Payload mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui32ExpPayload[ui32Idx],
pui32Payload[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
for(ui32Idx = 0; ui32Idx < ui32TagLength; ui32Idx++)
{
if(pui8Tag[ui32Idx] != pui8ExpTag[ui32Idx])
{
UARTprintf("Tag mismatch on byte %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui8ExpTag[ui32Idx],
pui8Tag[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000004;
}
}
//
// Clear the array containing the ciphertext.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32Payload[ui32Idx] = 0;
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
pui32Tag[ui32Idx] = 0;
}
//
// Perform the decryption with uDMA.
//
UARTprintf("Performing decryption with uDMA.\n");
AES128CCMDecrypt(pui32Key, pui32CipherText, pui32Payload,
ui32PayloadLength, pui32Nonce, ui32NonceLength,
pui32AuthData, ui32AuthDataLength, pui32Tag,
ui32TagLength, true);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < (ui32PayloadLength / 4); ui32Idx++)
{
if(pui32Payload[ui32Idx] != pui32ExpPayload[ui32Idx])
{
UARTprintf("Payload mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui32ExpPayload[ui32Idx],
pui32Payload[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
for(ui32Idx = 0; ui32Idx < ui32TagLength; ui32Idx++)
{
if(pui8Tag[ui32Idx] != pui8ExpTag[ui32Idx])
{
UARTprintf("Tag mismatch on byte %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui8ExpTag[ui32Idx],
pui8Tag[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000004;
}
}
//
// Clear the array containing the ciphertext.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32Payload[ui32Idx] = 0;
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
pui32Tag[ui32Idx] = 0;
}
}
//
// Finished.
//
if(ui32Errors)
{
UARTprintf("Demo failed with error code 0x%x.\n", ui32Errors);
GrStringDrawCentered(&sContext, "Demo failed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
else
{
UARTprintf("Demo completed successfully.\n");
GrStringDrawCentered(&sContext, "Demo passed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
while(1)
{
}
}
//*****************************************************************************
//
// This example decrypts blocks ciphertext using AES128 and AES256 in GCM
// mode. It does the decryption first without uDMA and then with uDMA.
// The results are checked after each operation.
//
//*****************************************************************************
int
main(void)
{
uint32_t pui32PlainText[64], pui32Tag[4], pui32Y0[4], ui32Errors, ui32Idx;
uint32_t *pui32Key, ui32IVLength, *pui32IV, ui32DataLength;
uint32_t *pui32ExpPlainText, ui32AuthDataLength, *pui32AuthData;
uint32_t *pui32CipherText, *pui32ExpTag;
uint32_t ui32KeySize;
uint32_t ui32SysClock;
uint8_t ui8Vector;
tContext sContext;
//
// 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, "aes-gcm-decrypt");
//
// Show some instructions on the display
//
GrContextFontSet(&sContext, g_psFontCm20);
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDrawCentered(&sContext, "Connect a terminal to", -1,
GrContextDpyWidthGet(&sContext) / 2, 60, false);
GrStringDrawCentered(&sContext, "UART0 (115200,N,8,1)", -1,
GrContextDpyWidthGet(&sContext) / 2, 80, false);
GrStringDrawCentered(&sContext, "for more information.", -1,
GrContextDpyWidthGet(&sContext) / 2, 100, false);
//
// Initialize local variables.
//
ui32Errors = 0;
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32PlainText[ui32Idx] = 0;
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
pui32Tag[ui32Idx] = 0;
}
//
// Enable stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPUStackingEnable();
//
// Enable AES interrupts.
//
ROM_IntEnable(INT_AES0);
//
// Enable debug output on UART0 and print a welcome message.
//
ConfigureUART();
UARTprintf("Starting AES GCM decryption demo.\n");
GrStringDrawCentered(&sContext, "Starting demo...", -1,
GrContextDpyWidthGet(&sContext) / 2, 140, false);
//
// Enable the uDMA module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
//
// Setup the control table.
//
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initialize the CCM and AES modules.
//
if(!AESInit())
{
UARTprintf("Initialization of the AES module failed.\n");
ui32Errors |= 0x00000001;
}
//
// Loop through all the given vectors.
//
for(ui8Vector = 0;
(ui8Vector <
(sizeof(g_psAESGCMTestVectors) / sizeof(g_psAESGCMTestVectors[0]))) &&
(ui32Errors == 0);
ui8Vector++)
{
UARTprintf("Starting vector #%d\n", ui8Vector);
//
// Get the current vector's data members.
//
ui32KeySize = g_psAESGCMTestVectors[ui8Vector].ui32KeySize;
pui32Key = g_psAESGCMTestVectors[ui8Vector].pui32Key;
ui32IVLength = g_psAESGCMTestVectors[ui8Vector].ui32IVLength;
pui32IV = g_psAESGCMTestVectors[ui8Vector].pui32IV;
ui32DataLength = g_psAESGCMTestVectors[ui8Vector].ui32DataLength;
pui32ExpPlainText = g_psAESGCMTestVectors[ui8Vector].pui32PlainText;
ui32AuthDataLength =
g_psAESGCMTestVectors[ui8Vector].ui32AuthDataLength;
pui32AuthData = g_psAESGCMTestVectors[ui8Vector].pui32AuthData;
pui32CipherText = g_psAESGCMTestVectors[ui8Vector].pui32CipherText;
pui32ExpTag = g_psAESGCMTestVectors[ui8Vector].pui32Tag;
//
// If both the data lengths are zero, then it's a special case.
//
if((ui32DataLength == 0) && (ui32AuthDataLength == 0))
{
UARTprintf("Performing decryption without uDMA.\n");
//
// Figure out the value of Y0 depending on the IV length.
//
AESGCMY0Get(ui32KeySize, pui32IV, ui32IVLength, pui32Key, pui32Y0);
//
// Perform the basic encryption.
//
AESECBEncrypt(ui32KeySize, pui32Y0, pui32Tag, pui32Key, 16);
}
else
{
//
// Figure out the value of Y0 depending on the IV length.
//
AESGCMY0Get(ui32KeySize, pui32IV, ui32IVLength, pui32Key, pui32Y0);
//
// Perform the decryption without uDMA.
//
UARTprintf("Performing decryption without uDMA.\n");
AESGCMDecrypt(ui32KeySize, pui32CipherText, pui32PlainText,
ui32DataLength, pui32Key, pui32Y0, pui32AuthData,
ui32AuthDataLength, pui32Tag, false);
}
//
// Check the results.
//
for(ui32Idx = 0; ui32Idx < (ui32DataLength / 4); ui32Idx++)
{
if(pui32ExpPlainText[ui32Idx] != pui32PlainText[ui32Idx])
{
UARTprintf("Plaintext mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui32ExpPlainText[ui32Idx],
pui32PlainText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
if(pui32ExpTag[ui32Idx] != pui32Tag[ui32Idx])
{
UARTprintf("Tag mismatch on word %d. Exp: 0x%x, Act: 0x%x\n",
ui32Idx, pui32ExpTag[ui32Idx], pui32Tag[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000003;
}
}
//
// Clear the arrays containing the ciphertext and tag to ensure things
// are working correctly.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32PlainText[ui32Idx] = 0;
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
pui32Tag[ui32Idx] = 0;
}
//
// Only use DMA with the vectors that have data.
//
if((ui32DataLength != 0) || (ui32AuthDataLength != 0))
{
//
// Perform the decryption with uDMA.
//
UARTprintf("Performing decryption with uDMA.\n");
AESGCMDecrypt(ui32KeySize, pui32CipherText, pui32PlainText,
ui32DataLength, pui32Key, pui32Y0, pui32AuthData,
ui32AuthDataLength, pui32Tag, true);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < (ui32DataLength / 4); ui32Idx++)
{
if(pui32ExpPlainText[ui32Idx] != pui32PlainText[ui32Idx])
{
UARTprintf("Plaintext mismatch on word %d. Exp: 0x%x, "
"Act: 0x%x\n", ui32Idx,
pui32ExpPlainText[ui32Idx],
pui32PlainText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
for(ui32Idx = 0; ui32Idx < 4; ui32Idx++)
{
if(pui32ExpTag[ui32Idx] != pui32Tag[ui32Idx])
{
UARTprintf("Tag mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, pui32ExpTag[ui32Idx],
pui32Tag[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000003;
}
}
}
}
//
// Finished.
//
if(ui32Errors)
{
UARTprintf("Demo failed with error code 0x%x.\n", ui32Errors);
GrStringDrawCentered(&sContext, "Demo failed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
else
{
UARTprintf("Demo completed successfully.\n");
GrStringDrawCentered(&sContext, "Demo passed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
//
// Wait forever.
//
while(1)
{
}
}
//*****************************************************************************
//
// This example demonstrates how to send a string of data to the UART.
//
//*****************************************************************************
int
main(void)
{
uint32_t ui32SysClock;
tContext sContext;
//
// 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, "ble-btool");
//
// PJ0, 1, 4, 5 are used for UART3.
//
ROM_GPIOPinConfigure(GPIO_PJ0_U3RX);
ROM_GPIOPinConfigure(GPIO_PJ1_U3TX);
ROM_GPIOPinConfigure(GPIO_PJ4_U3RTS);
ROM_GPIOPinConfigure(GPIO_PJ5_U3CTS);
ROM_GPIOPinTypeUART(GPIO_PORTJ_BASE, GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5);
//
// Display UART configuration on the display.
//
GrStringDraw(&sContext, "Use BTool on PC", -1, 70, 40, 0);
GrStringDraw(&sContext, "Port:", -1, 70, 70, 0);
GrStringDraw(&sContext, "Baud:", -1, 70, 95, 0);
GrStringDraw(&sContext, "Data:", -1, 70, 120, 0);
GrStringDraw(&sContext, "Parity:", -1, 70, 145, 0);
GrStringDraw(&sContext, "Stop:", -1, 70, 170, 0);
GrStringDraw(&sContext, "Flow:", -1, 70, 195, 0);
GrStringDraw(&sContext, "Uart 0", -1, 150, 70, 0);
GrStringDraw(&sContext, "115,200 bps", -1, 150, 95, 0);
GrStringDraw(&sContext, "8 Bit", -1, 150, 120, 0);
GrStringDraw(&sContext, "None", -1, 150, 145, 0);
GrStringDraw(&sContext, "1 Bit", -1, 150, 170, 0);
GrStringDraw(&sContext, "CTS/RTS", -1, 150, 195, 0);
//
// Enable the (non-GPIO) peripherals used by this example. PinoutSet()
// already enabled GPIO Port A.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART3);
//
// Enable processor interrupts.
//
IntMasterEnable();
//
// Configure the UART0 for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART0_BASE, ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Configure the UART3 for 115,200, 8-N-1 operation.
//
ROM_UARTConfigSetExpClk(UART3_BASE, ui32SysClock, 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
//
// Configure the UART3 with flow control.
//
UARTFlowControlSet(UART3_BASE, UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX);
//
// Enable the UART interrupt.
//
ROM_IntEnable(INT_UART0);
ROM_IntEnable(INT_UART3);
ROM_UARTIntEnable(UART0_BASE, UART_INT_RX | UART_INT_RT);
ROM_UARTIntEnable(UART3_BASE, UART_INT_RX | UART_INT_RT);
//
// Loop forever passing data between UART0 and UART3.
//
while(1)
{
}
}
//*****************************************************************************
//
// This is the main example program. It checks to see that the interrupts are
// processed in the correct order when they have identical priorities,
// increasing priorities, and decreasing priorities. This exercises interrupt
// preemption and tail chaining.
//
//*****************************************************************************
int
main(void)
{
uint_fast8_t ui8Error;
//
// Run from the PLL at 120 MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Configure the device pins.
//
PinoutSet(false, false);
//
// Configure the UART.
//
ConfigureUART();
//
// Configure the B3, L1 and L0 to be outputs to indicate entry/exit of one
// of the interrupt handlers.
//
GPIOPinTypeGPIOOutput(GPIO_A_BASE, GPIO_A_PIN);
GPIOPinTypeGPIOOutput(GPIO_B_BASE, GPIO_B_PIN);
GPIOPinTypeGPIOOutput(GPIO_C_BASE, GPIO_C_PIN);
GPIOPinWrite(GPIO_A_BASE, GPIO_A_PIN, 0);
GPIOPinWrite(GPIO_B_BASE, GPIO_B_PIN, 0);
GPIOPinWrite(GPIO_C_BASE, GPIO_C_PIN, 0);
//
// Set up and enable the SysTick timer. It will be used as a reference
// for delay loops in the interrupt handlers. The SysTick timer period
// will be set up for 100 times per second.
//
ROM_SysTickPeriodSet(g_ui32SysClock / 100);
ROM_SysTickEnable();
//
// Reset the error indicator.
//
ui8Error = 0;
//
// Enable interrupts to the processor.
//
ROM_IntMasterEnable();
//
// Enable the interrupts.
//
ROM_IntEnable(INT_GPIOA);
ROM_IntEnable(INT_GPIOB);
ROM_IntEnable(INT_GPIOC);
//
// Indicate that the equal interrupt priority test is beginning.
//
g_ui32IntMode = EQUAL_PRIORITY;
//
// Set the interrupt priorities so they are all equal.
//
ROM_IntPrioritySet(INT_GPIOA, 0x00);
ROM_IntPrioritySet(INT_GPIOB, 0x00);
ROM_IntPrioritySet(INT_GPIOC, 0x00);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the LCD.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 3) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 1))
{
ui8Error |= 1;
}
//
// Wait two seconds.
//
Delay(2);
//
// Indicate that the decreasing interrupt priority test is beginning.
//
g_ui32IntMode = DECREASING_PRIORITY;
//
// Set the interrupt priorities so that they are decreasing (i.e. C > B >
// A).
//
ROM_IntPrioritySet(INT_GPIOA, 0x80);
ROM_IntPrioritySet(INT_GPIOB, 0x40);
ROM_IntPrioritySet(INT_GPIOC, 0x00);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the UART.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 3) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 1))
{
ui8Error |= 2;
}
//
// Wait two seconds.
//
Delay(2);
//
// Indicate that the increasing interrupt priority test is beginning.
//
g_ui32IntMode = INCREASING_PRIORITY;
//
// Set the interrupt priorities so that they are increasing (i.e. C < B <
// A).
//
ROM_IntPrioritySet(INT_GPIOA, 0x00);
ROM_IntPrioritySet(INT_GPIOB, 0x40);
ROM_IntPrioritySet(INT_GPIOC, 0x80);
//
// Reset the interrupt flags.
//
g_ui32GPIOa = 0;
g_ui32GPIOb = 0;
g_ui32GPIOc = 0;
g_ui32Index = 1;
//
// Trigger the interrupt for GPIO C.
//
HWREG(NVIC_SW_TRIG) = INT_GPIOC - 16;
//
// Put the current interrupt state on the UART.
//
DisplayIntStatus();
//
// Verify that the interrupts were processed in the correct order.
//
if((g_ui32GPIOa != 1) || (g_ui32GPIOb != 2) || (g_ui32GPIOc != 3))
{
ui8Error |= 4;
}
//
// Wait two seconds.
//
Delay(2);
//
// Disable the interrupts.
//
ROM_IntDisable(INT_GPIOA);
ROM_IntDisable(INT_GPIOB);
ROM_IntDisable(INT_GPIOC);
//
// Disable interrupts to the processor.
//
ROM_IntMasterDisable();
//
// Print out the test results.
//
UARTprintf("\033[2J\033[H");
UARTprintf("Interrupts example\n\n");
if(ui8Error)
{
if(ui8Error & 1)
{
UARTprintf("Equal Priority Fail!\n");
}
if(ui8Error & 2)
{
UARTprintf("Decreasing Priority Fail!\n");
}
if(ui8Error & 4)
{
UARTprintf("Increasing Priority Fail!\n");
}
}
else
{
UARTprintf("Success!");
}
//
// Loop forever.
//
while(1)
{
}
}
//*****************************************************************************
//
// 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);
}
}
}
//*****************************************************************************
//
// This example demonstrates the use of the watchdog timer.
//
//*****************************************************************************
int
main(void)
{
tRectangle sRect;
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Set the device pinout appropriately for this board.
//
PinoutSet();
//
// Initialize the touch screen driver.
//
TouchScreenInit();
TouchScreenCallbackSet(WatchdogTouchCallback);
//
// Initialize the display driver.
//
Kitronix320x240x16_SSD2119Init();
//
// Initialize the graphics context and find the middle X coordinate.
//
GrContextInit(&g_sContext, &g_sKitronix320x240x16_SSD2119);
//
// 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, "watchdog", -1,
GrContextDpyWidthGet(&g_sContext) / 2, 8, 0);
//
// Show the state and offer some instructions to the user.
//
GrContextFontSet(&g_sContext, g_pFontCmss20);
GrStringDrawCentered(&g_sContext, "Watchdog is being fed.", -1,
GrContextDpyWidthGet(&g_sContext) / 2 ,
(GrContextDpyHeightGet(&g_sContext) / 2), 1);
GrContextFontSet(&g_sContext, g_pFontCmss14);
GrStringDrawCentered(&g_sContext, "Tap the screen to starve the watchdog",
-1, GrContextDpyWidthGet(&g_sContext) / 2 ,
(GrContextDpyHeightGet(&g_sContext) / 2) + 20, 1);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO PF3 as an output. This drives an LED on the board that will
// toggle when a watchdog interrupt is processed.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3);
ROM_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);
//
// Enable the watchdog interrupt.
//
ROM_IntEnable(INT_WATCHDOG);
//
// Set the period of the watchdog timer.
//
ROM_WatchdogReloadSet(WATCHDOG0_BASE, ROM_SysCtlClockGet());
//
// Enable reset generation from the watchdog timer.
//
ROM_WatchdogResetEnable(WATCHDOG0_BASE);
//
// Enable the watchdog timer.
//
ROM_WatchdogEnable(WATCHDOG0_BASE);
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(1)
{
}
}
//*****************************************************************************
//
// This example encrypts blocks of plaintext using TDES in CBC mode. It
// does the encryption first without uDMA and then with uDMA. The results
// are checked after each operation.
//
//*****************************************************************************
int
main(void)
{
uint32_t pui32CipherText[16], ui32Errors, ui32Idx, ui32SysClock;
tContext sContext;
//
// Run from the PLL at 120 MHz.
//
ui32SysClock = 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, "tdes-cbc-encrypt");
//
// Show some instructions on the display
//
GrContextFontSet(&sContext, g_psFontCm20);
GrContextForegroundSet(&sContext, ClrWhite);
GrStringDrawCentered(&sContext, "Connect a terminal to", -1,
GrContextDpyWidthGet(&sContext) / 2, 60, false);
GrStringDrawCentered(&sContext, "UART0 (115200,N,8,1)", -1,
GrContextDpyWidthGet(&sContext) / 2, 80, false);
GrStringDrawCentered(&sContext, "for more information.", -1,
GrContextDpyWidthGet(&sContext) / 2, 100, false);
//
// Initialize local variables.
//
ui32Errors = 0;
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32CipherText[ui32Idx] = 0;
}
//
// Enable stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPUStackingEnable();
//
// Enable DES interrupts.
//
ROM_IntEnable(INT_DES0);
//
// Enable debug output on UART0 and print a welcome message.
//
ConfigureUART();
UARTprintf("Starting TDES CBC encryption demo.\n");
GrStringDrawCentered(&sContext, "Starting demo...", -1,
GrContextDpyWidthGet(&sContext) / 2, 140, false);
//
// Enable the uDMA module.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UDMA);
//
// Setup the control table.
//
ROM_uDMAEnable();
ROM_uDMAControlBaseSet(g_psDMAControlTable);
//
// Initialize the CCM and DES modules.
//
if(!DESInit())
{
UARTprintf("Initialization of the DES module failed.\n");
ui32Errors |= 0x00000001;
}
//
// Perform the encryption without uDMA.
//
UARTprintf("Performing encryption without uDMA.\n");
TDESCBCEncrypt(g_pui32TDESPlainText, pui32CipherText, g_pui32TDESKey,
64, g_pui32TDESIV, false);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
if(pui32CipherText[ui32Idx] != g_pui32TDESCipherText[ui32Idx])
{
UARTprintf("Ciphertext mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, g_pui32TDESCipherText[ui32Idx],
pui32CipherText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000002;
}
}
//
// Clear the array containing the ciphertext.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
pui32CipherText[ui32Idx] = 0;
}
//
// Perform the encryption with uDMA.
//
UARTprintf("Performing encryption with uDMA.\n");
TDESCBCEncrypt(g_pui32TDESPlainText, pui32CipherText, g_pui32TDESKey,
64, g_pui32TDESIV, true);
//
// Check the result.
//
for(ui32Idx = 0; ui32Idx < 16; ui32Idx++)
{
if(pui32CipherText[ui32Idx] != g_pui32TDESCipherText[ui32Idx])
{
UARTprintf("Ciphertext mismatch on word %d. Exp: 0x%x, Act: "
"0x%x\n", ui32Idx, g_pui32TDESCipherText[ui32Idx],
pui32CipherText[ui32Idx]);
ui32Errors |= (ui32Idx << 16) | 0x00000004;
}
}
//
// Finished.
//
if(ui32Errors)
{
UARTprintf("Demo failed with error code 0x%x.\n", ui32Errors);
GrStringDrawCentered(&sContext, "Demo failed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
else
{
UARTprintf("Demo completed successfully.\n");
GrStringDrawCentered(&sContext, "Demo passed.", -1,
GrContextDpyWidthGet(&sContext) / 2, 180, false);
}
while(1)
{
}
}
//*****************************************************************************
//
// Print "Hello World!" to the display on the Intelligent Display Module.
//
//*****************************************************************************
int
main(void)
{
tContext sContext;
uint32_t ui32SysClock;
uint32_t i;
uint32_t reg_read;
//
// Run from the PLL at 120 MHz.
//
/*
ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_SYSDIV_10 | //Needed for ADC
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
*/
ui32SysClock = SysCtlClockFreqSet(( SYSCTL_SYSDIV_10 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_25MHZ), 120000000);
//
// Configure the device pins.
//
PinoutSet();
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_1); //OUT 0 L1
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_0); //OUT 1 L0
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_2); //OUT 2 L2
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_3); //OUT 3 L3
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_4); //OUT 4 L4
GPIOPinTypeGPIOOutput(GPIO_PORTL_BASE, GPIO_PIN_5); //OUT 5 L5
GPIOPinTypeGPIOOutput(GPIO_PORTP_BASE, GPIO_PIN_5); //OUT 6 P5
GPIOPinTypeGPIOOutput(GPIO_PORTP_BASE, GPIO_PIN_4); //OUT 7 P4
GPIOPinTypeGPIOInput (GPIO_PORTM_BASE, GPIO_PIN_3); //IN 0 M3
GPIOPinTypeGPIOInput (GPIO_PORTM_BASE, GPIO_PIN_2); //IN 1 M2
GPIOPinTypeGPIOInput (GPIO_PORTM_BASE, GPIO_PIN_1); //IN 2 M1
GPIOPinTypeGPIOInput (GPIO_PORTM_BASE, GPIO_PIN_0); //IN 3 M0
GPIOPinTypeGPIOInput (GPIO_PORTN_BASE, GPIO_PIN_4); //IN 4 N4
GPIOPinTypeGPIOInput (GPIO_PORTA_BASE, GPIO_PIN_7); //IN 5 A7
GPIOPinTypeGPIOInput (GPIO_PORTC_BASE, GPIO_PIN_6); //IN 6 C6
GPIOPinTypeGPIOInput (GPIO_PORTC_BASE, GPIO_PIN_5); //IN 7 C5
//RGB LED
GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_5); //RED N5
GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_7); //GREEN Q7
GPIOPinTypeGPIOOutput(GPIO_PORTQ_BASE, GPIO_PIN_4); //BLUE Q4
//Initialize the UART
QUT_UART_Init( ui32SysClock );
//Initialize AIN0
QUT_ADC0_Init();
//
// Initialize the display driver.
//
Kentec320x240x16_SSD2119Init(ui32SysClock);
//
// Initialize the graphics context.
//
GrContextInit(&sContext, &g_sKentec320x240x16_SSD2119);
//
// Draw the application frame.
//
FrameDraw(&sContext, "FestoTester");
//
// Initialize the touch screen driver.
//
TouchScreenInit(ui32SysClock);
//
// Set the touch screen event handler.
//
TouchScreenCallbackSet(WidgetPointerMessage);
//
// Add the compile-time defined widgets to the widget tree.
//
WidgetAdd(WIDGET_ROOT, (tWidget *)&g_sBackground);
//
// Paint the widget tree to make sure they all appear on the display.
//
WidgetPaint(WIDGET_ROOT);
QUT_UART_Send( (uint8_t *)"FestoTester", 11 );
//
// Loop forever, processing widget messages.
//
while(1)
{
//
// Process any messages from or for the widgets.
//
WidgetMessageQueueProcess();
//Turn on RED LED
GPIO_PORTN_DATA_R |= 0x20;
//Check GPIO Inputs
for( i = 0; i < 8; i++ )
{
input_status[i] = 0;
reg_read = qut_get_gpio( i );
if ( reg_read != 0 ){
input_status[i] = INPUT_STATUS_IS_ONE;
}
}
//Read the ADC0
adc0_read = QUT_ADC0_Read();
QUT_UART_Send( (uint8_t *)"\n\radc0_read=", 12 );
QUT_UART_Send_uint32_t( adc0_read );
//Relimit the ADC read from 0 to 4096 into a pixel limit from 0 to 280
num_analog_pixels = (adc0_read * 280 ) / 4096;
//UARTprintf("num_analog_pixels = %4d\r", num_analog_pixels );
//QUT_UART_Send( (uint8_t *)"\rnum_analog_pixels=", 19 );
//QUT_UART_Send_uint32_t( num_analog_pixels );
//qut_delay_secs(1);
//Repaint the screen
WidgetPaint(WIDGET_ROOT);
}
}
