Vestido LED reactivo al movimiento: 216 pixeles WS2812B cosidos a mano

Hay un momento exacto, en cualquier fiesta, en que alguien gira y todas las miradas se van detrás. Este proyecto convierte ese giro en luz: un vestido de lunares donde cada punto blanco esconde un LED direccionable, y donde el acelerómetro detecta el movimiento para lanzar destellos que suben por la falda justo cuando tú te mueves. En reposo, la tela respira con un titileo lento. En un giro fuerte, se enciende entera.

Al terminar esta guía vas a saber tres cosas concretas: cómo cortar y recablear una tira WS2812B para convertirla en pixeles individuales que caben en un lunar de 4 cm, cómo leer un acelerómetro I2C para disparar animaciones sin botones ni control remoto, y cómo alimentar 216 LEDs colgando de una prenda sin que se caiga la tensión ni te quedes sin batería a mitad de la noche. El proyecto original es de Erin St Blaine para Adafruit; esta versión está reconstruida con lo que sí llega a Chile.

Por qué el vestido "sabe" que estás bailando

Antes del cableado conviene entender el truco, porque es lo que separa este proyecto de una tira de luces pegada a la ropa.

Un acelerómetro no mide movimiento: mide aceleración, y eso incluye la gravedad. Un módulo quieto sobre la mesa no reporta cero, reporta unos 9,8 m/s² en el eje que apunta hacia abajo. Por eso el disparo no se hace comparando un solo eje contra un umbral, sino calculando la magnitud del vector completo:

magnitud = √(x² + y² + z²)

Con el vestido quieto esa magnitud se queda pegada en ~9,8 sin importar cómo estés parada o parado. Cuando giras, saltas o frenas de golpe, la aceleración propia se suma a la gravedad y la magnitud se dispara por encima de 14 o 15 m/s². Ese es el umbral que usa el código final, y es también la única variable que vas a querer ajustar de verdad: bájala a 12 si quieres un vestido nervioso que reacciona a cada paso, súbela a 18 si solo quieres que responda a giros grandes.

La segunda mitad del truco es el protocolo de los LEDs. Los WS2812B son direccionables en serie: un solo pin de datos alimenta toda la cadena, y cada chip se queda con los primeros 24 bits que le llegan y reenvía el resto al siguiente. Eso significa que la posición física de cada pixel en la tela queda determinada por el orden en que los cableaste, no por su ubicación. Todo el diseño de la animación depende de ese mapeo, y por eso el layout sobre el vestido es un paso de ingeniería, no de decoración.

Hardware: qué cambia al armarlo acá

El tutorial original usa una placa Adafruit RP2040 Prop Maker Feather y una tira de "seed pixels" pre armada con conectores JST. Ninguna de las dos llega a Chile, pero las dos se reemplazan sin perder el proyecto.

La sustitución importante es la de la placa. Se mantiene el mismo microcontrolador RP2040 a propósito: CircuitPython corre idéntico, la librería neopixel es la misma y el código del tutorial original te sirve como referencia línea por línea. Un ESP32 sería más barato, pero CircuitPython no lo soporta bien en su versión clásica WROOM, y tendrías que reescribir todo en Arduino o MicroPython. No vale la pena.

Lo que sí pierdes al cambiar de placa es la conveniencia: la Prop Maker trae el acelerómetro soldado, un borne de tornillo para la tira y un MOSFET que corta la alimentación de los LEDs por software. La Pico no trae nada de eso. A cambio cuesta un tercio.

Preparar los pixeles: el paso que nadie te cuenta

Acá está la diferencia real entre el proyecto original y esta versión. La tira de seed pixels de Adafruit ya viene con cada LED separado en un cablecito de 5 cm, lista para coser. La tira WS2812B que consigues acá es una cinta continua de silicona con 60 LEDs por metro, pegados uno al lado del otro.

Para que un LED caiga justo sobre cada lunar tienes que cortar y recablear. El procedimiento, repetido 216 veces:

