Prop It Game: arma tu propio Bop It con Feather RP2040 y CircuitPython

Lanzamiento al aire libre, fiesta de cumpleaños, viaje en auto. el Bop It de los 90 todavía manda. ¿Y si lo armas tú mismo, con un Feather RP2040 PropMaker, una pantalla 14-segmentos, batería recargable y carcasa 3D impresa con tu paleta favorita? Eso es exactamente lo que hace este proyecto: un Prop It Game programado en CircuitPython que reproduce el formato clásico (Push, Slide, Flip, Shake, Spin) pero abierto y modificable.

Qué vas a saber al terminar

• Cablear un Feather RP2040 PropMaker con 5 inputs distintos (mecánico, capacitivo, magnético, inercial)
• Imprimir y ensamblar una carcasa multi color compatible con impresoras AMS o monocolor
• Cargar CircuitPython y un Project Bundle en el RP2040
• Reproducir audio i2S mientras lees inputs en paralelo con audiomixer
• Diseñar un loop de juego que acelera con el score (música más rápida + menos tiempo de reacción)

La idea: un Bop It abierto

El Bop It original de Hasbro tiene 6 inputs canónicos. Esta versión chilena del Adafruit Prop It implementa 5 + score visible:

• PUSH → key switch mecánico Kailh Choc
• SLIDE → potenciómetro deslizante de 35mm
• FLIP → toggle switch SPDT mini panel mount
• SHAKE → acelerómetro LIS3DH integrado en el Feather
• SPIN → sensor Hall (US5881LUA) + rodamiento de bolas 608ZZ con imanes de neodimio incrustados

El display 14-segmentos quad muestra qué input toca, y el NeoPixel Stick visualiza el countdown de turno. Cuando aciertas, el score sube, la música acelera, y el tiempo de reacción se acorta. al estilo del original.

Diagrama de circuito y conexiones

El cableado se ve denso pero es directo cuando lo piensas por agrupación lógica:

Buses I2C compartidos:

• Display 14-seg quad → conector STEMMA JST del Feather
• Acelerómetro LIS3DH → ya integrado en la placa, no necesitas cablearlo

GPIO directos:

• Key switch Kailh → D5 (con pull up interno)
• Toggle switch → pin EXTERNAL_BUTTON (con pull up interno)
• Sensor Hall → pin EXTERNAL_SERVO (con pull up interno) + resistencia 10kΩ entre VCC y signal
• Potenciómetro slide → A0 (ADC, lectura analógica)

Audio i2S:

• Speaker mini oval 8Ω 1W → pines VO+/VO, del Feather (amplificador i2S integrado)

Alimentación:

• Batería LiPo 2200mAh 3.7V → conector JST PH del Feather
• NeoPixel Stick 8 → 5V/GND/EXTERNAL_NEOPIXELS del Feather
• Slide switch ON/OFF entre EN y GND para corte de energía

💡 Trick clave: el rodamiento 608ZZ no es decorativo. Las bolas internas son ferromagnéticas, así que si pegas dos imanes de neodimio en el cubo y los enfrentas al sensor Hall, cada giro del rodamiento dispara el pulso SPIN. No necesitas encoder ni magnetómetro caro.

Piezas 3D: requisitos de impresión

• Volumen mínimo: 100 × 135 × 31mm. Cabe en cualquier Bambu A1 Mini, Ender 3, Prusa Mini, Voron 0.
• Filamento: PLA estándar. La carcasa principal es robusta. no necesitas PETG.
• Multi color (opcional): la mitad frontal está diseñada para impresoras AMS (Bambu) o IDEX. Si tu impresora es monocolor, hay una variante de archivo single color en el repo.
• Difusor LED: pieza que cubre el NeoPixel Stick. Imprímela en PLA blanco o transparente para que se vea el countdown.
• Archivos 3MF orientados y listos: descarga el ZIP del repo Adafruit Prop It y manda directo al slicer.

Cargar CircuitPython en el RP2040

Si nunca usaste CircuitPython, el proceso es 5 minutos:

1. Descarga el UF2 más reciente de CircuitPython para el "Feather RP2040 Prop Maker" desde circuitpython.org.
2. Mantén apretado el botón BOOT/BOOTSEL mientras conectas el cable USB. El Pi/PC monta un disco llamado RPI-RP2.
3. Arrastra el archivo UF2 al disco RPI-RP2. El disco desaparece y aparece uno nuevo llamado CIRCUITPY.
4. Listo. Ya tienes Python corriendo en tu microcontrolador.

