11. Non-Blocking Timing & State Machines

Why delay blocks

delay(ms) freezes the whole sketch until the wait ends. During that freeze, loop cannot read buttons, update a second LED, print Serial, or service sensors.

millis() returns milliseconds since the board started and keeps counting while your code runs. Instead of sleeping, you check whether enough time has passed since the last action for each task.

The millis pattern

For each timed task: store the last time you acted, compare against the interval, act when due, then update the stamp.

Pseudocode: if (now - lastRun >= interval) { lastRun = now; doWork(); }

unsigned long now = millis();
if (now - lastFast >= 200) {
  lastFast = now;
  fastState = !fastState;
  digitalWrite(ledFast, fastState);
}

Independent timers

Each task needs its own lastRun variable and its own interval. The worked sketch blinks D5 every 200 ms and D6 every 700 ms while still watching a button.

Tasks share loop but do not wait for each other. If one LED rate looks wrong, check that task's interval and stamp - not the other task.

Shared timeline

Imagine millis as a shared clock. Fast toggles happen often, slow toggles less often, and the button is checked on every loop pass. Empty gaps are not delay - loop is still spinning and checking.

Debounce without delay

Mechanical buttons bounce. Lesson 10 used a millis debounce; here it sits beside the LED timers.

When the raw reading changes, restart lastDebounce. Only after about 40 ms of quiet, and only if the reading differs from the last stable state, accept the new edge. On a stable press to GND (LOW with INPUT_PULLUP), increment the press count.

State machines: one variable, many steps

A state machine stores which step a behaviour is in, in one variable. Each pass of loop() asks two questions: which state am I in, and is it time to leave it? Each state can last a different time and switch different outputs, which a plain blink cannot do.

Write the states as a table first - state, outputs, how long, next state - then turn each row into one branch. Record stateStart whenever the state changes, so elapsed time is measured from the start of the current step. The same shape runs alarm sequences, motor start-up and the practical assessment tasks.

unsigned long elapsed = millis() - stateStart;

if (state == RED && elapsed >= 4000) {
  state = GREEN;
  stateStart = millis();
  showLights(false, false, true);
} else if (state == GREEN && elapsed >= 3000) {
  state = AMBER;
  stateStart = millis();
  showLights(false, true, false);
} else if (state == AMBER && elapsed >= 1000) {
  state = RED;
  stateStart = millis();
  showLights(true, false, false);
}

unsigned long and overflow

millis() returns unsigned long. Store every timestamp as unsigned long too. Using int will break as time grows.

After about 49 days millis rolls over to zero. The subtraction now - lastRun still works correctly with unsigned long arithmetic, so do not rewrite the pattern with signed types or absolute millis comparisons.

Wiring and safe build sequence

1. D5 -> 330 ohm -> LED1 -> GND
2. D6 -> 330 ohm -> LED2 -> GND
3. Button from D2 to GND; use INPUT_PULLUP

What this sketch is for: Red, green and amber LEDs step through a sequence with a different time for each state. loop() never waits, so a button or sensor could be added without changing the timing.

const byte redPin = 8;
const byte amberPin = 9;
const byte greenPin = 10;

const byte RED = 0;
const byte GREEN = 1;
const byte AMBER = 2;

byte state = RED;
unsigned long stateStart = 0;

void showLights(bool red, bool amber, bool green) {
  digitalWrite(redPin, red);
  digitalWrite(amberPin, amber);
  digitalWrite(greenPin, green);
}

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(amberPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  Serial.begin(9600);
  showLights(true, false, false);
  Serial.println("RED");
}

void loop() {
  unsigned long elapsed = millis() - stateStart;

  if (state == RED && elapsed >= 4000) {
    state = GREEN;
    stateStart = millis();
    showLights(false, false, true);
    Serial.println("GREEN");
  } else if (state == GREEN && elapsed >= 3000) {
    state = AMBER;
    stateStart = millis();
    showLights(false, true, false);
    Serial.println("AMBER");
  } else if (state == AMBER && elapsed >= 1000) {
    state = RED;
    stateStart = millis();
    showLights(true, false, false);
    Serial.println("RED");
  }
}