Generating precise delays with timers in Embedded C - Step-by-Step Execution

Concept Flow - Generating precise delays with timers

Configure Timer

↓

Start Timer

↓

Timer Counts

↓

Check if Timer Reached Delay

↓

Stop Timer

↓

Delay Complete

The timer is set up and started, then counts until it reaches the desired delay, after which it stops and signals completion.

Execution Sample

Embedded C

void delay_ms(int ms) {
  timer_init();
  timer_start();
  while(timer_count() < ms) {}
  timer_stop();
}

This function creates a delay of 'ms' milliseconds by starting a timer and waiting until the timer count reaches 'ms'.

Execution Table

Step	Action	Timer Count (ms)	Condition	Result
1	Initialize timer	0	N/A	Timer ready at 0 ms
2	Start timer	0	N/A	Timer counting begins
3	Check timer count	0	0 < ms	Continue waiting
4	Check timer count	1	1 < ms	Continue waiting
5	Check timer count	2	2 < ms	Continue waiting
...	...	...	...	...
n-1	Check timer count	ms-1	ms-1 < ms	Continue waiting
n	Check timer count	ms	ms < ms is False	Exit loop
n+1	Stop timer	ms	N/A	Timer stopped, delay complete

💡 Timer count reached the desired delay value, loop exits and timer stops

Variable Tracker

Variable	Start	After 1	After 2	After n-1	After n	Final
timer_count	0	1	2	ms-1	ms	ms
delay_ms (input)	ms	ms	ms	ms	ms	ms

Key Moments - 2 Insights

Why does the loop check 'timer_count() < ms' instead of 'timer_count() <= ms'?

Because the loop must exit when timer_count equals ms, so the condition is false at that point, stopping the delay exactly at ms (see execution_table row n).

What happens if the timer is not stopped after the delay?

The timer would keep running, possibly causing incorrect timing later. The stop action (execution_table row n+1) ensures the timer resets for next use.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what is the timer count and condition result?

A Timer count is 1, condition true (continue waiting)

B Timer count is 0, condition true (continue waiting)

C Timer count is 0, condition false (exit loop)

D Timer count is 1, condition false (exit loop)

💡 Hint

Refer to execution_table row 3 for timer count and condition

At which step does the timer stop according to the execution_table?

A Step n+1

B Step n

C Step 1

D Step 2

💡 Hint

Look at the action column in execution_table row n+1

If the condition was changed to 'timer_count() <= ms', when would the loop exit?

A When timer_count is ms

B Immediately at 0

C When timer_count is ms+1

D Never exits

💡 Hint

Consider that '<=' allows the loop to continue while timer_count equals ms (see condition logic in execution_table)

Concept Snapshot

Generating precise delays with timers:
- Initialize and configure timer
- Start timer counting
- Loop while timer count < desired delay
- Stop timer when delay reached
- Ensures accurate timing
- Always stop timer to reset for next use

Full Transcript

This visual execution shows how to create precise delays using timers in embedded C. First, the timer is initialized and started. Then the program checks the timer count repeatedly until it reaches the desired delay in milliseconds. Once the timer count equals the delay, the loop exits and the timer is stopped. This method avoids inaccurate delays caused by simple loops and ensures precise timing. Key points include checking the condition correctly and stopping the timer after the delay completes.

Practice

1. What is the main purpose of using timers in embedded C programming for delays?

easy

A. To create precise and accurate wait times without blocking the CPU

B. To increase the CPU clock speed automatically

C. To store large amounts of data temporarily

D. To handle user input events directly

Solution

1. Step 1: Understand timer functionality

   Timers count clock pulses to measure time intervals precisely without busy-waiting.

2. Step 2: Identify timer use for delays

   Using timers allows the program to wait exact times while freeing CPU for other tasks.

3. Final Answer:

   To create precise and accurate wait times without blocking the CPU -> Option A

