Cubo LED con Arduino: cómo hacer un cubo 3x3x3 y 4x4x4 con código

Un cubo LED es uno de los proyectos de luz más vistosos que puedes hacer con Arduino: los LEDs, colocados en una cuadrícula tridimensional, se encienden capa a capa y dibujan planos que giran, gotas de lluvia que caen y cubos que crecen y se encogen en el aire. Para tu primer cubo LED con Arduino lo mejor es empezar con un tamaño 3x3x3 (27 LEDs) o 4x4x4 (64 LEDs); con esas medidas bastan los pines de un Arduino Uno, unos cuantos transistores y algo de paciencia con el soldador. El truco está en no dar un pin a cada LED, sino usar la multiplexación por capas y columnas: controlas 27 LEDs con 12 pines, y 64 LEDs con solo 7 pines gracias a dos chips 74HC595.

En esta guía aprenderás cómo funciona un cubo LED, cómo preparar una plantilla de soldadura, cómo unir las capas paso a paso, por qué las capas deben controlarse con transistores y cómo se calculan las resistencias. Después encontrarás código Arduino que reproduce animaciones con arrays en un cubo 3x3x3, cómo ampliarlo a un cubo 4x4x4 con el 74HC595, versiones para ESP32 y Raspberry Pi Pico (MicroPython), la alternativa WS2812B para un cubo a color y soluciones para los errores de montaje más habituales, como un LED al revés o una soldadura fría.

¿Qué es un cubo LED y cómo funciona?

Un cubo LED se forma apilando capas horizontales de LEDs colocados a la misma distancia. En cada capa se sueldan entre sí las patas de cátodo (−) de todos los LEDs, de modo que cada capa tiene una única línea de cátodo común. Las patas de ánodo (+) de los LEDs situados unos encima de otros se sueldan en vertical y forman las columnas. Un cubo 3x3x3 tiene 3 capas y 9 columnas, y un cubo 4x4x4 tiene 4 capas y 16 columnas. Cada LED está justo en el cruce de una capa y una columna: para encender un LED aplicas tensión positiva a su columna y conectas su capa a GND.

Puedes describir cada LED del cubo con tres coordenadas: x (de izquierda a derecha), y (de delante hacia atrás) y z (de abajo arriba). En el código de este artículo el número de columna se calcula con c = y × 3 + x (en el 4x4x4, c = y × 4 + x), y z es el número de capa. Igual que un píxel en una pantalla, cada punto de luz del cubo se llama vóxel (píxel de volumen). Crear una animación consiste, en el fondo, en decidir qué vóxeles se encienden en cada momento.

¿Cómo funciona la multiplexación por capas y columnas?

Si enciendes varias capas a la vez, la tensión positiva de una columna enciende un LED en cada capa activa de esa columna, así que no puedes dibujar el patrón que quieres. Por eso el cubo se recorre capa a capa: el Arduino apaga primero todas las capas, escribe en los pines el patrón de columnas de la primera capa, enciende solo esa capa durante unos milisegundos, la apaga y pasa a la segunda. Cuando este ciclo se repite más de cien veces por segundo, el ojo retiene la luz un instante (persistencia de la visión) y ves todas las capas encendidas a la vez.

Calcular la velocidad de barrido es sencillo: frecuencia de refresco = 1 / (número de capas × tiempo por capa). Si en un cubo 3x3x3 mantienes cada capa encendida 3 ms, una vuelta dura 9 ms y el cubo se refresca unas 110 veces por segundo. En un 4x4x4 con 2 ms por capa, la vuelta dura 8 ms y la frecuencia es de 125 Hz. Por debajo de 50–60 Hz el ojo nota el parpadeo; por encima de 100 Hz se ve totalmente estable a simple vista y aparecen menos bandas en la cámara del móvil. El precio es el brillo: como cada capa solo luce 1/3 del tiempo (1/4 en el 4x4x4), la corriente media de un LED baja a esa fracción de su corriente instantánea.

Lista de materiales

Cómo hacer la plantilla de soldadura

