The ESP32 LED Chaser: Mastering Sequential GPIO Control

In the world of embedded systems, the LED Chaser is the definitive next step after the basic 'Blink' sketch. It moves beyond simple on/off states into the realm of Logic Sequencing. Using the high-speed GPIO pins of the ESP32, we can create complex visual patterns by controlling the timing and order of multiple output signals.

The Concept: Persistence and Timing

An LED chaser functions by activating one LED in a series, holding it for a specific duration, and then passing the 'ON' state to the next LED. By manipulating the delay between these transitions, we can create the illusion of a single light 'running' across a breadboard. This project is the foundation for understanding how to manage multiple hardware outputs efficiently using code.

Circuit Architecture

To build a 5-LED chaser, we connect the anodes of the LEDs to the ESP32's digital pins and the cathodes to the ground rail. Using current-limiting resistors is critical to ensure the ESP32 pins do not exceed their current rating (approx. 12mA-40mA depending on the pin).

Component	ESP32 GPIO Pin	Role
LED 1	GPIO 15	First Sequence Output
LED 2	GPIO 2	Second Sequence Output
LED 3	GPIO 4	Third Sequence Output
LED 4	GPIO 16	Fourth Sequence Output
LED 5	GPIO 17	Fifth Sequence Output
220Ω Resistors	In Series	Current Limitation
Common Rail	GND	Return Path

Programming: Array-Based Sequencing

Rather than writing individual code for every pin, we use an Integer Array. This allows the CPU to iterate through the pins using a for loop, making the code scalable for 5, 10, or even 20 LEDs.

// Define the GPIO pins in an array
int ledPins[] = {15, 2, 4, 16, 17};
int totalLEDs = 5;

void setup() {
  // Set all pins as OUTPUT using a loop
  for (int i = 0; i < totalLEDs; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  // Forward Chase
  for (int i = 0; i < totalLEDs; i++) {
    digitalWrite(ledPins[i], HIGH);
    delay(100);
    digitalWrite(ledPins[i], LOW);
  }
}

Beyond the Basic Chase: Complex Patterns

Once the hardware is set up, the patterns are limited only by software. By modifying the loop logic, the ESP32 can execute various animations common in automotive and decorative lighting.

The Knight Rider Effect: A back-and-forth scan where the light bounces from the last LED to the first.
The Ping-Pong: Two lights starting at opposite ends and meeting in the middle.
The Pulse: All LEDs fading in and out simultaneously using PWM frequencies.
Random Twinkle: Using the random() function to trigger pins at irregular intervals for a star-like effect.

Common Pitfalls

Dim LEDs: Ensure you are using the 3.3V logic levels correctly. High-resistance resistors (over 1kΩ) may make the LEDs too dim.
ESP32 Reboots: If driving many LEDs (more than 8), the total current might exceed the ESP32's regulator limit. Use an external 5V power supply for the LED rail if necessary.
Skipped LEDs: Double-check the GPIO numbers in your code. Some pins (like GPIO 0 or 12) have special 'strapping' functions and might behave unexpectedly during boot.

Summary

The ESP32 LED Chaser is more than just a visual prop; it is a masterclass in I/O multiplexing and array manipulation. By mastering the timing between these pins, you prepare yourself for more advanced projects like driving 7-segment displays, dot matrices, or SPI-based LED strips.