1. Corta la tira exactamente por la marca de tijera entre pixel y pixel. Cada segmento queda con sus tres pads: +5V, DIN/DOUT y GND.
2. Estaña los pads de salida del pixel N y los de entrada del pixel N+1.
3. Suelda tres tramos de cable UL1007 26 AWG de unos 4 cm entre ambos: rojo a +5V, negro a GND, y un tercer color desde DOUT del pixel N hacia DIN del pixel N+1.
4. Antes de soldar, ensarta un tramo de termorretráctil de 3 mm en cada cable. Después de soldar, córrelo sobre la junta y aplica calor.

Sí, son varias horas. Trabaja en tandas de 20 pixeles y prueba cada tanda antes de seguir: encontrar una soldadura fría cuando llevas 8 unidades es molesto, encontrarla cuando llevas 200 es rehacer medio vestido.

La flecha impresa en la tira indica el sentido de los datos y no es negociable: los WS2812B tienen un único sentido de propagación. Si cableas un segmento al revés, todo lo que va después de ese punto queda apagado, aunque la alimentación esté perfecta.

Conexiones y alimentación

Con los pixeles listos, el resto del cableado es corto:

• +5V de la cadena → VBUS de la Pico (pin 40), que es la línea de 5 V que entra por el USB.
• GND de la cadena → cualquier GND de la Pico. Esta unión de tierras es obligatoria: sin una tierra común, la señal de datos no tiene referencia y los LEDs parpadean en colores aleatorios.
• DIN del primer pixel → GP2, con una resistencia de 470 Ω en serie.
• MPU-6050: VCC a 3V3(OUT) de la Pico, GND a tierra, SDA a GP0, SCL a GP1.

Dos componentes que el tutorial original no menciona y que acá sí conviene poner, porque estás trabajando con cables largos y una fuente conmutada:

La resistencia de 470 Ω en la línea de datos amortigua el flanco de subida de la señal. Los WS2812B conmutan en nanosegundos, y un cable de 30 cm hasta el primer pixel se comporta como una línea de transmisión: sin amortiguación, el rebote de la señal puede leerse como un bit espurio y el primer LED de la cadena se pone de un color que no le corresponde.

El capacitor de 680 µF va directo entre +5V y GND, lo más cerca posible del primer pixel. Cuando 216 LEDs pasan de apagados a blanco pleno en un solo ciclo, la demanda de corriente salta de golpe; el capacitor entrega ese pico local y evita que la tensión caiga lo suficiente como para resetear la Pico.

Sobre el consumo: en teoría, 216 pixeles a blanco pleno piden unos 13 A. En la práctica este proyecto nunca se acerca, porque el brillo va limitado a BRIGHTNESS = 0.3 y las animaciones encienden pocos pixeles a la vez. Con eso el consumo real ronda 1,5 a 2 A, que un módulo power bank de dos celdas 18650 entrega sin problema durante varias horas.

Cose un bolsillo interno a la altura de la cintura, con velcro, para la batería y la Pico. Que quede accesible: vas a querer apagarlo sin desvestirte.

CircuitPython y la prueba de cableado

Descarga el .uf2 de CircuitPython para Raspberry Pi Pico desde circuitpython.org. Para entrar al bootloader, mantén presionado el botón BOOTSEL mientras conectas el cable USB, y suéltalo cuando aparezca la unidad RPI-RP2. Arrastra el archivo .uf2 a esa unidad; el disco desaparece y vuelve a aparecer como CIRCUITPY. Ahí ya puedes copiar archivos.

Copia a CIRCUITPY/lib/ las carpetas neopixel.mpy y adafruit_mpu6050.mpy desde el bundle oficial de librerías, y después el code.py.

Un detalle que te va a ahorrar una hora de frustración: muchos cables USB son solo de carga y no llevan las líneas de datos. Si conectas la Pico y no aparece ninguna unidad, prueba con otro cable antes de asumir que la placa está mala.

