micros() for microsecond precision in Arduino - Mini Project: Build & Apply

Using micros() for Microsecond Precision Timing

📖 Scenario: You want to measure how long a button is pressed with very fine detail. The Arduino micros() function helps you track time in microseconds, which is much faster than seconds or milliseconds.

🎯 Goal: Build a simple Arduino program that records the time when a button is pressed and released using micros(), then calculates and shows the press duration in microseconds.

📋 What You'll Learn

Create a variable to store the button pin number.

Create variables to store the press start and end times using unsigned long.

Use micros() to get the current time in microseconds.

Calculate the duration the button was pressed in microseconds.

Print the duration to the Serial Monitor.

💡 Why This Matters

🌍 Real World

Measuring very short events like button presses or sensor pulses accurately is important in robotics, timing circuits, and signal processing.

💼 Career

Understanding microsecond timing helps in embedded systems development, hardware interfacing, and performance optimization.

1

Set up the button pin and variables

Create a variable called buttonPin and set it to 2. Create two variables called pressStart and pressEnd of type unsigned long and set both to 0.

Arduino

int buttonPin = 2;
unsigned long pressStart = 0;
unsigned long pressEnd = 0;
// Your code here

Hint

Use int for the pin number and unsigned long for time variables.

2

Configure the button pin in setup()

Write the setup() function. Inside it, use pinMode(buttonPin, INPUT_PULLUP) to set the button pin as input with pull-up resistor. Also, start serial communication with Serial.begin(9600).

Arduino

int buttonPin = 2;
unsigned long pressStart = 0;
unsigned long pressEnd = 0;

void setup() {
  // Set buttonPin as input with pull-up resistor
  // Start serial communication at 9600 baud
  // Your code here
}

Hint

Use pinMode and Serial.begin inside setup().

3

Detect button press and release times using micros()

Write the loop() function. Inside it, read the button state with digitalRead(buttonPin). When the button is pressed (state is LOW), set pressStart to micros(). When the button is released (state is HIGH) and pressStart is not zero, set pressEnd to micros().

Arduino

int buttonPin = 2;
unsigned long pressStart = 0;
unsigned long pressEnd = 0;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  // Read the button state
  // If pressed, set pressStart to micros()
  // If released and pressStart not zero, set pressEnd to micros()
  // Your code here
}

Hint

Use digitalRead to check button state and micros() to get time.

4

Calculate and print the press duration

Inside the loop(), after setting pressEnd, calculate the duration as pressEnd - pressStart. Print the duration in microseconds using Serial.print() and Serial.println(). Then reset pressStart and pressEnd to 0.

Arduino

int buttonPin = 2;
unsigned long pressStart = 0;
unsigned long pressEnd = 0;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int buttonState = digitalRead(buttonPin);
  if (buttonState == LOW) {
    if (pressStart == 0) {
      pressStart = micros();
    }
  } else {
    if (pressStart != 0) {
      pressEnd = micros();
      // Calculate duration and print it
      // Reset pressStart and pressEnd
      // Your code here
    }
  }
}

Hint

Calculate duration by subtracting pressStart from pressEnd. Use Serial.print and Serial.println to show the message.

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