Imagen 1
Imagen 2
Imagen 3
Imagen 4
Imagen 5
Imagen 6

Conoce el Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos

KIT Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos.

Cod. Kit 1201

Se trata de 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 Programable Sumo, Seguidor de Línea y Evasor Obstáculos y llévalas al limite!.

El Kit cuenta con las siguientes características:

  • Altura: 53 mm
  • Ancho 175 mm
  • Largo 215 mm

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.

  • 1pzs. Estructura principal de acrílico.
  • 1pza. Alerón de acrílico.
  • 2pzs. Soporte de alerón de acrílico.
  • 3pzs. Separador de acrílico.
  • 4pzs. Soporte tipo T de acrílico.
  • 1pza. Soporte de sensor ultra sónico de acrílico.
  • 1pza. Pala de acrílico.
  • 15pzs. Bujes de acrílico.
  • 1pza. Tarjeta Arduino NANO v3 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 65x25mm
  • 1pza. Roll on
  • 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. Porta pilas para 4 pilas A.
  • 2pzs. Tornillo M3 x 8 mm con tuerca.
  • 7pzs. Tornillo M3 x 12 mm con tuerca.
  • 4pzs. Tornillo M3 x 30 mm con tuerca.
  • 6pzs. Tornillo 1/8″ x 3/4″
  • 2pzs. Tornillo 1/8″ x 1/2″
  • 1pza. Cable JST de 5 vías
  • 1pza. 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) 396617165

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

Comportamiento del programa
Comportamiento del programa

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?

Seguidor de Linea Blanca

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

Seguidor de Linea Blanca
Sumo Autónomo para Fondo Negro

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

Sumo Autónomo para Fondo Negro
Sumo Bluetooth

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

Sumo Bluetooth
Evasor de Obstáculos

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

Evasor de Obstáculos

¿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 Programable Sumo, Seguidor de Línea y Evasor Obstáculos, asi como ver su funcionamiento.

A continuación te dejamos los diferentes códigos con los que se puede programar el Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos.

Antes de subir cualquier código, RETIRA EL MODULO BLUETOOTH.

Seguidor de Linea Blanca

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos. 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);

if ((l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550 ) && 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 > 550 && l2 < 550 && l3 < 550 || l1 > 550 && l2 > 550 && l3 < 550)
{
derecha();
}
else if (l1 < 550 && l2 < 550 && l3 > 550 || l1 < 550 && l2 > 550 && l3 > 550) 
{
izquierda();
}
else if (l1 < 550 && l2 > 550 && l3 < 550) 
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550) //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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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


void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Seguidor de Linea Negra

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);

if ((l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550 ) && 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 < 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 > 550) 
{
derecha();
}
else if (l1 > 550 && l2 > 550 && l3 < 550 || l1 > 550 && l2 < 550 && l3 < 550) 
{
izquierda();
}
else if (l1 > 550 && l2 < 550 && l3 > 550) 
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550) //Detener en caso de 3 sensores en el mismo color
{
alto();
}
}

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

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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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


void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Evasor de Obstáculos

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

}

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

void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Robot Sumo Autónomo para Fondo Blanco

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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 línea 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 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);

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

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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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

void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Robot Sumo Autónomo para Fondo Negro

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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 línea 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 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);

if(distancia()<150){
if(l1 > 550 || l2 > 550|| l3 > 550)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
adelanter();
}
}
else
{
if(l1 > 550 || l2 > 550 || l3 > 550)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
adelantes();
}
}
}

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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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

void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Robot Sumo Autónomo Sin Bordes

Comportamiento del programa.

El Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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.

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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int lec0=A2;
int lec1=A1;

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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;

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);
}

void loop()
{
l3=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);
if(distancia()<150){
adelanter();
}
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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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

void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
Robot Sumo Bluetooth
Robot Sumo Bluetooth

Comportamiento del programa.

Podrás controlar el Robot Programable Sumo, Seguidor de Línea y Evasor Obstáculos 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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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;

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);
}

