BATTLE BOTS - Torneo De Robots Sumo

by Makerspace Prepa UDEM in Teachers > 10

3080 Views, 29 Favorites, 0 Comments

BATTLE BOTS - Torneo De Robots Sumo

Cover instructables.png


Este instructable es tu guía paso a paso para armar y programar un mini-robot de sumo. Aquí encontrarás todo lo necesario: desde la preparación de motores y fuente de poder, hasta la instalación de componentes electrónicos, carga del código base y pruebas finales en el dohyō.

¡Pon a prueba tu creatividad, diviértete en el proceso y prepárate para dar lo mejor en la arena! 🤖🔥

⚠️Nota: Este instructable documenta un torneo interno organizado en nuestra institución. No se trata de una convocatoria abierta, sino de un recurso compartido con fines educativos y para inspirar a otras comunidades de creadores.

Supplies

DSC_1266.JPG

Materiales

  1. Base estructural de MDF (proporcionada por tu MakerSpace) *En caso de daño o pérdida, en el "Paso 3: Esambla La Estructura Base" se incluyen planos DXF para reponer las piezas mediante corte láser
  2. Papel, cartón, MDF, acrílico u otros materiales ligeros para fabricar el casco exterior
  3. Pegamento para madera, silicón caliente o cinta doble cara
  4. Cinchos plásticos de diferentes tamaños
  5. 16 tornillos hexagonales M3 x 10~12 mm *opcional
  6. 16 tuercas hexagonales M3 *opcional


Herramientas

  1. Pinzas de microcorte
  2. Pinzas pelacables
  3. Juego de llaves Allen
  4. Cautín para soldar
  5. Estaño para soldadura
  6. Pasta para soldar
  7. Cinta aislante o termofit *opcional
  8. Destornillador eléctrico *opcional
  9. Broca de 3 mm *opcional


Componentes Electrónicos

  1. 1 Arduino UNO o Placa de desarrollo similar Ver en Steren (El tutorial se basa en esta placa, aunque también es compatible con Arduino Nano o similar)
  2. 1 cable USB Tipo A a USB Tipo B (o complatible con la placa de desarrollo)
  3. 1 Puente H o tarjeta de control de motores L298N Ver en Steren
  4. 2 motores reductores de doble eje tipo I, relación 1:120, color amarillo Ver en Steren (Alternativa) 2 motores reductores de doble eje tipo I, relación 1:48 Ver en Steren
  5. 1 juego de llantas de plástico compatibles con motor reductor Ver en Steren
  6. 2 sensores seguidores de línea ST1140 Ver en Steren
  7. 1 sensor ultrasónico equivalente a SRF04 Ver en Steren
  8. 1 broche porta pila de 9V Ver en Steren
  9. 1 switch de balancín, 1 tiro / 1 polo / 2 posiciones Ver en Steren
  10. 1 batería de 9V *se recomienda contar con repuestos o utilizar recargables
  11. Juego de cables jumpers tipo Dupont (plug-plug y jack-plug) de 15 cm ~ 20 cm Ver en Steren


Equipo de Seguridad

  1. Lentes de seguridad
  2. Mascarilla N95
  3. Guantes resistentes al calor


Software

  1. Arduino IDE versión 2.3.6 Descargar aquí

Prepara La Fuente De Poder

DSC_1243.JPG
DSC_1246.JPG
DSC_1249.JPG
DSC_1252.JPG
DSC_1254.JPG
DSC_1257.JPG
DSC_1261.JPG
DSC_1258.JPG
DSC_1260.JPG
DSC_1259.JPG
  1. Corta y pela (5–7 mm) un extremo de dos cables jumper con plug (15–20 cm)
  2. Pela el cable rojo (+) del broche porta pila de 9V
  3. Suelda el cable rojo (+) del broche a una terminal del switch de balancín
  4. Suelda uno de los jumpers preparados (con plug en la punta) al otro extremo del switch
  5. Aísla ambas uniones con termofit o cinta aislante
  6. Pela el cable negro (–) del broche porta pila
  7. Suelda el otro jumper preparado (con plug en la punta) directamente al cable negro (–)
  8. Aísla la unión del negativo con termofit o cinta


