Bastón de Mago Interactivo DIY – Arduino 101, Tira LED, Regulador y Más

Componentes y Suministros

Componente	Cantidad	Notas
Arduino 101	1	IMU integrado para detección de gestos
Regulador Pololu $4	1	Step-down para LEDs
Portapilas 3x AA con interruptor	1	Alimentación portátil
Pilas AA	3	Cualquier tipo
Adaptador Jack Barril Macho	1	$1.95, conexión/desconexión fácil
Adaptador Jack Barril Hembra	1	$1.95, conexión/desconexión fácil
Tira LED Direccionable (NeoPixel)	1	60 píxeles, compatible NeoPixel
Cinta Deportiva (Tela)	1	Sujeción electrónica y agarre
Gomas Elásticas	1	Sujeción temporal
Bastón (palo escoba, tubería, palo natural...)	1	Base física

Aplicaciones y Servicios Online

• Arduino IDE

Sobre el Proyecto

Este proyecto usa Arduino 101, batería y tira LED para crear un Bastón de Mago controlado por gestos. Definimos tres "hechizos" de luz que se invocan moviendo el bastón en tres gestos distintos.

Tecnología

El código usa la IMU (Unidad de Medición Inercial) del Arduino 101 para leer fuerzas G, pero no usa el Motor de Coincidencia de Patrones (PME). En su lugar, cuenta impulsos rápidos en ejes X, Y, Z y lanza hechizos al detectar combinaciones específicas en tiempo corto.

Lanzamiento de Hechizos

Dos golpes verticales rápidos inician un hechizo. Luego, mueve el bastón bruscamente hacia adelante (hechizo 1), izquierda/derecha (hechizo 2), o un tercer golpe vertical (hechizo 3). Un golpe vertical final lanza el hechizo seleccionado.

Retroalimentación Visual

Para saber en qué paso del gesto estás, la tira LED da feedback: doble golpe inicial → destello blanco rápido (hechizo iniciado). Cada paso posterior muestra feedback visual del hechizo que se seleccionará.

Lanzamiento de Hechizos (Detalle)

Sujeta el bastón con el Arduino 101 frente a ti. Primero doble-golpe (suave) en el suelo o dos pulsos verticales rápidos en el aire. Al ver destello blanco:

• Movimiento brusco adelante/atrás → Hechizo 1 (luz verde fija)
• Inclinación izquierda/derecha → Hechizo 2 (luz azul fija)
• Tercer movimiento vertical → Hechizo 3 (luz roja fija)

Una vez la luz está fija en el color del hechizo, golpe vertical final lo lanza: la tira destella y brilla en el color seleccionado.

¡Los gestros son sensibles al tiempo! Solo 1 segundo entre cada paso o el hechizo se reinicia. Si fallas, espera un segundo y vuelve a empezar. Así evitas lanzamientos accidentales al caminar.

Construcción de la Electrónica

Básicamente: Arduino 101, batería, tira NeoPixel.

Opciones de alimentación: 9V directo a Arduino (vida corta), LiPo (máxima potencia/peso pero carga compleja). Equilibrio: 3 pilas AA + regulador $4 (misma electrónica que Shadow Theater y Kaleidoscope Infinity Mirror).

Paso 1

Cortar ~1 cm del extremo de la tira LED para obtener el conector. Pelar cables.

Paso 2

Separar pines header del regulador, soldar dos a cables verde y amarillo para enchufar en pines Arduino 101.

Paso 3

Soldar cable rojo a terminal VIN del regulador, y dos headers rectos en GND y VOUT.

Paso 4

Conectar adaptadores jack barril. Pelar cables del portapilas, montar en jack macho: ROJO a (+), NEGRO a (-). Aprieta tornillos.

Conectar jack hembra a cables sueltos del inicio de la tira LED: AMARILLO a (-), ROJO a (+).

Paso 5

Conectar arnés a Arduino 101: VERDE → PIN 6, AMARILLO → GND cerca pin 13. Regulador: GND → GND, VOUT → pin "VIN" Arduino 101. ¡No invertir! Polaridad inversa = humo y quemaduras.

Subida del Código de Ejemplo

Paso 1

Con portapilas APAGADO, conectar Arduino 101 por USB a PC, subir código de ejemplo con Arduino IDE. Si es primera vez con Arduino 101: guía oficial.

Desconectar USB, encender portapilas, probar gestos con puerto USB hacia abajo y pines frente a ti. Cuatro movimientos verticales lanza Hechizo Rojo.

