Pantuflas LED reactivas a la presión con NeoPixel y RP2040

Pantuflas que largan una onda de luz al pisar

¿Has visto esas zapatillas infantiles que parpadean con cada paso? Este proyecto lleva esa idea al banco del maker: unas pantuflas peludas que detectan tu pisada y disparan una onda de color que sale desde el centro de la suela y se va apagando sola. Lo entretenido es que cada pisada cambia el color, así que caminar por la casa se vuelve un pequeño show de luces.

Al terminar vas a saber leer un sensor de fuerza con CircuitPython, manejar una tira NeoPixel direccionable y esconder toda la electrónica dentro de un calzado blando sin que moleste al caminar. Es un proyecto wearable ideal para partir: casi nada de soldadura fina, sin cajas impresas en 3D y un resultado que llama la atención al tiro.

Qué hace el proyecto

• Detecta cuándo apoyas el pie con un sensor de fuerza resistivo (FSR) escondido en la plantilla.
• Lee ese toque como una señal digital simple: pisado o sin pisar.
• Lanza una animación de onda en la tira NeoPixel cosida al borde de la suela.
• Cambia de color en cada pisada (blanco, rosa, morado, azul) y se apaga con un fundido suave.
• Funciona con una batería LiPo de 3.7V, así que las pantuflas quedan 100% portátiles.

Materiales (por par)

El proyecto original de Erin St Blaine arma las dos pantuflas con estos componentes:

• Placa Adafruit RP2040 Prop Maker Feather (1 por pantufla)
• Sensor de fuerza resistivo FSR redondo, 0.3 a 10 N (1 por pantufla)
• Tira NeoPixel direccionable WS2812B, unos 16 LED por pantufla
• Batería LiPo 3.7V con conector JST (la del tutorial es de 2000 mAh)
• Cable de extensión JST de 2 pines con interruptor on/off
• Cable flexible de núcleo siliconado 26 AWG para las soldaduras
• Un par de pantuflas peludas, hilo grueso, aguja y pistola de silicona

La placa Prop Maker Feather es clave porque trae un terminal de tornillo con salida de 5V conmutada y carga de batería LiPo integrada, así no necesitas un módulo de carga aparte. Si usas otra placa RP2040, fíjate en ese detalle: vas a tener que resolver la alimentación de la tira y la carga por tu cuenta.

Conexiones

El cableado es de los más simples que vas a encontrar en un wearable:

• Tira NeoPixel al terminal de tornillo: +5V a +5V, G a G, y la línea de datos DI al pin NEO.
• Sensor FSR entre los pines G y A0 de la placa. No importa qué pata va a cada pin, el FSR no tiene polaridad. Tampoco necesitas una resistencia externa: el código activa la resistencia interna del microcontrolador.
• Batería e interruptor: enchufa el cable con switch al conector JST de la placa, y la batería al otro extremo del switch. Así cortas la corriente sin desenchufar nada.

El código en CircuitPython

La lógica no usa lectura analógica con umbrales: trata el FSR como un botón. Con la resistencia interna activada, el pin A0 lee True en reposo y False cuando lo aprietas. Cada vez que detecta el cambio, avanza al siguiente color y lanza la onda desde el LED central hacia los extremos, dejando una estela que se desvanece.

Un punto importante de esta placa: el terminal NeoPixel externo está apagado por defecto. Por eso el código habilita board.EXTERNAL_POWER antes de encender los píxeles. Si te saltas esa línea, la tira simplemente no prende.

Guarda el archivo como code.py en la unidad CIRCUITPY de la placa y se recargará solo.

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

import time
import board
import digitalio
import neopixel

# Ajustes del usuario
NUM_PIXELS = 20
ACTIVE_SECONDS = 3.0
PIXEL_BRIGHTNESS = 0.3
RIPPLE_DELAY = 0.05   # mas bajo = onda mas rapida
TRAIL_FADE = 0.6      # mas alto = estela mas larga
FADE_DELAY = 0.03
FADE_STEPS = 20

# Ciclo de colores: blanco, rosa, morado, azul
COLOR_SEQUENCE = [
    (255, 255, 255),
    (255, 100, 180),
    (180, 0, 255),
    (0, 120, 255),
]

# El FSR va entre A0 y GND. Con el pull-up interno activado:
# sin pisar = True, pisando = False.
motion = digitalio.DigitalInOut(board.A0)
motion.direction = digitalio.Direction.INPUT
motion.pull = digitalio.Pull.UP

# El Prop-Maker Feather necesita habilitar EXTERNAL_POWER
# para alimentar el terminal NeoPixel externo.
external_power = digitalio.DigitalInOut(board.EXTERNAL_POWER)
external_power.direction = digitalio.Direction.OUTPUT
external_power.value = True

pixels = neopixel.NeoPixel(
    board.EXTERNAL_NEOPIXELS,
    NUM_PIXELS,
    brightness=PIXEL_BRIGHTNESS,
    auto_write=False,
)


def get_next_color(i):
    i = (i + 1) % len(COLOR_SEQUENCE)
    return i, COLOR_SEQUENCE[i]