✅ Resultado esperado: Al final en cada extremo tendrás un plug listo para conectar fácilmente al circuito, el switch debe quedar en medio del cable positivo (rojo) y el negativo (negro) se extiende directo

Monta Los Motores

DSC_1275.JPG
DSC_1286.JPG
DSC_1288.JPG
DSC_1289.JPG
DSC_1290.JPG
DSC_1293.JPG
DSC_1277.JPG
DSC_1282.JPG
DSC_1283.JPG
DSC_1279.JPG
DSC_1280.JPG
DSC_1281.JPG
DSC_1285.JPG
  1. Identifica los dos soportes de MDF (cada uno con dos orificios alineados a la parte trasera del motoreductor)
  2. Toma 4 jumpers con plug (15–20 cm), 2 de un color y 2 de otro color. A cada jumper, córtale un extremo, pela 5–7 mm ese lado y deja el plug en el extremo opuesto
  3. En cada motor, suelda un par de jumpers (uno por terminal) usando el color A para el motor de la columna izquierda y el color B para el de la columna derecha
  4. Aísla las soldaduras con termofit o cinta aislante para evitar falsos contactos
  5. Coloca el primer motoreductor sobre su columna, apoyándolo contra el lado plano (no sobre el lado del pequeño cilindro amarillo)
  6. Pasa un cincho a través de ambos orificios, rodea el motor y ajusta hasta que quede firme en la columna
  7. Repite con el segundo motoreductor sobre la otra columna, pero en espejo: al juntar ambas columnas como “lado izquierdo” y “lado derecho”, los cilindros amarillos deben quedar hacia afuera


✅ Resultado esperado: dos módulos (columna + motor) montados en espejo, cada motor con dos jumpers (de color consistente), soldados y aislados, terminando en plug listos para conectarse al controlador de motores

💡 Consejo: Si quieres, etiqueta con masking tape arriba/abajo para mantener referencia de polaridad.

Ensambla La Estructura Base

DSC_1265.JPG
DSC_1295.JPG
DSC_1296.JPG
DSC_1297.JPG
DSC_1298.JPG
DSC_1299.JPG
DSC_1300.JPG
DSC_1301.JPG
DSC_1302.JPG
DSC_1303.JPG
DSC_1305.JPG
DSC_1307.JPG
DSC_1308.JPG
DSC_1309.JPG
DSC_1315.JPG
DSC_1316.JPG
DSC_1317.JPG

📸 Para ensamblar la estructura principal utiliza como referencia las fotografías de arriba.

💡 Consejo: Notarás que algunas piezas del kit tienen huecos en forma de “ t ”: estos permiten usar tornillos y tuercas M3 para dar mayor firmeza a la unión; sin embargo, también puedes optar por pegamento para madera o silicón caliente si prefieres un método más sencillo.

✅ Sabrás que lo hiciste bien cuando:

  1. Los motores quedan fijos gracias a que sus columnas quedan prensadas entre el chasis y el segundo nivel, con la parte metálica orientada hacia atrás y los cilindros amarillos hacia afuera.
  2. Sobre la parte frontal del chasis se sostiene una pieza que contiene dos grandes huecos ciruclares apuntando hacia el frente.
  3. Debajo de la parte frontal del chasis se ensmabla una media esfera, que actúa como apoyo para evitar que el frente toque el suelo.
  4. En el segundo nivel deben quedar visibles unas figuras rectangulares marcadas con láser, que servirán como guía para ubicar más adelante el puente H (L298N) y el Arduino UNO.