Este es el código de prueba. Cárgalo antes de coser nada: es mucho más fácil ubicar los pixeles en la tela cuando están encendidos.

# SPDX-License-Identifier: MIT

"""Prueba de cableado: enciende los 216 pixeles en amarillo (Raspberry Pi Pico)."""

import time
import board
import neopixel


NUM_PIXELS = 216
BRIGHTNESS = 0.2
YELLOW = (255, 255, 0)


# En la Pico el pin de datos es un GPIO cualquiera: aca usamos GP2.
pixels = neopixel.NeoPixel(
    board.GP2,
    NUM_PIXELS,
    brightness=BRIGHTNESS,
    auto_write=False,
    pixel_order=neopixel.GRB,
)


pixels.fill(YELLOW)
pixels.show()


while True:
    time.sleep(1)

Y este es el equivalente en la placa del tutorial original, por si usas una Prop Maker Feather. Fíjate en dos diferencias: la Prop Maker necesita habilitar EXTERNAL_POWER por software antes de que los LEDs reciban corriente, y su tira usa orden de color BGR en vez del GRB de las tiras WS2812B genéricas. Si tus LEDs encienden en azul o rojo en vez de amarillo, ese es el parámetro que tienes que cambiar.

# SPDX-FileCopyrightText: 2026 Erin St Blaine
# SPDX-License-Identifier: MIT

"""Light all the dress NeoPixels yellow for testing."""

import time
import board
import digitalio
import neopixel


NUM_PIXELS = 216
BRIGHTNESS = 0.2
YELLOW = (255, 255, 0)


# Turn on the board's external NeoPixel power.
external_power = digitalio.DigitalInOut(board.EXTERNAL_POWER)
external_power.direction = digitalio.Direction.OUTPUT
external_power.value = True


# Set up the dress NeoPixels.
pixels = neopixel.NeoPixel(
    board.EXTERNAL_NEOPIXELS,
    NUM_PIXELS,
    brightness=BRIGHTNESS,
    auto_write=False,
    pixel_order=neopixel.BGR,
)


# Light every pixel yellow.
pixels.fill(YELLOW)
pixels.show()


# Keep the program running.
while True:
    time.sleep(1)

Layout: dónde van y dónde no van los pixeles

El patrón de lunares define el layout, pero hay criterios que importan más que la estética.

Evita las zonas de tensión. Nada de pixeles en el asiento ni en la espalda baja: cada vez que te sientes o viajes en auto, esas soldaduras trabajan. Tampoco en la cintura, si piensas usar cinturón. Las juntas soldadas son el punto débil de todo el montaje.

Recorrido diagonal. Con lunares separados entre 38 y 45 mm, un tramo diagonal de lunar a lunar entra cómodo con cables de 4 cm. Intentar saltar en horizontal a la columna siguiente queda justo y deja el cable en tensión permanente.

Una sola cadena. Puedes encadenar unos 300 WS2812B antes de necesitar inyección de corriente en el medio, así que 216 pixeles caben en un solo recorrido continuo y te ahorras el cableado paralelo. Empieza el pixel 0 cerca de la pretina, donde va la controladora, sube y baja en zigzag por un costado siguiendo el estampado, cruza por la espalda baja y repite en la otra cadera.

Si un tramo pasa por una zona que prefieres dejar oscura, no lo cortes: déjalo cableado y apágalo por código. Un pixel en negro no consume prácticamente nada y mantiene la cadena continua.

Montaje en la tela

Fija cada pixel con un punto de entretela termoadhesiva por dentro de la tela: refuerza la zona y evita que el LED tironee del género. Después cose el pixel por sus bordes con dos o tres puntadas de hilo común. No uses hilo conductor para esto. acá la corriente va por los cables soldados, y un hilo conductor cruzando la tela solo puede provocar cortos.