Discusión del Código

(Si solo quieres usar el código tal cual, salta a Construcción del Bastón.)

El código usa detección de golpes de la IMU para contar impulsos, con temporizador que reinicia cuenta tras breve tiempo sin nuevos golpes. Si se alcanza combinación correcta antes de expirar, se llama a función "hechizo".

Un golpe firme en suelo registra golpe inicial + varios "ruido" por vibraciones. El primer código en loop() busca impulso dominante de cada lote y lo clasifica: 1 = vertical, 2 = adelante/atrás, 3 = izquierda/derecha. Variable gesture guarda cada impulso dominante.

Para rastrear combinaciones, usa switch que avanza según gestos se acumulan. Es como un libro "elige tu aventura": cada paso dice "si siguiente impulso es izquierda/derecha, ve a paso 2, si temporizador expiró, vuelve a cero".

Hechizos

Aquí cambias fácilmente lo que hace cada hechizo. Actualmente son ejemplos theaterChase en diferentes colores. Puedes añadir más, cambiar colores, escribir tus propias funciones de luz. Primeros tres parámetros de theaterChase son RGB, último es velocidad (mayor = más lento).

/////////////////////////////////////////////////hechizos//////////////////////
void hechizoGolpe() { // rojo
  theaterChase(strip.Color(127, 20, 0), 20);
  theaterChase(strip.Color(127, 20, 50), 55);
  strip.show();
}
void hechizoIzquierda() { // azul
  theaterChase(strip.Color(0, 0, 100), 20);
  theaterChase(strip.Color(0, 30, 120), 75);
  strip.show();
}
void hechizoAdelante() { // verde
  theaterChase(strip.Color(0, 127, 0), 30);
  theaterChase(strip.Color(0, 127, 90), 55);
  strip.show();
}

Construcción del Bastón

¡Mucha creatividad aquí! Me centro en construcción técnica básica, pero diviértete haciendo un bastón único. Difusores como tul, papel tisú, o botella plástica sobre LEDs crean efectos geniales.

Paso 1: Encontrar Palo/Bastón

Palo escoba, tubería riego, palo natural. En tiendas de manualidades (Michael's) venden bonitos. Opcional: enrollar sección con cinta deportiva para área de trabajo limpia.

Poner algunas gomas elásticas para facilitar sujeción.

Paso 2: Colocar Arduino 101 con Puerto USB Abajo

Usar goma elástica para sujetar Arduino 101.

Paso 3: Enrollar Tira LED con Ayuda de Gomas en Ambos Extremos

Paso 4: Enrollar Cinta Deportiva para Fijar Arduino 101 y Portapilas

Dejar acceso al interruptor del portapilas. Portapilas seguro para golpes, pero accesible para cambio de pilas.

Paso 5: Difuminar Luces LED y Decorar

Código

Código de Ejemplo Bastón Mago (Arduino)

Cuenta impulsos en ejes X, Y, Z; ciertas combinaciones invocan "hechizos" (efectos de luz) en tira NeoPixel.

/* Copyright (c) 2016 Intel Corporation. All rights reserved.
   Arduino 101 "Wizard's Walking Staff".
   Usa librería Adafruit Neopixel: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation
   Requiere último Intel Curie Core: https://www.arduino.cc/en/Guide/Arduino101 */

#include "CurieIMU.h"
#include <Adafruit_NeoPixel.h>

#define PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

int tr = 0, tg = 0, tb = 0; // color objetivo
int r = 0, g = 0, b = 0;    // color actual
long globaltimer = 0;
long gesturetimer = 0;
long ledtimer = 0;
int fade = 10; // velocidad suavizado
int tap = 0, lr = 0, fb = 0; // contadores impulsos vertical, izq/der, adel/atr
int gesture = 0;
int state = 0; // máquina de estados

void setup() {
  globaltimer = millis();
  gesturetimer = millis();
  ledtimer = millis();

  CurieIMU.begin();
  CurieIMU.attachInterrupt(eventCallback);
  CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 1500); // 1.5g = 1500 mg
  CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, 50);    // ms de pico para interrupción
  CurieIMU.interrupts(CURIE_IMU_SHOCK);

  strip.begin();
  strip.show(); // todos apagados
}

