Publicado el

Cómo hacer un sumobot. !Tutorial completo!

cómo armar un sumobot tutprial completo

[nextpage title=”1.- Introducción: Sumobots.”]
En este tutorial se muestra cómo armar un sumobot, desarrollaremos un mini sumobot funcional básico. Los sumobots son robots que tienen como objetivo sacar a su contrincante del área de combate, deben ser autónomos por lo que necesitan sensores que detectan a su enemigo y lo empujan hasta sacarlo, en el siguiente video puedes ver una competencia sumobot.

Robot Rumble 2017 – Torneo Internacional de Robótica en México

Un torneo internacional de robótica en el que participan equipos de todos los estados de la República Mexicana y también competidores de otros países. Presentamos cómo se vivió el evento en Mayo del 2017. Ejemplos de combates de sumobot profesional.


Los sumobots deben realizar 2 actividades:
Detectar al enemigo y atacar. Esto lo logra detectando al enemigo con unos sensores de distancia, cuando se detecta un objeto cercano se aproxima a atacarlo.
Evitar salir del área de combate. El área de combate es negro con una línea blanca alrededor, entonces se usan unos sensores que son capaces de detectar dicha línea y al encontrarla la evitarán.

Tutorial cómo armar un sumobot ¡Comenzamos!

[nextpage title=”2.- Materiales.”]
1x Arduino Nano
1x Chasis de metal para mini sumobot (10cm x 10cm) con pala de Latón
2x Micromotor Metálico Polulu
1x Par de bases para micromotor Polulu
1x Par de llantas para mini sumobot
2x Sensores de distancia Sharp de 4-30cm
2x Conectores para sensor de distancia Sharp
1x Driver de motor TB6612FNG
2x Sensor de reflectancia infrarrojo
1x Soldadura
Jumpers hembra-hembra
Jumpers macho-macho
Interruptor 1 polo 2 tiros
Thermofit
Pistola de silicón

¿Te gusta la robótica? Quizás te interesaría participar en nuestros Talleres de Entrenamiento online y presenciales. Haz tu registro y podrás recibir una invitación especial con información de próximas fechas, lugares y temas que se van a impartir. ¡Víve la experiencia! Haz clic aquí o en la imagen de aquí abajo.
workshops-t-bem-talleres-de-robotica-y-electronica_

[nextpage title=”3.- Detección de línea blanca.”]
Parte importante de cómo armar un Mini Sumobot son Los sensores de línea, los cuáles evitarán que el sumobot salga del área de combate, primero tenemos que soldar el conector header al sensor, utilizaremos conectores a 90° para reducir la altura.

Sensor-Linea-001

Debemos cuidar que al soldar el conector quede lo más paralelo posible a la tarjeta como en la siguiente imagen:

Sensor-Linea-002

Luego usando Jumpers hembra-hembra se conectará cada sensor al arduino.
SensorArduino

Vin 5V
GND GND
Vout D2

Sensor-Linea-003

Se hará un programa muy corto con el que se probará su funcionamiento. Si el sensor detecta línea blanca se encenderá el LED, hay que destacar que el sensor envía un voltaje bajo cuando detecta línea blanca.
[code language=”java”]
int LED = 13;
int lectura_linea_1;
int lectura_linea_2;
void setup() {
pinMode(LED,OUTPUT);
Serial.begin(9600);
}
void loop() {
delay(100);
lectura_linea_1 = analogRead(A0);
lectura_linea_2 = analogRead(A1);
Serial.println(lectura_linea_1);
Serial.println(lectura_linea_2);
if(lectura_linea_1 < 30 || lectura_linea_2 < 30)
digitalWrite(LED,HIGH);
else
digitalWrite(LED,LOW);
}
[/code]
Para probar el sensor utilizaremos algún objeto que sea de color blanco y negro, nosotros hicimos una tarjeta con una hoja de papel y cinta de aislar.

Tarjeta-Blanco-Negro

Y finalmente, al probar el sensor detectando el objeto en una superficie blanca o negra, se encenderá y apagará el LED respectivamente:

prueba-sensor-linea

Una vez probados ambos sensores procedemos a colocarlos en la estructura, recomendamos usar silicón para adherirlos a la estructura y para que quede aislado el sensor para evitar hacer algún corto circuito.
El sensor debe ser colocado en el orificio de la parte inferior del chasis de sumobot.