4. Quick Check:

   Timers = precise delays [OK]

Hint: Timers count clock pulses for exact delays [OK]

Common Mistakes:

• Thinking timers speed up the CPU
• Confusing timers with memory storage
• Assuming timers handle user input

2. Which of the following is the correct way to start a hardware timer in embedded C?

easy

A. beginTimer();

B. start_timer();

C. timer_start();

D. initTimer();

Solution

1. Step 1: Recognize common timer function names

   Standard embedded C libraries often use timer_start() to begin timers.

2. Step 2: Check syntax correctness

   timer_start(); is a valid function call matching typical timer APIs.

3. Final Answer:

   timer_start(); -> Option C

4. Quick Check:

   Correct timer start syntax = timer_start() [OK]

Hint: Look for standard function names like timer_start() [OK]

Common Mistakes:

• Using incorrect function names like start_timer()
• Confusing initialization with starting
• Missing parentheses in function calls

3. Given the code snippet:

timer_set(1000); // Set timer for 1000 ms
timer_start();
while(!timer_expired()) {
  // wait
}
LED_toggle();

What happens after this code runs?

medium

A. LED toggles immediately without delay

B. LED toggles after approximately 1 second delay

C. LED never toggles because timer_expired() is always false

D. LED toggles after 1000 CPU cycles, not milliseconds

Solution

1. Step 1: Understand timer_set and timer_start

   The timer is set for 1000 milliseconds and then started to count down.

2. Step 2: Analyze the while loop waiting for timer expiration

   The loop waits until timer_expired() returns true, which happens after ~1 second.

3. Final Answer:

   LED toggles after approximately 1 second delay -> Option B

4. Quick Check:

   timer_set(1000) = 1 second delay [OK]

Hint: timer_set(ms) delays for ms milliseconds [OK]

Common Mistakes:

• Assuming timer_expired() never becomes true
• Confusing CPU cycles with milliseconds
• Thinking LED toggles immediately

4. Identify the error in this delay code:

timer_set(500);
while(timer_expired()) {
  // wait
}
LED_on();

medium

A. timer_expired() function does not exist

B. timer_set() should be called after the while loop

C. LED_on() should be called before timer_set()

D. The while condition should be !timer_expired() to wait correctly

Solution

1. Step 1: Analyze the while loop condition

   The loop waits while timer_expired() is true, but timer just set, so expired is false initially.

2. Step 2: Correct the condition to wait until timer expires

   It should wait while timer is NOT expired, so condition must be negated: !timer_expired().

3. Final Answer:

   The while condition should be !timer_expired() to wait correctly -> Option D

4. Quick Check:

   Wait while not expired = !timer_expired() [OK]

Hint: Wait while timer not expired: use !timer_expired() [OK]

Common Mistakes:

• Using timer_expired() without negation in wait loop
• Calling timer_set() after waiting
• Assuming LED_on() order affects delay

5. You want to toggle an LED every 250 ms precisely using a timer interrupt. Which approach is best?

hard

A. Use a timer interrupt set for 250 ms to toggle LED inside ISR

B. Use a busy-wait loop with delay function for 250 ms repeatedly

C. Toggle LED once and never use timer

D. Use a timer interrupt but toggle LED outside ISR only

Solution

1. Step 1: Understand precise timing with interrupts

   Using timer interrupts allows exact timing without blocking CPU.

2. Step 2: Identify best place to toggle LED

   Toggling LED inside the timer ISR ensures it happens exactly every 250 ms.

3. Final Answer:

   Use a timer interrupt set for 250 ms to toggle LED inside ISR -> Option A

4. Quick Check:

   Timer ISR toggles LED precisely every 250 ms [OK]

Hint: Toggle LED inside timer ISR for precise periodic delay [OK]

Common Mistakes:

• Using busy-wait loops causing CPU blocking
• Toggling LED outside ISR losing timing precision
• Not using timer interrupts for periodic tasks