Build a 64-LED audio-reactive display that responds to music and sound in real time. This project chains together an 8x8 NeoPixel matrix with an Arduino Uno and a stereo audio input circuit, creating a dynamic light show synchronized to audio frequencies. The guide includes a complete wiring diagram, parts list, and step-by-step assembly instructions for the power distribution, data connections, and audio conditioning circuit.
The firmware handles audio envelope detection, brightness control, and pixel mapping across the matrix. Builders will learn how to condition stereo audio signals, manage power delivery for addressable LEDs, and tune sensitivity parameters for responsive visual effects. Assembly covers power supply preparation, audio circuit construction on breadboard, and testing procedures before connecting to an audio source.
Wiring diagram

Gather all the parts
Assemble it in 9 steps
1. Preparar dos conjuntos separados
Coloca el Arduino UNO junto a la protoboard (placa de pruebas sin soldadura) para formar la sección de control de baja corriente. Monta panel_1 a panel_6 como las seis caras de un cubo separado, nunca sobre la protoboard. Deja holgura para un cable de datos, una referencia de masa y seis ramales de alimentación.
- Etiqueta los paneles del 1 al 6 antes del montaje.
- Comprueba las marcas reales DIN, DOUT, +5 V y GND; no supongas posiciones ni direcciones.
- No conduzcas la corriente de los paneles por la protoboard.
2. Montar la distribución externa de alimentación de 5 A
Fuera de la protoboard, conecta tu fuente regulada de 5 V y 5 A a un bloque de distribución con bornes usando cable de 18 AWG o más grueso. Coloca un fusible de 5 A en el positivo, cerca de la fuente. Conecta bulk_cap entre +5 V y GND: terminal positivo a +5 V y terminal negativo marcado con franja a GND.
- Mantén cortos los terminales del condensador.
- Usa rojo para +5 V y negro para GND.
- La fuente proporciona como máximo 25 W: 5 V × 5 A.
- Invertir el condensador de 1000 µF puede provocar sobrecalentamiento o rotura.
- No utilices el antiguo fusible principal de 25 A.
3. Tender los seis ramales de alimentación
Desde el bloque externo, lleva seis pares independientes de cables rojo y negro a panel_1 hasta panel_6. Usa cable multifilar de 20 AWG o más grueso, conectores adecuados y sujeción contra tirones. Conecta cada par solamente a los terminales +5 V y GND verificados del panel. Si el fabricante permite inyección en ambos extremos, añade alimentación allí desde las mismas salidas. Los seis ramales comparten un límite total de 5 A.
- No pases toda la corriente del cubo por las pistas de un solo panel.
- Utiliza un fusible de ramal de 4 A únicamente si el portafusibles, cable y conexión del panel admiten esa corriente; conserva el fusible principal de 5 A.
- No encadenes toda la alimentación por conectores o pistas pequeños sin autorización del fabricante.
- No conectes el +5 V externo al pin 5 V del Arduino alimentado por USB.
4. Conectar una única cadena de datos
Conecta D6 al extremo de data_resistor correspondiente al Arduino. Lleva el otro extremo al DIN verificado de panel_1 mediante un único cable de datos. Dentro del cubo, conecta con enlaces cortos: panel_1 DOUT → panel_2 DIN; panel_2 DOUT → panel_3 DIN; panel_3 DOUT → panel_4 DIN; panel_4 DOUT → panel_5 DIN; panel_5 DOUT → panel_6 DIN. Deja panel_6 DOUT sin conectar.
- Coloca la resistencia de 470 Ω cerca de DIN de panel_1.
- Sigue las aristas del cubo con enlaces cortos y etiqueta ambos extremos.
- DIN es la entrada y DOUT la salida: invertirlos impide recibir datos.
- Solo panel_1 DIN recibe datos directamente del Arduino.
5. Conectar la masa común
Lleva un cable negro de referencia desde GND del bloque de distribución a un pin GND del Arduino. No debe transportar corriente de alimentación de los paneles. Alimenta el Arduino por USB y mantén el +5 V externo desconectado de sus pines de alimentación.
- La masa común permite que Arduino y paneles compartan la referencia de cero voltios.
- Sin masa común pueden aparecer parpadeos, colores aleatorios o falta de respuesta.
- Nunca alimentes los paneles a través del Arduino, USB o protoboard.
6. Montar el circuito de audio en la protoboard
Verifica con un conector TRS que P5 del PJ-307 es Tip/izquierdo, P2 es Ring/derecho y P1 es Sleeve/masa. Deja P3 y P4 libres. Conecta P5 → mix_cap_l → mix_resistor_l → nodo BIAS. Conecta P2 → mix_cap_r → mix_resistor_r → el mismo nodo BIAS. Conecta bias_top entre 5 V del Arduino y BIAS; bias_bottom entre BIAS y GND. Conecta el positivo de bias_cap a BIAS y su negativo a GND; conecta bias_bypass entre BIAS y GND. Conecta BIAS → a0_resistor → A0. En clamp_high, ánodo a A0 y cátodo marcado con banda a 5 V del Arduino. En clamp_low, ánodo a GND y cátodo marcado con banda a A0. Conecta P1 a GND del Arduino.
- Usa condensadores de película o bipolares de 1 µF para el acoplamiento.
- Aleja BIAS, A0 y el cableado de audio del mazo de potencia.
- Usa solo una salida de línea de la mesa de mezclas, nunca una salida para altavoces.
- No conectes la mesa hasta superar las comprobaciones del siguiente paso.
7. Comprobar tensiones y corriente antes del audio
Con la mesa desconectada, alimenta el Arduino por USB. Mide BIAS respecto a GND: aproximadamente 2,5 V. A0 también debe medir aproximadamente 2,5 V y permanecer entre 0 y 5 V. Con todas las fuentes desconectadas, comprueba que no haya cortocircuito entre +5 V y GND del cubo y que exista continuidad entre GND de la fuente y GND del Arduino. Enciende la fuente y comprueba aproximadamente 5 V en cada entrada de panel. Durante las pruebas mide la corriente continua de alimentación: el brillo por software no garantiza el consumo.
- Prueba primero un panel y añade los demás uno a uno.
- Detén la prueba si cae la tensión, se calientan conectores o fusibles, o la corriente se aproxima a 5 A.
- Para medir corriente, el instrumento se coloca en serie, nunca directamente entre +5 V y GND; respeta el rango, fusible y tiempo máximo de tu multímetro.
- Si BIAS o A0 quedan fuera de 0–5 V, desconecta y corrige el cableado antes de conectar la mesa.
- Apaga la fuente antes de mover conectores.
8. Probar el cubo con brillo conservador
Usa TEST_MODE = true y conserva MAX_BRIGHTNESS = 32. Con la hipótesis de 60 mA por LED, 384 LED necesitarían unos 23 A y 115 W a blanco máximo; tu fuente solo proporciona 5 A y 25 W. La estimación escalada a 32/255 es de unos 2,9 A, pero depende del panel, colores y fuente: mide el consumo real. Empieza con panel_1 y añade los demás en orden. Mantén la corriente sostenida por debajo de 4 A.
- La animación normalmente consume menos que el blanco máximo, pero esto no demuestra seguridad.
- Si superas 4 A o algún panel cae por debajo de unos 4,5 V, reduce MAX_BRIGHTNESS a 24, revisa el cableado y repite la prueba.
- La fuente de 5 A no permite usar todo el cubo a blanco máximo.
- No conectes ni desconectes paneles mientras estén alimentados.
- DOUT de panel_6 queda libre.
9. Conectar la mesa y utilizar el cubo
Una vez verificadas BIAS y A0, conecta la salida de línea de la mesa a audio_jack con nivel bajo. Enciende la fuente LED y conecta USB al Arduino. Usa el botón Deploy de Schematik con TEST_MODE = false. Reproduce música y aumenta lentamente el nivel de línea. Mantén el límite 32 solo si has medido menos de 4 A en todo el cubo y las tensiones permanecen estables; si no, utiliza 24 o prueba menos paneles.
- Si la respuesta es débil, aumenta SENSITIVITY gradualmente, no el brillo máximo.
- Nunca conectes una salida de potencia para altavoces.
- Para apagar, baja el nivel de audio y detén la señal de datos desconectando USB antes de apagar la fuente LED, evitando aplicar datos a paneles sin alimentación.
Review all connections
1. Connections between "led_supply" and "Arduino"
2. Connections between "bulk_cap" and "Arduino"
3. Connections between "panel_1" and "Arduino"
4. Connections between "panel_2" and "Arduino"
5. Connections between "panel_3" and "Arduino"
6. Connections between "panel_4" and "Arduino"
7. Connections between "panel_5" and "Arduino"
8. Connections between "panel_6" and "Arduino"
9. Connections between "data_resistor" and "Arduino"
10. Connections between "audio_jack" and "Arduino"
11. Connections between "mix_cap_l" and "Arduino"
12. Connections between "mix_cap_r" and "Arduino"
13. Connections between "mix_resistor_l" and "Arduino"
14. Connections between "mix_resistor_r" and "Arduino"
15. Connections between "bias_top" and "Arduino"
16. Connections between "bias_bottom" and "Arduino"
17. Connections between "bias_cap" and "Arduino"
18. Connections between "bias_bypass" and "Arduino"
19. Connections between "a0_resistor" and "Arduino"
20. Connections between "clamp_high" and "Arduino"
21. Connections between "clamp_low" and "Arduino"
Deploy the firmware
#include <Adafruit_NeoPixel.h>
// Cubo WS2812B de 6 caras y 384 LED, reactivo al audio, con Arduino Uno.
// Activa TEST_MODE antes de conectar la mesa para identificar paneles y colores.
const uint8_t LED_PIN = 6;
const uint8_t AUDIO_PIN = A0;
const uint16_t FACE_PIXELS = 64;
const uint8_t FACE_COUNT = 6;
const uint16_t LED_COUNT = FACE_PIXELS * FACE_COUNT;
const bool TEST_MODE = false;
const uint8_t MAX_BRIGHTNESS = 32; // conservador: 32/255 durante las pruebas
const uint16_t SENSITIVITY = 18; // aumenta gradualmente si la respuesta es débil
const uint8_t ENVELOPE_SMOOTHING = 6; // un valor mayor suaviza la respuesta
const uint16_t FRAME_MS = 45; // aproximadamente 22 imágenes por segundo
Adafruit_NeoPixel pixels(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Modifica esta tabla tras identificar los paneles. Cada entrada indica el
// número de panel de la cadena (0..5) asignado a esa cara del cubo.
const uint8_t facePanel[FACE_COUNT] = {0, 1, 2, 3, 4, 5};
// Usa true si una cara tiene su primer LED en el extremo opuesto.
const bool faceReverse[FACE_COUNT] = {false, false, false, false, false, false};
uint16_t baseline = 512;
uint16_t envelope = 0;
uint32_t lastFrame = 0;
uint16_t phase = 0;
uint16_t physicalPixel(uint8_t face, uint8_t x, uint8_t y) {
uint8_t local = y * 8 + ((y & 1) ? (7 - x) : x); // disposición serpenteante habitual; verifica tu panel
if (faceReverse[face]) local = 63 - local;
return facePanel[face] * FACE_PIXELS + local;
}
uint8_t readAmplitude() {
long sum = 0;
const uint8_t samples = 24;
for (uint8_t i = 0; i < samples; i++) {
uint16_t reading = analogRead(AUDIO_PIN);
baseline = (baseline * 31UL + reading) / 32; // elimina la componente continua que cambia lentamente
sum += abs((int)reading - (int)baseline);
}
uint16_t instant = (uint16_t)(sum / samples);
uint16_t target = min(255, (instant * SENSITIVITY) / 10);
envelope = (envelope * (ENVELOPE_SMOOTHING - 1UL) + target) / ENVELOPE_SMOOTHING;
return envelope;
}
void showPanelTest() {
const uint32_t colors[] = {
pixels.Color(32, 0, 0), pixels.Color(0, 32, 0), pixels.Color(0, 0, 32),
pixels.Color(20, 0, 20), pixels.Color(0, 0, 0)
};
for (uint8_t panel = 0; panel < FACE_COUNT; panel++) {
pixels.clear();
for (uint8_t i = 0; i < FACE_PIXELS; i++) pixels.setPixelColor(panel * FACE_PIXELS + i, colors[panel % 5]);
pixels.show();
delay(700);
}
}
void renderFluid(uint8_t level) {
// En esta animación se actualizan deliberadamente los 384 LED.
uint8_t baseHue = (phase >> 2) & 0xFF;
uint8_t value = 6 + (level * (MAX_BRIGHTNESS - 6UL)) / 255;
for (uint8_t face = 0; face < FACE_COUNT; face++) {
for (uint8_t y = 0; y < 8; y++) {
for (uint8_t x = 0; x < 8; x++) {
uint8_t wave = (uint8_t)(x * 17 + y * 23 + face * 39 + (phase >> 3));
uint8_t distance = abs((int)wave - 128);
uint8_t glow = 255 - distance;
uint8_t localValue = (uint16_t)value * (70 + (glow >> 1)) / 198;
uint8_t hue = baseHue + wave + level / 3;
pixels.setPixelColor(physicalPixel(face, x, y), pixels.ColorHSV((uint16_t)hue * 257, 220, localValue));
}
}
}
pixels.show();
}
void setup() {
pixels.begin();
pixels.setBrightness(MAX_BRIGHTNESS);
pixels.clear();
pixels.show(); // arranque seguro con los LED apagados
delay(300);
if (TEST_MODE) showPanelTest();
}
void loop() {
if (TEST_MODE) {
showPanelTest();
return;
}
uint32_t now = millis();
if (now - lastFrame < FRAME_MS) return;
lastFrame = now;
uint8_t level = readAmplitude();
phase += 2 + level / 18; // la música acelera el movimiento fluido
renderFluid(level);
}Remix this project
Make it yours in one click
Open a full copy of this project in your own Schematik workspace, diagram, code, parts, and assembly steps included. Swap the sensor, add features, or redesign the whole thing with AI. The author's original stays untouched.




