Robodacta Steam

Robot Mini sumo 10x10

Conoce el Robot Mini sumo 10x10

  • KIT Robot Mini Sumo 10×10

Cod. Kit 1202 

Armar un Robot Mini Sumo 10×10 cm es un proyecto interesante y divertido, fomenta la creatividad y el desarrollo de habilidades enfocadas a la programación. Para poder competir en desafíos que pondrán a prueba tus capacidades ¡Aplica tus conocimientos armando el Robot Mini sumo 10×10 y llévalas al limite!.

El Kit cuenta con las siguientes características:

  • Altura: 86.5 mm
  • Ancho 99.5 mm
  • Largo 96.5 mm
  • Peso sin baterías: 293gr
  • Peso con baterías AA: 362gr
  • Peso con baterías cuadradas: 323gr
 

El robot puede ser programado para diferentes funciones, entre las cuales tenemos:

  • Seguidor de Línea Blanca.
  • Seguidor de Línea Negra.
  • Evasor de Obstáculos.
  • Robot Sumo Autónomo para fondo Blanco.
  • Robot Sumo Autónomo para fondo Negro.
  • Robot Bluetooth RC.
  • 4 Programas en 1. 

Antes de ensamblar el Kit verifica que el material este completo y en buen estado.

Materiales

El Kit incluye.

  • 8pzs. De acrílico negro para armar la estructura
  • 1 Tarjeta Arduino UNO R3 CH340 SMD C/cable USB
  • 1pza. Tarjeta shield con puente H L293D.
  • 2pzs. Motorreductor plástico 1:48 de doble eje con cables
  • 2pzs. Ruedas de plástico 40x40mm
  • 4pzs. Aro de goma 40x40mm
  • 1pza. Modulo sensor de líneas
  • 1pza. HC-SR04 Sensor distancia Ultrasónico
  • 1pza. Módulo Bluetooth BT-04 ó HC-06 (depende de disponibilidad).
  • 1pza. Portapilas para 4 pilas AA
  • 1pza. Conector doble para pila 9V
  • 2 pzs Tornillo M3 x 8 mm con tuerca
  • 20 pzs Tornillo M3 x 12 mm con tuerca
  • 4 pzs Tornillo M3 x 30 mm con tuerca
  • 2 pzs Pija 2.3 x 8 mm
  • 1 pza Cable JST de 5 vías
  • 1 pza Cable JST de 4 vías
 
Si detectas que el kit llego incompleto o algún componente dañado, puedes mandarnos un mensaje 

Correo: contacto@robodacta.mx

A nuestro numero de WhatsApp: (56) 3966171

¿Cómo se arma?

Ensamble 

Para ensamblar del robot observa el siguiente video en donde explicamos paso a paso el armado.  

  • Notas:
    • Antes de iniciar con el ensamble remueve el plástico protector de las piezas de acrílico. 
    • Es importante no apretar los tornillos de forma excesiva ya que podrías romper alguna de las piezas de acrílico. 
    • No retirar los cinchos que sujetan los cables de los motores ya que estos evitan que se rompan sus terminales con el movimiento.

Diagrama de Conexiones

Una vez completado el ensamble del Robot, realiza las conexiones.  A continuación te mostramos los diagramas de conexiones.

Nota importante

No pases a la siguiente sección hasta que verifiques que tu Kit esta correctamente ensamblado y cableado.

La tarjeta de tu Kit ya viene programada con el código de 4 en 1

Este es un programa que compila 4 de los programas. Los cuales son Seguidor de Linea Blanca, Evasor de Obstáculos, Sumo en fondo Negro, y Sumo RC.

En el caso del sumo RC, la aplicación para controlar el Kit es la misma, si ya la descargaste anteriormente, no es necesario descargarla de nuevo. 

Nota: Esta aplicación solo sirve para dispositivos con sistema operativo ANDROID.

¿Cómo cambiar entre programas?

Los cables son los elementos que nos ayudaran a seleccionar el código a ejecutar.