El secreto de un cubo bien hecho es la plantilla. Si sueldas los LEDs sujetándolos con la mano, las distancias se descuadran, las capas quedan torcidas y el cubo se ve deformado. La plantilla es una pieza de madera con agujeros a la misma distancia en los que los LEDs se colocan boca abajo, con la cúpula hacia abajo. La separación la marca la longitud de la pata de cátodo: en la mayoría de los LEDs de 5 mm la pata corta mide unos 25 mm, pero mide los tuyos con una regla. Al doblar la pata 90° a 2–3 mm de la cápsula, la parte horizontal que queda debe solaparse 2–3 mm con la pata del LED vecino; por eso una separación de 20 mm es un buen punto de partida.

1. Dibuja con una regla una cuadrícula de 3x3 (o 4x4) sobre contrachapado, MDF o cartón grueso, con 20 mm entre puntos y al menos 2 cm de margen hasta los bordes.
2. Marca cada punto primero con un clavo y luego taládralo recto con una broca de 5 mm. El LED debe quedar firme en el agujero pero salir sin forzarlo; si entra muy justo, agranda un poco el agujero.
3. Dibuja en un borde de la plantilla una flecha que indique la dirección del cátodo; la pata corta de todos los LEDs apuntará hacia el mismo lado.
4. Prepara cuatro separadores de la misma altura, adecuados a la distancia entre capas, que sostengan la capa superior mientras unes las capas; sirven trozos de listón de madera o cartón doblado.

Montaje paso a paso: capas y columnas

1. Dobla las patas: Dobla 90° en horizontal la pata corta (cátodo) de cada LED, a 2–3 mm de la cápsula, hacia la flecha de la plantilla. La pata larga (ánodo) queda vertical.
2. Coloca la primera capa: Pon los LEDs en los agujeros con la cúpula hacia abajo. Cada pata de cátodo de una fila debe tocar la pata de cátodo del LED siguiente; la del último LED de la fila puede quedar libre.
3. Suelda los cátodos: Suelda cada punto de contacto en 2–3 segundos como máximo, con el soldador a 320–350 °C. Después suelda un alambre recto (una pata de resistencia cortada o cobre estañado) atravesando los extremos de las filas para unirlas. Así la capa se convierte en una sola línea eléctrica y en un marco resistente; en el 4x4x4, poner un alambre en cada extremo la refuerza aún más.
4. Prueba la capa: Sin sacar la capa de la plantilla, conecta la línea de cátodo a GND y toca cada pata de ánodo con 5 V a través de una resistencia de 220 Ω. Si algún LED no se enciende, cámbialo ahora.
5. Haz el resto de capas: Repite el proceso hasta tener 3 (o 4) capas. Mantén las patas de cátodo apuntando hacia el mismo lado en todas las capas para que las columnas queden justo una encima de otra.
6. Une las capas: Deja una capa en la plantilla y alinea la siguiente justo encima, apoyada en los separadores. Haz un pequeño codo de 2 mm en la punta de cada pata de ánodo que apunta hacia arriba en los LEDs de abajo, para que pase junto a la cápsula del LED de arriba y se apoye en su pata de ánodo. Suelda primero las cuatro esquinas, comprueba la alineación y termina después el resto de columnas.
7. Saca los cables de las capas: Suelda un cable a la línea de cátodo de cada capa y bájalo por un lateral del cubo. Estos cables no deben tocarse entre sí ni tocar las columnas; deja unos milímetros entre ellos.
8. Monta la base: Da la vuelta al cubo; las patas de ánodo libres de la última capa que añadiste apuntan ahora hacia abajo, y esa capa pasa a ser la más cercana a la base, es decir, la capa inferior (z = 0). Pasa las patas y los cables de capa por una placa perforada, suéldalos y coloca las resistencias de columna junto a cada columna.

Controlar las capas con transistores

