Timer interrupts with TimerOne library in Arduino - Deep Dive

Overview - Timer interrupts with TimerOne library

What is it?

Timer interrupts with the TimerOne library allow an Arduino to run a specific piece of code automatically at regular time intervals without stopping the main program. This means the Arduino can do other tasks while still keeping track of time events. The TimerOne library simplifies setting up these timed events using the hardware timer built into the Arduino.

Why it matters

Without timer interrupts, the Arduino would have to wait or check repeatedly for time to pass, which wastes time and slows down other tasks. Timer interrupts let the Arduino multitask efficiently, making projects like blinking LEDs, reading sensors, or controlling motors more precise and responsive. This is crucial for real-time applications where timing matters.

Where it fits

Before learning timer interrupts, you should understand basic Arduino programming, how loops and functions work, and simple delay timing. After mastering timer interrupts, you can explore advanced multitasking, other hardware timers, and real-time operating systems for microcontrollers.

Mental Model

Core Idea

A timer interrupt is like a silent alarm clock inside the Arduino that rings at set times to run special code without stopping everything else.

Think of it like...

Imagine cooking multiple dishes at once. You set a kitchen timer to beep every few minutes to remind you to stir the pot, but you keep cooking other things in the meantime. The timer beep is the interrupt telling you to do a quick task without stopping all cooking.

┌─────────────────────────────┐
│        Main Program          │
│  (runs continuously)         │
│                             │
│  ┌───────────────────────┐  │
│  │ Timer Interrupt Alarm │◄─┼─ Rings at set intervals
│  └───────────────────────┘  │
│           │                 │
│           ▼                 │
│  ┌───────────────────────┐  │
│  │ Interrupt Service     │  │
│  │ Routine (ISR) runs    │  │
│  │ special code quickly  │  │
│  └───────────────────────┘  │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Arduino Timers Basics

Concept: Learn what hardware timers are and how they count time inside the Arduino.

Arduino boards have built-in timers that count clock pulses to measure time. These timers can trigger events when they reach certain counts. Normally, you use delay() to wait, but timers can do this without stopping the program.

Result

You know that timers are special counters inside the Arduino that can help measure time precisely.

Understanding that timers are hardware counters helps you see why they can run independently and more accurately than software delays.

2

Foundation

What Are Interrupts and Why Use Them

Concept: Interrupts let the Arduino stop what it's doing briefly to run important code immediately.

An interrupt is a signal that tells the Arduino to pause the main program and run a special function called an Interrupt Service Routine (ISR). After the ISR finishes, the Arduino goes back to the main program. This allows quick reactions to events like timers or buttons.

Result

You understand that interrupts let the Arduino multitask by handling urgent tasks right away.

Knowing interrupts let the Arduino respond instantly without waiting helps you design responsive programs.

3

Intermediate

Installing and Using TimerOne Library

🤔Before reading on: do you think TimerOne library works with all Arduino boards or only some? Commit to your answer.

Concept: TimerOne library simplifies setting up timer interrupts on Arduino Uno and similar boards.

TimerOne is a ready-made library that controls Timer1 hardware on Arduino Uno. You install it via the Arduino Library Manager. It lets you set timer intervals easily and attach functions to run when the timer fires.

Result

You can quickly set up timer interrupts without writing low-level code.

Using a library abstracts complex timer registers, making timer interrupts accessible to beginners.

4

Intermediate

Writing an Interrupt Service Routine (ISR)

🤔Before reading on: do you think ISRs can use delay() or Serial.print()? Commit to your answer.

Concept: ISRs are special functions triggered by interrupts and have strict rules.

An ISR must be short and fast. It cannot use delay() or Serial.print() because these rely on interrupts themselves. Instead, ISRs should set flags or update variables quickly. TimerOne library lets you attach your ISR with Timer1.attachInterrupt(yourFunction).

Result

You know how to write safe and efficient ISRs for timer interrupts.

Understanding ISR limitations prevents common bugs and program crashes.

5

Intermediate

Configuring Timer Intervals Precisely

🤔Before reading on: do you think timer intervals are set in milliseconds or microseconds with TimerOne? Commit to your answer.

Concept: TimerOne uses microseconds for precise timing control.

You set the timer interval in microseconds using Timer1.initialize(microseconds). For example, 1000000 microseconds equals 1 second. This lets you create very accurate timed events.

Result

You can control how often your ISR runs with microsecond precision.

Knowing the unit of time for intervals helps avoid timing mistakes and unexpected behavior.

6

Advanced

Combining Timer Interrupts with Main Code

🤔Before reading on: do you think variables shared between ISR and main code need special handling? Commit to your answer.

Concept: Variables shared between ISR and main code must be handled carefully to avoid errors.

When the ISR changes a variable used in the main program, declare it as volatile to tell the compiler it can change anytime. Also, disable interrupts briefly when reading multi-byte variables to avoid reading partial data.

Result

Your program can safely share data between ISR and main code without corruption.

Understanding volatile and interrupt safety prevents subtle bugs in multitasking Arduino programs.

7

Expert

Advanced TimerOne Internals and Limitations

🤔Before reading on: do you think TimerOne can be used on all Arduino models or only specific ones? Commit to your answer.

Concept: TimerOne works only on Arduino boards with Timer1 hardware and has limits on timer resolution and conflicts.

TimerOne controls 16-bit Timer1 on Arduino Uno and similar boards. It cannot be used on boards without Timer1 or with different timer hardware. Also, using TimerOne disables PWM on pins 9 and 10 because they share Timer1. Understanding these limits helps avoid hardware conflicts.

Result

