micros() for microsecond precision in Arduino - Step-by-Step Execution

Concept Flow - micros() for microsecond precision

Start Program

↓

Call micros()

↓

Get time in microseconds since start

↓

Use time value for timing or events

↓

Repeat or end

The program calls micros() to get the time in microseconds since the Arduino started, then uses that value for precise timing.

Execution Sample

Arduino

unsigned long startTime = micros();
// wait some time
unsigned long elapsed = micros() - startTime;
Serial.println(elapsed);

This code measures how many microseconds have passed since startTime.

Execution Table

Step	Action	micros() value (µs)	Calculation	Output
1	Call micros() to get startTime	1000	startTime = 1000	-
2	Wait some microseconds	-	-	-
3	Call micros() again	3500	-	-
4	Calculate elapsed time	-	elapsed = 3500 - 1000 = 2500	-
5	Print elapsed time	-	-	2500

💡 Program ends or repeats; micros() keeps counting microseconds since start.

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 4	Final
startTime	undefined	1000	1000	1000	1000
elapsed	undefined	undefined	undefined	2500	2500

Key Moments - 2 Insights

Why do we subtract startTime from micros() to get elapsed time?

Because micros() returns total microseconds since start, subtracting startTime gives the time passed since we saved startTime (see execution_table step 4).

What happens if micros() overflows (resets to zero)?

micros() overflows roughly every 70 minutes, but subtraction still works correctly with unsigned arithmetic, so elapsed time remains accurate.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of elapsed?

A 2500

B 3500

C 1000

D 4500

💡 Hint

Check the Calculation column in step 4 of execution_table.

At which step is the startTime variable assigned a value?

A Step 3

B Step 4

C Step 1

D Step 5

💡 Hint

Look at the Action and Calculation columns in execution_table step 1.

If the wait time was longer, how would the elapsed value change in the table?

A It would be smaller

B It would be larger

C It would be the same

D It would be zero

💡 Hint

Elapsed time is micros() now minus startTime, so longer wait means larger elapsed (see variable_tracker).

Concept Snapshot

micros() returns time in microseconds since Arduino started
Use unsigned long to store micros() values
Subtract startTime from current micros() to get elapsed time
Useful for precise timing and measuring intervals
micros() overflows every ~70 minutes but subtraction still works

Full Transcript

This visual execution shows how the Arduino function micros() returns the number of microseconds since the program started. First, we save the current micros() value in startTime. After waiting some time, we call micros() again and subtract startTime to find the elapsed microseconds. This method helps measure precise time intervals. Even if micros() overflows after about 70 minutes, the subtraction still works correctly because of unsigned arithmetic. The execution table tracks each step, showing variable values and calculations. The variable tracker shows how startTime and elapsed change during execution. Key moments clarify why subtraction is needed and how overflow is handled. The quiz tests understanding of elapsed time calculation and variable assignment.

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