void loop() {
  // Filtro básico: IMU registra múltiples golpes por rebote. Capturar impulso dominante.
  if (millis() - globaltimer > 170) {
    if ((tap > lr) && (tap > fb)) { gesture = 1; } // vertical
    else if ((lr > fb) && (lr > tap)) { gesture = 2; } // izq/der
    else if ((fb > lr) || (fb > tap)) { gesture = 3; } // adel/atr
    tap = lr = fb = 0; // reset contadores
  }

  // Timeouts
  if (millis() - globaltimer > 1000) { globaltimer = millis() - 170; tr = tg = tb = 0; state = 0; }
  if (millis() - gesturetimer > 1000) { gesturetimer = millis() - 350; tr = tg = tb = 0; state = 0; }

  // Máquina de estados para gestos
  switch (state) {
    case 0: // sin gestos, escuchar primer golpe
      if (millis() - gesturetimer > 350 && gesture == 1) {
        state = 1; gesture = 0; gesturetimer = millis();
      }
      break;
    case 1: // un golpe, esperar segundo
      if (millis() - gesturetimer > 350 && gesture == 1) {
        r = g = b = 10; // destello blanco feedback
        state = 2; gesture = 0; gesturetimer = millis();
      }
      break;
    case 2: // dos golpes - punto de bifurcación
      if (millis() - gesturetimer > 350) {
        if (gesture == 1) { state = 3; gesture = 0; gesturetimer = millis(); } // tercer golpe
        if (gesture == 2) { state = 4; gesture = 0; gesturetimer = millis(); } // izq/der
        if (gesture == 3) { state = 5; gesture = 0; gesturetimer = millis(); } // adel/atr
      }
      break;
    case 3: // tres golpes - hechizo golpe (rojo)
      tr = 20; tg = 0; tb = 0; globaltimer = millis() - 250;
      if (millis() - gesturetimer > 350 && gesture == 1) {
        state = 0; tapspell();
      }
      break;
    case 4: // dos golpes + izq/der - hechizo izquierda (azul)
      tr = 0; tg = 0; tb = 20; globaltimer = millis() - 250;
      if (millis() - gesturetimer > 350 && gesture == 1) {
        state = 0; leftspell();
      }
      break;
    case 5: // dos golpes + adel/atr - hechizo adelante (verde)
      tr = 0; tg = 20; tb = 0; globaltimer = millis() - 250;
      if (millis() - gesturetimer > 350 && gesture == 1) {
        state = 0; forwardspell();
      }
      break;
  }

  // Suavizado color LED (no bloqueante)
  if (millis() - ledtimer > fade) {
    if (tr > r + 1) r++; if (tg > g + 1) g++; if (tb > b + 1) b++;
    if (tr < r) r--; if (tg < g) g--; if (tb < b) b--;
    for (int i = 0; i < strip.numPixels(); i++) strip.setPixelColor(i, r, g, b);
    strip.show();
    ledtimer = millis();
  }
}

// Interrupción IMU
static void eventCallback(void) {
  if (CurieIMU.getInterruptStatus(CURIE_IMU_SHOCK)) {
    if (CurieIMU.shockDetected(X_AXIS, POSITIVE) || CurieIMU.shockDetected(X_AXIS, NEGATIVE)) { tap++; globaltimer = millis(); }
    if (CurieIMU.shockDetected(Y_AXIS, POSITIVE) || CurieIMU.shockDetected(Y_AXIS, NEGATIVE)) { lr++; globaltimer = millis(); }
    if (CurieIMU.shockDetected(Z_AXIS, POSITIVE) || CurieIMU.shockDetected(Z_AXIS, NEGATIVE)) { fb++; globaltimer = millis(); }
  }
}

// Funciones de hechizos (desde ejemplo Adafruit Strandtest)
void tapspell() {
  theaterChase(strip.Color(127, 20, 0), 20);
  theaterChase(strip.Color(127, 20, 50), 55);
  strip.show();
}
void leftspell() {
  theaterChase(strip.Color(0, 0, 100), 20);
  theaterChase(strip.Color(0, 30, 120), 75);
  strip.show();
}
void forwardspell() {
  theaterChase(strip.Color(0, 127, 0), 30);
  theaterChase(strip.Color(0, 127, 90), 55);
  strip.show();
}

// Teatro persecución luces
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j = 0; j < 10; j++) {
    for (int q = 0; q < 3; q++) {
      for (uint16_t i = 0; i < strip.numPixels(); i += 3) strip.setPixelColor(i + q, c);
      strip.show(); delay(wait);
      for (uint16_t i = 0; i < strip.numPixels(); i += 3) strip.setPixelColor(i + q, 0);
    }
  }
}