Un pin de columna alimenta a un solo LED, pero cuando una capa está encendida, la corriente de todos los LEDs de esa capa vuelve a GND por la misma línea de cátodo. En un cubo 3x3x3 son 9 LEDs × 12,7 mA ≈ 115 mA, y en el cubo 4x4x4 con 74HC595, 16 LEDs × 5 mA ≈ 80 mA. El límite recomendado para un pin del Arduino Uno es de 20 mA y el máximo absoluto de 40 mA, así que no puedes conectar una línea de capa directamente a un pin. La solución es poner un transistor NPN bajo cada capa: el colector va a la línea de capa, el emisor a GND y la base a un pin del Arduino a través de una resistencia. Cuando el pin pasa a HIGH, el transistor entra en saturación y lleva la capa a GND. Para que el transistor conduzca por completo, elige una corriente de base de aproximadamente 1/10 a 1/20 de la corriente de colector: para 115 mA hacen falta 6–12 mA, y (5 V − 0,7 V) / 470 Ω ≈ 9 mA cae justo en ese rango. Tienes los detalles en ¿Qué es un transistor? y los patillajes en la herramienta de transistores.

Cálculo de resistencias: de columna y de base

La resistencia de columna es el único componente que limita la corriente del LED, y hay una en cada columna; no necesitas una resistencia por LED, porque en una columna solo se enciende un LED a la vez. La fórmula sale de la ley de Ohm: R = (Valimentación − VLED − VCE(sat)) / ILED. Con 5 V de alimentación, un LED rojo de 2,0 V de tensión directa y un transistor que en saturación cae unos 0,2 V, si buscas 12 mA sale R = (5 − 2,0 − 0,2) / 0,012 ≈ 233 Ω. El valor normalizado más cercano, 220 Ω, deja pasar unos 12,7 mA por el LED. Con un LED azul de 3,1 V, esos mismos 220 Ω dan unos 7,7 mA, un brillo que se ve sin problema con la multiplexación.

En el cubo con 74HC595 elegimos a propósito resistencias más altas: por el pin VCC o GND de este chip pueden pasar como máximo 70 mA en total, y con una capa encendida las ocho salidas pueden lucir a la vez. 8 × 5,5 mA ≈ 44 mA deja un margen seguro. La corriente media del LED, que determina el brillo percibido, es la corriente instantánea dividida entre el número de capas: 12,7 / 3 ≈ 4,2 mA en el 3x3x3 y 5,5 / 4 ≈ 1,4 mA en el 4x4x4. Los LEDs eficientes de hoy se ven claramente en interiores con estas corrientes, aunque en una habitación muy luminosa un cubo 4x4x4 puede parecer algo apagado. Para calcular con los valores de tu propio LED usa las herramientas resistencia para LED y tensiones de LED.

Esquema de conexión del cubo LED 3x3x3

Código Arduino para el cubo LED 3x3x3: animaciones con arrays

Cada fotograma de la animación se guarda como un número por capa. Una capa 3x3x3 tiene 9 LEDs, así que basta un valor de 9 bits; lo guardamos como uint16_t y el bit c representa la columna c. Los fotogramas se escriben en la memoria flash con PROGMEM, de modo que incluso animaciones de cientos de fotogramas no llenan los 2 KB de RAM del Uno. El código siguiente no necesita ninguna librería extra.