Para acceder al modo seguidor de línea blanca coloca los cables de la siguiente manera:

 

Para acceder al modo sumo autónomo para fondo negro coloca los cables de la siguiente manera:

Para acceder al modo bluetooth RC coloca los cables de la siguiente manera:

Para acceder al modo evasor de obstáculos coloca los cables de la siguiente manera:

 

¿Cómo lo vamos a programar?

Instalación Programa Arduino

Antes de cargar el programa de tu elección, instala el entorno de programación con el cual podrás subir los códigos a tu robot. 

Para esta sección preparamos un PDF el cual podrás descargar con el siguiente botón con las instrucciones detalladas de cada uno de los pasos con imágenes.  

(El siguiente PDF incluye el paso 1, 2 y 3)

En caso de que ya conozcas un poco de este proceso te dejamos a continuación la explicación corta.

Paso 1.- Descargar de driver CH341

Como uno de los pasos para la instalación de nuestro entorno será el de descargar e instalar el driver necesario para que nuestra computadora pueda reconocer el dispositivo Arduino.

Paso 2.- Descarga e instalación de Arduino  

Descarga la aplicación de Arduino con el cual podrás editar, subir y abrir los códigos. 

Paso 3.- Subir un código

En esta parte podrás subir nuestros programas al Kit Robot Mini Sumo 10×10, asi como ver su funcionamiento.

Para poder subir cualquier código considera que el Módulo Bluetooth no debe de estar conectado, de esta manera aseguramos que el código se cargue correctamente

A continuación te dejamos los diferentes códigos con los que se puede programar el Kit Robot Mini Sumo 10×10. 

Comportamiento del programa.

El Robot Mini sumo 10×10 deberá seguir una Linea Blanca en un fondo negro a través de los sensores de línea.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 10;
int sensorcenter = 11;
int sensorright = 12;

long cont1 = 0;

int l1 = 0;
int l2 = 0;
int l3 = 0;


int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;


int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 150;

void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
}

void loop()
{
l3=digitalRead(sensorleft);
l2=digitalRead(sensorcenter);
l1=digitalRead(sensorright);

if ((l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;//decremento de ciclos para salir de la memoria
}

////////////////////////////////////////////////////////////////////////////

if (l1==1 && l2==0 && l3==0 || l1==1 && l2==1 && l3==0) //left turn
{
izquierda();
}
else if (l1==0 && l2==0 && l3==1 || l1==0 && l2==1 && l3==1) //right turn
{
derecha();
}
else if (l1==0 && l2==1 && l3==0) //go forward straight
{
adelante();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}
else
{
if(l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}

///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3; //memory variables
}

long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}


void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

El Robot Mini sumo 10×10 deberá seguir una Linea Negra en un fondo blanco a través de los sensores de línea.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 10;
int sensorcenter = 11;
int sensorright = 12;

long cont1 = 0;

int l1 = 0;
int l2 = 0;
int l3 = 0;


int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;


int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 200;

void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
}

void loop()
{
l3=digitalRead(sensorleft);
l2=digitalRead(sensorcenter);
l1=digitalRead(sensorright);

if ((l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0) && cont1 > 0) //feedback when comes all sensor on white
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;//decremento de ciclos para salir de la memoria
}

////////////////////////////////////////////////////////////////////////////

if (l1==0 && l2==1 && l3==1 || l1==0 && l2==0 && l3==1) //left turn
{
izquierda();
}
else if (l1==1 && l2==1 && l3==0 || l1==1 && l2==0 && l3==0) //right turn
{
derecha();
}
else if (l1==1 && l2==0 && l3==1) //go forward straight
{
adelante();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}
else
{
if(l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}

///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3; //memory variables
}

long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}


void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, vel);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

El Robot Mini sumo 10×10 deberá evadir obstáculos los cuales podrá detectar de frente, lo cual hará que cambie de dirección

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 12;
int sensorcenter = 11;
int sensorright = 10;

int l1 = 0;
int l2 = 0;
int l3 = 0;


int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;


int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 200;

void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);
}

