Non-blocking code architecture in Arduino - Step-by-Step Execution

Concept Flow - Non-blocking code architecture

Start loop()

↓

Check time elapsed?

No→Do other tasks

↓

Repeat loop()

↓

Perform action

↓

Update last action time

↓

Do other tasks

↓

Repeat loop()

The loop checks if enough time has passed to do an action without stopping other tasks, then performs the action and continues running other code.

Execution Sample

Arduino

unsigned long previousMillis = 0;
const long interval = 1000;

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    // action code here
  }
  // other code here
}

This code runs an action every 1000 milliseconds without stopping other code from running.

Execution Table

Step	currentMillis	previousMillis	Condition (currentMillis - previousMillis >= interval)	Action	Output
1	0	0	0 - 0 >= 1000 ? False	Skip action	No action
2	500	0	500 - 0 >= 1000 ? False	Skip action	No action
3	1000	0	1000 - 0 >= 1000 ? True	Update previousMillis=1000; perform action	Action performed
4	1500	1000	1500 - 1000 >= 1000 ? False	Skip action	No action
5	2000	1000	2000 - 1000 >= 1000 ? True	Update previousMillis=2000; perform action	Action performed
6	2500	2000	2500 - 2000 >= 1000 ? False	Skip action	No action
Exit	N/A	N/A	Loop repeats indefinitely	Loop continues	No stop

💡 The loop runs forever, checking time and performing actions only when interval passes.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	Final
previousMillis	0	0	0	1000	1000	2000	2000	2000
currentMillis	0	0	500	1000	1500	2000	2500	2500

Key Moments - 3 Insights

Why doesn't the code use delay() to wait for the interval?

Using delay() would stop all code and block other tasks. The execution_table shows the loop keeps running and checking time without stopping.

How does the code know when to perform the action?

It compares currentMillis and previousMillis to see if the interval passed, as shown in the Condition column of the execution_table.

What happens to previousMillis after the action runs?

It updates to currentMillis to reset the timer, so the next action waits for the full interval again (see Step 3 and Step 5).

Visual Quiz - 3 Questions

Look at the execution_table at Step 3. What is the value of previousMillis after the action?

A 500

B 0

C 1000

D 1500

💡 Hint

Check the 'Action' and 'previousMillis' columns at Step 3 in the execution_table.

At which step does the condition become true for the first time?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Condition' column in the execution_table to find when it first becomes true.

If interval was changed to 500, how would Step 2's condition change?

A 500 - 0 >= 500 would be False

B 500 - 0 >= 500 would be True

C Condition would not change

D Condition would be invalid

💡 Hint

Compare the condition formula with the new interval value in the execution_table.

Concept Snapshot

Non-blocking code uses millis() to check elapsed time.
Avoid delay() to keep code responsive.
Use variables to track last action time.
Perform actions only when interval passes.
Loop keeps running other tasks smoothly.

Full Transcript

This example shows how to write Arduino code that does not stop running other tasks while waiting. Instead of delay(), it uses millis() to check if enough time passed since the last action. If yes, it performs the action and updates the timer. Otherwise, it continues running other code. The execution table traces each step, showing how variables change and when actions happen. This method keeps the program responsive and able to do many things at once.