//*****************************************************************************
//
// 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)
{
}
}
//*****************************************************************************
//
// This example demonstrates the use of the watchdog timer.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the crystal at 120MHz.
//
g_ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
SYSCTL_OSC_MAIN |
SYSCTL_USE_PLL |
SYSCTL_CFG_VCO_480), 120000000);
//
// Initialize the buttons driver.
//
ButtonsInit();
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPION);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO PN0 as an output. This drives an LED on the board that will
// toggle when a watchdog interrupt is processed.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTN_BASE, GPIO_PIN_0);
ROM_GPIOPinWrite(GPIO_PORTN_BASE, GPIO_PIN_0, 0);
//
// Enable the watchdog interrupt.
//
ROM_IntEnable(INT_WATCHDOG);
//
// Set the period of the watchdog timer to 1 second.
//
ROM_WatchdogReloadSet(WATCHDOG0_BASE, g_ui32SysClock);
//
// Enable reset generation from the watchdog timer.
//
ROM_WatchdogResetEnable(WATCHDOG0_BASE);
//
// Enable the watchdog timer.
//
ROM_WatchdogEnable(WATCHDOG0_BASE);
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(1)
{
//
// Poll for the select button pressed
//
uint8_t ui8Buttons = ButtonsPoll(0, 0);
if(ui8Buttons & USR_SW1)
{
SW1ButtonPressed();
while(1)
{
}
}
}
}
//*****************************************************************************
//
// This example demonstrates the use of the watchdog timer.
//
//*****************************************************************************
int
main(void)
{
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initialize the UART and write status.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
GPIOPinConfigure(GPIO_PA0_U0RX);
GPIOPinConfigure(GPIO_PA1_U0TX);
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioInit(0);
UARTprintf("\033[2JWatchdog example\n");
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO D0 as an output. This drives an LED on the board that will
// toggle when a watchdog interrupt is processed.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTD_BASE, GPIO_PIN_0);
ROM_GPIOPinWrite(GPIO_PORTD_BASE, GPIO_PIN_0, 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 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 demonstrates the use of the watchdog timer.
//
//*****************************************************************************
int
main(void)
{
int_fast32_t i32CenterX;
tRectangle sRect;
//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();
//
// Set the clocking to run directly from the crystal.
//
ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Initialize the display and buttons drivers.
//
CFAL96x64x16Init();
ButtonsInit();
//
// Initialize the graphics context and find the middle X coordinate.
//
GrContextInit(&g_sContext, &g_sCFAL96x64x16);
i32CenterX = GrContextDpyWidthGet(&g_sContext) / 2;
//
// Fill the top part of the screen with blue to create the banner.
//
sRect.i16XMin = 0;
sRect.i16YMin = 0;
sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
sRect.i16YMax = 9;
GrContextForegroundSet(&g_sContext, ClrDarkBlue);
GrRectFill(&g_sContext, &sRect);
//
// Change foreground for white text.
//
GrContextForegroundSet(&g_sContext, ClrWhite);
//
// Put the application name in the middle of the banner.
//
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "watchdog", -1, i32CenterX, 4, 0);
//
// Show the state and offer some instructions to the user.
//
GrContextFontSet(&g_sContext, g_psFontFixed6x8);
GrStringDrawCentered(&g_sContext, "Feeding", -1, i32CenterX, 14, 1);
GrStringDrawCentered(&g_sContext, "Watchdog", -1, i32CenterX, 24, 1);
GrStringDrawCentered(&g_sContext, "Press", -1, i32CenterX, 36, 1);
GrStringDrawCentered(&g_sContext, "Select", -1, i32CenterX, 46, 1);
GrStringDrawCentered(&g_sContext, "to stop", -1, i32CenterX, 56, 1);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_WDOG0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//
// Enable processor interrupts.
//
ROM_IntMasterEnable();
//
// Set GPIO PG2 as an output. This drives an LED on the board that will
// toggle when a watchdog interrupt is processed.
//
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTG_BASE, GPIO_PIN_2);
ROM_GPIOPinWrite(GPIO_PORTG_BASE, GPIO_PIN_2, 0);
//
// Enable the watchdog interrupt.
//
ROM_IntEnable(INT_WATCHDOG);
//
// Set the period of the watchdog timer.
//
ROM_WatchdogReloadSet(WATCHDOG0_BASE, ROM_SysCtlClockGet());
//
// Enable reset generation from the watchdog timer.
//
ROM_WatchdogResetEnable(WATCHDOG0_BASE);
//
// Enable the watchdog timer.
//
ROM_WatchdogEnable(WATCHDOG0_BASE);
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(1)
{
//
// Poll for the select button pressed
//
uint8_t ui8Buttons = ButtonsPoll(0, 0);
if(ui8Buttons & SELECT_BUTTON)
{
SelectButtonPressed();
while(1)
{
}
}
}
}