💡 Si después de programar tu code.py el RP2040 queda en "loop de boot" o CIRCUITPY no aparece, puedes rescatarlo con el UF2 "nuke". borra completamente la flash y vuelves al estado de fábrica. Cuidado: pierdes todos los archivos del board, así que respalda tu code.py antes.

El loop del juego: arquitectura del código

El code.py completo usa CircuitPython y tres bibliotecas Adafruit (adafruit_ht16k33 para el display, adafruit_lis3dh para el acelerómetro, adafruit_ticks para el timer no bloqueante). La estructura es:

1. Setup de pines: inicializa cada input como DigitalInOut con Pull.UP o como AnalogIn.
2. Audio mixer: instancia un audiomixer.Mixer con 2 canales. uno para música de fondo (loop), otro para SFX por turno.
3. Loop principal: cada N ms elige aleatoriamente un input objetivo, muestra el texto en el display 14-seg, reproduce el SFX correspondiente y arranca un timer. Si el input correcto se activa antes del timeout, score++; si pasa el timeout o se activa otro, game over.
4. Escalado de dificultad: cada 5 turnos, TRIGGER_INTERVAL baja en INTERVAL_CHANGE y wav_bg.rate sube. la música acelera literalmente con el score.

Extracto del setup de pines, mixer y inputs:

# SPDX-FileCopyrightText: 2026 Liz Clark for Adafruit Industries
# SPDX-License-Identifier: MIT
'''Prop-It CircuitPython code. Feather Prop Maker RP2040 with MX key, hall effect sensor,
toggle switch, slide potentiometer and onboard accelerometer. Background music plays in loop
and individual sound effects for each input play with audio mixer'''

import random
import board
import neopixel
import audiobusio
import audiomixer
import audiocore
import audiospeed
import adafruit_lis3dh
from analogio import AnalogIn
from digitalio import DigitalInOut, Direction, Pull
from adafruit_ht16k33 import segments
from rainbowio import colorwheel
import simpleio
from adafruit_ticks import ticks_ms, ticks_diff, ticks_add

# external power
external_power           = DigitalInOut(board.EXTERNAL_POWER)
external_power.direction = Direction.OUTPUT
external_power.value     = True

# alphanumeric display
display = segments.Seg14x4(board.STEMMA_I2C())

# neopixel strip
pixels = neopixel.NeoPixel(board.EXTERNAL_NEOPIXELS, 8, brightness=0.6, auto_write=True)

# accelerometer
i2c = board.I2C()
int1 = DigitalInOut(board.ACCELEROMETER_INTERRUPT)
lis3dh = adafruit_lis3dh.LIS3DH_I2C(i2c, int1=int1)
lis3dh.range = adafruit_lis3dh.RANGE_2_G
SHAKE_THRESHOLD = 15

key = DigitalInOut(board.D5) # mx key
key.direction = Direction.INPUT
key.pull = Pull.UP
toggle = DigitalInOut(board.EXTERNAL_BUTTON) # toggle switch
toggle.direction = Direction.INPUT
toggle.pull = Pull.UP
hall = DigitalInOut(board.EXTERNAL_SERVO) # hall effect sensor
hall.direction = Direction.INPUT
hall.pull = Pull.UP

# potentiometer
slider = AnalogIn(board.A0)
last_slider_zone = [0]

def get_slider_zone(): # helper for slider to read it as a zone
    raw = slider.value
    zone = int(simpleio.map_range(raw, 0, 65535, 0, 4))
    if abs(zone - last_slider_zone[0]) >= 2:
        last_slider_zone[0] = zone
    return last_slider_zone[0]

TEXT_FILES = ["/sfx_files/push.wav", "/sfx_files/flip.wav", "/sfx_files/spin.wav",
              "/sfx_files/slide.wav", "/sfx_files/shake.wav"]
SFX_FILES = ["/sfx_files/push_it_fx.wav", "/sfx_files/flip_it_fx.wav", "/sfx_files/spin_it_fx.wav",
             "/sfx_files/slide_it_fx.wav", "/sfx_files/shake_it_fx.wav"]
inputs = [
    {'label': "PUSH", 'current_state': False, 'last_state': False, 'txt_file': TEXT_FILES[0],
     'sfx_file': SFX_FILES[0], 'check': lambda: key.value},
    {'label': "FLIP", 'current_state': False, 'last_state': False, 'txt_file': TEXT_FILES[1],
     'sfx_file': SFX_FILES[1], 'check': lambda: toggle.value},
    {'label': "SPIN", 'current_state': False, 'last_state': False, 'txt_file': TEXT_FILES[2],
     'sfx_file': SFX_FILES[2], 'check': lambda: hall.value},
    {'label': "SLDE", 'current_state': False, 'last_state': False, 'txt_file': TEXT_FILES[3],
     'sfx_file': SFX_FILES[3], 'check': get_slider_zone},
    {'label': "SHKE", 'current_state': False, 'last_state': False, 'txt_file': TEXT_FILES[4],
     'sfx_file': SFX_FILES[4], 'check': lambda: lis3dh.shake(shake_threshold=SHAKE_THRESHOLD)},
]