You know when TimerOne is suitable and when to choose other timers or methods.

Knowing hardware constraints and side effects helps design robust, conflict-free Arduino projects.

Under the Hood

The TimerOne library configures the Arduino's Timer1 hardware registers to count clock pulses at a set rate. When the timer reaches the set count (compare match), it triggers an interrupt. The microcontroller pauses the main program, runs the ISR, then resumes. This uses the microcontroller's interrupt vector table and hardware timer counters.

Why designed this way?

TimerOne was created to simplify the complex and error-prone process of configuring hardware timer registers directly. It provides an easy interface to set timer intervals and attach ISRs, making timer interrupts accessible to beginners and reducing bugs. The design balances ease of use with hardware control.

┌───────────────┐
│ Arduino CPU   │
│               │
│  ┌─────────┐  │
│  │ Timer1  │◄─┼─ Counts clock pulses
│  └─────────┘  │
│       │       │
│       ▼       │
│  ┌─────────┐  │
│  │ Compare │  │
│  │ Match   │  │
│  └─────────┘  │
│       │       │
│       ▼       │
│  ┌─────────┐  │
│  │ Interrupt│ │
│  │ Trigger  │ │
│  └─────────┘  │
│       │       │
│       ▼       │
│  ┌─────────┐  │
│  │ ISR     │  │
│  └─────────┘  │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Can you safely use delay() inside an ISR? Commit to yes or no.

Common Belief: You can use delay() inside an ISR to wait for some time.

Reality: delay() relies on interrupts to count time, but interrupts are disabled inside an ISR, so delay() will not work and can freeze the program.

Why it matters: Using delay() inside an ISR causes the program to hang, making the Arduino unresponsive.

Quick: Does TimerOne work on all Arduino boards? Commit to yes or no.

Common Belief: TimerOne library works on every Arduino board regardless of model.

Reality: TimerOne only works on boards with 16-bit Timer1 hardware like Arduino Uno. It does not work on boards without Timer1 or with different timer hardware.

Why it matters: Trying to use TimerOne on unsupported boards leads to compile errors or unexpected behavior.

Quick: Are variables shared between ISR and main code safe without special keywords? Commit to yes or no.

Common Belief: Variables changed in ISR and read in main code do not need special handling.

Reality: Such variables must be declared volatile and accessed carefully to avoid reading inconsistent or partial data.

Why it matters: Ignoring this causes subtle bugs where variables appear to change randomly or incorrectly.

Quick: Does using TimerOne affect PWM pins? Commit to yes or no.

Common Belief: Using TimerOne does not affect any PWM pins on the Arduino.

Reality: TimerOne uses Timer1 hardware which controls PWM on pins 9 and 10, disabling PWM functionality on these pins.

Why it matters: Not knowing this can break PWM-based features like motor speed control or LED brightness on those pins.

Expert Zone

1

TimerOne's use of 16-bit Timer1 means maximum interval and resolution depend on clock speed and prescaler settings, which experts tune for precision.

2

Combining multiple libraries that use Timer1 can cause conflicts; experts carefully manage or avoid overlapping timer usage.

3

ISR execution time affects overall system responsiveness; experts optimize ISRs to be as short as possible to prevent missed interrupts.

When NOT to use

Avoid TimerOne on Arduino boards without Timer1 hardware like Arduino Mega or Due; use libraries designed for their timers instead. For very complex multitasking, consider real-time operating systems or hardware timers with DMA support.

Production Patterns

In real-world projects, TimerOne is used for precise periodic sensor readings, PWM signal generation, or timed motor control. Professionals often combine timer interrupts with state machines and flag variables to build responsive, non-blocking applications.

Connections

Real-Time Operating Systems (RTOS)

Builds-on

Understanding timer interrupts is foundational for grasping how RTOS schedule tasks and manage time slices precisely.

Event-Driven Programming

Same pattern

Timer interrupts are hardware events triggering code, similar to software events in event-driven programming, showing how systems react to signals.

Human Reflexes in Biology

Analogy in different field

Just like timer interrupts cause immediate reactions in Arduino, human reflexes trigger quick responses without conscious thought, illustrating fast automatic reactions.

Common Pitfalls

#1 Using delay() inside an ISR causes the program to freeze.

Wrong approach:

void timerISR() { delay(1000); }

Correct approach:

volatile bool flag = false;
void timerISR() { flag = true; }

Root cause:

Misunderstanding that delay() depends on interrupts which are disabled inside ISRs.

#2 Not declaring shared variables as volatile leads to unpredictable behavior.

Wrong approach:

int count = 0;
void timerISR() { count++; }
void loop() { Serial.println(count); }

Correct approach:

volatile int count = 0;
void timerISR() { count++; }
void loop() { noInterrupts(); int safeCount = count; interrupts(); Serial.println(safeCount); }

Root cause:

Ignoring compiler optimizations and interrupt timing causes inconsistent variable reads.

#3 Using TimerOne on unsupported boards causes errors.

Wrong approach:

#include
// Code for Arduino Mega which lacks Timer1 compatibility

Correct approach:

// Use appropriate timer library for the board, e.g., TimerThree for Arduino Mega

Root cause:

Assuming all Arduino boards have the same timer hardware.

Key Takeaways

Timer interrupts let Arduino run code at precise intervals without stopping the main program.

The TimerOne library simplifies using hardware Timer1 on Arduino Uno for timed interrupts.

ISRs must be short and cannot use functions like delay() or Serial.print() safely.

Shared variables between ISR and main code need volatile declaration and careful access.

TimerOne affects PWM pins 9 and 10 and only works on boards with Timer1 hardware.