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");
}
/**
* 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);
}
uint32_t intervalTimer_runTest(uint32_t timerNumber) {
intervalTimer_init(timerNumber);
intervalTimer_reset(timerNumber);
// Show that the timer is reset.
printf("timer %ld TCR0 should be 0 at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
printf("timer %ld TCR1 should be 0 at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
// Statements returns false if TCR0 and TCR1 aren't 0
if (readTimerRegister(INTERVALTIMER_TCR0_ADDRESS , timerNumber) !=INTERVALTIMER_INITIALIZE) {
return INTERVALTIMER_VALID_TIMER_FALSE;
}
if (readTimerRegister(INTERVALTIMER_TCR1_ADDRESS , timerNumber) !=INTERVALTIMER_INITIALIZE) {
return INTERVALTIMER_VALID_TIMER_FALSE;
}
intervalTimer_start(timerNumber);
// Show that the timer is running.
// Test points for comparison
u32 TP_One;
u32 TP_Two;
printf("The following register values should be changing while reading them.\n\r");
printf("timer %ld TCR0 should be changing at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
TP_One = readTimerRegister(INTERVALTIMER_TCR0_ADDRESS , timerNumber);
printf("timer %ld TCR0 should be changing at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
printf("timer %ld TCR0 should be changing at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
printf("timer %ld TCR0 should be changing at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
TP_Two = readTimerRegister(INTERVALTIMER_TCR0_ADDRESS , timerNumber);
printf("timer %ld TCR0 should be changing at this point:%ld\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
// Statement returns false if TCR0 isn't changing
if (TP_One == TP_Two) {
return INTERVALTIMER_VALID_TIMER_FALSE;
}
// Wait about 2 minutes so that you roll over to TCR1.
// If you don't see a '1' in TCR1 after this long wait you probably haven't programmed the timer correctly.
waitALongTime();
printf("timer %ld TCR0 value after wait:%lx\n\r", timerNumber , readTimerRegister(INTERVALTIMER_TCR0_ADDRESS, timerNumber));
printf("timer %ld TCR1 should have changed at this point:%ld\n\r", timerNumber ,readTimerRegister(INTERVALTIMER_TCR1_ADDRESS, timerNumber));
// Statement returns false if TCR1 didn't change
if (readTimerRegister(INTERVALTIMER_TCR1_ADDRESS,timerNumber) == INTERVALTIMER_INITIALIZE) {
return INTERVALTIMER_VALID_TIMER_FALSE;
}
return INTERVALTIMER_VALID_TIMER_TRUE;
}
// runs a test to see if timers are operating correctly
uint32_t intervalTimer_runTest(uint32_t timerNumber)
{
intervalTimer_init(timerNumber); //initialize the timer
intervalTimer_reset(timerNumber); //reset the timer
printf("timer_0 TCR0 should be 0 at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET)); // Show that the timer is reset.
printf("timer_0 TCR1 should be 0 at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR1_OFFSET)); //reset the TCR1 as well as TCR0
intervalTimer_start(timerNumber); // Show that the timer is running.
printf("The following register values should be changing while reading them.\n\r"); //print statement to the screen
printf("timer_0 TCR0 should be changing at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET)); //these print the current values of the timer
printf("timer_0 TCR0 should be changing at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET)); //repeat multiple times to show that change is continuous as time passes
printf("timer_0 TCR0 should be changing at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET));
printf("timer_0 TCR0 should be changing at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET));
printf("timer_0 TCR0 should be changing at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET));
waitALongTime(); // Wait about 2 minutes so that you roll over to TCR1.
printf("timer_0 TCR0 value after wait:%lx\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR0_OFFSET));// If you don't see a '1' in TCR1 after this long wait you probably haven't programmed the timer correctly.
printf("timer_0 TCR1 should have changed at this point:%ld\n\r", readTimerRegister(timerNumber, INTERVALTIMER_TCR1_OFFSET));//this shows the time that has passed
}
//
// This will configure the counter, start it, see if it runs, stop it, see if it stays stopped.
// Pretty good way to test for the existence of the counter hardware.
u32 intervalTimer_test(u32 timerNumber) {
u32 errorValue = 0;
// See if the hardware appears to be present by writing a value to the load register and reading it back.
u32 loadValue = 0x55AA;
intervalTimer_writeRegister(timerNumber, INTERVAL_TIMER_TLR0_REG_OFFSET, loadValue);
if (loadValue != intervalTimer_readRegister(timerNumber, INTERVAL_TIMER_TLR0_REG_OFFSET)) {
printf("intervalTimer_test: hardware for timer: %lu does not appear to be present.\n\r", timerNumber);
}
intervalTimer_init(timerNumber); // Init the timer.
intervalTimer_reset(timerNumber); // Reset the timer to 0.
u32 counter0Value = intervalTimer_readRegister(timerNumber, INTERVAL_TIMER_TCR0_REG_OFFSET);
// See if the timer is reset. Timer should be zero at this point.
if (counter0Value) {
printf("intervalTimer_test: counter 0 should be zero after initialization. Value is: %lu.\n", counter0Value);
errorValue = 1;
} else {
// OK, see if the timer will run.
intervalTimer_start(timerNumber);
volatile int i; // Wait for a bit.
for (i=0; i<1000; i++);
counter0Value = intervalTimer_readRegister(timerNumber, INTERVAL_TIMER_TCR0_REG_OFFSET);
if (!counter0Value) {
printf("intervalTimer_test: counter 0 does not seem to be running. Value is: %lu.\n\r", counter0Value);
errorValue = 1;
} else {
// OK. See if the timer will stop.
intervalTimer_stop(timerNumber);
counter0Value = intervalTimer_readRegister(timerNumber, INTERVAL_TIMER_TCR0_REG_OFFSET);
int i; // Wait for a bit.
for (i=0; i<1000; i++);
u32 secondCounter0Value = intervalTimer_readRegister(timerNumber, INTERVAL_TIMER_TCR0_REG_OFFSET);
if (counter0Value != secondCounter0Value) {
printf("intervalTimer_test: counter 0 does not seem to be stopped.\n\r");
errorValue = 1;
}
}
}
return errorValue;
}
// ******************************* Start Timer ISR *********************************
void timerIsr(void* callBackRef) {
#ifdef INTERVALTIMER_H_ // Enable interval timing when this is defined.
intervalTimer_start(0);
#endif
isrInvocationCount++; // Just keep track of the count for now.
interrupts_isrFlagGlobal = 1;
// Put the code that you want executed on a timer interrupt below here.
#ifdef INTERRUPTS_ENABLE_HEARTBEAT_LED
updateHeartBeatLed();
#endif
// This will capture ADC samples into the queue if defined.
#ifdef INTERRUPTS_ENABLE_ADC_DATA_CAPTURE
sampleTimerTicks--;
if (sampleTimerTicks == 0) {
totalXadcSampleCount++;
#ifdef QUEUE_H_
queue_overwritePush(adcDataQueue1, XSysMon_GetAdcData(&xSysMonInst, XADC_AUX_CHANNEL_14) >> 4);
#endif
sampleTimerTicks = PRIVATE_TIMER_TICKS_PER_ADC_SAMPLE;
}
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;
}
