int main() { // init the display so we can draw on it! display_init(); // fill the display with black so it's all ready to have buttons drawn on it display_fillScreen(DISPLAY_BLACK); // Init all interrupts (but does not enable the interrupts at the devices). // Prints an error message if an internal failure occurs because the argument = true. interrupts_initAll(true); interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE); printf("timer load value:%ld\n\r", (int32_t) TIMER_LOAD_VALUE); u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond(); printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond); interrupts_enableTimerGlobalInts(); // Initialization of the clock display is not time-dependent, do it outside of the state machine. // clockDisplay_init(); // Start the private ARM timer running. interrupts_startArmPrivateTimer(); // Enable interrupts at the ARM. interrupts_enableArmInts(); // The while-loop just waits until the total number of timer ticks have occurred before proceeding. while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)); // All done, now disable interrupts and print out the interrupt counts. interrupts_disableArmInts(); printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount()); printf("internal interrupt count: %ld\n\r", isr_functionCallCount); return 0; }
/** * More advanced test that uses timer interrupts */ void test_Full() { // Initialize the GPIO LED driver and print out an error message if it fails (argument = true). // You need to init the LEDs so that LED4 can function as a heartbeat. leds_init(true); // Init all interrupts (but does not enable the interrupts at the devices). // Prints an error message if an internal failure occurs because the argument = true. interrupts_initAll(true); interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE); u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond(); printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond); // Allow the timer to generate interrupts. interrupts_enableTimerGlobalInts(); // Initialization of the clock display is not time-dependent, do it outside of the state machine. //ticTacToeDisplay_init(); // Keep track of your personal interrupt count. Want to make sure that you don't miss any interrupts. int32_t personalInterruptCount = 0; // Start the private ARM timer running. interrupts_startArmPrivateTimer(); // Enable interrupts at the ARM. interrupts_enableArmInts(); // interrupts_isrInvocationCount() returns the number of times that the timer ISR was invoked. // This value is maintained by the timer ISR. Compare this number with your own local // interrupt count to determine if you have missed any interrupts. double duration_max = 0.0; while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) { if (interrupts_isrFlagGlobal) { // This is a global flag that is set by the timer interrupt handler. // Count ticks. personalInterruptCount++; intervalTimer_initAll(); intervalTimer_start(INTERVALTIMER_TIMER0); ticTacToeControl_tick(); intervalTimer_stop(INTERVALTIMER_TIMER0); // print out the longest tick execution time for user reference. double duration; // measured with the intervalTimer intervalTimer_getTotalDurationInSeconds(INTERVALTIMER_TIMER0, &duration); // If this duration was larger than the previous max, update the values // and print it out. if (duration_max < duration) { duration_max = duration; printf("Duration:%lf\n", duration); } intervalTimer_resetAll(); interrupts_isrFlagGlobal = 0; } } interrupts_disableArmInts(); printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount()); printf("internal interrupt count: %ld\n\r", personalInterruptCount); }
int main() { srand(LARGE_PRIME_NUMBER); // Initialize the GPIO LED driver and print out an error message if it fails (argument = true). // You need to init the LEDs so that LD4 can function as a heartbeat. leds_init(true); // Init all interrupts (but does not enable the interrupts at the devices). // Prints an error message if an internal failure occurs because the argument = true. interrupts_initAll(true); interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE); u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond(); printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond); // Allow the timer to generate interrupts. interrupts_enableTimerGlobalInts(); // Initialization of the clock display is not time-dependent, do it outside of the state machine. //TicTacToeDisplay_init(); display_init(); display_fillScreen(DISPLAY_BLACK); buttons_init(); // Keep track of your personal interrupt count. Want to make sure that you don't miss any interrupts. int32_t personalInterruptCount = 0; // Start the private ARM timer running. interrupts_startArmPrivateTimer(); // Enable interrupts at the ARM. interrupts_enableArmInts(); // interrupts_isrInvocationCount() returns the number of times that the timer ISR was invoked. // This value is maintained by the timer ISR. Compare this number with your own local // interrupt count to determine if you have missed any interrupts. while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) { if (interrupts_isrFlagGlobal) { // This is a global flag that is set by the timer interrupt handler. // Count ticks. double duration0; personalInterruptCount++; SimonControl_tick(); verifySequence_tick(); flashSequence_tick(); simonbuttonHandler_tick(); interrupts_isrFlagGlobal = FLAG_DOWN; } } interrupts_disableArmInts(); printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount()); printf("internal interrupt count: %ld\n\r", personalInterruptCount); return 0; }
void hitLedTimer_runTest() { printf("\r\n-----HitLed Timer Test-----\r\n"); hitLedTimer_init(); // We want to use the interval timers. intervalTimer_initAll(); intervalTimer_resetAll(); intervalTimer_testAll(); printf("Laser Tag Test Program\n\r"); // Find out how many timer ticks per second. u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond(); printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond); // Initialize the GPIO LED driver and print out an error message if it fails (argument = true). // The LD4 LED provides a heart-beat that visually verifies that interrupts are running. leds_init(true); // Init all interrupts (but does not enable the interrupts at the devices). // Prints an error message if an internal failure occurs because the argument = true. interrupts_initAll(true); // Enables the main interrupt on the time. interrupts_enableTimerGlobalInts(); // Start the private ARM timer running. interrupts_startArmPrivateTimer(); printf("This program will run for %d seconds and print out statistics at the end of the run.\n\r", TOTAL_SECONDS); printf("Starting timer interrupts.\n\r"); // Enable global interrupt of System Monitor. The system monitor contains the ADC. Mainly to detect EOC interrupts. interrupts_enableSysMonGlobalInts(); // Start a duration timer and compare its timing against the time computed by the timerIsr(). // Assume that ENABLE_INTERVAL_TIMER_0_IN_TIMER_ISR is defined in interrupts.h so that time spent in timer-isr is measured. int countInterruptsViaInterruptsIsrFlag = 0; // Enable interrupts at the ARM. interrupts_enableArmInts(); intervalTimer_start(1); // Wait until TOTAL seconds have expired. globalTimerTickCount is incremented by timer isr. while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) { if (interrupts_isrFlagGlobal) { // If this is true, an interrupt has occured (at least one). countInterruptsViaInterruptsIsrFlag++; // Note that you saw it. interrupts_isrFlagGlobal = 0; // Reset the shared flag. // Place non-timing critical code here. hitLedTimer_start(); while(hitLedTimer_running()) {} utils_msDelay(300); } } interrupts_disableArmInts(); // Disable ARM interrupts. intervalTimer_stop(1); // Stop the interval timer. double runningSeconds, isrRunningSeconds; intervalTimer_getTotalDurationInSeconds(1, &runningSeconds); printf("Total run time as measured by interval timer in seconds: %g.\n\r", runningSeconds); intervalTimer_getTotalDurationInSeconds(0, &isrRunningSeconds); printf("Measured run time in timerIsr (using interval timer): %g.\n\r", isrRunningSeconds); printf("Detected interrupts via global flag: %d\n\r", countInterruptsViaInterruptsIsrFlag); printf("During %d seconds, an average of %7.3f ADC samples were collected per second.\n\r", TOTAL_SECONDS, (float) isr_getTotalAdcSampleCount() / (float) TOTAL_SECONDS); printf("\r\n-----End HitLed Timer Test-----\r\n"); }
int main() { //buttonHandler_runTest(10); //flashSequence_runTest(); //verifySequence_runTest(); // The formula for computing the load value is based upon the formula from 4.1.1 (calculating timer intervals) // in the Cortex-A9 MPCore Technical Reference Manual 4-2. // Assuming that the prescaler = 0, the formula for computing the load value based upon the desired period is: // load-value = (period * timer-clock) - 1 // Initialize the GPIO LED driver and print out an error message if it fails (argument = true). // You need to init the LEDs so that LD4 can function as a heartbeat. leds_init(true); // Init all interrupts (but does not enable the interrupts at the devices). // Prints an error message if an internal failure occurs because the argument = true. interrupts_initAll(true); interrupts_setPrivateTimerLoadValue(TIMER_LOAD_VALUE); u32 privateTimerTicksPerSecond = interrupts_getPrivateTimerTicksPerSecond(); printf("private timer ticks per second: %ld\n\r", privateTimerTicksPerSecond); // Allow the timer to generate interrupts. interrupts_enableTimerGlobalInts(); // Initialization of the Simon game state machines is not time-dependent so we do it outside of the state machine. display_init(); display_fillScreen(DISPLAY_BLACK); // Keep track of your personal interrupt count. Want to make sure that you don't miss any interrupts. int32_t personalInterruptCount = 0; // Start the private ARM timer running. interrupts_startArmPrivateTimer(); // Enable interrupts at the ARM. interrupts_enableArmInts(); // interrupts_isrInvocationCount() returns the number of times that the timer ISR was invoked. // This value is maintained by the timer ISR. Compare this number with your own local // interrupt count to determine if you have missed any interrupts. double *seconds; while (interrupts_isrInvocationCount() < (TOTAL_SECONDS * privateTimerTicksPerSecond)) { if (interrupts_isrFlagGlobal) { // This is a global flag that is set by the timer interrupt handler. // Count ticks. personalInterruptCount++; verifySequence_tick(); flashSequence_tick(); buttonHandler_tick(); intervalTimer_start(1); simonControl_tick(); intervalTimer_stop(1); intervalTimer_getTotalDurationInSeconds(1,seconds); printf("%f \r\n",*seconds); //printf("interrupt count: %lu \r\n", interrupts_isrInvocationCount()); intervalTimer_reset(1); interrupts_isrFlagGlobal = 0; } } interrupts_disableArmInts(); printf("isr invocation count: %ld\n\r", interrupts_isrInvocationCount()); printf("internal interrupt count: %ld\n\r", personalInterruptCount); return 0; }