void loop()
{
l1=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l3=analogRead(sensorright);

if(distancia()<15){
alto();
delay(500);
atras();
delay(700);
derecha();
delay(500);
adelanter();
}

else {
adelanter();
}

}

long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}


void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, vel);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

El Robot Mini sumo 10×10 girara en hacia la derecha en busca de un contrincante, en el momento en que detecte un objetivo, lo embestirá gracias al sensor ultrasónico, siempre y cuando el kit se encuentre en algún área con fondo Blanco, esto es gracias a los sensores de línea.

Si alguno de los sensores de linea se encuentra en alguna área con fondo negro, el Sumo retrocederá y girara con el fin de evitar salirse del área con fondo Blanco, posteriormente volverá a a buscar algún objetivo.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 12;
int sensorcenter = 11;
int sensorright = 10;

int l1 = 0;
int l2 = 0;
int l3 = 0;

int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;

int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 200;

void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);

delay(2000);
adelanter();
delay(1000);
alto();
delay(700);
}

void loop()
{
l1=digitalRead(sensorleft);
l2=digitalRead(sensorcenter);
l3=digitalRead(sensorright);

if(distancia()<150){
if(l1==0 || l2==0 || l3==0)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{

adelanter();
}
}
else
{
if(l1==0 || l2==0 || l3==0)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
derecha();
}
}

}

long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}

void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, vel);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

El Robot Mini sumo 10×10 girara en hacia la derecha en busca de un contrincante, en el momento en que detecte un objetivo, lo embestirá gracias al sensor ultrasónico, siempre y cuando el kit se encuentre en algún área con fondo Negro, esto es gracias a los sensores de línea.

Si alguno de los sensores de linea se encuentra en alguna área con fondo blanco, el Sumo retrocederá y girara con el fin de evitar salirse del área con fondo Negro, posteriormente volverá a a buscar algún objetivo.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 12;
int sensorcenter = 11;
int sensorright = 10;

int l1 = 0;
int l2 = 0;
int l3 = 0;

int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;

int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 200;

void setup()
{
Serial.begin(9600);
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorright, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorleft, INPUT);

delay(2000);
adelanter();
delay(1000);
alto();
delay(700);
}

void loop()
{
l1=digitalRead(sensorleft);
l2=digitalRead(sensorcenter);
l3=digitalRead(sensorright);

if(distancia()<150){
if(l1==1 || l2==1 || l3==1)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{

adelanter();
}
}
else
{
if(l1==1 || l2==1 || l3==1)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
derecha();
}
}

}

long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}

void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, vel);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

Podrás controlar el Robot Mini sumo 10×10 por medio de conexión bluetooth atreves de una aplicación compatible con Android. 

Nota: Esta aplicación solo sirve para dispositivos con sistema operativo ANDROID.

En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = 12;
int sensorcenter = 11;
int sensorright = 10;

int l1 = 1;
int l2 = 1;
int l3 = 1;

int f1 = 0;
int f2 = 0;
int f3 = 0;

int f4 = 0;
int f5 = 0;
int f6 = 0;

long cont1 = 0;
int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

char valorBoton;
char penultimo = ‘n’;
char antepenultimo = ‘m’;
char vali = ‘b’;
int vel = 255;

void setup()
{
Serial.begin(9600);

pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
pinMode(echo, INPUT);
pinMode(triger, OUTPUT);
digitalWrite(triger, LOW);

digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);

pinMode(sensorleft, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorright, INPUT);

}