void loop()
{
l3=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);
      if(Serial.available() > 0)
      { 
        valorBoton = Serial.read();
        if((antepenultimo == 'w' && penultimo == 'd' && valorBoton == 'h') 
                  || (antepenultimo == 'w' && penultimo == 'a' && valorBoton == 'f'))//wdh o waf
        {
          vali = 'i';
          adelanter();
          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';
          izquierda();
          penultimo = 'n';
          antepenultimo = 'm';
        } 
        else if((antepenultimo == 'd' && penultimo == 'w' && valorBoton == 't') 
                  || (antepenultimo == 'd' && penultimo == 's' && valorBoton == 'g'))//dwt o dsg
        {
          vali = 'l';
          derecha();
          penultimo = 'n';
          antepenultimo = 'm';
        } 
        else if(vali == 'i')//Validacion no se suelta adelante
        {
          adelanter();
          if(valorBoton == 't')
          {
            vali = 'b';
            alto();
          }
          else if(valorBoton == 'd') { //d
            derecha();
          }
          else if(valorBoton == 'a') { //a
            izquierda();
          }
        }
        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
        {
          izquierda();
          if(valorBoton == 'f')
          {
            vali = 'b';
            alto();
          }
          else if(valorBoton == 'w') { //w
            izquierda();
          }
          else if(valorBoton == 'a') { //s
            atrasderecha();
          }
        }
        else if(vali == 'l')//Validacion no se suelta derecha
        {
          derecha();
          if(valorBoton == 'h')
          {
            vali = 'b';
            alto();
          }
          else if(valorBoton == 'w') { //w
            derecha();
          }
          else if(valorBoton == 'a') { //s
            atrasizquierda();
          }
        }
        
        //Combinaciones de dos botones:
        else if(valorBoton == 'w') { //w
          adelanter();
        }
        else if(valorBoton == 's') { //s
          atras();
        }
        else if(penultimo != 's' && valorBoton == 'a') { //a
          izquierda();
        }
        else if(penultimo != 's' && valorBoton == 'd') { //d
          derecha();
        }
        else if(penultimo == 'w' && valorBoton == 'a') { //wa
          izquierda();
        }
        else if(penultimo == 'w' && valorBoton == 'd') { //wd
          derecha();
        }
        else if(penultimo == 'w' && valorBoton == 'f') { //wf
          adelanter();
        }
        else if(penultimo == 'w' && valorBoton == 'h') { //wh
          adelanter();
        }
        else if(penultimo == 't' && valorBoton == 'a') { //ta
          izquierda();
        }
        else if(penultimo == 't' && valorBoton == 'd') { //td
          derecha();
        }
        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
          izquierda();
        }
        else if(penultimo == 'd' && valorBoton == 'w') { //dw
          derecha();
        }
        else if(penultimo == 'f' && valorBoton == 'w') { //fw
          adelanter();
        }
        else if(penultimo == 'h' && valorBoton == 'w') { //hw
          adelanter();
        }
        else if(penultimo == 'a' && valorBoton == 't') { //at
          izquierda();
        }
        else if(penultimo == 'd' && valorBoton == 't') { //dt
          derecha();
        }
        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);
  digitalWrite(motA1, 0);//PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}

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

void adelante()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 50);  //PWM
  analogWrite(motB1, 50); //PWM
  digitalWrite(motB0, 1);
} 

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

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

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

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

}

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

void atrasizquierda(){
  digitalWrite(motA0, 1);
  digitalWrite(motA1, 0); //PWM
  digitalWrite(motB0, 0); //PWM
  digitalWrite(motB1, 0);
}
4 programas en 1
4 programas en 1

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.

Seguidor de Linea Blanca

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

Seguidor de Linea Blanca
Sumo Autónomo para Fondo Negro

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

Sumo Autónomo para Fondo Negro
Sumo Bluetooth

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

Sumo Bluetooth
Evasor de Obstáculos

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

Evasor de Obstáculos

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.

Ver Código
int motB0 = 2;
int motB1 = 3; //PWM
int motA1 = 4;
int motA0 = 5; //PWM

int lec0=A2;
int lec1=A1;

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;

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;

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);}

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

