Timer interrupt for periodic tasks in Embedded C - Deep Dive

Overview - Timer interrupt for periodic tasks

What is it?

A timer interrupt is a special signal generated by a hardware timer inside a microcontroller. It tells the processor to pause its current work and run a specific piece of code at regular time intervals. This allows the system to perform tasks periodically without waiting or checking manually. It is like setting an alarm clock that rings repeatedly to remind you to do something.

Why it matters

Without timer interrupts, microcontrollers would have to waste time constantly checking if it's time to do a task, which is inefficient and slow. Timer interrupts let the system do other work and only respond when needed, making devices faster and more power-efficient. This is crucial in real-time systems like watches, sensors, or robots where tasks must happen on time.

Where it fits

Before learning timer interrupts, you should understand basic microcontroller programming and how interrupts work in general. After mastering timer interrupts, you can explore advanced real-time operating systems and multitasking techniques that rely on precise timing.

Mental Model

Core Idea

A timer interrupt is like a repeating alarm that automatically triggers a task at fixed time intervals without manual checking.

Think of it like...

Imagine you set a kitchen timer to beep every 5 minutes while cooking. You don't watch the clock; when the timer beeps, you know it's time to stir the pot. The timer interrupt works the same way inside a microcontroller.

┌───────────────┐       ┌───────────────┐
│   Main Code   │──────▶│   Timer Tick  │
└───────────────┘       └───────────────┘
          ▲                      │
          │                      ▼
   (Interrupted)         ┌───────────────┐
                         │ Interrupt     │
                         │ Service       │
                         │ Routine (ISR) │
                         └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding hardware timers basics

Concept: Learn what hardware timers are and how they count time inside a microcontroller.

Hardware timers are special counters that increase or decrease at a fixed rate based on the microcontroller's clock. They can count up to a set value and then reset. This counting helps measure time intervals precisely without software delays.

Result

You know that timers keep track of time automatically and can signal when a set time passes.

Understanding timers as automatic counters helps you see how they can replace manual time tracking in code.

2

Foundation

Basics of interrupts in microcontrollers

Concept: Learn how interrupts pause normal code to run special functions immediately.

An interrupt is a signal that tells the microcontroller to stop what it's doing and run a special function called an Interrupt Service Routine (ISR). After the ISR finishes, the microcontroller returns to the original task. This allows quick responses to events.

Result

You understand that interrupts let the microcontroller react instantly to important signals.

Knowing interrupts let you handle events without constantly checking for them in your main code.

3

Intermediate

Configuring timer interrupts for periodic tasks

🤔Before reading on: do you think timer interrupts need manual checking in the main code or run automatically? Commit to your answer.

Concept: Learn how to set up a timer to generate interrupts at fixed intervals to run code periodically.

To use timer interrupts, you configure the timer's count value and enable its interrupt. When the timer reaches the count, it triggers an interrupt, running the ISR automatically. For example, setting a timer to interrupt every 1 millisecond lets you run code every 1 ms without delay loops.

Result

Your microcontroller runs the ISR code automatically at the set time intervals.

Understanding that timer interrupts automate periodic task execution without blocking the main program.

4

Intermediate

Writing an Interrupt Service Routine (ISR)

🤔Before reading on: do you think ISRs can contain long, complex code or should be short and fast? Commit to your answer.

Concept: Learn how to write the special function that runs when a timer interrupt occurs.

An ISR is a function triggered by the interrupt. It should be short and fast to avoid delaying other tasks. For example, toggling an LED or updating a counter inside the ISR is common. You must also clear the interrupt flag inside the ISR to allow future interrupts.

Result

Your ISR runs quickly and correctly handles the timer interrupt.

Knowing ISRs must be efficient prevents system slowdowns and missed interrupts.

5

Intermediate

Using timer interrupts for multiple periodic tasks

🤔Before reading on: do you think one timer interrupt can handle many tasks or only one? Commit to your answer.

Concept: Learn how to manage several periodic tasks using a single timer interrupt.

You can use one timer interrupt to run multiple tasks by checking counters or flags inside the ISR. For example, if the timer interrupts every 1 ms, you can run Task A every 10 ms and Task B every 50 ms by counting interrupts inside the ISR.

Result

Multiple tasks run periodically with precise timing using one timer interrupt.

Understanding task scheduling inside ISRs helps optimize limited hardware resources.

6

Advanced

Handling timer interrupt latency and jitter

🤔Before reading on: do you think timer interrupts always run exactly on time without delay? Commit to your answer.

Concept: Learn about delays and variations in interrupt timing and how to minimize them.

Interrupt latency is the delay between the timer event and ISR execution, caused by other interrupts or code. Jitter is the variation in timing between interrupts. To reduce these, keep ISRs short, prioritize interrupts properly, and avoid disabling interrupts for long periods.

Result

Your periodic tasks run more reliably with minimal timing errors.

Knowing about latency and jitter helps design more accurate real-time systems.

7

Expert

Advanced timer interrupt techniques and pitfalls

🤔Before reading on: do you think nesting timer interrupts or using heavy code inside ISRs is safe? Commit to your answer.

Concept: Explore complex uses of timer interrupts, including nesting, reentrancy, and common mistakes.

Nesting interrupts means allowing interrupts inside ISRs, which can cause complex bugs if not handled carefully. Heavy processing inside ISRs can block other interrupts, causing missed events. Using volatile variables and proper synchronization prevents data corruption. Also, beware of timer overflow and ensure the timer reloads correctly.

Result

You can write robust timer interrupt code that avoids common traps and runs safely in complex systems.