void loop()
{

if(Serial.available() > 0)
{
valorBoton = Serial.read();
//Penultimo = n neutral antepenultimo = m neutral
//Donde se quiera una izquierda se debe poner derecha y al reves
//3 señales o 3 botones al mismo tiempo
if((antepenultimo == ‘w’ && penultimo == ‘d’ && valorBoton == ‘h’)
|| (antepenultimo == ‘w’ && penultimo == ‘a’ && valorBoton == ‘f’))//wdh o waf
{
vali = ‘i’;
adelante();
penultimo = ‘n’;
antepenultimo = ‘m’;
}
else if((antepenultimo == ‘s’ && penultimo == ‘d’ && valorBoton == ‘h’)
|| (antepenultimo == ‘s’ && penultimo == ‘a’ && valorBoton == ‘f’))//sdh o saf
{
vali = ‘k’;
atras();
penultimo = ‘n’;
antepenultimo = ‘m’;
}
else if((antepenultimo == ‘a’ && penultimo == ‘w’ && valorBoton == ‘t’)
|| (antepenultimo == ‘a’ && penultimo == ‘s’ && valorBoton == ‘g’))//awt o asg
{
vali = ‘j’;
derecha();
penultimo = ‘n’;
antepenultimo = ‘m’;
}
else if((antepenultimo == ‘d’ && penultimo == ‘w’ && valorBoton == ‘t’)
|| (antepenultimo == ‘d’ && penultimo == ‘s’ && valorBoton == ‘g’))//dwt o dsg
{
vali = ‘l’;
izquierda();
penultimo = ‘n’;
antepenultimo = ‘m’;
}
else if(vali == ‘i’)//Validacion no se suelta adelante
{
adelante();
if(valorBoton == ‘t’)
{
vali = ‘b’;
alto();
}
else if(valorBoton == ‘d’) { //d
izquierda();
}
else if(valorBoton == ‘a’) { //a
derecha();
}
}
else if(vali == ‘k’)//Validacion no se suelta atras
{
atras();
if(valorBoton == ‘g’)
{
vali = ‘b’;
alto();
}
else if(valorBoton == ‘d’) { //d
atrasderecha();
}
else if(valorBoton == ‘a’) { //a
atrasizquierda();
}
}
else if(vali == ‘j’)//Validacion no se suelta izquierda
{
derecha();
if(valorBoton == ‘f’)
{
vali = ‘b’;
alto();
}
else if(valorBoton == ‘w’) { //w
derecha();
}
else if(valorBoton == ‘a’) { //s
atrasderecha();
}
}
else if(vali == ‘l’)//Validacion no se suelta derecha
{
izquierda();
if(valorBoton == ‘h’)
{
vali = ‘b’;
alto();
}
else if(valorBoton == ‘w’) { //w
izquierda();
}
else if(valorBoton == ‘a’) { //s
atrasizquierda();
}
}

//Combinaciones de dos botones:
else if(valorBoton == ‘w’) { //w
adelante();
}
else if(valorBoton == ‘s’) { //s
atras();
}
else if(penultimo != ‘s’ && valorBoton == ‘a’) { //a
derecha();
}
else if(penultimo != ‘s’ && valorBoton == ‘d’) { //d
izquierda();
}
else if(penultimo == ‘w’ && valorBoton == ‘a’) { //wa
derecha();
}
else if(penultimo == ‘w’ && valorBoton == ‘d’) { //wd
izquierda();
}
else if(penultimo == ‘w’ && valorBoton == ‘f’) { //wf
adelante();
}
else if(penultimo == ‘w’ && valorBoton == ‘h’) { //wh
adelante();
}
else if(penultimo == ‘t’ && valorBoton == ‘a’) { //ta
derecha();
}
else if(penultimo == ‘t’ && valorBoton == ‘d’) { //td
izquierda();
}
else if(penultimo == ‘s’ && valorBoton == ‘a’) { //sa
atrasizquierda();
}
else if(penultimo == ‘s’ && valorBoton == ‘d’) { //sd
atrasderecha();
}
else if(penultimo == ‘s’ && valorBoton == ‘f’) { //sf
atras();
}
else if(penultimo == ‘s’ && valorBoton == ‘h’) { //sh
atras();
}
else if(penultimo == ‘g’ && valorBoton == ‘a’) { //ga
atrasderecha();
}
else if(penultimo == ‘g’ && valorBoton == ‘d’) { //gd
atrasizquierda();
}
//Espejo
else if(penultimo == ‘a’ && valorBoton == ‘w’) { //aw
derecha();
}
else if(penultimo == ‘d’ && valorBoton == ‘w’) { //dw
izquierda();
}
else if(penultimo == ‘f’ && valorBoton == ‘w’) { //fw
adelante();
}
else if(penultimo == ‘h’ && valorBoton == ‘w’) { //hw
adelante();
}
else if(penultimo == ‘a’ && valorBoton == ‘t’) { //at
derecha();
}
else if(penultimo == ‘d’ && valorBoton == ‘t’) { //dt
izquierda();
}
else if(penultimo == ‘a’ && valorBoton == ‘s’) { //as
atrasderecha();
}
else if(penultimo == ‘d’ && valorBoton == ‘s’) { //ds
atrasizquierda();
}
else if(penultimo == ‘f’ && valorBoton == ‘s’) { //fs
atras();
}
else if(penultimo == ‘h’ && valorBoton == ‘s’) { //hs
atras();
}
else if(penultimo == ‘a’ && valorBoton == ‘g’) { //ag
atrasderecha();
}
else if(penultimo == ‘d’ && valorBoton == ‘g’) { //dg
atrasizquierda();
}

else {
//Si se presionan más de dos botones o no se presionan los adecuados
alto();
penultimo = ‘n’;
antepenultimo = ‘m’;

}
//Actualizar la penultimo

Serial.print(antepenultimo);
Serial.print(” “);
Serial.print(penultimo);
Serial.print(” “);
Serial.print(valorBoton);
Serial.print(” “);
Serial.print(vali);
Serial.println(” “);


antepenultimo = penultimo;
penultimo = valorBoton;
/*if(valorBoton != penultimo) {
penultimo = valorBoton;*/

}
}
long distancia()
{
long t;
long d;

digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);

