Laberinto de Canicas con Arduino: Juego de Mesa DIY en Cartón

Componentes y Suministros

• Arduino UNO (cualquier placa) × 1
• Servomotor SG90 9g × 2
• Protoboard (genérica) × 1
• Módulo Joystick × 1
• Cables jumper (genéricos) × 1

Herramientas y Máquinas Necesarias

• Pistola de silicona (genérica)
• Cúter / Navaja afilada

Aplicaciones y Servicios Online

• Arduino IDE

Sobre el Proyecto

Te muestro cómo hacer un juego de mesa Laberinto de Canicas controlado por Arduino, súper fácil y divertido de hacer. ¡Y lo mejor es que está hecho de cartón!

La idea del juego es navegar la canica a través del laberinto para llegar al portal al final y ganar.

Por supuesto hay muchas ideas para mejorar el juego y hacerlo más divertido, como poner sensores al final, un buzzer que suene al jugar, o incluso hacer agujeros en el propio laberinto.

La Idea

Me aburrí de los juegos electrónicos y empecé a buscar juegos de habilidad física, así que encontré el Laberinto y me gustó.

¿Qué es el Laberinto?

El Laberinto es un juego de habilidad física que consiste en una caja con un laberinto en la tapa con agujeros, y una canica de acero. El objetivo es inclinar el tablero para guiar la canica al final del laberinto sin que caiga en ningún agujero. Algunas versiones tienen una superficie suspendida que rota en dos ejes, cada uno controlado por una perilla. Se venden versiones portátiles con tapa transparente. El juego fue desarrollado por BRIO en Suecia y lanzado allí en 1946.

Diseño

Empecé a diseñar mi propio laberinto usando SketchUp Pro para imaginar el aspecto. Cuidé dar un tamaño adecuado y hacerlo bastante fácil para que los niños también puedan construir su propio laberinto.

Los archivos de diseño están disponibles para descargar y hacer tu propio juego de cartón en solo 1 hora.

Herramientas y Materiales

• Cartón 3mm
• Silicona caliente
• Cúter
• Regla y lápiz

Componentes Electrónicos

• Arduino (cualquier modelo)
• Mini protoboard
• Cables jumper
• 2× Servomotor 9g
• Módulo Joystick
• 2 tornillos y tuercas 12mm × 3mm

Recortar las Piezas

1. Recorta un cuadrado de 20×20 cm para la base.
2. Recorta dos trapecios isósceles de 14×16 cm para los laterales.
3. Haz un agujero rectangular en uno para el servomotor (eje X).
4. Taladra un agujero de 3mm en el otro, en el centro exacto, contra el eje del servo (eje X).
5. Recorta cuatro rectángulos de 14×4 cm para soportes interiores.
6. Taladra agujero de 3mm en uno para el eje Y.
7. Haz agujero rectangular en uno de estos cuatro para el servomotor (eje Y).
8. Elige tu laberinto de los archivos adjuntos, recorta cuadrado 12×12 cm.
9. Tip: Pega el laberinto en papel como guía.
10. Recorta al menos ocho rectángulos de 1.5×12 cm para las paredes. Ajusta tamaños.
11. Sigue las guías y pega las paredes en su lugar.
12. Pega los servomotores en su lugar.
13. Pega los cuernos de los servos en las piezas rectangulares.

Cableado

• Pin 8 Arduino → cable amarillo servo 1 (eje X)
• Pin 9 Arduino → cable amarillo servo 2 (eje Y)
• Rojo y marrón de servos → protoboard
• Pin A0 Arduino → Joystick VRx
• Pin A1 Arduino → Joystick VRy
• VCC y GND Joystick → protoboard
• 5V y GND Arduino → protoboard

Código

#include <Servo.h>

Servo myServoX; // Servo eje X
Servo myServoY; // Servo eje Y

int ServoXPin = 8;
int ServoYPin = 9;
int ServoXHomePos = 90;
int ServoYHomePos = 90;
int ServoXPos = 103;
int ServoYPos = 135;

int XAxlePin = A0;
int YAxlePin = A1;
int XAxleValue = 0;
int YAxleValue = 0;

int range = 12;        // Rango de salida movimiento X/Y
int center = range/2;  // Posición reposo
int threshold = range/4; // Umbral zona muerta

void setup() {
  myServoX.attach(ServoXPin);
  myServoY.attach(ServoYPin);
  ServoXPos = ServoXHomePos;
  ServoYPos = ServoYHomePos;
  myServoX.write(ServoXPos);
  myServoY.write(ServoYPos);
  Serial.begin(9600);
}

void loop() {
  XAxleValue = readAxis(XAxlePin);
  YAxleValue = readAxis(YAxlePin);
  
  Serial.print(XAxleValue, DEC);
  Serial.print(" - ");
  Serial.println(YAxleValue, DEC);

  // Movimiento suave con delay proporcional a desviación
  if (XAxleValue > 0) {
    ServoXPos++; myServoX.write(ServoXPos);
    delay(100 * (7 - XAxleValue));
  }
  if (XAxleValue < 0) {
    ServoXPos--; myServoX.write(ServoXPos);
    delay(100 * (7 + XAxleValue));
  }
  if (YAxleValue > 0) {
    ServoYPos++; myServoY.write(ServoYPos);
    delay(100 * (7 - YAxleValue));
  }
  if (YAxleValue < 0) {
    ServoYPos--; myServoY.write(ServoYPos);
    delay(100 * (7 + YAxleValue));
  }

  // Límites de movimiento (±20° desde centro)
  if (ServoXPos > ServoXHomePos + 20) ServoXPos = ServoXHomePos + 20;
  if (ServoXPos < ServoXHomePos - 20) ServoXPos = ServoXHomePos - 20;
  if (ServoYPos > ServoYHomePos + 20) ServoYPos = ServoYHomePos + 20;
  if (ServoYPos < ServoYHomePos - 20) ServoYPos = ServoYHomePos - 20;

  delay(10);
}

int readAxis(int thisAxis) {
  int reading = analogRead(thisAxis);
  reading = map(reading, 0, 1023, 0, range);
  int distance = reading - center;
  if (abs(distance) < threshold) distance = 0;
  return distance;
}

Esquemáticos