Why Multiple timed events with millis() in Arduino? - Purpose & Use Cases

The Big Idea

What if your program could keep running smoothly while handling many timed tasks at once?

The Scenario

Imagine you want to turn on a light for 2 seconds, then after 5 seconds, turn on a buzzer for 1 second, and keep doing this repeatedly. You try to do this by writing code that waits and pauses for each event one after another.

The Problem

Using simple delay commands to wait for each event means your whole program stops and does nothing else during those pauses. This makes it impossible to handle multiple events at the same time or respond quickly to other inputs. It's like waiting in line for your turn and missing everything else happening around you.

The Solution

Using millis() lets you check how much time has passed without stopping your program. You can track multiple timers independently and trigger events exactly when their time comes, all while your program keeps running smoothly. This way, you can handle many timed events at once without freezing anything.

Before vs After

✗ Before

delay(2000); // wait 2 seconds
turnOnLight();
delay(5000); // wait 5 seconds
turnOnBuzzer();

✓ After

if (millis() - lastLightTime >= 2000) { turnOnLight(); lastLightTime = millis(); }
if (millis() - lastBuzzerTime >= 5000) { turnOnBuzzer(); lastBuzzerTime = millis(); }

What It Enables

You can create responsive programs that handle many timed actions at once without stopping or missing anything.

Real Life Example

Think of a traffic light system where red, yellow, and green lights change at different times, and a pedestrian button can be pressed anytime to change the sequence. Using millis() lets the system keep track of all lights and button presses smoothly.

Key Takeaways

Using delay() pauses your whole program and blocks other actions.

millis() lets you track time without stopping your program.

This allows multiple timed events to run independently and smoothly.

Practice

1. What is the main advantage of using millis() for timing multiple events in Arduino instead of delay()?

easy

A. It resets the Arduino automatically.

B. It stops the program until the time passes.

C. It makes the program run slower.

D. It allows the program to run other tasks while waiting.

Solution

1. Step 1: Understand delay() behavior

   delay() pauses the whole program, stopping all other actions.

2. Step 2: Understand millis() advantage

   millis() returns elapsed time without stopping the program, so other tasks can run simultaneously.

3. Final Answer:

   It allows the program to run other tasks while waiting. -> Option D

4. Quick Check:

   millis() enables multitasking [OK]

Hint: Remember: delay() stops, millis() doesn't [OK]

Common Mistakes:

• Thinking millis() pauses the program
• Confusing delay() with non-blocking timing
• Believing millis() resets Arduino

2. Which of the following is the correct way to declare a variable to store the last time an event occurred using millis()?

easy

A. unsigned long lastEventTime = 0;

B. int lastEventTime = 0;

C. float lastEventTime = 0.0;

D. char lastEventTime = '0';

Solution

1. Step 1: Identify the correct data type for time

   Since millis() returns an unsigned long value, the variable must be unsigned long.

2. Step 2: Check variable initialization

   Initializing to 0 is correct to mark the start time.

3. Final Answer:

   unsigned long lastEventTime = 0; -> Option A

4. Quick Check:

   Use unsigned long for millis() times [OK]

Hint: Use unsigned long for time variables with millis() [OK]

Common Mistakes:

• Using int which can overflow quickly
• Using float which is not precise for time
• Using char which is for characters, not numbers

3. What will be the output of the following Arduino code snippet if millis() returns 5000 at the moment of checking?

unsigned long previousMillis = 3000;
unsigned long interval = 1500;

if (millis() - previousMillis >= interval) {
  Serial.println("Event triggered");
} else {
  Serial.println("Waiting");
}

medium

A. Waiting

B. No output

C. Event triggered

D. Compilation error

Solution

1. Step 1: Calculate elapsed time

   Elapsed time = 5000 (current millis) - 3000 (previousMillis) = 2000 ms.

2. Step 2: Compare elapsed time with interval

   Interval is 1500 ms. Since 2000 >= 1500, the condition is true, so "Event triggered" should print.

3. Final Answer:

   Event triggered -> Option C

4. Quick Check:

   Elapsed time 2000 >= 1500 triggers event [OK]

Hint: Subtract previousMillis from millis() to check elapsed time [OK]

Common Mistakes:

• Mixing up >= and > operators
• Forgetting to subtract previousMillis
• Assuming output without calculation

4. Identify the error in this code snippet that tries to blink two LEDs at different intervals using millis():

unsigned long previousMillis1 = 0;
unsigned long previousMillis2 = 0;
const long interval1 = 1000;
const long interval2 = 2000;

void loop() {
  if (millis() - previousMillis1 >= interval1) {
    digitalWrite(LED1, !digitalRead(LED1));
    previousMillis1 = millis();
  }
  if (millis() - previousMillis1 >= interval2) {
    digitalWrite(LED2, !digitalRead(LED2));
    previousMillis2 = millis();
  }
}

medium

A. LED pins are not defined.

B. Second if condition uses previousMillis1 instead of previousMillis2.

C. Intervals should be unsigned long, not long.

D. digitalWrite cannot toggle LEDs.

Solution

1. Step 1: Check timing variables in conditions

   The second if condition incorrectly uses previousMillis1 instead of previousMillis2, causing wrong timing for LED2.

2. Step 2: Understand impact of error

   This mistake means LED2 timing depends on LED1 timing, so LED2 won't blink at its own interval.

3. Final Answer:

   Second if condition uses previousMillis1 instead of previousMillis2. -> Option B

4. Quick Check:

   Each event needs its own previousMillis variable [OK]

Hint: Use separate previousMillis for each timed event [OK]

Common Mistakes:

• Reusing the same previousMillis variable for multiple events
• Not updating previousMillis after event
• Confusing interval variables

5. You want to control three LEDs blinking at 500ms, 1000ms, and 1500ms intervals respectively without using delay(). Which approach correctly manages all three timed events using millis()?

hard

A. Use three separate previousMillis variables and check each with its own interval inside loop().

B. Use one previousMillis variable and reset it after each LED toggles.

C. Use delay(500) and toggle all LEDs together.

D. Use millis() only once and toggle LEDs based on dividing millis() by intervals.

Solution

1. Step 1: Understand independent timing needs

   Each LED needs its own timer to blink independently at different intervals.

2. Step 2: Evaluate options

   Use three separate previousMillis variables and check each with its own interval inside loop(), allowing independent timing without blocking.

3. Final Answer:

   Use three separate previousMillis variables and check each with its own interval inside loop(). -> Option A

4. Quick Check:

   Separate timers for each event [OK]

Hint: Assign each event its own timer variable for independent control [OK]

Common Mistakes:

• Using one timer for all events causing sync issues
• Using delay which blocks other events
• Trying to calculate toggles from one millis() value without state