LEDs & Lighting

Every LED needs a current-limiting resistor. The ESP32 runs at 3.3 V and can source/sink up to 40 mA per GPIO, but keep typical LEDs at 5–15 mA for longevity.

Formula: R = (V _supply − V _f ) / I _LED — round up to the nearest standard value.

Connect the resistor on either side of the LED — before the anode or after the cathode. The cathode (−) is the shorter lead and the flat side of the LED case.

Parallel (correct)

GPIO ──[R]── LED1 ── GND
     ──[R]── LED2 ── GND
     ──[R]── LED3 ── GND

Each LED has its own resistor and shares the GPIO. Current adds up: three LEDs at 10 mA = 30 mA total — stay within the 40 mA GPIO limit.

Series (avoid at 3.3 V)

GPIO ──[R]── LED ── LED ── GND

3.3 V minus two forward voltages leaves little headroom. Series wiring is only practical at 5 V or higher.

The 74HC595 converts 3 serial GPIO lines into 8 parallel outputs — ideal when you need more LED outputs than available GPIOs. Multiple chips can be daisy-chained (Q7S → next DS) for 16, 24 … outputs with the same 3 pins.

Arduino code

#define PIN_DS    23   // serial data
#define PIN_SRCLK 18   // shift-register clock
#define PIN_RCLK  5    // latch / storage clock

void shiftWrite(byte data) {
    digitalWrite(PIN_RCLK, LOW);
    shiftOut(PIN_DS, PIN_SRCLK, MSBFIRST, data);
    digitalWrite(PIN_RCLK, HIGH);   // latch: outputs update here
}

void setup() {
    pinMode(PIN_DS,    OUTPUT);
    pinMode(PIN_SRCLK, OUTPUT);
    pinMode(PIN_RCLK,  OUTPUT);
    shiftWrite(0x00);               // all LEDs off at boot
}

void loop() {
    shiftWrite(0b01010101);         // LEDs 0, 2, 4, 6 on
    delay(500);
    shiftWrite(0b10101010);         // LEDs 1, 3, 5, 7 on
    delay(500);
}

The MAX7219 and MAX7221 are serial-interface, 8-digit LED display driver ICs. They handle multiplexing, constant-current drive, and brightness control internally — leaving the ESP32 free of timing-critical refresh loops. One chip drives up to 64 individual LEDs (as an 8×8 matrix) or eight 7-segment display digits over a 3-wire SPI interface.

MAX7219 vs MAX7221

RSET resistor (ISET pin)

A single resistor from ISET to V _CC sets the peak segment current. All 64 outputs share this limit — choose based on your LED forward current rating.

Intensity register (0x0A, values 0–15) provides a further 16-step software brightness control on top of RSET — useful for day/night dimming.

Register map

With LedControl library (recommended)

// Library Manager → search "LedControl" by Eberhard Fahle
#include <LedControl.h>

// LedControl(DIN, CLK, CS, numDevices)
LedControl lc(23, 18, 5, 1);

void setup() {
    lc.shutdown(0, false);      // wake from power-save mode
    lc.setIntensity(0, 8);      // brightness 0–15
    lc.clearDisplay(0);
}

void loop() {
    // Set individual LED: device 0, row, col, on/off
    for (int row = 0; row < 8; row++) {
        for (int col = 0; col < 8; col++) {
            lc.setLed(0, row, col, true);
            delay(40);
            lc.setLed(0, row, col, false);
        }
    }
}

// Set an entire row at once (e.g. annunciator bank)
// lc.setRow(device, row, 0b10110001);

Raw SPI — no library

#define PIN_DIN  23
#define PIN_CLK  18
#define PIN_CS   5

void max7221Send(byte reg, byte data) {
    digitalWrite(PIN_CS, LOW);
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, reg);
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, data);
    digitalWrite(PIN_CS, HIGH);
}

void setup() {
    pinMode(PIN_DIN, OUTPUT);
    pinMode(PIN_CLK, OUTPUT);
    pinMode(PIN_CS,  OUTPUT);
    digitalWrite(PIN_CS, HIGH);

    max7221Send(0x09, 0x00);    // decode mode: none (raw LED bits)
    max7221Send(0x0A, 0x08);    // intensity: 8/15
    max7221Send(0x0B, 0x07);    // scan limit: rows 0–7
    max7221Send(0x0C, 0x01);    // shutdown register: normal operation
    max7221Send(0x0F, 0x00);    // display test: off
}

void loop() {
    max7221Send(0x01, 0b10101010);   // row 1: alternate LEDs on
    delay(500);
    max7221Send(0x01, 0b01010101);
    delay(500);
}

Daisy-chaining two MAX7221 chips

Connect DOUT of the first chip to DIN of the second. Share CLK, CS, and GND. Each transaction must clock through data for every device in the chain.

// Daisy-chaining two MAX7221 chips
// ESP32 → chip A (DOUT) → chip B DIN

void sendToAll(byte reg, byte data) {
    digitalWrite(PIN_CS, LOW);
    // Shift to chip B first (furthest in chain)
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, reg);
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, data);
    // Then chip A
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, reg);
    shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, data);
    digitalWrite(PIN_CS, HIGH);
}

void sendToDevice(int device, byte reg, byte data) {
    // device 0 = chip A (first), device 1 = chip B (last)
    digitalWrite(PIN_CS, LOW);
    for (int i = 1; i >= 0; i--) {
        if (i == device) {
            shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, reg);
            shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, data);
        } else {
            shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, 0x00);  // no-op
            shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, 0x00);
        }
    }
    digitalWrite(PIN_CS, HIGH);
}

const int LED_PIN = 23;

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

void loop() {
    digitalWrite(LED_PIN, HIGH);
    delay(500);
    digitalWrite(LED_PIN, LOW);
    delay(500);
}