def ripple_frame(center, radius, rgb):
    for px in range(NUM_PIXELS):
        d = abs(px - center)
        if d == radius:
            pixels[px] = rgb
        elif d < radius:
            r, g, b = pixels[px]
            pixels[px] = (int(r * TRAIL_FADE), int(g * TRAIL_FADE), int(b * TRAIL_FADE))
        else:
            pixels[px] = (0, 0, 0)
    pixels.show()


def ripple_for(seconds, rgb, idx):
    center = NUM_PIXELS // 2
    end = time.monotonic() + seconds
    was = False
    radius = 0
    while time.monotonic() < end:
        pressed = not motion.value
        if pressed and not was:
            idx, rgb = get_next_color(idx)
            end = time.monotonic() + seconds
            radius = 0
        ripple_frame(center, radius, rgb)
        radius = 0 if radius > NUM_PIXELS else radius + 1
        time.sleep(RIPPLE_DELAY)
        was = pressed
    return idx


def fade_out():
    snap = [pixels[i] for i in range(NUM_PIXELS)]
    for step in range(FADE_STEPS, -1, -1):
        f = step / FADE_STEPS
        for i in range(NUM_PIXELS):
            r, g, b = snap[i]
            pixels[i] = (int(r * f), int(g * f), int(b * f))
        pixels.show()
        time.sleep(FADE_DELAY)
    pixels.fill((0, 0, 0))
    pixels.show()


# Secuencia de arranque rojo, verde, azul
for c in [(255, 0, 0), (0, 255, 0), (0, 0, 255)]:
    pixels.fill(c)
    pixels.show()
    time.sleep(0.2)
pixels.fill((0, 0, 0))
pixels.show()

last = motion.value
idx = -1
while True:
    now = motion.value
    if now != last:
        if not now:  # paso de True a False = pisada
            idx, rgb = get_next_color(idx)
            idx = ripple_for(ACTIVE_SECONDS, rgb, idx)
            fade_out()
        last = now
    time.sleep(0.01)

Montaje en la pantufla

1. Abre la costura trasera de la pantufla con un descosedor y sigue un par de centímetros por la costura de la suela a ambos lados. Saca la plantilla de espuma.
2. Mete la tira de LED en la suela con las luces mirando hacia afuera y vuelve a poner la espuma encima para sujetarla. Conviene recortar un poco la espuma para que la tira entre pareja, sin bultos ni torceduras, con el LED del medio justo en la punta.
3. Acomoda la placa en el lado derecho con el puerto USB hacia atrás (lo vas a necesitar para cargar la batería) y el terminal de tornillo mirando hacia afuera, lejos del tobillo.
4. Pega el FSR con una gota de silicona caliente entre el forro de tela y la plantilla, justo donde cae la pisada.
5. Ubica la batería en el lado izquierdo y empuja el cable sobrante del switch. Deja el interruptor afuera, accesible, y cose de nuevo las costuras con hilo resistente.

Antes de cerrar todo, enciende el switch: deberías ver una secuencia rápida roja, verde y azul de arranque, y al tocar el FSR la onda de color debería recorrer la suela.

Variantes y mejoras

Cuando ya tengas la onda básica andando, puedes llevar el proyecto más lejos:

• Onda más gruesa: el código deja comentadas dos líneas en ripple_frame que encienden el frente de onda con un grosor de 3 píxeles en vez de 1. Descoméntalas para un efecto más marcado.
• Sensibilidad por pasos: en lugar de tratar el FSR como botón, podrías leerlo en modo analógico con analogio y distinguir un pisotón fuerte de un paso suave, asignando animaciones distintas a cada nivel de presión.
• Modo fiesta: lleva la cuenta de pisadas seguidas en un intervalo corto y, al superar cierto número, dispara una animación arcoíris completa en vez de la onda de un color.

Personalización para Chile

En Chile puedes conseguir la base del proyecto en MechatronicStore. Ten presente que el FSR, la tira NeoPixel flexible y la batería LiPo de celda única están sin stock al momento de escribir esto, así que conviene revisar disponibilidad antes de comprar:

• Raspberry Pi Pico 2 (SKU N340) por $9.990 CLP. Es la placa RP2040 disponible en catálogo. Cumple la misma función de microcontrolador, pero al no ser la Prop Maker Feather no trae el terminal de tornillo ni la carga LiPo integrada: vas a alimentar la tira y resolver la batería aparte.
• Cable paralelo por metro, varios calibres (SKU V109) desde $700 CLP. Sirve para extender las soldaduras de la tira y del FSR, equivalente al cable siliconado del tutorial.

Para el sensor de fuerza busca el FSR402 y, para la iluminación, cualquier tira WS2812B direccionable del catálogo: son los mismos componentes que usa Adafruit con otra marca.

Recursos

• Tutorial original (inglés): Stomp Reactive Light Up Slippers por Erin St Blaine para Adafruit.
• Código completo: Ripple Slippers code.py en el repositorio de Adafruit.

Versión chilena con componentes en stock local en MechatronicStore. Tutorial inspirado en el proyecto de Adafruit, reescrito y adaptado para makers chilenos.