Understanding advanced interrupt behavior prevents subtle bugs and system crashes in production.

Under the Hood

The hardware timer counts clock pulses from the microcontroller's clock source. When the count matches a preset compare value, the timer hardware sets an interrupt flag and signals the CPU. The CPU pauses the current program, saves its state, and jumps to the ISR address. After executing the ISR, the CPU restores the previous state and resumes normal execution. The timer then resets or continues counting based on configuration.

Why designed this way?

This design allows precise timing without CPU intervention, freeing the processor for other tasks. Hardware timers are independent of software speed and delays, ensuring consistent timing. Early microcontrollers lacked this, forcing inefficient software delays. Hardware interrupts evolved to improve responsiveness and multitasking in embedded systems.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Clock Source  │──────▶│ Hardware Timer│──────▶│ Interrupt Flag│
└───────────────┘       └───────────────┘       └───────────────┘
                                                      │
                                                      ▼
                                              ┌───────────────┐
                                              │ CPU Interrupt │
                                              │ Controller    │
                                              └───────────────┘
                                                      │
                                                      ▼
                                              ┌───────────────┐
                                              │ Interrupt     │
                                              │ Service       │
                                              │ Routine (ISR) │
                                              └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do timer interrupts guarantee zero delay in task execution? Commit yes or no.

Common Belief: Timer interrupts always run exactly on time without any delay.

Reality: There is always some delay (latency) due to CPU processing other interrupts or instructions before servicing the timer interrupt.

Why it matters: Assuming zero delay can cause timing errors in critical systems, leading to missed deadlines or incorrect behavior.

Quick: Can you safely run long, complex code inside an ISR? Commit yes or no.

Common Belief: You can put any code inside an ISR, even if it takes a long time.

Reality: ISRs should be short and fast; long code blocks can block other interrupts and cause system instability.

Why it matters: Ignoring this can cause missed interrupts, slow response, and system crashes.

Quick: Does one timer interrupt only handle one task? Commit yes or no.

Common Belief: Each timer interrupt can only be used for one periodic task.

Reality: One timer interrupt can manage multiple tasks by using counters or flags inside the ISR.

Why it matters: Believing otherwise leads to inefficient use of hardware timers and limits system design.

Quick: Are timer interrupts the same as software delay loops? Commit yes or no.

Common Belief: Timer interrupts are just fancy software delays that pause the program.

Reality: Timer interrupts run asynchronously and do not pause the main program; they allow multitasking and precise timing.

Why it matters: Confusing these leads to inefficient code and misunderstanding of real-time behavior.

Expert Zone

1

Timer interrupt precision depends on clock source stability and prescaler settings, which experts tune for accuracy.

2

Using volatile keyword for variables shared between ISR and main code prevents compiler optimization bugs.

3

Nested interrupts require careful priority management to avoid deadlocks and ensure system responsiveness.

When NOT to use

Timer interrupts are not suitable for very long or complex tasks inside ISRs; instead, use them to set flags and handle heavy processing in the main loop or RTOS tasks. For ultra-high precision timing, hardware peripherals like PWM or dedicated timers may be better.

Production Patterns

In real systems, timer interrupts often trigger flags or counters checked in the main loop to keep ISRs short. Multiple periodic tasks are scheduled by counting interrupts. Priority-based interrupt nesting and watchdog timers ensure system reliability.

Connections

Real-time Operating Systems (RTOS)

Builds-on

Understanding timer interrupts is essential to grasp how RTOS schedule tasks and manage time slices precisely.

Event-driven programming

Same pattern

Timer interrupts are a hardware example of event-driven programming where code runs in response to events rather than sequentially.

Human circadian rhythms

Analogy in biology

Just like timer interrupts trigger tasks at regular intervals, our biological clocks trigger processes like sleep and hormone release periodically.

Common Pitfalls

#1 Writing long code inside the ISR causing system slowdowns.

Wrong approach:

void Timer_ISR() {
// Heavy processing
for(int i=0; i<10000; i++) {
process_data(i);
}
clear_interrupt_flag();
}

Correct approach:

volatile int flag = 0;
void Timer_ISR() {
flag = 1; // Set flag quickly
clear_interrupt_flag();
}
// In main loop:
if(flag) {
flag = 0;
process_data();
}

Root cause:

Misunderstanding that ISRs must be short and deferring heavy work to main code improves responsiveness.

#2 Not clearing the interrupt flag inside the ISR, causing repeated interrupts.

Wrong approach:

void Timer_ISR() {
toggle_led();
// Missing clear_interrupt_flag();
}

Correct approach:

void Timer_ISR() {
toggle_led();
clear_interrupt_flag();
}

Root cause:

Forgetting to reset the interrupt flag causes the interrupt to retrigger immediately, leading to infinite ISR calls.

#3 Using non-volatile variables shared between ISR and main code causing incorrect behavior.

Wrong approach:

int counter = 0;
void Timer_ISR() {
counter++;
}
// main code reads counter without volatile

Correct approach:

volatile int counter = 0;
void Timer_ISR() {
counter++;
}

Root cause:

Compiler optimizations assume variables don't change unexpectedly; volatile tells compiler to always read fresh value.

Key Takeaways

Timer interrupts let microcontrollers run code automatically at precise time intervals without manual checking.

ISRs must be short and efficient to keep the system responsive and avoid missing interrupts.

One timer interrupt can manage multiple periodic tasks by using counters or flags inside the ISR.

Understanding interrupt latency and jitter is key to designing reliable real-time systems.

Properly clearing interrupt flags and using volatile variables prevents common bugs in timer interrupt code.