En ese mismo segundo nivel encontrarás las marcas rectangulares grabadas con láser que indican dónde colocar el puente H (L298N) y el Arduino UNO (uno al lado del otro).

⚠️Para fijarlos puedes usar silicón caliente, cinta doble cara, cinchos de plástico o, si prefieres un montaje más firme, hacer orificios con una broca de 3 mm y asegurarlos con tornillos y tuercas M3.


👇🏻 Descarga los archivos de corte láser (opcional)

Asegura Los Componentes Electrónicos

DSC_1319.JPG
DSC_1320.JPG
DSC_1321.JPG
DSC_1322.JPG
DSC_1323.JPG
DSC_1324.JPG
DSC_1325.JPG
DSC_1327.JPG
DSC_1328.JPG
DSC_1331.JPG
DSC_1329.JPG

Primero, coloca los sensores seguidores de línea debajo del chasis. Puedes fijarlos con un cincho o con un tornillo M3, procurando que los sensores queden apuntando hacia adelante. Su posición es personalizable: puedes ajustarlos o girarlos a lo largo de la ranura según la estrategia de tu equipo.

Después, monta el sensor ultrasónico de proximidad en la pieza frontal superior del chasis, la que tiene dos grandes orificios. El transmisor y receptor deben entrar a presión en los huecos, quedando orientados hacia el frente del robot, con los plugs del sensor apuntando hacia arriba.

En el segundo nivel de la estructura verás un espacio diseñado para instalar el interruptor. Asegúrate de pasar por ahí los cables hacia la parte trasera del chasis para que queden ordenados y listos para conectarse, y acomoda el broche portapilas dentro de la estructura, de manera que quede accesible para insertar o cambiar la pila fácilmente.

Conecta Todo El Sistema

Untitled design (3).png
DSC_1332.JPG
DSC_1333.JPG
DSC_1334.JPG
DSC_1335.JPG
DSC_1336.JPG
DSC_1337.JPG
DSC_1339.JPG
DSC_1340.JPG
DSC_1342.JPG
DSC_1343.JPG
DSC_1341.JPG

Ahora que todos los módulos están fijos en la estructura, es momento de realizar las conexiones eléctricas. A continuación encontrarás las conexiones organizadas por componente, para que sea más sencillo de seguir:

🔋 Broche Portapilas

  1. Cable rojo (+) → Módulo H, bornera VMS (+)
  2. Cable negro (−) → Módulo H, bornera GND (−)


⚙️ Módulo H

  1. Bornera VMS (+) (mismo tornillo que el cable rojo de la pila) → Arduino UNO, pin VIN (o jack barrel)
  2. Bornera GND (−) (mismo tornillo que el cable negro de la pila) → Arduino UNO, pin GND
  3. Bornera 5V → Sensores de línea izquierdo y derecho, pin V+
  4. Pin header 5V → Sensor ultrasónico, pin Vcc
  5. Pin header GND → Sensor ultrasónico, pin GND
  6. Pin ENA → Arduino UNO, pin D5 (PWM)
  7. Pin IN1 → Arduino UNO, pin D8
  8. Pin IN2 → Arduino UNO, pin D9
  9. Pin ENB → Arduino UNO, pin D6 (PWM)
  10. Pin IN3 → Arduino UNO, pin D10
  11. Pin IN4 → Arduino UNO, pin D11


📟 Arduino UNO

  1. Pin D3 → Sensor ultrasónico, pin TRIG
  2. Pin D2 → Sensor ultrasónico, pin ECHO
  3. Pin D7 → Sensor de línea izquierdo, pin S
  4. Pin D4 → Sensor de línea derecho, pin S
  5. Pin GND → Sensor de línea izquierdo, pin G
  6. Otro pin GND → Sensor de línea derecho, pin G


Motores

  1. Motor izquierdo → Módulo H, salidas OUT1 y OUT2 (un cable en cada salida)
  2. Motor derecho → Módulo H, salidas OUT3 y OUT4 (un cable en cada salida)


Nota importante: Cada conexión aparece solo una vez; los sensores y motores no repiten lo que ya se explicó en el Módulo H o Arduino.

Fija Las Llantas

DSC_1346.JPG
DSC_1348.JPG

Coloca cada llanta en el eje correspondiente de su motoreductor hasta que quede bien asentada y sin juego. Asegúrate de que ambas ruedas estén alineadas y giren libremente sin rozar el chasis ni la columna del motor.

⚠️Regla importante: Las llantas deben ser de fricción normal, sin sustancias añadidas. El robot no puede usar materiales adhesivos, superficies de succión, ventosas o cualquier mecanismo destinado a fijarse o adherirse al dohyō.

Carga El Código Base

DSC_1352.JPG
DSC_1357.JPG
DSC_1354.JPG
DSC_1356.JPG

⚠️ No conectes la batería de 9 V al broche mientras el Arduino esté conectado por USB a la computadora.

💻 Instala Arduino IDE y carga el código base para que tu robot pueda arrancar con una configuración funcional.

  1. Instala Arduino IDE (2.3.6) y ábrelo por primera vez
  2. Instala la librería NewPing: Sketch → Include Library → Manage Libraries… → busca “NewPing” → Install
  3. Abre un nuevo documento en blanco dentro de Arduino IDE
  4. Copia todo el código que aparece a continuación y pégalo dentro del documento en blanco de Arduino IDE
  5. Conecta el Arduino UNO a tu computadora usando el cable USB
  6. Selecciona la tarjeta: Tools → Board → Arduino AVR Boards → Arduino Uno
  7. Selecciona el puerto: Tools → Port → elige el puerto USB activo de tu computadora
  8. Haz clic en Verify (✓) y luego en Upload (→) hasta ver el mensaje “Upload done”
  9. Desconecta USB si vas a probar en mesa y, solo entonces, conecta la pila y usa el interruptor para encender


👇🏻 Copia el código completo

#include <NewPing.h>

/* ===================== MAPEOS DE TU PROTOTIPO ===================== */
// Puente H (L298N / "módulo H")
const int ENA = 5; // PWM motor IZQ
const int IN1 = 8; // UR1
const int IN2 = 9; // UR2

const int ENB = 6; // PWM motor DER
const int IN3 = 10; // UR3
const int IN4 = 11; // UR4

// Sensores de línea (S = señal)
const int LINE_LEFT = 7; // sensor de línea izquierda (S)
const int LINE_RIGHT = 4; // sensor de línea derecha (S)

// Ultrasónico (HC-SR04/SRF04 eq.)
#define TRIG_PIN 3
#define ECHO_PIN 2
#define MAX_DISTANCE 200
NewPing sonar(TRIG_PIN, ECHO_PIN, MAX_DISTANCE);

/* ===================== AJUSTES ===================== */
// Tus módulos de línea quedaron LOW=negro, HIGH=blanco:
const bool LINE_HIGH_IS_WHITE = false;

// >>> Inversión por software de cada lado <<<
// Si el robot “avanza hacia atrás”, deja ambos en true.
// Si luego inviertes cables y queda correcto, ponlos en false.
const bool LEFT_INVERT = true;
const bool RIGHT_INVERT = true;

// Velocidades (0-255)
const int SPEED_FWD = 200; // avance
const int SPEED_TURN = 200; // giro
const int SPEED_REV = 200; // reversa

// Tiempos base
const unsigned long TURN_EDGE_MS = 180; // giro cuando un sensor ve borde
const unsigned long RANDOM_TURN_MS = 200; // giro aleatorio cuando NO hay objeto
const unsigned long ADV_AFTER_TURN = 200; // avanzar después del giro aleatorio