1// 3x3x3 LED küp: katman çoklama ve dizilerle animasyon / 3x3x3 LED cube: layer multiplexing and array animations
2const byte colPins[9]   = {2, 3, 4, 5, 6, 7, 8, 9, 10};   // sütun anotları, 220 ohm ile / column anodes via 220 ohm
3const byte layerPins[3] = {A0, A1, A2};                     // alt, orta, üst katman transistörü / bottom, middle, top layer transistor
4
5// Her kare 3 katman, her katman 9 bit: bit c = sütun c (c = y*3 + x)
6// Each frame has 3 layers of 9 bits: bit c = column c (c = y*3 + x)
7const uint16_t frames[][3] PROGMEM = {
8  {0b111111111, 0b000000000, 0b000000000},  // 0: alt katman / bottom layer
9  {0b000000000, 0b111111111, 0b000000000},  // 1: orta katman / middle layer
10  {0b000000000, 0b000000000, 0b111111111},  // 2: üst katman / top layer
11  {0b000000000, 0b000010000, 0b000000000},  // 3: yalnız merkez / centre only
12  {0b111101111, 0b101000101, 0b111101111},  // 4: tel kafes, 12 kenar / wireframe, 12 edges
13  {0b010010010, 0b010010010, 0b010010010},  // 5: dönen düzlem, 1. konum / rotating plane, step 1
14  {0b100010001, 0b100010001, 0b100010001},  // 6: dönen düzlem, 2. konum / rotating plane, step 2
15  {0b000111000, 0b000111000, 0b000111000},  // 7: dönen düzlem, 3. konum / rotating plane, step 3
16  {0b001010100, 0b001010100, 0b001010100},  // 8: dönen düzlem, 4. konum / rotating plane, step 4
17  {0b111111111, 0b111111111, 0b111111111}   // 9: hepsi açık / all on
18};
19
20void setup() {
21  for (byte c = 0; c < 9; c++) pinMode(colPins[c], OUTPUT);
22  for (byte z = 0; z < 3; z++) pinMode(layerPins[z], OUTPUT);  // LOW: katmanlar kapalı / LOW: layers off
23}
24
25// Bir kareyi verilen süre boyunca katman katman tarar / scans one frame layer by layer for the given time
26void showFrame(byte f, unsigned int ms) {
27  unsigned long start = millis();
28  while (millis() - start < ms) {
29    for (byte z = 0; z < 3; z++) {
30      uint16_t bits = pgm_read_word(&frames[f][z]);         // katman verisini oku / read the layer data
31      for (byte c = 0; c < 9; c++) digitalWrite(colPins[c], bitRead(bits, c));
32      digitalWrite(layerPins[z], HIGH);                      // katmanı aç / layer on
33      delay(3);                                              // 3 ms göster / show for 3 ms
34      digitalWrite(layerPins[z], LOW);                       // sütunlar değişmeden önce kapat / off before the columns change
35    }
36  }
37}
38
39void loop() {
40  for (byte f = 0; f <= 4; f++) showFrame(f, 500);           // katmanlar, merkez, kafes / layers, centre, wireframe
41  for (byte turn = 0; turn < 4; turn++)                      // düzlemi 4 tur döndür / spin the plane 4 times
42    for (byte f = 5; f <= 8; f++) showFrame(f, 120);
43  showFrame(9, 800);                                         // hepsi açık / all on
44}

El corazón del código es la función showFrame(). Para cada capa, primero escribe el patrón de columnas en los pines, luego enciende solo el transistor de esa capa durante 3 ms y apaga la capa antes de que cambien las columnas. Este orden importa: si cambias las columnas con una capa encendida, el patrón de la capa anterior aparece un instante en la nueva capa y se produce el efecto fantasma (ghosting). bitRead(bits, c) devuelve el bit c del número como 0 o 1, y pgm_read_word() lee el valor de 16 bits desde la flash. loop() muestra primero las capas una a una, luego el centro y las 12 aristas del cubo, y después gira un plano vertical por cuatro posiciones para crear un efecto de molinillo.

Diseña tus propias animaciones

Para dibujar un fotograma nuevo, mira el cubo desde arriba e imagina cada capa como una hoja cuadriculada de 3x3. Marca las columnas que quieres encender y escribe el número binario después de 0b de izquierda a derecha, del bit 8 al bit 0. Por ejemplo, las cuatro esquinas son las columnas 0, 2, 6 y 8, lo que da 0b101000101. Si escribes el mismo valor en las tres capas obtienes barras verticales en las cuatro esquinas; si solo lo escribes en la capa central, cuatro puntos flotando en el aire. Si los números binarios te resultan nuevos, el artículo Sistemas numéricos y operaciones con bits lo explica con detalle. Algunas técnicas que te serán útiles al programar:

• Desplazar bits: Si desplazas a la izquierda el valor de una capa 3 bits en el 3x3x3 o 4 bits en el 4x4x4, el patrón pasa a la fila de atrás; elimina los bits que se salen con & y conseguirás ondas y textos en movimiento.
• Copiar capas: Copiar el array de capas un paso hacia abajo o hacia arriba produce efectos de lluvia, burbujas que suben y ascensor.
• Aleatoriedad: Vóxeles elegidos con random() que destellan un momento crean un cielo estrellado o chispas.
• Invertir: Con el operador ~ conviertes un fotograma en su negativo, y alternar rápido entre ambos da un destello llamativo.