if(digitalRead(lec0)==0){
if(digitalRead(lec1)==0){
// Seguidor de linea blanca
if ((l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550 ) && 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 > 550 && l2 < 550 && l3 < 550)
{
derecha();
}
else if (l1 < 550 && l2 < 550 && l3 > 550)
{
izquierda();
}
else if (l1 < 550 && l2 > 550 && l3 < 550)
{
adelanter();
cont1 = 20000; // Numero de ciclos para mantener la memoria
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550) //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 > 550 || l2 > 550|| l3 > 550)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
adelanter();
}
}
else
{
if(l1 > 550 || l2 > 550 || l3 > 550)
{
alto();
delay(1000);
atras();
delay(1000);
derecha();
delay(700);
}
else{
adelantes();
}
}
}

} 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();
if((antepenultimo == 'w'
 && penultimo == 'd'
 && valorBoton == 'h'
)
|| (antepenultimo == 'w'
 && penultimo == 'a'
 && valorBoton == 'f'
))//wdh o waf
{
vali = 'i';
adelanter();
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'
;
izquierda();
penultimo = 'n'
;
antepenultimo = 'm'
;
}
else if((antepenultimo == 'd'
 && penultimo == 'w'
 && valorBoton == 't'
)
|| (antepenultimo == 'd'
 && penultimo == 's'
 && valorBoton == 'g'
))//dwt o dsg
{
vali = 'l'
;
derecha();
penultimo = 'n'
;
antepenultimo = 'm'
;
}
else if(vali == 'i'
)//Validacion no se suelta adelante
{
adelanter();
if(valorBoton == 't'
)
{
vali = 'b'
;
alto();
}
else if(valorBoton == 'd'
) { //d
derecha();
}
else if(valorBoton == 'a'
) { //a
izquierda();
}
}
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
{
izquierda();
if(valorBoton == 'f'
)
{
vali = 'b'
;
alto();
}
else if(valorBoton == 'w'
) { //w
izquierda();
}
else if(valorBoton == 'a'
) { //s
atrasderecha();
}
}
else if(vali == 'l'
)//Validacion no se suelta derecha
{
derecha();
if(valorBoton == 'h'
)
{
vali = 'b'
;
alto();
}
else if(valorBoton == 'w'
) { //w
derecha();
}
else if(valorBoton == 'a'
) { //s
atrasizquierda();
}
}

//Combinaciones de dos botones:
else if(valorBoton == 'w'
) { //w
adelanter();
}
else if(valorBoton == 's'
) { //s
atras();
}
else if(penultimo != 's'
 && valorBoton == 'a'
) { //a
izquierda();
}
else if(penultimo != 's'
 && valorBoton == 'd'
) { //d
derecha();
}
else if(penultimo == 'w'
 && valorBoton == 'a'
) { //wa
izquierda();
}
else if(penultimo == 'w'
 && valorBoton == 'd'
) { //wd
derecha();
}
else if(penultimo == 'w'
 && valorBoton == 'f'
) { //wf
adelanter();
}
else if(penultimo == 'w'
 && valorBoton == 'h'
) { //wh
adelanter();
}
else if(penultimo == 't'
 && valorBoton == 'a'
) { //ta
izquierda();
}
else if(penultimo == 't'
 && valorBoton == 'd'
) { //td
derecha();
}
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
izquierda();
}
else if(penultimo == 'd'
 && valorBoton == 'w'
) { //dw
derecha();
}
else if(penultimo == 'f'
 && valorBoton == 'w'
) { //fw
adelanter();
}
else if(penultimo == 'h'
 && valorBoton == 'w'
) { //hw
adelanter();
}
else if(penultimo == 'a'
 && valorBoton == 't'
) { //at
izquierda();
}
else if(penultimo == 'd'
 && valorBoton == 't'
) { //dt
derecha();
}
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);
digitalWrite(motA1, 0);//PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}

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

void adelante()
{
digitalWrite(motA1, 1);
analogWrite(motA0, 50); //PWM
analogWrite(motB1, 50); //PWM
digitalWrite(motB0, 1);
}

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

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

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

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

}

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


void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0); //PWM
digitalWrite(motB0, 0); //PWM
digitalWrite(motB1, 0);
}
Modo Fútbol

Modo Futbol

Utiliza los aditamentos para futbol y transforma tu robot en un gran jugador. Puedes pintarlos de hasta 4 colores diferentes los aditamentos para formar grandes equipos

Recomendación: Usar con programa “robot sumo bluetooth” o programa “4 programa en 1”

Puede elegir entre los diferentes colores!

Color fútbol 1
Color fútbol 2
Color fútbol 3
Color fútbol 4