t = pulseIn(echo, HIGH);
d = t / 59;
if (d <= 1 || d >= 25)
{
d = 1000;
}
delay(10);
return d;
}


void alto()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0);//PWM
analogWrite(motB0,0); //PWM
digitalWrite(motB1, 0);
}

void atras()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 1);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 1);
}

void adelante()
{
digitalWrite(motA0, 1);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);
}

void adelanter()
{
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 1); //PWM
digitalWrite(motB1, 0);
}

void derecha()
{
digitalWrite(motA0, vel);
analogWrite(motA1, 255-vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

void atrasderecha()
{
digitalWrite(motA0, 0);
digitalWrite(motA1, 0); //PWM
analogWrite(motB0, 255-vel); //PWM
digitalWrite(motB1, 1);
}

void izquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, 0); //PWM
analogWrite(motB0, vel); //PWM
digitalWrite(motB1, 0);

}

void atrasizquierda()
{
digitalWrite(motA0, 0);
analogWrite(motA1, vel); //PWM
analogWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

Comportamiento del programa.

Este es un programa que compila 4 de los programas anteriores, siendo el Seguidor de Linea Blanca, Evasor de Obstáculos, Sumo en fondo Negro, y Sumo RC.

En el caso del sumo RC, la aplicación para controlar el Kit es la misma, si ya la descargaste anteriormente, no es necesario descargarla de nuevo. 

Nota: Esta aplicación solo sirve para dispositivos con sistema operativo ANDROID.

¿Cómo cambiar entre programas?

Los cables son los elementos que nos ayudaran a seleccionar el código a ejecutar.

Para acceder al modo seguidor de línea blanca coloca los cables de la siguiente manera:

 

Para acceder al modo sumo autónomo para fondo negro coloca los cables de la siguiente manera:

Para acceder al modo bluetooth RC coloca los cables de la siguiente manera:

Para acceder al modo evasor de obstáculos coloca los cables de la siguiente manera:

 

int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int lec0 = A0;
int lec1 = A2;

long cont1 = 0;

int sensorleft = 10;
int sensorcenter = 11;
int sensorright = 12;
 
int l1 = 0;
int l2 = 0;
int l3 = 0;


int f1 = 0;
int f2 = 0;
int f3 = 0;
 
int f4 = 0;
int f5 = 0;
int f6 = 0;


int buzzer = 6; //El pin al que se conecta el buzzer es el 6

int echo = 8;
int triger = 7;

int vel = 200;


char valorBoton;
char penultimo = ‘n’;
char antepenultimo = ‘m’;
char vali = ‘b’;

void setup()
{
  Serial.begin(9600);
  pinMode(motA0, OUTPUT);
  pinMode(motA1, OUTPUT);
  pinMode(motB0, OUTPUT);
  pinMode(motB1, OUTPUT);
  pinMode(buzzer, OUTPUT); // Pin 6 declarado como salida
  pinMode(echo, INPUT);
  pinMode(triger, OUTPUT);
  digitalWrite(triger, LOW);
 
  digitalWrite(motA0, LOW);
  digitalWrite(motA1, LOW);
  digitalWrite(motB0, LOW);
  digitalWrite(motB1, LOW);
 

  pinMode(sensorright, INPUT);
  pinMode(sensorcenter, INPUT);
  pinMode(sensorleft, INPUT);
  pinMode(lec0,INPUT_PULLUP);
  pinMode(lec1,INPUT_PULLUP);

  delay(1500); // tarda 1.5s en iniciar cualquier programa

}

void loop()
{
l3=digitalRead(sensorleft);
l2=digitalRead(sensorcenter);
l1=digitalRead(sensorright);

if(digitalRead(lec0)==0){
    if(digitalRead(lec1)==0){
      // A1=0 A2=0 Seguidor de linea
      // Para conseguir que sea linea blanca, cambiar al incio del “void loop”: l3 por l1, y l1 por l3
      /*
      Ejemplo
      l1=analogRead(sensorleft);
      l2=analogRead(sensorcenter);
      l3=analogRead(sensorright);
      ESTO ES PARA LINEA NEGRA
      */

    if ((l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0) && cont1 > 0) //feedback when comes all sensor on white
      {
        l1 = f1;
        l2 = f2;
        l3 = f3;
        cont1=cont1-1;//decremento de ciclos para salir de la memoria
      }

      ////////////////////////////////////////////////////////////////////////////
     
      if (l1==1 && l2==0 && l3==0 || l1==1 && l2==1 && l3==0) //left turn
      {
        izquierda();
      }
      else if (l1==0 && l2==0 && l3==1 || l1==0 && l2==1 && l3==1) //right turn
      {
        derecha();
      }
      else if (l1==0 && l2==1 && l3==0) //go forward straight
      {
        adelante();
        cont1 = 20000; // Numero de ciclos para mantener la memoria
      }
      else
      {
        if(l1==1 && l2==1 && l3==1 || l1==0 && l2==0 && l3==0)  //Detener en caso de 3 sensores en el mismo color
        {
          alto();
        }
      }
     
      ///////////////////////////////////////////////////////////////////
      f1 = l1;
      f2 = l2;
      f3 = l3;      //memory variables

    } else{
      //A1=0 A2=1 SUMO
      // Para volverlo sumo para fondo blanco cambiar los valores del if de la siguiente manera
      //l1 > 550 && l2 > 550  && l3 > 550
     if(distancia()<150){
if(l1==1 || l2==1 || l3==1)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{

adelanter();
}
}
else
{
if(l1==1 || l2==1 || l3==1)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
derecha();
}
}

     
    }

  }  else{
         if(digitalRead(lec1)==0){
        //A1=1 A2=0  Evasor

        if(distancia()<15){
        alto();
        delay(500);
        atras();
        delay(700);
        derecha();
        delay(500);
        adelanter();
        }

        else {
        adelanter();
        }

        } else{
        //A1=1 A2=1 RC
       
        if(Serial.available() > 0)
      {
        valorBoton = Serial.read();
        //Penultimo = n neutral antepenultimo = m neutral
        //Donde se quiera una izquierda se debe poner derecha y al reves
        //3 señales o 3 botones al mismo tiempo
        if((antepenultimo == ‘w’ && penultimo == ‘d’ && valorBoton == ‘h’)
                  || (antepenultimo == ‘w’ && penultimo == ‘a’ && valorBoton == ‘f’))//wdh o waf
        {
          vali = ‘i’;
          adelante();
          penultimo = ‘n’;
          antepenultimo = ‘m’;
        }
        elseif((antepenultimo == ‘s’ && penultimo == ‘d’ && valorBoton == ‘h’)
                  || (antepenultimo == ‘s’ && penultimo == ‘a’ && valorBoton == ‘f’))//sdh o saf
        {
          vali = ‘k’;
          atras();
          penultimo = ‘n’;
          antepenultimo = ‘m’;
        }
        elseif((antepenultimo == ‘a’ && penultimo == ‘w’ && valorBoton == ‘t’)
                  || (antepenultimo == ‘a’ && penultimo == ‘s’ && valorBoton == ‘g’))//awt o asg
        {
          vali = ‘j’;
          derecha();
          penultimo = ‘n’;
          antepenultimo = ‘m’;
        }
        elseif((antepenultimo == ‘d’ && penultimo == ‘w’ && valorBoton == ‘t’)
                  || (antepenultimo == ‘d’ && penultimo == ‘s’ && valorBoton == ‘g’))//dwt o dsg
        {
          vali = ‘l’;
          izquierda();
          penultimo = ‘n’;
          antepenultimo = ‘m’;
        }
        else if(vali == ‘i’)//Validacion no se suelta adelante
        {
          adelante();
          if(valorBoton == ‘t’)
          {
            vali = ‘b’;
            alto();
          }
          else if(valorBoton == ‘d’) { //d
            izquierda();
          }
          else if(valorBoton == ‘a’) { //a
            derecha();
          }
        }
        else if(vali == ‘k’)//Validacion no se suelta atras
        {
          atras();
          if(valorBoton == ‘g’)
          {
            vali = ‘b’;
            alto();
          }
          else if(valorBoton == ‘d’) { //d
            atrasderecha();
          }
          else if(valorBoton == ‘a’) { //a
            atrasizquierda();
          }
        }
        else if(vali == ‘j’)//Validacion no se suelta izquierda
        {
          derecha();
          if(valorBoton == ‘f’)
          {
            vali = ‘b’;
            alto();
          }
          else if(valorBoton == ‘w’) { //w
            derecha();
          }
          else if(valorBoton == ‘a’) { //s
            atrasderecha();
          }
        }
        else if(vali == ‘l’)//Validacion no se suelta derecha
        {
          izquierda();
          if(valorBoton == ‘h’)
          {
            vali = ‘b’;
            alto();
          }
          else if(valorBoton == ‘w’) { //w
            izquierda();
          }
          else if(valorBoton == ‘a’) { //s
            atrasizquierda();
          }
        }
       
        //Combinaciones de dos botones:
        else if(valorBoton == ‘w’) { //w
          adelante();
        }
        else if(valorBoton == ‘s’) { //s
          atras();
        }
        else if(penultimo != ‘s’ && valorBoton == ‘a’) { //a
          derecha();
        }
        else if(penultimo != ‘s’ && valorBoton == ‘d’) { //d
          izquierda();
        }
        else if(penultimo == ‘w’ && valorBoton == ‘a’) { //wa
          derecha();
        }
        else if(penultimo == ‘w’ && valorBoton == ‘d’) { //wd
          izquierda();
        }
        else if(penultimo == ‘w’ && valorBoton == ‘f’) { //wf
          adelante();
        }
        else if(penultimo == ‘w’ && valorBoton == ‘h’) { //wh
          adelante();
        }
        else if(penultimo == ‘t’ && valorBoton == ‘a’) { //ta
          derecha();
        }
        else if(penultimo == ‘t’ && valorBoton == ‘d’) { //td
          izquierda();
        }
        else if(penultimo == ‘s’ && valorBoton == ‘a’) { //sa
          atrasizquierda();
        }
        else if(penultimo == ‘s’ && valorBoton == ‘d’) { //sd
          atrasderecha();
        }
        else if(penultimo == ‘s’ && valorBoton == ‘f’) { //sf
          atras();
        }
        else if(penultimo == ‘s’ && valorBoton == ‘h’) { //sh
          atras();
        }
        else if(penultimo == ‘g’ && valorBoton == ‘a’) { //ga
          atrasderecha();
        }
        else if(penultimo == ‘g’ && valorBoton == ‘d’) { //gd
          atrasizquierda();
        }
        //Espejo
        else if(penultimo == ‘a’ && valorBoton == ‘w’) { //aw
          derecha();
        }
        else if(penultimo == ‘d’ && valorBoton == ‘w’) { //dw
          izquierda();
        }
        else if(penultimo == ‘f’ && valorBoton == ‘w’) { //fw
          adelante();
        }
        else if(penultimo == ‘h’ && valorBoton == ‘w’) { //hw
          adelante();
        }
        else if(penultimo == ‘a’ && valorBoton == ‘t’) { //at
          derecha();
        }
        else if(penultimo == ‘d’ && valorBoton == ‘t’) { //dt
          izquierda();
        }
        else if(penultimo == ‘a’ && valorBoton == ‘s’) { //as
          atrasderecha();
        }
        else if(penultimo == ‘d’ && valorBoton == ‘s’) { //ds
          atrasizquierda();
        }
        else if(penultimo == ‘f’ && valorBoton == ‘s’) { //fs
          atras();
        }
        else if(penultimo == ‘h’ && valorBoton == ‘s’) { //hs
          atras();
        }
        else if(penultimo == ‘a’ && valorBoton == ‘g’) { //ag
          atrasderecha();
        }
        else if(penultimo == ‘d’ && valorBoton == ‘g’) { //dg
          atrasizquierda();
        }
       
        else {
          //Si se presionan más de dos botones o no se presionan los adecuados
          alto();
          penultimo = ‘n’;
          antepenultimo = ‘m’;
         
        }
        //Actualizar la penultimo

        Serial.print(antepenultimo);
        Serial.print(”  “);
        Serial.print(penultimo);
        Serial.print(”  “);
        Serial.print(valorBoton);
        Serial.print(”  “);
        Serial.print(vali);
        Serial.println(”  “);
       
       
        antepenultimo = penultimo;
        penultimo = valorBoton;
        /*if(valorBoton != penultimo) {
          penultimo = valorBoton;*/
     
      }

        }

  }

}