Cubo LED 4x4x4: ampliación con el 74HC595

Un cubo 4x4x4 tiene 16 columnas y 4 capas; controlarlo directamente exige 20 pines, es decir, todos los pines del Uno, incluidos D0 y D1. Si en su lugar controlas las columnas con dos registros de desplazamiento 74HC595 en cascada, las 16 columnas solo gastan 3 pines (datos, reloj y latch); sumando 4 pines para las capas, el total es de 7 pines. La salida Q7' (pin 9) del primer chip va a la entrada DS del segundo, y las líneas de reloj y latch son comunes a ambos chips. Las columnas 0–7 (las dos filas delanteras) se conectan a las salidas Q0–Q7 del primer chip, y las columnas 8–15 (las dos filas traseras) al segundo. El mismo método crece hasta 4 chips para un cubo 5x5x5 y 8 chips para un 8x8x8.

1// 4x4x4 LED küp: 2 adet 74HC595 (16 sütun) + 4 transistörlü katman / 4x4x4 LED cube: two 74HC595s (16 columns) + 4 transistor layers
2const byte DATA_PIN  = 11;                 // 74HC595 DS (14)
3const byte CLOCK_PIN = 13;                 // 74HC595 SH_CP (11)
4const byte LATCH_PIN = 10;                 // 74HC595 ST_CP (12)
5const byte layerPins[4] = {2, 3, 4, 5};    // alttan üste katman transistörleri, 470 ohm ile / layer transistors bottom to top, via 470 ohm
6
7uint16_t cube[4];                          // ekrandaki görüntü: katman başına 16 bit / current image: 16 bits per layer
8
9// Hazır kareler: bit c = sütun c (c = y*4 + x) / ready-made frames: bit c = column c (c = y*4 + x)
10const uint16_t frames[][4] PROGMEM = {
11  {0xFFFF, 0x0000, 0x0000, 0x0000},        // alt katman / bottom layer
12  {0x0000, 0xFFFF, 0x0000, 0x0000},
13  {0x0000, 0x0000, 0xFFFF, 0x0000},
14  {0x0000, 0x0000, 0x0000, 0xFFFF},        // üst katman / top layer
15  {0x9009, 0x0000, 0x0000, 0x9009},        // 8 köşe / 8 corners
16  {0xF99F, 0x9009, 0x9009, 0xF99F},        // tel kafes / wireframe
17  {0x0000, 0x0660, 0x0660, 0x0000}         // içteki 2x2x2 küp / inner 2x2x2 cube
18};
19const byte FRAME_COUNT = sizeof(frames) / sizeof(frames[0]);
20
21void write16(uint16_t v) {                 // 16 biti iki entegreye gönder / send 16 bits to both chips
22  digitalWrite(LATCH_PIN, LOW);
23  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, highByte(v));  // önce uzaktaki entegre / far chip first
24  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, lowByte(v));
25  digitalWrite(LATCH_PIN, HIGH);           // çıkışlara aktar / copy to the outputs
26}
27
28void refresh() {                           // her 2 ms'de sıradaki katmana geç / move to the next layer every 2 ms
29  static byte z = 0;
30  static unsigned long last = 0;
31  if (micros() - last < 2000) return;
32  last = micros();
33  digitalWrite(layerPins[z], LOW);         // eski katmanı kapat / old layer off
34  z = (z + 1) % 4;
35  write16(cube[z]);                        // yeni katmanın sütunları / columns of the new layer
36  digitalWrite(layerPins[z], HIGH);        // yeni katmanı aç / new layer on
37}
38
39void holdFor(unsigned int ms) {            // beklerken küpü yenilemeye devam et / keep refreshing while waiting
40  unsigned long start = millis();
41  while (millis() - start < ms) refresh();
42}
43
44void clearCube() {
45  for (byte z = 0; z < 4; z++) cube[z] = 0;
46}
47
48void setVoxel(byte x, byte y, byte z) {    // tek LED yak, x/y/z = 0..3 / light one LED, x/y/z = 0..3
49  bitSet(cube[z], y * 4 + x);
50}
51
52void loadFrame(byte f) {                   // PROGMEM'deki kareyi yükle / load a frame from PROGMEM
53  for (byte z = 0; z < 4; z++) cube[z] = pgm_read_word(&frames[f][z]);
54}
55
56void sweep() {                             // dikey düzlemi x ekseninde kaydır / sweep a vertical plane along x
57  for (byte x = 0; x < 4; x++) {
58    clearCube();
59    for (byte y = 0; y < 4; y++)
60      for (byte z = 0; z < 4; z++) setVoxel(x, y, z);
61    holdFor(150);
62  }
63}
64
65void rain(byte steps) {                    // yağmur: damlalar yukarıdan düşer / rain: drops fall from the top
66  clearCube();
67  for (byte s = 0; s < steps; s++) {
68    for (byte z = 0; z < 3; z++) cube[z] = cube[z + 1];   // her şeyi bir kat indir / move everything down a layer
69    cube[3] = bit(random(16)) | bit(random(16));         // üstte 1-2 yeni damla / 1-2 new drops on top
70    holdFor(120);
71  }
72}
73
74void setup() {
75  pinMode(DATA_PIN, OUTPUT);
76  pinMode(CLOCK_PIN, OUTPUT);
77  pinMode(LATCH_PIN, OUTPUT);
78  for (byte z = 0; z < 4; z++) pinMode(layerPins[z], OUTPUT);
79  randomSeed(analogRead(A0));              // boştaki A0'dan rastgele tohum / random seed from the unconnected A0
80}
81
82void loop() {
83  for (byte f = 0; f < FRAME_COUNT; f++) {
84    loadFrame(f);
85    holdFor(500);
86  }
87  for (byte i = 0; i < 3; i++) sweep();
88  rain(80);
89}