/* ===================== HELPERS DE MOTORES ===================== */
// dir: +1 = adelante, -1 = atrás, 0 = freno
static inline void motorLeft(int dir, int pwm){
pwm = constrain(pwm, 0, 255);
int d = LEFT_INVERT ? -dir : dir;
if (d > 0) { digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW); }
else if (d < 0) { digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH); }
else { digitalWrite(IN1, HIGH); digitalWrite(IN2, HIGH); } // freno
analogWrite(ENA, pwm);
}
static inline void motorRight(int dir, int pwm){
pwm = constrain(pwm, 0, 255);
int d = RIGHT_INVERT ? -dir : dir;
if (d > 0) { digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW); }
else if (d < 0) { digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH); }
else { digitalWrite(IN3, HIGH); digitalWrite(IN4, HIGH); } // freno
analogWrite(ENB, pwm);
}

void avanzar() { motorLeft(+1, SPEED_FWD); motorRight(+1, SPEED_FWD); }
void retroceder() { motorLeft(-1, SPEED_REV); motorRight(-1, SPEED_REV); }
void girarIzquierda(){ motorLeft(-1, SPEED_TURN); motorRight(+1, SPEED_TURN); }
void girarDerecha() { motorLeft(+1, SPEED_TURN); motorRight(-1, SPEED_TURN); }
void detener() { motorLeft(0, 0); motorRight(0, 0); }

/* ===================== SENSORES DE LÍNEA ===================== */
bool readLeftWhite(){
int v = digitalRead(LINE_LEFT);
return LINE_HIGH_IS_WHITE ? (v == HIGH) : (v == LOW);
}
bool readRightWhite(){
int v = digitalRead(LINE_RIGHT);
return LINE_HIGH_IS_WHITE ? (v == HIGH) : (v == LOW);
}

/* ===================== SETUP / LOOP ===================== */
void setup() {
pinMode(ENA, OUTPUT); pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT);
pinMode(ENB, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT);

pinMode(LINE_LEFT, INPUT);
pinMode(LINE_RIGHT, INPUT);

pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);

detener(); // motores en estado seguro
Serial.begin(9600);
randomSeed(analogRead(A0));
}

void loop() {
// Leer línea (interpretación según LINE_HIGH_IS_WHITE)
bool leftWhite = readLeftWhite(); // true = blanco en izquierdo
bool rightWhite = readRightWhite(); // true = blanco en derecho

// 🚩 Prioridad: no salirse de la pista
if (leftWhite) { // borde a la izquierda → gira a la derecha
girarDerecha();
delay(TURN_EDGE_MS);
return;
}
if (rightWhite) { // borde a la derecha → gira a la izquierda
girarIzquierda();
delay(TURN_EDGE_MS);
return;
}

// Ultrasonido
delay(15);
unsigned int distancia = sonar.ping_cm();

if (distancia > 0 && distancia < 30) {
// ✅ Objeto cerca → avanzar
avanzar();
} else {
// ❌ Sin objeto → giro aleatorio y luego avanzar un poco
if (random(2) == 0) girarIzquierda();
else girarDerecha();

delay(RANDOM_TURN_MS);
avanzar();
delay(ADV_AFTER_TURN);
}
}


🤖 Nota: el código base es un punto de partida. Puedes modificar parámetros o crear tu propio código para mejorar la estrategia de tu robot.

Personaliza Tu Estrategia

Makerspace_BattleBots_2025_CodeTests-ezgif.com-video-to-gif-converter.gif

El código que te compartimos en el paso anterior es solo una referencia. A partir de aquí puedes modificar la lógica de tu robot para darle una personalidad propia y aumentar tus posibilidades de ganar.

🔛 Por ejemplo, puedes optar por una estrategia de patrullaje lineal: tu robot avanza firme hacia adelante, y cuando detecta la línea blanca se da la vuelta en una dirección aleatoria para volver a avanzar en otro ángulo. Este ciclo se repite constantemente, y si durante el recorrido detecta al contrincante, cambia de velocidad para empujarlo fuera del tablero.

