Timing-based state machines in Arduino - Mini Project: Build & Apply

Timing-based state machines

📖 Scenario: You want to control an LED that changes its state (ON/OFF) automatically after certain time intervals, like a traffic light changing colors. This helps you learn how to use timing and states in Arduino programming.

🎯 Goal: Build a simple Arduino program that uses a timing-based state machine to turn an LED ON for 3 seconds, then OFF for 2 seconds, repeatedly.

📋 What You'll Learn

Use a variable called ledPin set to 13 for the LED pin

Use a variable called state to track the LED state (ON or OFF)

Use a variable called previousMillis to store the last time the LED state changed

Use unsigned long type for timing variables

Use millis() function to get the current time

Use digitalWrite() to turn the LED ON or OFF

Use if statements to check if it is time to change the LED state

💡 Why This Matters

🌍 Real World

Timing-based state machines are used in devices like traffic lights, automatic doors, and home appliances to control actions based on time.

💼 Career

Understanding timing and state machines is important for embedded systems programming, robotics, and IoT device development.

1

Set up the LED pin and initial state

Create a variable called ledPin and set it to 13. Create a variable called state and set it to LOW. In the setup() function, set ledPin as an output.

Arduino

int ledPin = 13;
int state = LOW;

void setup() {
  pinMode(ledPin, OUTPUT);
  // Your code here
}

void loop() {
  // Your code here
}

Hint

Use int ledPin = 13; and int state = LOW;. In setup(), use pinMode(ledPin, OUTPUT);.

2

Add timing variables

Create a variable called previousMillis of type unsigned long and set it to 0. Create two variables called onInterval and offInterval of type unsigned long and set them to 3000 and 2000 respectively.

Arduino

int ledPin = 13;
int state = LOW;
unsigned long previousMillis = 0;
unsigned long onInterval = 3000;
unsigned long offInterval = 2000;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // Your code here
}

Hint

Use unsigned long previousMillis = 0; and set onInterval to 3000 and offInterval to 2000.

3

Write the timing-based state machine logic

In the loop() function, create a variable called currentMillis and set it to millis(). Use an if statement to check if the LED is ON (state == HIGH) and if the time since previousMillis is greater than or equal to onInterval. If true, set state to LOW and update previousMillis to currentMillis. Use an else if to check if the LED is OFF (state == LOW) and if the time since previousMillis is greater than or equal to offInterval. If true, set state to HIGH and update previousMillis to currentMillis. Finally, use digitalWrite(ledPin, state) to set the LED.

Arduino

int ledPin = 13;
int state = LOW;
unsigned long previousMillis = 0;
unsigned long onInterval = 3000;
unsigned long offInterval = 2000;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();
  // Your code here
}

Hint

Use unsigned long currentMillis = millis(); and check time differences with if and else if. Change state and update previousMillis. Use digitalWrite(ledPin, state); to set the LED.

4

Display the LED state changes

Add a Serial.begin(9600); line in the setup() function. In the loop(), after changing the state, add Serial.println("LED ON"); when the LED turns ON and Serial.println("LED OFF"); when the LED turns OFF. This will print the LED state changes to the Serial Monitor.

Arduino

int ledPin = 13;
int state = LOW;
unsigned long previousMillis = 0;
unsigned long onInterval = 3000;
unsigned long offInterval = 2000;

void setup() {
  pinMode(ledPin, OUTPUT);
  // Your code here
}

void loop() {
  unsigned long currentMillis = millis();

  if (state == HIGH && currentMillis - previousMillis >= onInterval) {
    state = LOW;
    previousMillis = currentMillis;
    // Your code here
  } else if (state == LOW && currentMillis - previousMillis >= offInterval) {
    state = HIGH;
    previousMillis = currentMillis;
    // Your code here
  }

  digitalWrite(ledPin, state);
}

Hint

Start serial communication with Serial.begin(9600); in setup(). Print "LED ON" or "LED OFF" after changing state in loop().

Practice

1.

What is the main purpose of using millis() in a timing-based state machine on Arduino?

easy

A. To pause the program for a fixed time

B. To reset the Arduino board

C. To track elapsed time without stopping the program

D. To read analog sensor values

Solution

1. Step 1: Understand what millis() does

   millis() returns the number of milliseconds since the Arduino started running. It keeps counting without stopping the program.

2. Step 2: Connect millis() to timing-based state machines

   Using millis() lets the program check how much time passed and change states without pausing or blocking other tasks.

3. Final Answer:

   To track elapsed time without stopping the program -> Option C

4. Quick Check:

   millis() tracks time without delay [OK]

Hint: Remember: millis() never stops your code [OK]

Common Mistakes:

• Thinking millis() pauses the program
• Confusing millis() with delay()
• Using millis() to reset Arduino

2.

Which of the following is the correct way to check if 1000 milliseconds have passed using millis()?

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