En esta versión el barrido se hace en la función refresh() de forma no bloqueante: cada vez que se llama, comprueba con micros() si han pasado 2 ms; si es así, apaga la capa anterior, envía los 16 bits de la nueva capa a los dos chips y enciende la nueva capa. Así, el código de animación solo modifica el array cube[] y no tiene que ocuparse de refrescar el cubo. holdFor() sigue llamando a refresh() mientras espera, por lo que no debes usar un delay() largo en ninguna parte del programa. setVoxel(x, y, z) te permite encender un LED por sus coordenadas; sweep() lo usa para desplazar un plano vertical por el cubo, y rain() copia las capas un paso hacia abajo y añade gotas aleatorias arriba. La diferencia entre delay() y millis() la tienes en millis() y delay(), y cómo llevar el barrido a una interrupción de temporizador en Interrupciones en Arduino.

Cubo LED con ESP32

Los pines del ESP32 dan 3,3 V. Esa tensión no basta para controlar directamente LEDs azules y blancos, cuya tensión directa ronda los 3 V; tras la caída en la resistencia y en el transistor apenas queda nada. Por eso, en el ESP32 la solución más limpia es controlar las columnas a través de un 74HCT595 alimentado a 5 V: la familia HCT considera HIGH incluso 2 V, así que lee las señales de 3,3 V sin problemas, mientras los LEDs se alimentan de 5 V. Mantén 470 Ω en la base de los transistores de capa; (3,3 − 0,7) / 470 ≈ 5,5 mA bastan para una corriente de capa de 80 mA. El código 4x4x4 de arriba compila tal cual en el ESP32; solo tienes que cambiar las constantes de pines por los valores de la tabla (23, 18, 5 y 25, 26, 27, 32). Si quieres, también puedes usar el Wi-Fi del ESP32 para elegir animaciones desde una página web en el móvil; para empezar, mira ¿Qué es el ESP32?.

Cubo LED con Raspberry Pi Pico y MicroPython

