micros() for microsecond precision in Arduino - Time & Space Complexity

Time Complexity: micros() for microsecond precision

O(n)

Understanding Time Complexity

We want to understand how the time taken by code using micros() changes as the program runs longer.

How does the number of operations grow when measuring time in microseconds?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

unsigned long startTime = micros();
while (micros() - startTime < 1000) {
  // wait for 1000 microseconds (1 millisecond)
}

This code waits for 1000 microseconds by repeatedly checking the current time using micros().

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The while loop repeatedly calls micros() to check elapsed time.
• How many times: The loop runs until the difference reaches 1000 microseconds, so about 1000 times.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (microseconds)	Approx. Operations (loop iterations)
10	~10 calls to micros()
100	~100 calls to micros()
1000	~1000 calls to micros()

Pattern observation: The number of loop iterations grows directly with the microseconds to wait.

Final Time Complexity

Time Complexity: O(n)

This means the time spent waiting grows linearly with the number of microseconds you want to wait.

Common Mistake

[X] Wrong: "Calling micros() inside the loop is instant and does not affect timing."

[OK] Correct: Each call to micros() takes some time, so the loop runs about as many times as the microseconds you wait, making the total time proportional to the wait time.

Interview Connect

Understanding how loops with time checks grow helps you write efficient timing code in embedded systems, a useful skill for real projects and interviews.

Self-Check

"What if we replaced micros() with a function that updates less often, like millis()? How would the time complexity change?"

Practice

1. What does the Arduino function micros() return?

easy

A. The number of microseconds since the program started

B. The number of milliseconds since the program started

C. The current time in seconds

D. The number of seconds since the last reset

Solution

1. Step 1: Understand the purpose of micros()

   The micros() function returns the time in microseconds since the Arduino program began running.

2. Step 2: Compare options with the function's behavior

   Only The number of microseconds since the program started correctly states it returns microseconds since start. Others mention milliseconds or seconds, which are incorrect.

3. Final Answer:

   The number of microseconds since the program started -> Option A

4. Quick Check:

   micros() = microseconds since start [OK]

Hint: Remember micros() counts microseconds from program start [OK]

Common Mistakes:

• Confusing micros() with millis()
• Thinking it returns seconds
• Assuming it resets every second

2. Which of the following is the correct way to store the current microsecond count in a variable?

easy

A. unsigned long time = micros();

B. int time = micros();

C. float time = micros();

D. long time = micros();

Solution

1. Step 1: Identify the data type returned by micros()

   The micros() function returns an unsigned long integer representing microseconds.

2. Step 2: Match the correct variable type to store the value

   Only unsigned long can hold the large values from micros() without overflow or sign issues.

3. Final Answer:

   unsigned long time = micros(); -> Option A

4. Quick Check:

   Use unsigned long for micros() values [OK]

Hint: Use unsigned long to store micros() values safely [OK]

Common Mistakes:

• Using int which is too small
• Using float which loses precision
• Using signed long which can cause negative values

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

unsigned long start = micros();
// some delay here
unsigned long end = micros();
unsigned long diff = end - start;
Serial.println(diff);

Assuming the delay is about 500 microseconds.

medium

A. Always zero

B. A number close to 500000

C. A negative number

D. A number close to 500

Solution

1. Step 1: Understand the timing measurement

   The code measures the time difference in microseconds between two calls to micros().

2. Step 2: Interpret the delay and difference calculation

   If the delay is about 500 microseconds, the difference diff will be close to 500, printed as a positive number.

3. Final Answer:

   A number close to 500 -> Option D

4. Quick Check:

   diff = end - start ≈ 500 [OK]

Hint: Subtract micros() values to get elapsed microseconds [OK]

Common Mistakes:

• Expecting milliseconds instead of microseconds
• Thinking difference can be negative
• Confusing delay units

4. Identify the error in this Arduino code snippet:

unsigned long start = micros();
// some code
unsigned long end = micros();
int elapsed = end - start;
Serial.println(elapsed);

medium

A. micros() cannot be assigned to unsigned long

B. Using int for elapsed can cause overflow

C. Serial.println cannot print integers

D. Subtracting micros() values is invalid

Solution

1. Step 1: Check variable types for time difference

   The difference between two micros() values can be very large, exceeding the range of int.

2. Step 2: Understand overflow risk

   Using int (usually 16-bit) can cause overflow and incorrect negative values. It should be unsigned long.

3. Final Answer:

   Using int for elapsed can cause overflow -> Option B

4. Quick Check:

   Use unsigned long for elapsed time to avoid overflow [OK]

Hint: Use unsigned long, not int, for time differences [OK]

Common Mistakes:

• Using int instead of unsigned long
• Thinking micros() returns signed values
• Assuming Serial.println can't print integers

5. You want to measure how long a button is pressed in microseconds using micros(). Which approach correctly handles the timing even if the program runs longer than 70 minutes (when micros() overflows)?

hard

A. Ignore overflow because it never affects timing

B. Reset the Arduino every 60 minutes to avoid overflow

C. Store start time, then calculate elapsed as micros() - start using unsigned long subtraction

D. Use millis() instead because it never overflows

Solution

1. Step 1: Understand micros() overflow behavior

   micros() overflows roughly every 70 minutes, wrapping back to zero.

2. Step 2: Use unsigned long subtraction to handle overflow

   Unsigned subtraction correctly calculates elapsed time even if overflow happens, so micros() - start works safely.

3. Final Answer:

   Store start time, then calculate elapsed as micros() - start using unsigned long subtraction -> Option C

4. Quick Check:

   Unsigned subtraction handles micros() overflow correctly [OK]

Hint: Use unsigned subtraction to handle micros() overflow safely [OK]

Common Mistakes:

• Thinking micros() never overflows
• Using millis() which has lower precision
• Resetting Arduino unnecessarily