Tutorial Sumobot

En este tutorial 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 ¡Comenzamos!

 

1.- Lista de 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.

 

2.- 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.

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

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

Vin	5V
GND	GND
Vout	D2

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.

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

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.

 

3.- 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:

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.

Al soldar los conectores recomendamos el uso de termofit, tendrá un acabado más ajustado y resistente:

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):

 

 

 

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.

 

4.- 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).

Una vez soldados los motores debemos soldar unos conectores macho para el driver, soldaremos loa conectores macho para conectar al protoboard.

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:

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:


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:

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.

El circuito finalizado se debe ver de la siguiente manera:

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.

 

5.- 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.

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:

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:

Y atornilla ambos motores con su base en el chasis:

Luego coloca las llantas a los motores, para ello debes utilizar el tornillo prisionero que está en el centro de la llanta:

Debe quedar bien alineado el tornillo con la parte plana del eje del motor para que pueda sujetarse adecuadamente:

Antes de cerrar todo el chasis debes colocar la batería dentro del sumobot:

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:


Recomendamos revisar cuidadosamente todas las conexiones, debido a que el sistema ya incluye demasiados módulos es muy fácil cometer errores.

 

6.- 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á. 🙂