Sensor-Linea-Estructura

[nextpage title=”4.- Detección de objetos.”]
Para detectar el enemigo se debe medir la distancia de objetos que se encuentren al frente o a los lados del sumobot, para esto usaremos los sensores de distancia sharp, estos entregan un voltaje analógico que depende de la distancia que se esté midiendo.
El sensor entrega 3 volts si el objeto se encuentra cerca (no mide distancias menores a 4cm), y disminuye el voltaje que entrega cuando la distancia va incrementando. La siguiente gráfica explica su funcionamiento:

grafica-sensor-sharp

Los sensores utilizan unos conectores especiales, estos necesitan soldarse a otros conectores para después poder conectarlos al arduino. Puedes usar unos jumpers hembra o macho, si usas hembra puedes conectar directamente a tu arduino nano, si utilizas macho puedes conectar a un protoboard.
sensor-sharp-001
Al soldar los conectores recomendamos el uso de termofit, tendrá un acabado más ajustado y resistente:
Conector-sharp-soldado
Una vez soldados los conectores se conectarán al arduino y se probará su funcionamiento. Primero conecta el sensor al arduino como en el siguiente diagrama (esquemático y dibujo en fritzing):
esquematico-sensor-sharp
conexion-sensor-sharp
El código que nos permitirá medir la distancia y enviarla al puerto serie
[code language=”java”]
// Conexiones
int sensor_distancia_1 = A0;
// Inicialización
int lectura = 0;
void setup() {
Serial.begin(9600);
Serial.println(“Iniciando lectura de sensor”);
}
// Programa
void loop() {
lectura = analogRead(sensor_distancia_1);
Serial.println(lectura);
delay(1000);
}
[/code]
Una vez programado el código abre el monitor serie y te mostrará la lectura del sensor, prueba colocar un objeto frente a él a diferentes distancias y visualiza el dato que envía el monitor serie.

[nextpage title=”5.- Control de motores.”]
Ya probados los sensores queda por probar el movimiento de los motores, los motores a utilizar funcionan con un voltaje de corriente directa, para controlar el giro y la velocidad se usará un driver de motores.
Primero soldaremos los cables a los motores, igual que con los sensores de distancia usaremos jumpers para que sea fácil conectar a los motores:
Se deben soldar los cables de manera perpendicular al motor de modo que la longitud del motor sea lo más corta posible (ahora que se ha incluido el cable).
motores-001
Una vez soldados los motores debemos soldar unos conectores macho para el driver, soldaremos loa conectores macho para conectar al protoboard.
driver-motores-001
Luego armaremos en Protoboard un circuito con el Arduino Nano, el driver de motores y los motores, el objetivo será crear un programa en el que podamos controlar los motores, su giro y su velocidad.
Conectar el driver de motores es muy simple, solo se deben conectar las alimentaciones, las entradas de control y las salidas de potencia, con el siguiente diagrama te puedes guiar:

driver-motores-002

VCC. Alimentación de 5V
GND. Tierra
AO1. Salida 1 para motor A
AO2. Salida 2 para motor A
BO1. Salida 1 para motor B
BO2. Salida 2 para motor B
VMOT. Voltaje para alimentar a los motores, se debe conectar la batería Lipo a este pin
PWMA. Entrada de control de velocidad del motor A
AIN2. Entrada 2 de control para el motor A
AIN1. Entrada 1 de control para el motor A
STBY. Entrada para detener el funcionamiento de los motores, colocar una resistencia PULL-UP a 5V
BIN1. Entrada 1 de control para el motor B
BIN2. Entrada 2 de control para el motor B
PWMB. Entrada de control de velocidad del motor B
La conexión con el arduino debe ser la siguiente:

Driver Arduino
VCC 5V
GND GND
PWMA D5
PWMB D3
AIN2 D7
AIN1 D6
BIN1 D4
BIN2 D2
Driver Batería
VMOT 9V
GND GND
Driver Motores
AO1 Motor A*
AO2 Motor A*
BO1 Motor B*
BO2 Motor B*