La Pico también es una placa de 3,3 V y, con la configuración por defecto, sus pines solo entregan unos pocos miliamperios, así que usas el mismo circuito con 74HCT595. Alimenta los chips y los LEDs desde VBUS (pin 40), que lleva los 5 V del USB. En MicroPython los 16 bits se envían por SPI por hardware: los pines GP18 (SCK) y GP19 (MOSI) de SPI0 controlan las líneas de reloj y datos, y GP17 el latch. El código sigue la misma lógica: show() recorre un fotograma capa a capa durante el tiempo indicado, y en el efecto de lluvia el troceado de listas (cube[1:]) baja cada capa un paso. Para la instalación y los primeros pasos, consulta ¿Qué es la Raspberry Pi Pico?.

1# Pico + 2 adet 74HCT595 ile 4x4x4 LED küp / 4x4x4 LED cube with a Pico + two 74HCT595s
2from machine import Pin, SPI
3import time
4import random
5
6# GP18 = SCK -> SH_CP, GP19 = MOSI -> DS; GP16 (MISO) boş kalır / GP16 (MISO) stays unconnected
7spi = SPI(0, baudrate=1000000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
8latch = Pin(17, Pin.OUT, value=0)                                # ST_CP
9layers = [Pin(n, Pin.OUT, value=0) for n in (10, 11, 12, 13)]    # alttan üste, 470 ohm ile / bottom to top, via 470 ohm
10
11def write16(v):
12    latch.value(0)
13    spi.write(bytes((v >> 8, v & 0xFF)))    # önce uzaktaki entegre / far chip first
14    latch.value(1)                          # çıkışlara aktar / copy to the outputs
15
16def show(frame, ms):
17    # kareyi ms boyunca katman katman tara / scan the frame layer by layer for ms
18    end = time.ticks_add(time.ticks_ms(), ms)
19    while time.ticks_diff(end, time.ticks_ms()) > 0:
20        for z in range(4):
21            write16(frame[z])
22            layers[z].value(1)              # katmanı aç / layer on
23            time.sleep_us(2000)
24            layers[z].value(0)              # sütunlar değişmeden kapat / off before the columns change
25
26FRAMES = [
27    [0x9009, 0x0000, 0x0000, 0x9009],       # 8 köşe / 8 corners
28    [0xF99F, 0x9009, 0x9009, 0xF99F],       # tel kafes / wireframe
29    [0x0000, 0x0660, 0x0660, 0x0000],       # içteki küp / inner cube
30]
31
32while True:
33    for f in FRAMES:
34        show(f, 600)
35    cube = [0, 0, 0, 0]
36    for _ in range(60):                     # yağmur: her şey bir kat iner / rain: everything drops a layer
37        drop = (1 << random.getrandbits(4)) | (1 << random.getrandbits(4))
38        cube = cube[1:] + [drop]
39        show(cube, 120)

Cubos más grandes: 5x5x5 y 8x8x8

Cuando el cubo crece, crecen también dos problemas. El primero es la corriente: un cubo 8x8x8 tiene 64 LEDs por capa y, con 10 mA por LED, la corriente de capa llega a 640 mA; eso ya no es trabajo para un pequeño transistor TO-92, sino para un MOSFET de nivel lógico. El segundo es el tiempo de barrido: para mantener 100 Hz con 8 capas quedan 1,25 ms por capa y hay que enviar 64 bits (8 bytes) en cada una; shiftOut() es demasiado lento para esto y el SPI por hardware es imprescindible. Además, cada LED luce solo 1/8 del tiempo, así que el brillo baja; los cubos grandes necesitan drivers de columna más potentes y un adaptador externo de 5 V en lugar del USB (consulta Cómo alimentar un Arduino). Por eso tu primer cubo debería ser un 3x3x3 o un 4x4x4: dominarás la técnica antes de soldar 512 LEDs.

Alternativa: cubo LED a color con WS2812B

Si en vez de un cubo de un solo color prefieres elegir el color de cada LED por separado, puedes usar LEDs direccionables como el WS2812B. Cada uno de estos LEDs tiene su propio chip controlador, así que no necesitas multiplexación, transistores ni resistencias de columna: los 64 LEDs se encadenan con 5 V, GND y una línea de datos y se controlan con un solo pin. Para un cubo se usan LEDs direccionables de 5 mm con 4 patas (como el PL9823 o el APA106) o trozos cortados de una tira WS2812B. El precio es la corriente: unos 60 mA por LED en blanco total, es decir, 3,8 A para 64 LEDs. Por eso usa un adaptador de 5 V y 4 A, añade un condensador de 1000 µF en la alimentación y una resistencia de 330 Ω en la línea de datos, y limita el brillo por software. El código usa la librería Adafruit NeoPixel.

1// WS2812B ile 4x4x4 RGB LED küp / 4x4x4 RGB LED cube with WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const byte DATA_PIN = 6;                   // 330 ohm ile ilk LED'in DIN ucuna / to the first LED's DIN via 330 ohm
5const byte N = 4;
6Adafruit_NeoPixel cube(N * N * N, DATA_PIN, NEO_GRB + NEO_KHZ800);
7
8uint16_t idx(byte x, byte y, byte z) {     // koordinattan zincirdeki sıraya / coordinate to position in the chain
9  return z * 16 + y * 4 + x;               // düz (zikzaksız) kablolama varsayılır / assumes straight, non-zigzag wiring
10}
11
12void setup() {
13  cube.begin();
14  cube.setBrightness(40);                  // parlaklığı ve akımı sınırla (0-255) / limit brightness and current (0-255)
15}
16
17void loop() {
18  static uint16_t hue = 0;
19  for (byte z = 0; z < N; z++)
20    for (byte y = 0; y < N; y++)
21      for (byte x = 0; x < N; x++)         // her katman farklı tonda / each layer gets a different hue
22        cube.setPixelColor(idx(x, y, z), cube.gamma32(cube.ColorHSV(hue + z * 8192U)));
23  cube.show();
24  hue += 256;                              // gökkuşağını kaydır / shift the rainbow
25  delay(20);
26}

La función idx() del código convierte una coordenada x, y, z en la posición dentro de la cadena y supone que has cableado todas las filas en el mismo sentido. Si has hecho el cableado en zigzag, tendrás que usar 3 − x en lugar de x en las filas impares. Algunos LEDs direccionables de 5 mm esperan los colores en orden RGB; si ves verde en lugar de rojo, cambia NEO_GRB por NEO_RGB. setBrightness(40) reduce el brillo a un 16 % aproximadamente, de modo que incluso en el peor caso la corriente se queda en torno a 0,6 A.

Ideas de proyectos con un cubo LED

• Cubo que baila con la música: Aumenta el número de capas encendidas según el nivel de sonido que mides con un sensor de sonido y tendrás un ecualizador tridimensional.
• Juego de la serpiente en 3D: Dirige la serpiente por los tres ejes de un cubo 4x4x4 con un joystick y un botón; para más ideas de juegos, mira proyectos de juegos con Arduino.
• Cubo dado: Al pulsar un botón, los vóxeles se mezclan rápido y el cubo muestra un número del 1 al 6 con un patrón de puntos.
• Proyecto para la feria de ciencias: Explica la persistencia de la visión alargando el tiempo de capa con un potenciómetro y mostrando el momento en que empieza el parpadeo; para más ideas, mira ideas para ferias de ciencias.
• Elegir animaciones desde el móvil: Haz que cada letra que envíes con un módulo Bluetooth HC-05 lance una animación distinta.
• Lámpara de noche a color: Programa transiciones lentas de color en un cubo WS2812B; si usas un ESP32, controla los efectos desde el móvil con WLED.

Errores frecuentes y cómo solucionarlos

El cubo LED es uno de esos proyectos poco comunes que enseñan a la vez a soldar, a usar transistores, a calcular resistencias, a multiplexar y a manejar bits. Empieza con un 3x3x3 y, cuando domines el código y la lógica de las animaciones, pasa a un 4x4x4 con el 74HC595, o a WS2812B si quieres color. Si antes prefieres probar la idea de encender LEDs en secuencia en una sola fila, Arduino: coche fantástico y secuencia de LEDs es un buen calentamiento. En la app BlueGrays encontrarás proyectos de secuencia de LEDs, coche fantástico, animaciones WS2812B y matrices LED con esquemas de circuito y código paso a paso.