🔀 Otra opción es programar un comportamiento de exploración errática: el robot cambia de dirección con pasos cortos y movimientos irregulares, cubriendo la mayor parte del tablero en busca del rival. En cuanto detecta al contrincante, cambia de modo y avanza en línea recta con fuerza, buscando sacarlo del dohyō (esta es la lógica de nuestro código base).

💡 Al final, la creatividad, la estrategia y las habilidades de programación de tu equipo serán las que definan qué tan competitivo será tu robot en la arena.

Conecta La Batería

DSC_1360.JPG
DSC_1361.JPG

⚠️ Antes de conectar la batería, verifica que el switch esté en posición OFF.

Asegura la batería al chasis con cinta doble cara o una gota de silicón caliente, pero usa un adhesivo de desmontaje rápido en caso de que necesites reemplazarla durante el torneo.

🔋 Consejo extra: lleva baterías de repuesto o utiliza una pila recargable para evitar contratiempos durante el torneo.

Prueba En El Dohyō

DSC_1373.JPG
DSC_1385.JPG
DSC_1386.JPG
DSC_1362.JPG
DSC_1376.JPG
DSC_1377.JPG
DSC_1375.JPG

El escenario de batalla será un dohyō circular de color negro de 90 cm de diámetro, delimitado por una franja blanca de 4 cm que marca claramente el límite del área de combate

💥 Los combates se disputarán al mejor de tres asaltos (2 de 3), con una duración máxima de 3 minutos por round. En cada round, los robots iniciarán en posiciones diferentes:

  1. Round 1: al centro, de espaldas, separados 15 cm
  2. Round 2: al centro, de costado, separados 15 cm
  3. Round 3: en extremos opuestos, apuntando hacia el frente


🏆 Un equipo será declarado ganador de un asalto si logra empujar al rival fuera del círculo, si el oponente sale por sí mismo o si permanece inactivo más de 15 segundos.

En resumen: tu robot debe mantenerse siempre dentro del área negra, reaccionar a la línea blanca para evitar salirse y aprovechar cada encuentro con el contrincante para sacarlo del tablero.

Las pruebas en el dohyō serán el momento clave para confirmar si tu estrategia realmente funciona. 🚀

Diseña El Casco Exterior

WhatsApp Image 2025-09-30 at 2.30.10 PM.jpeg
WhatsApp Image 2025-09-30 at 2.30.10 PM (1).jpeg
Makerspace_BattleBots_2025_Enclosure.png
imagen.png
imagen (1).png

El último paso es dar identidad a tu robot. Aquí tienes total libertad para diseñar y fabricar un casco exterior que proteja los componentes electrónicos y, al mismo tiempo, le dé estilo propio a tu creación. Puedes utilizar materiales como cartón, MDF, acrílico, plásticos impresos en 3D u otros que tengas a tu alcance en el MakerSpace o en casa.

🔍 Eso sí, no olvides algunos puntos clave:

⚠️ El casco no debe obstruir los sensores, por lo que deberás hacer aberturas al frente para el sensor ultrasónico y dejar despejada la parte inferior para que los seguidores de línea funcionen sin problemas

⚠️ También asegúrate de dejar acceso al interruptor de encendido/apagado; si lo prefieres, puedes sacarlo por fuera del casco, ya que durante una batalla no se permite retirar la cubierta para encender el robot


🛑 Recuerda que puedes ser tan creativo como quieras, siempre que cumplas con las indicaciones generales:

  1. El robot no debe exceder un tamaño máximo de 15 × 15 cm (largo y ancho)
  2. El peso total no puede ser mayor a 350 g
  3. Está prohibido el uso de elementos que liberen gases o líquidos
  4. No se permite emplear materiales o estructuras que puedan manchar, rayar o dañar el escenario de combate.
  5. El uso de estructuras o cuchillas metálicas queda estrictamente prohibido