long distancia()
{
  long t;
  long d;

  digitalWrite(triger, HIGH);
  delayMicroseconds(10);
  digitalWrite(triger, LOW);

  t = pulseIn(echo, HIGH);
  d = t / 59;
  if (d <= 1 || d >= 25)
  {
    d = 1000;
  }
  delay(10);
  return d;
}


void alto()
{
  digitalWrite(motA0, 0);
  analogWrite(motA1, 0);//PWM
  analogWrite(motB0,0); //PWM
  digitalWrite(motB1, 0);
}

void atras()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 1);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 1);
}

void adelante()
{
  digitalWrite(motA0, 1);
  analogWrite(motA1, 255-vel);  //PWM
  analogWrite(motB0, vel); //PWM
  digitalWrite(motB1, 0);
}

void adelanter()
{
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0);  //PWM
  digitalWrite(motB0, 1); //PWM
  digitalWrite(motB1, 0);
}

void derecha()
{
  digitalWrite(motA0, vel);
  analogWrite(motA1, 255-vel); //PWM
  analogWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0); //PWM
  analogWrite(motB0, 255-vel); //PWM
  digitalWrite(motB1, 1);
}

void izquierda()
{
  digitalWrite(motA0, 0);
  analogWrite(motA1, 0); //PWM
  analogWrite(motB0, vel); //PWM
  digitalWrite(motB1, 0);

}

void atrasizquierda()
{
  digitalWrite(motA0, 0);
  analogWrite(motA1, vel); //PWM
  analogWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}