Non-blocking code architecture in Arduino - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does non-blocking code architecture mean in Arduino programming?

It means writing code that does not stop or wait for tasks to finish before moving on. The program keeps running other parts while waiting for events or delays.

beginner

Why should you avoid using delay() in Arduino sketches for non-blocking code?

Because delay() stops the whole program for a set time, blocking other tasks. Non-blocking code uses timers or checks time to keep the program responsive.

beginner

Which Arduino function helps to check elapsed time without stopping the program?

The millis() function returns the number of milliseconds since the Arduino started. It helps track time without blocking the code.

intermediate

How does using millis() support non-blocking code architecture?

By comparing the current millis() value to a stored time, the program can decide when to run tasks without stopping other code. This keeps the program active and responsive.

beginner

What is a simple example of non-blocking code structure in Arduino?

Using millis() to check if a certain time passed, then running a task, instead of using delay(). This allows other code to run continuously.

What happens when you use delay(1000) in Arduino code?

A The program resets after 1 second.

B The program runs other tasks during the 1 second.

C The program speeds up for 1 second.

D The program pauses for 1 second and does nothing else.

delay(1000) stops the program for 1000 milliseconds (1 second), blocking all other code.

Which function is best to use for non-blocking timing in Arduino?

A delay()

B millis()

C random()

D analogRead()

millis() returns the time since the program started and allows checking elapsed time without stopping the program.

In non-blocking code, how do you check if a certain time has passed?

A By comparing current millis() with a saved timestamp

B By restarting the Arduino

C By using delay()

D By using Serial.print()

You save the time when an event happens and compare it to millis() to see if enough time passed.

Why is non-blocking code important in Arduino projects?

A It makes the program slower.

B It uses more memory.

C It allows multiple tasks to run smoothly without waiting.

D It disables inputs.

Non-blocking code keeps the program responsive and able to handle many tasks at once.

Which of these is a sign of blocking code?

A Using delay() to wait

B Using functions

C Using interrupts

D Using millis() to check time

delay() stops the program and blocks other code from running.

Explain how you can use millis() to create a non-blocking delay in Arduino.

Think about checking time instead of stopping the program.

Why is non-blocking code architecture better for Arduino projects that handle multiple sensors or outputs?

Imagine trying to do many things at once without stopping.

Practice

1. What is the main advantage of using non-blocking code in Arduino programming?

easy

A. It uses less memory than blocking code.

B. It makes the code run slower but more stable.

C. It allows the Arduino to perform multiple tasks without waiting.

D. It automatically fixes hardware errors.

Solution

1. Step 1: Understand blocking vs non-blocking

   Blocking code stops the program until a task finishes, while non-blocking code lets the program keep running other tasks.

2. Step 2: Identify the benefit of non-blocking

   Non-blocking code allows multitasking and keeps the Arduino responsive.

3. Final Answer:

   It allows the Arduino to perform multiple tasks without waiting. -> Option C

4. Quick Check:

   Non-blocking = multitasking [OK]

Hint: Non-blocking means no waiting, so tasks run together [OK]

Common Mistakes:

• Thinking non-blocking slows code down
• Confusing memory use with blocking behavior
• Believing non-blocking fixes hardware issues

2. Which of the following is the correct way to check elapsed time without blocking in Arduino?

easy

A. delay(1000);

B. if (millis() - previousMillis >= interval) { /* do task */ }

C. while(millis() < 1000) { /* wait */ }

D. delayMicroseconds(1000);

Solution

1. Step 1: Identify blocking vs non-blocking code

   delay() and while loops that wait block the program, stopping other tasks.

2. Step 2: Recognize millis() usage

   Using millis() to check elapsed time allows the program to continue running other code.

3. Final Answer:

   if (millis() - previousMillis >= interval) { /* do task */ } -> Option B

4. Quick Check:

   millis() check = non-blocking [OK]

Hint: Use millis() difference, not delay(), to avoid blocking [OK]

Common Mistakes:

• Using delay() which blocks the program
• Using while loops that wait for time
• Confusing delayMicroseconds with non-blocking

3. What will be the output of this Arduino code snippet?

unsigned long previousMillis = 0;
const long interval = 1000;
void loop() {
  if (millis() - previousMillis >= interval) {
    previousMillis = millis();
    Serial.println("Tick");
  }
}

medium

A. Prints "Tick" every second repeatedly.

B. Prints "Tick" continuously without delay.

C. Prints "Tick" once and stops.

D. Does not print anything due to syntax error.

Solution

1. Step 1: Analyze the millis() timing check

   The code checks if 1000 milliseconds (1 second) have passed since last print.

2. Step 2: Understand the loop behavior

   When 1 second passes, it updates previousMillis and prints "Tick" again, repeating forever.

3. Final Answer:

   Prints "Tick" every second repeatedly. -> Option A

4. Quick Check:

   millis() timer triggers print every 1 second [OK]

Hint: millis() timer resets each print for repeated ticks [OK]

Common Mistakes:

• Thinking it prints only once
• Assuming continuous printing without delay
• Believing there is a syntax error

4. Identify the problem in this non-blocking Arduino code and how to fix it:

unsigned long previousMillis = 0;
const long interval = 1000;
void loop() {
  if (millis() > previousMillis + interval) {
    Serial.println("Hello");
  }
}

medium

A. It never updates previousMillis, causing continuous prints.

B. The comparison operator should be '<' instead of '>'.

C. The interval variable must be unsigned long, not long.

D. Serial.println() cannot be used inside loop.

Solution

1. Step 1: Check the timing logic

   The code checks if millis() is greater than previousMillis + interval but never updates previousMillis.

2. Step 2: Understand the effect

   Without updating previousMillis, the condition stays true, so "Hello" prints continuously without delay.

3. Final Answer:

   It never updates previousMillis, causing continuous prints. -> Option A

4. Quick Check:

   Missing previousMillis update = continuous print [OK]

Hint: Always update previousMillis after action to avoid repeats [OK]

Common Mistakes:

• Forgetting to update previousMillis
• Changing comparison operator incorrectly
• Thinking Serial.println() is invalid in loop

5. You want to blink an LED every 500ms and read a sensor every 200ms without blocking. Which code structure best achieves this?

hard

A. Use while loops to wait 500ms and 200ms before each task.

B. Use delay(500) for LED blink and delay(200) for sensor reading in sequence.

C. Use a single millis() timer for both tasks with combined interval 700ms.

D. Use two millis() timers, one for LED and one for sensor, each updating separately.

Solution

1. Step 1: Understand multitasking with millis()

   Each task needs its own timer to run independently without blocking.

2. Step 2: Evaluate options

   Use two millis() timers, one for LED and one for sensor, each updating separately. This uses two separate millis() timers, allowing LED and sensor to run at different intervals smoothly.

3. Final Answer:

   Use two millis() timers, one for LED and one for sensor, each updating separately. -> Option D

4. Quick Check:

   Separate timers = true multitasking [OK]

Hint: Use separate millis() timers for each task to avoid blocking [OK]

Common Mistakes:

• Using delay() which blocks all tasks
• Combining intervals causing missed timings
• Using while loops that block execution