Deja los cables con una pequeña curva de holgura entre pixel y pixel. La tela se estira al bailar; si el cable queda tenso, la soldadura es lo primero que cede.

El código reactivo completo

Con todo cosido y probado, este es el code.py final. Lee el acelerómetro cada 20 ms y, cuando la magnitud supera el umbral, lanza un destello que recorre la cadena de principio a fin.

Las cuatro variables que vale la pena tocar están arriba del archivo: UMBRAL define qué tan brusco tiene que ser el movimiento, LARGO_FLASH cuántos pixeles mide la cola luminosa, y COLOR_BASE / COLOR_FLASH la paleta. Si quieres que el destello se vea más rápido, baja el time.sleep(0.01) de la función destello().

# SPDX-License-Identifier: MIT

"""Vestido reactivo: destellos que suben por la falda con cada giro."""

import math
import time
import board
import busio
import neopixel
import adafruit_mpu6050


NUM_PIXELS = 216
BRIGHTNESS = 0.3
UMBRAL = 14.0          # m/s^2 de magnitud total que dispara el destello
LARGO_FLASH = 12       # cuantos pixeles mide la cola del destello
COLOR_BASE = (30, 0, 45)
COLOR_FLASH = (255, 140, 20)


i2c = busio.I2C(board.GP1, board.GP0)
mpu = adafruit_mpu6050.MPU6050(i2c)

pixels = neopixel.NeoPixel(
    board.GP2,
    NUM_PIXELS,
    brightness=BRIGHTNESS,
    auto_write=False,
    pixel_order=neopixel.GRB,
)


def magnitud(lectura):
    x, y, z = lectura
    return math.sqrt(x * x + y * y + z * z)


def destello():
    for inicio in range(-LARGO_FLASH, NUM_PIXELS):
        pixels.fill(COLOR_BASE)
        for i in range(LARGO_FLASH):
            pos = inicio + i
            if 0 <= pos < NUM_PIXELS:
                atenuacion = (i + 1) / LARGO_FLASH
                pixels[pos] = (
                    int(COLOR_FLASH[0] * atenuacion),
                    int(COLOR_FLASH[1] * atenuacion),
                    int(COLOR_FLASH[2] * atenuacion),
                )
        pixels.show()
        time.sleep(0.01)


pixels.fill(COLOR_BASE)
pixels.show()

while True:
    if magnitud(mpu.acceleration) > UMBRAL:
        destello()
        pixels.fill(COLOR_BASE)
        pixels.show()
    time.sleep(0.02)

Errores comunes

Ningún LED enciende. Revisa primero la tierra común entre la cadena y la Pico. Es el error número uno y no da ninguna señal visible.

Enciende un color equivocado. Cambia pixel_order entre neopixel.GRB y neopixel.RGB. Las tiras WS2812B genéricas casi siempre son GRB, pero hay lotes que vienen RGB.

Enciende hasta cierto punto y después nada. Soldadura fría o segmento invertido justo en ese pixel. Cuenta cuántos encendieron: ese número te da la posición exacta de la falla.

Los últimos pixeles se ven amarillentos o pálidos. Caída de tensión en la línea de 5 V. Suelda un segundo par de cables de alimentación desde la fuente directo al final de la cadena. solo +5V y GND, nunca datos.

El vestido dispara solo. Umbral muy bajo. Sube UMBRAL de a uno hasta que el caminar normal deje de activarlo.

La Pico se reinicia al encender los LEDs. Falta el capacitor, o el power bank no entrega corriente suficiente. Baja BRIGHTNESS a 0.2 y verifica que el módulo esté especificado para al menos 2 A.

Variantes y mejoras

Reactivo a la música en vez del movimiento. Cambia el MPU-6050 por un micrófono con salida analógica y lee la amplitud desde un pin ADC de la Pico. Con eso el vestido pulsa al ritmo de la música del lugar en vez de a tus giros. mucho mejor para una banda en escenario que para un baile suelto.