Mira el IGNORE_MAP = {4: [2], 2: [4]} — es clave: cuando estás sacudiendo (SHAKE = index 4), el acelerómetro genera spikes que el sensor Hall podría leer como SPIN; al revés también. Ese mapa le dice al loop que ignore SPIN durante un turno SHAKE y viceversa, evitando falsos positivos.

Hardware secundario: tornillería

El BOM original lista tornillos métricos imperiales convertidos. Para que las piezas calcen bien:

• 3× M3 × 6mm (acero, cabeza hex)
• 4× M3 × 4mm
• 1× M3 × 20mm
• 2× M2.5 × 4mm
• 2× M2 × 6mm
• 2× M2 × 8mm

En Chile encontrás todos estos en cualquier ferretería técnica o ferretería online especializada en tornillería métrica.

Variantes y mejoras

Cinco extensiones que NO están en el tutorial original:

1. Modo multijugador hot seat. Conecta dos Feathers via UART o ESP NOW (si pones un ESP32 en lugar del RP2040). El primer board muestra el input, el segundo registra el tiempo de reacción. vence quien acumula menos tiempo total en 20 turnos.

2. Sensor extra: pulsar el aire (gesture). Reemplaza el SLIDE por un APDS-9960 conectado al bus I2C. Detecta gestures arriba/abajo/izquierda/derecha y multiplica los inputs efectivos a 8 sin agregar piezas mecánicas.

3. Persistencia de high score. CircuitPython no escribe a CIRCUITPY en runtime por defecto. Agrega un boot.py que habilite escritura solo si conectas el toggle switch en una posición específica al arrancar. así guardas el high score en score.txt sin sacrificar el flujo de edición del código.

4. Modo party con NeoPixel Ring 24 LED externo. Usa el pin TX libre para encender un anillo NeoPixel externo que muestra el countdown como reloj radial. Más vistoso para fiestas/streams.

5. Voz en lugar de texto. Cambia los WAV de "PUSH"/"FLIP"/"SPIN" por TTS generado con Coqui o gTTS en español, mexicano, chileno. la diferencia con la versión gringa la sientes inmediatamente.

Personalización para Chile

Equivalencias del catálogo MechatronicStore frente al BOM original Adafruit:

• Placa Feather RP2040 PropMaker. corazón del proyecto, microcontrolador con amplificador i2S integrado.
• Display LED 14 segmentos 4 dígitos I2C. la versión amarilla 0.54" del original puede venir en rojo/verde/blanco; cualquiera funciona porque comparte la backpack HT16K33.
• NeoPixel Stick 8 LED WS2812B. la tira corta usada para countdown.
• Potenciómetro deslizante 35mm 10kΩ. el slide pot.
• Switch mecánico Kailh Choc blanco. el clicky para el PUSH.
• Toggle switch SPDT panel mount. para el FLIP.
• Sensor Hall lineal A3144. equivalente al US5881LUA del original; ambos detectan campo magnético.
• Rodamiento de bolas 608ZZ. el cubo del SPIN, viene en sets de 4.
• Batería LiPo 2200mAh 3.7V. alimentación recargable.
• Speaker mini 8Ω 1W. para audio i2S.
• Imanes de neodimio 5mm. los pegas al rodamiento para activar el sensor Hall.
• Filamento PLA 1.75mm. colores a tu gusto. La caja Bambu PLA Matte rinde varios proyectos.
• Resistencias 10kΩ 1/4W. necesaria entre VCC y signal del Hall.

Total estimado del rig en MechatronicStore: aproximadamente CLP $95.000, sin contar filamento (1 spool de 1kg te da varias carcasas).

Recursos

• Tutorial original: Prop It Game por Ruiz Brothers y Liz Clark en Adafruit Learning System
• Repositorio CAD de partes 3D Adafruit: Adafruit_CAD_Parts en GitHub
• CircuitPython UF2 para Feather RP2040 PropMaker: circuitpython.org
• Bibliotecas usadas: adafruit_ht16k33, adafruit_lis3dh, adafruit_ticks (todas en el bundle oficial)
• Fritzing parts Adafruit: Adafruit Fritzing-Parts en GitHub

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