Cubo LED RGB + ESP32

Firmware Arduino (FastLED) con los 4 modos · BOOT = siguiente modo

// Cubo LED RGB 10x10x10 (1000 WS2812B en serie) con ESP32 DevKit
// Libreria: FastLED (Gestor de bibliotecas de Arduino IDE)
//
// Conexiones:
//   GPIO13 (D13) -> DIN del LED 1 (ideal con un adaptador de nivel 74AHCT125, 3.3V -> 5V)
//   5V y GND de una FUENTE EXTERNA 5V (1000 LEDs pueden pedir hasta 60 A: inyecta
//   alimentacion en varias capas) -> LEDs. El GND de la fuente y el de la ESP32 van unidos.
//   BOOT (GPIO0) = siguiente modo   |   EN = reset (arranca apagado)

#include <FastLED.h>

#define DATA_PIN  13
#define BOOT_PIN  0
#define S         10
#define NUM_LEDS  (S * S * S)

CRGB leds[NUM_LEDS];
uint8_t  mode = 0;            // 0 = apagado, 1..4 = modos
uint32_t t0 = 0, lastPress = 0;

// Cableado: cada capa en zigzag; las capas impares se recorren al reves
uint16_t idx(uint8_t x, uint8_t y, uint8_t z) {
  uint16_t s = y * S + ((y % 2 == 0) ? x : S - 1 - x);
  if (z % 2 == 1) s = S * S - 1 - s;
  return z * S * S + s;
}

// ---- Modo 1: rojo / verde / azul ----
void modeColors() {
  uint8_t c = ((millis() - t0) / 1500) % 3;
  fill_solid(leds, NUM_LEDS, c == 0 ? CRGB::Red : (c == 1 ? CRGB::Green : CRGB::Blue));
}

// ---- Modo 2: recorrido en serie con estela ----
uint16_t lastHead = 0;
void modeChase() {
  uint16_t head = ((millis() - t0) / 7) % NUM_LEDS;
  fadeToBlackBy(leds, NUM_LEDS, 25);
  while (lastHead != head) {
    lastHead = (lastHead + 1) % NUM_LEDS;
    leds[lastHead] = CHSV(lastHead * 255UL / NUM_LEDS, 255, 255);
  }
}

// ---- Modo 3: encendido en orden aleatorio ----
uint16_t order[NUM_LEDS], nOn = 0;
uint32_t holdT = 0;
void shuffleOrder() {
  for (uint16_t i = 0; i < NUM_LEDS; i++) order[i] = i;
  for (uint16_t i = NUM_LEDS - 1; i > 0; i--) {
    uint16_t j = random16(i + 1);
    uint16_t tmp = order[i]; order[i] = order[j]; order[j] = tmp;
  }
  nOn = 0;
}
void modeRandom() {
  if (nOn < NUM_LEDS) {
    uint16_t want = (millis() - t0) / 6;
    while (nOn <= want && nOn < NUM_LEDS) leds[order[nOn++]] = CHSV(random8(), 255, 255);
    if (nOn >= NUM_LEDS) holdT = millis();
  } else if (millis() - holdT > 1500) {
    FastLED.clear();
    shuffleOrder();
    t0 = millis();
  }
}

// ---- Modo 4: formas 3D (piramide, corazon, cubo) ----
bool inShape(uint8_t s, uint8_t x, uint8_t y, uint8_t z) {
  if (s == 0) {                                   // piramide
    return fmaxf(fabsf(x - 4.5f), fabsf(y - 4.5f)) <= (10 - z) / 2.0f;
  } else if (s == 1) {                            // corazon
    float X = (x - 4.5f) / 3.7f, Y = (y - 4.5f) / 3.7f, Z = (z - 4.5f) / 3.7f - 0.05f;
    float a = X * X + 2.25f * Y * Y + Z * Z - 1;
    return a * a * a - X * X * Z * Z * Z - 0.1125f * Y * Y * Z * Z * Z <= 0;
  } else {                                        // aristas de un cubo
    auto e   = [](uint8_t v) { return v == 1 || v == 8; };
    auto inr = [](uint8_t v) { return v >= 1 && v <= 8; };
    return inr(x) && inr(y) && inr(z) && (e(x) + e(y) + e(z)) >= 2;
  }
}
void modeShapes() {
  uint32_t t = millis() - t0;
  uint8_t s = (t / 3000) % 3;
  CRGB col = CHSV((s * 85 + t / 25) & 255, 255, 255);
  for (uint8_t z = 0; z < S; z++)
    for (uint8_t y = 0; y < S; y++)
      for (uint8_t x = 0; x < S; x++)
        leds[idx(x, y, z)] = inShape(s, x, y, z) ? col : CRGB::Black;
}

void setMode(uint8_t m) {
  mode = m;
  t0 = millis();
  lastHead = 0;
  FastLED.clear();
  if (m == 3) shuffleOrder();
}

void setup() {
  pinMode(BOOT_PIN, INPUT_PULLUP);
  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(60);
  FastLED.setMaxPowerInVoltsAndMilliamps(5, 20000);   // limita a 20 A; ajusta a tu fuente
  FastLED.clear(true);
}

void loop() {
  if (digitalRead(BOOT_PIN) == LOW && millis() - lastPress > 250) {
    lastPress = millis();
    setMode(mode % 4 + 1);                            // 1 -> 2 -> 3 -> 4 -> 1 ...
  }
  switch (mode) {
    case 1: modeColors(); break;
    case 2: modeChase();  break;
    case 3: modeRandom(); break;
    case 4: modeShapes(); break;
  }
  FastLED.show();
}