Control remoto desde el celular. Con una Raspberry Pi Pico 2 W tienes WiFi a bordo: puedes levantar un servidor web mínimo y cambiar paleta, brillo y umbral desde el navegador, sin desconectar nada ni sacarte el vestido.

Mapeo 2D real. El código de esta guía trata la cadena como una línea. Si anotas la coordenada (x, y) de cada pixel sobre la tela en una lista dentro del código, puedes calcular animaciones geométricas de verdad: ondas que suben desde el ruedo, un barrido horizontal, o un efecto radial desde la cintura. Es puro software y es el salto de calidad más grande que puedes hacerle al proyecto.

Modo de bajo consumo. Agrega un MOSFET canal P entre la batería y la línea de 5 V de los LEDs, controlado desde un GPIO. Así puedes cortar la alimentación de la tira por completo cuando no hay movimiento durante un par de minutos, y triplicar la autonomía. Es exactamente lo que hace la Prop Maker original con su pin EXTERNAL_POWER.

Personalización para Chile

Todo lo electrónico lo consigues en MechatronicStore:

• Cinta LED WS2812B 5 m, 60 LED/m, IP65 (SKU G-599). $23.990 CLP. Rinde 300 pixeles; te sobran para el próximo proyecto.
• Raspberry Pi Pico USB-C (SKU N-221). $8.990 CLP. Mismo RP2040 que la placa del tutorial original.
• Giroscopio y acelerómetro MPU-6050 GY-521 (SKU GO3-4). $4.490 CLP. Reemplaza el sensor que la Prop Maker trae integrado.
• Cable UL1007 26 AWG rojo (SKU V-121V2) y negro (SKU V-121V1). $500 CLP el metro cada uno. Calcula unos 10 metros de cada color para 216 pixeles.
• Tubo termorretráctil 3 mm (SKU E-424). $550 CLP el metro.
• Cable con conector JST XH2.54 de 3 pines, 20 cm (SKU C-208). $390 CLP. Para poder desconectar la falda de la controladora al lavar.
• Módulo power bank 2×18650 con salida USB (SKU N-115). $8.590 CLP, más dos baterías 18650 (SKU GT2-10) a $3.390 CLP cada una.
• Cable USB tipo C a tipo A 1 m (SKU B-101). $2.190 CLP.
• Resistencia 470 Ω 1/4 W (SKU GK5-18). $100 CLP.
• Capacitor electrolítico 680 µF 16 V (SKU GF3-3). $580 CLP. El valor clásico de referencia es 1000 µF; 680 µF cumple la misma función de reservorio para este consumo.

Fuera del catálogo quedan dos cosas: el vestido de lunares claros (búscalo en tiendas de ropa retro o vintage, entre $20.000 y $35.000) y la mercería básica. aguja, hilo, entretela termoadhesiva y velcro para el bolsillo de la batería, unos $5.000 en total.

Equivalencias que conviene tener claras: si el tutorial original menciona la NeoPixel Seed Strand, la tira WS2812B cortada y recableada cumple exactamente la misma función eléctrica, solo que el trabajo de separar los pixeles lo haces tú. Y si menciona la RP2040 Prop Maker Feather, la Pico más el MPU-6050 dan el mismo resultado por menos de la mitad del precio, a cambio de dos cables extra.

Recursos

• Tutorial original: Polka Dot Electro Swing Dress with NeoPixels, por Erin St Blaine para Adafruit Learning System
• Guía original en PDF: polka dot-dress with-neopixels.pdf
• Repositorio de código de las guías Adafruit: Adafruit_Learning_System_Guides
• CircuitPython para Raspberry Pi Pico: circuitpython.org/board/raspberry_pi_pico
• Bundle de librerías CircuitPython (incluye neopixel): Adafruit_CircuitPython_Bundle
• Librería del acelerómetro: Adafruit_CircuitPython_MPU6050

Versión chilena inspirada en el proyecto de Adafruit, reconstruida con componentes en stock local en MechatronicStore.