Timer interrupt for periodic tasks in Embedded C - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Timer Interrupt Handler Increment

What is the output of the following embedded C code snippet simulating a timer interrupt incrementing a counter?

Embedded C

#include <stdio.h>

volatile int counter = 0;

void Timer_ISR() {
    counter++;
}

int main() {
    for(int i = 0; i < 5; i++) {
        Timer_ISR();
    }
    printf("Counter: %d\n", counter);
    return 0;
}

A Counter: 5

B Counter: 0

C Counter: 4

D Counter: 1

💡 Hint

Think about how many times the interrupt function is called.

The Timer_ISR function is called 5 times in the loop, each time incrementing the counter by 1, so the final value is 5.

🧠 Conceptual

intermediate

Purpose of volatile keyword in timer interrupt variables

Why is the volatile keyword important for variables shared between the main program and a timer interrupt handler?

A It automatically initializes the variable to zero before use.

B It makes the variable read-only to prevent accidental changes.

C It prevents the compiler from optimizing out accesses to the variable, ensuring the latest value is always read.

D It allows the variable to be stored in faster CPU registers.

💡 Hint

Think about how the compiler might optimize code when it doesn't expect a variable to change unexpectedly.

The volatile keyword tells the compiler that the variable can change at any time, such as inside an interrupt, so it must always read the variable from memory and not cache it in a register.

🔧 Debug

advanced

Identify the bug in timer interrupt setup

What is the bug in this timer interrupt setup code that causes the interrupt not to trigger periodically?

Embedded C

#include <avr/io.h>
#include <avr/interrupt.h>

volatile int tick = 0;

void timer_init() {
    TCCR0A = 0;
    TCCR0B = (1 << CS02) | (1 << CS01); // Invalid prescaler (incorrect)
    TIMSK0 = (1 << TOIE0);
    sei();
}

ISR(TIMER0_OVF_vect) {
    tick++;
}

int main() {
    timer_init();
    while(1) {
        // main loop
    }
}

A sei() should be called before timer_init() to enable interrupts.

B tick variable should not be volatile.

C Interrupt vector name TIMER0_OVF_vect is incorrect for this MCU.

D Prescaler bit combination is invalid; valid prescalers are powers of two or specific values like 1024.

💡 Hint

Check the prescaler bits and their valid values for the timer control register.

The prescaler bits set in TCCR0B do not correspond to a valid prescaler value. The combination (1 << CS02) | (1 << CS01) sets bits 2 and 1, which is not a valid prescaler setting for AVR timers (selects external clock source). This prevents the timer from counting correctly and the interrupt from triggering.

📝 Syntax

advanced

Syntax error in timer interrupt declaration

Which option correctly declares a timer interrupt service routine (ISR) for Timer1 overflow in AVR C?

A void TIMER1_OVF_vect() { /* handler code */ }

B ISR(TIMER1_OVF_vect) { /* handler code */ }

C interrupt TIMER1_OVF_vect() { /* handler code */ }

D void ISR_TIMER1_OVF() { /* handler code */ }

💡 Hint

Look for the special macro used to define ISRs in AVR GCC.

In AVR GCC, the ISR macro with the interrupt vector name is used to declare interrupt handlers. Other forms are invalid syntax or not recognized as ISRs.

🚀 Application

expert

Calculate timer overflow frequency

Given an 8-bit timer with a 16 MHz clock and a prescaler of 256, what is the frequency (in Hz) at which the TIMER0 overflow interrupt triggers?

A Approximately 244 Hz

B Approximately 62500 Hz

C Approximately 16000000 Hz

D Approximately 256 Hz

💡 Hint

Calculate timer tick frequency first, then find overflow frequency using 256 counts for 8-bit timer.

Timer tick frequency = CPU frequency / prescaler = 16,000,000 / 256 = 62,500 Hz. The timer overflows after 256 ticks, so overflow frequency = 62,500 / 256 ≈ 244 Hz.