void loop() {
  unsigned long currentMillis = millis();
  // What condition checks if interval passed?
  if (__________) {
    // do something
    previousMillis = currentMillis;
  }
}

easy

A. previousMillis + currentMillis <= interval

B. previousMillis - currentMillis >= interval

C. currentMillis + previousMillis >= interval

D. currentMillis - previousMillis >= interval

Solution

1. Step 1: Understand elapsed time calculation

   Elapsed time is current time minus previous time: currentMillis - previousMillis.

2. Step 2: Check if elapsed time reached interval

   We compare if elapsed time is greater or equal to the interval: currentMillis - previousMillis >= interval.

3. Final Answer:

   currentMillis - previousMillis >= interval -> Option D

4. Quick Check:

   Elapsed time = current - previous [OK]

Hint: Subtract previous from current time to get elapsed [OK]

Common Mistakes:

• Reversing subtraction order
• Adding times instead of subtracting
• Using <= instead of >=

3.

What will be the output of this Arduino code snippet that uses a timing-based state machine?

unsigned long previousMillis = 0;
const long interval = 2000;
int ledState = LOW;

void setup() {
  pinMode(13, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    if (ledState == LOW) {
      ledState = HIGH;
    } else {
      ledState = LOW;
    }
    digitalWrite(13, ledState);
    Serial.println(ledState);
  }
}

medium

A. Prints alternating 0 and 1 every 2 seconds

B. Prints 1 continuously every 2 seconds

C. Prints 0 continuously every 2 seconds

D. No output because of syntax error

Solution

1. Step 1: Understand the timing and state toggle

   Every 2000 ms, the code toggles ledState between LOW (0) and HIGH (1).

2. Step 2: Check output printed

   Each toggle prints the current ledState (0 or 1) to Serial, alternating every 2 seconds.

3. Final Answer:

   Prints alternating 0 and 1 every 2 seconds -> Option A

4. Quick Check:

   State toggles and prints 0,1 alternately [OK]

Hint: Toggle state and print inside timed if-block [OK]

Common Mistakes:

• Assuming constant output without toggle
• Confusing HIGH/LOW with 1/0
• Missing update of previousMillis

4.

Identify the bug in this timing-based state machine code and choose the fix.

unsigned long previousMillis = 0;
const long interval = 1000;
int ledState = LOW;

void setup() {
  pinMode(13, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis > interval) {
    ledState = !ledState;
    digitalWrite(13, ledState);
  }
}

medium

A. Add previousMillis = currentMillis; inside the if-block

B. Change int ledState to bool ledState

C. Replace ! with ~ in toggle

D. Remove the if condition to toggle every loop

Solution

1. Step 1: Check timing update logic

   The code never updates previousMillis, so the condition stays true forever after first pass.

2. Step 2: Fix by updating previousMillis

   Adding previousMillis = currentMillis; inside the if-block resets the timer for the next interval.

3. Final Answer:

   Add previousMillis = currentMillis; inside the if-block -> Option A

4. Quick Check:

   Update previousMillis to reset timer [OK]

Hint: Always update previousMillis after interval check [OK]

Common Mistakes:

• Forgetting to update previousMillis
• Using bitwise NOT (~) instead of logical NOT (!)
• Removing timing check causes fast toggling

5.

You want to create a state machine that cycles through three LED states: OFF, RED, GREEN. Each state lasts 3 seconds. Which code snippet correctly implements this using millis()?

unsigned long previousMillis = 0;
const long interval = 3000;
int state = 0;

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    state = (state + 1) % 3;
    switch(state) {
      case 0:
        digitalWrite(RED_PIN, LOW);
        digitalWrite(GREEN_PIN, LOW);
        break;
      case 1:
        digitalWrite(RED_PIN, HIGH);
        digitalWrite(GREEN_PIN, LOW);
        break;
      case 2:
        digitalWrite(RED_PIN, LOW);
        digitalWrite(GREEN_PIN, HIGH);
        break;
    }
  }
}

hard

A. Does not change states due to missing update

B. Correctly cycles OFF, RED, GREEN every 3 seconds

C. Cycles states every 1 second instead of 3

D. Cycles only RED and GREEN, skipping OFF

Solution

1. Step 1: Check timing and state update

   The code uses millis() to check 3 seconds passed, then updates state cycling 0,1,2 with modulo 3.

2. Step 2: Verify LED outputs per state

   State 0 turns both LEDs off, 1 turns RED on, 2 turns GREEN on. This matches the required cycle.

3. Final Answer:

   Correctly cycles OFF, RED, GREEN every 3 seconds -> Option B

4. Quick Check:

   State cycles with modulo and timing [OK]

Hint: Use modulo (%) to cycle states smoothly [OK]

Common Mistakes:

• Forgetting to update previousMillis
• Incorrect modulo causing wrong cycles
• Not turning off LEDs in OFF state