Timer overflow behavior in Embedded C - Step-by-Step Execution

Concept Flow - Timer overflow behavior

Timer starts at 0

↓

Timer counts up each tick

↓

Timer reaches max value

↓

Timer overflows to 0

↓

Overflow interrupt triggers (optional)

↓

Timer continues counting

The timer counts up from zero to its maximum value, then resets to zero (overflows), optionally triggering an interrupt before continuing.

Execution Sample

Embedded C

uint8_t timer = 0;
for (int i = 0; i < 260; i++) {
  timer++;
  if (timer == 0) {
    // overflow occurred
  }
}

This code simulates an 8-bit timer incrementing and detecting when it overflows back to zero.

Execution Table

Iteration	timer before ++	timer after ++	Overflow?
1	0	1	No
2	1	2	No
3	2	3	No
254	253	254	No
255	254	255	No
256	255	0	Yes
257	0	1	No
258	1	2	No
259	2	3	No
260	3	4	No

💡 Loop ends after 260 increments; overflow detected at iteration 256 when timer resets from 255 to 0.

Variable Tracker

Variable	Start	After 1	After 2	After 255	After 256	After 260
timer	0	1	2	255	0	4

Key Moments - 3 Insights

Why does the timer reset to 0 after reaching 255?

Because the timer is an 8-bit variable, it can only hold values 0 to 255. When incremented at 255, it overflows and wraps back to 0, as shown in execution_table row 6.

How can we detect when an overflow happens?

By checking if the timer value becomes 0 immediately after incrementing, as done in the code and shown in execution_table at iteration 256.

Does the timer stop after overflow?

No, the timer continues counting from 0 upwards after overflow, as seen in execution_table rows after iteration 256.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of timer after iteration 256?

A 0

B 255

C 1

D 256

💡 Hint

Check the 'timer after ++' column at iteration 256 in the execution_table.

At which iteration does the timer overflow occur?

A 255

B 260

C 256

D 1

💡 Hint

Look for the row where 'Overflow?' is 'Yes' in the execution_table.

If the timer was 16-bit instead of 8-bit, how would the overflow iteration change?

A It would overflow at iteration 256

B It would overflow at iteration 65536

C It would never overflow

D It would overflow at iteration 260

💡 Hint

16-bit timer max value is 65535, so overflow happens after that many increments.

Concept Snapshot

Timer overflow behavior:
- Timer counts up from 0 to max value (e.g., 255 for 8-bit)
- When max reached, next increment resets timer to 0 (overflow)
- Overflow can trigger interrupt or flag
- Timer continues counting after overflow
- Detect overflow by checking if timer == 0 after increment

Full Transcript

This visual execution shows how a timer variable in embedded C counts up from zero, increments each step, and overflows when it reaches its maximum value. For an 8-bit timer, the max value is 255. When incremented at 255, it resets to zero, which is called overflow. The execution table traces each increment, showing timer values before and after increment, and marks when overflow happens. The variable tracker summarizes timer values at key steps. Key moments clarify why overflow happens, how to detect it, and that counting continues after overflow. The quiz tests understanding of timer values at specific iterations and how overflow changes with timer size. The snapshot summarizes the core behavior of timer overflow in embedded systems.

Practice

1. What happens when a timer in embedded C reaches its maximum count value?

easy

A. It causes the microcontroller to reset.

B. It stops counting permanently.

C. It resets to zero and continues counting (overflow).

D. It triggers a syntax error in the program.

Solution

1. Step 1: Understand timer counting behavior

   Timers count up from zero to a maximum value based on their bit size.

2. Step 2: Identify what happens at max value

   When the timer reaches its max, it resets to zero and continues counting, called overflow.

3. Final Answer:

   It resets to zero and continues counting (overflow). -> Option C

4. Quick Check:

   Timer overflow means reset to zero [OK]

Hint: Timer overflow means count resets to zero [OK]

Common Mistakes:

• Thinking timer stops at max value
• Assuming overflow causes microcontroller reset
• Confusing overflow with syntax errors

2. Which of the following is the correct way to check a timer overflow flag in embedded C?

easy

A. if (TIMER_FLAG != 1) { /* handle overflow */ }

B. if (TIMER_FLAG == 1) { /* handle overflow */ }

C. if (TIMER_FLAG == 0) { /* handle overflow */ }

D. if TIMER_FLAG = 1 { /* handle overflow */ }

Solution

1. Step 1: Understand syntax for condition check

   In C, conditions use double equals '==' to compare values inside parentheses.

2. Step 2: Identify correct overflow flag check

   Checking if TIMER_FLAG equals 1 means overflow occurred, so use 'if (TIMER_FLAG == 1)'.

3. Final Answer:

   if (TIMER_FLAG == 1) { /* handle overflow */ } -> Option B

4. Quick Check:

   Use '==' for comparison in if conditions [OK]

Hint: Use '==' to compare flags in if statements [OK]

Common Mistakes:

• Using single '=' instead of '==' in if condition
• Checking for zero instead of one for overflow
• Missing parentheses around condition

3. Given this code snippet, what will be the value of overflow_count after the timer overflows twice?

volatile uint8_t timer = 254;
volatile uint8_t overflow_count = 0;

void timer_ISR() {
  timer++;
  if (timer == 0) {
    overflow_count++;
  }
}

medium

A. 2

B. 1

C. 0

D. 254

Solution

1. Step 1: Understand timer increment and overflow

   Timer starts at 254, increments to 255, then overflows to 0, triggering overflow_count++.

2. Step 2: Count overflows after two increments

   After two overflows (timer wraps to 0 twice), overflow_count increments twice, so value is 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Two overflows increment count twice [OK]

Hint: Overflow increments count when timer resets to zero [OK]

Common Mistakes:

• Confusing timer value with overflow count
• Forgetting overflow increments counter
• Assuming overflow_count resets with timer

4. Identify the error in this timer overflow handling code:

volatile uint8_t timer = 0;
volatile uint8_t overflow_flag = 0;

void timer_ISR() {
  timer++;
  if (timer = 0) {
    overflow_flag = 1;
  }
}

medium

A. Overflow flag should be reset inside ISR.

B. Timer variable should be uint16_t, not uint8_t.

C. Missing semicolon after timer++.

D. Using assignment '=' instead of comparison '==' in if condition.

Solution

1. Step 1: Check if condition syntax

   The condition uses '=' which assigns 0 to timer instead of comparing it.

2. Step 2: Correct comparison operator

   It should use '==' to check if timer equals 0 for overflow detection.

3. Final Answer:

   Using assignment '=' instead of comparison '==' in if condition. -> Option D

4. Quick Check:

   Use '==' for comparisons, not '=' [OK]

Hint: Use '==' in if conditions, not '=' [OK]

Common Mistakes:

• Confusing '=' with '==' in conditions
• Assuming timer type causes error here
• Ignoring missing flag reset logic

5. You want to measure a time interval longer than your 8-bit timer max count (255). Which method correctly uses timer overflow to achieve this?

hard

A. Count the number of overflows in an interrupt and multiply by 256 plus current timer value.

B. Reset the timer to zero manually before it overflows.

C. Increase the timer frequency to count faster.

D. Ignore overflow and only read the timer value.

Solution

1. Step 1: Understand timer max count limitation

   An 8-bit timer counts from 0 to 255, then overflows back to 0.

2. Step 2: Use overflow count to extend timing range

   Counting overflows lets you track how many times timer wrapped, extending measurable time.

3. Step 3: Calculate total time

   Total count = (overflow_count * 256) + current timer value, giving full interval.

4. Final Answer:

   Count the number of overflows in an interrupt and multiply by 256 plus current timer value. -> Option A

5. Quick Check:

   Overflow count extends timer range [OK]

Hint: Use overflow count x max + timer for long intervals [OK]

Common Mistakes:

• Resetting timer manually loses overflow info
• Increasing frequency doesn't extend max count
• Ignoring overflow loses timing accuracy