*No importa cual pin del motor se coloca, en caso de que se conecte al revés el resultado será que el motor girará al sentido contrario a lo esperado, eso se corregirá al final, después de haber montado del todo.
El circuito para armar un sumobot hasta ahora se debe ver de la siguiente manera:
control-motores-002
control-motores-003
Se utilizaron las líneas de alimentación del protoboard para conectar 5V y GND, el voltaje de la batería se conectará directamente en el pin del driver de motores.
Además también es conveniente agregar un interruptor para la alimentación del circuito, el interruptor debe ser de 2 posiciones, estos interruptores tienen 3 pines, debes soldar el del centro y uno e los extremos:
interruptor-001
Uno de los cables del interruptor va conectado al voltaje de la batería y el otro al punto en el que queremos alimentar el circuito.
switch-bateria-001
El circuito finalizado se debe ver de la siguiente manera:
control-motores-001
Una vez conectado todo se programará el Arduino con el siguiente código para probar los motores:
[code language=”java”]
// Conexiones
int pwma = 3;
int pwmb = 5;
int ai1 = 2;
int ai2 = 4;
int bi1 = 6;
int bi2 = 7;
// Inicialización
void setup() {
pinMode(pwma,OUTPUT);
pinMode(pwmb,OUTPUT);
pinMode(ai1,OUTPUT);
pinMode(ai2,OUTPUT);
pinMode(bi1,OUTPUT);
pinMode(bi2,OUTPUT);
analogWrite(pwma,200);
analogWrite(pwmb,200);
}
// Rutina
void loop() {
digitalWrite(ai1,HIGH);
digitalWrite(ai2,LOW);
digitalWrite(bi1,HIGH);
digitalWrite(bi2,LOW);
delay(1000);
digitalWrite(ai1,LOW);
digitalWrite(ai2,HIGH);
digitalWrite(bi1,HIGH);
digitalWrite(bi2,LOW);
delay(1000);
digitalWrite(ai1,HIGH);
digitalWrite(ai2,LOW);
digitalWrite(bi1,LOW);
digitalWrite(bi2,HIGH);
delay(1000);
digitalWrite(ai1,LOW);
digitalWrite(ai2,HIGH);
digitalWrite(bi1,LOW);
digitalWrite(bi2,HIGH);
delay(1000);
}
[/code]
¡¡¡CUIDADO!!!
Revisa muy bien que tu circuito no tenga conectado por error el voltaje de la batería con el voltaje de 5V, esto podría dañar tu computadora gravemente.
Si todo salió bien los motores deberían moverse hacia un lado y hacia el otro.
[nextpage title=”6.- Montaje de los componentes.”]
Cuando ya se han probado todos los componentes por separado lo siguiente es montar todo el circuito electrónico, sensores, motores y control en el chasis. Recomendamos el uso de silicón y tornillos, el silicón además de ayudar a fijar los componentes también les permitirá aislar los circuitos y evitar cortos circuitos.
Primero se deben montar los sensores para detectar la línea, esos deben ir colocados por dentro del chasis de modo que el sensor encaje con el orificio asignado, en el chasis, en la siguiente imagen podrán ver cómo debe quedar colocado el sensor. Para mayor comodidad recomendamos desarmar el chasis.
MiniSumo-1
Lo siguiente es colocar los sensores de distancia en la parte lateral del sumobot, en la siguiente imagen se muestra como debe quedar colocado el sensor:
MiniSumo-2
Después debemos colocar los motores, para ello utilizaremos los Brackets o Bases para micromotor Polulu, coloca la base como se muestra en la imagen:
MiniSumo-4
Y atornilla ambos motores con su base en el chasis:
MiniSumo-5
Luego coloca las llantas a los motores, para ello debes utilizar el tornillo prisionero que está en el centro de la llanta:
MiniSumo-3
Debe quedar bien alineado el tornillo con la parte plana del eje del motor para que pueda sujetarse adecuadamente:
MiniSumo-6
Antes de cerrar todo el chasis debes colocar la batería dentro del sumobot:
MiniSumo-7
Finalmente cierras el chasis del sumobot y colocas el protoboard encima del chasis del sumobot, conectas todo de acuerdo a los circuitos anteriormente vistos y está todo listo para programarlo con la aplicación final:
MiniSumo-8
MiniSumo-9
Recomendamos revisar cuidadosamente todas las conexiones, debido a que el sistema ya incluye demasiados módulos es muy fácil cometer errores.
[nextpage title=”Programación de la aplicación final”]
Para unir todas las funciones se hace un programa que revisa los sensores de línea y los sensores de distancia para tomar una decisión de hacia dónde moverse:
[code language=”java”]
// Conexiones
int pwma = 3;
int pwmb = 5;
int ai1 = 2;
int ai2 = 4;
int bi1 = 6;
int bi2 = 7;
int LED = 13;
// Variables
int lectura_linea_derecha = 0;
int lectura_linea_izquierda = 0;
int lectura_distancia_derecha = 0;
int lectura_distancia_izquierda = 0;
// Inicialización
void setup() {
pinMode(pwma,OUTPUT);
pinMode(pwmb,OUTPUT);
pinMode(ai1,OUTPUT);
pinMode(ai2,OUTPUT);
pinMode(bi1,OUTPUT);
pinMode(bi2,OUTPUT);
analogWrite(pwma,100);
analogWrite(pwmb,100);
}
// Rutina
void loop() {
lectura_linea_izquierda = analogRead(A0); // Lectura del sensor de línea izquierdo
lectura_linea_derecha = analogRead(A1); // Lectura del sensor de línea derecho
//Con este código eliminamos el ruido que pueda haber en las lecturas del sensor.
int i=0;
lectura_distancia_izquierda=0;
lectura_distancia_derecha=0;
do{
lectura_distancia_izquierda = lectura_distancia_izquierda + analogRead(A2); // Lectura de sensor de distancia izquierdo
lectura_distancia_derecha = lectura_distancia_derecha + analogRead(A3); // Lectura de sensor de distancia derecha
i=i+1;
}while(i<16);
lectura_distancia_izquierda=lectura_distancia_izquierda/i;
lectura_distancia_derecha=lectura_distancia_derecha/i;
// ¡Detección de línea por el lado izquierdo!
if(lectura_linea_izquierda < 30){
reversa();
delay(500);
derecha();
delay(100);
adelante();
}
// ¡Detección de línea por el lado derecho!
if(lectura_linea_derecha < 30){
reversa();
delay(500);
izquierda();
delay(100);
adelante();
}
// ¡Detección de objeto por el lado izquierdo!
if(lectura_distancia_izquierda > 200){
izquierda();
delay(1000);
adelante();
}
// ¡Detección de objeto por el lado derecho!
if(lectura_distancia_derecha > 200){
derecha();
delay(1000);
adelante();
}
}
void adelante(){
digitalWrite(ai1,HIGH);
digitalWrite(ai2,LOW);
digitalWrite(bi1,HIGH);
digitalWrite(bi2,LOW);
}
void derecha(){
digitalWrite(ai1,LOW);
digitalWrite(ai2,HIGH);
digitalWrite(bi1,HIGH);
digitalWrite(bi2,LOW);
}
void izquierda(){
digitalWrite(ai1,HIGH);
digitalWrite(ai2,LOW);
digitalWrite(bi1,LOW);
digitalWrite(bi2,HIGH);
}
void reversa(){
digitalWrite(ai1,LOW);
digitalWrite(ai2,HIGH);
digitalWrite(bi1,LOW);
digitalWrite(bi2,HIGH);
}
void detener(){
digitalWrite(ai1,LOW);
digitalWrite(ai2,LOW);
digitalWrite(bi1,LOW);
digitalWrite(bi2,LOW);
}
[/code]

Gracias por dejar tus comentarios si tienes dudas, si crees que este artículo le puede servir a alguien compártelo, el mundo te lo agradecerá. 🙂

Quizás de te sea de utilidad un chasis para minisumo. Es un diseño en 3D listo para descargarse, completamente gratuito. Puedes hacer clic en el enlace o en la imagen de aquí abajo. Además te compartimos otra forma de acomodar y darle forma adecuada a un minisumobot.

Chasis para minisumobot – Diseño en 3D para imprimirlo ¡YA!

 

Guía para montar un minisumobot con un chasis impreso en 3D.

Otra guía que podría ser de ayuda para la creción de tus prototipos. ¿Cómo hacer tus propias llantas de caucho de silicón para tus robots?
Da clic aquí en la imagen o link de abajo para saber más.

Cómo hacer llantas de caucho de silicón para minisumo y vehículos RC – Tutorial.

Compártelo: