KIT Mini Sumo 10×10 v2

Conoce el Robot Mini sumo 10x10 V2

KIT Mini Sumo 10×10 v2

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 para armar la estructura
4pzs. 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 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. Porta pilas 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) 39661716

¿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.
Con ayuda de unas pinzas, tijeras o cutter, corte cuidadosamente las pestañas que sobre salen de los motores.

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

¿Cómo cambiar entre programas?

Los cables son los elementos que nos ayudarán 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.

Sumo Autónomo para Fondo Negro

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

Sumo Bluetooth

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

Evasor de Obstáculos

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)

Descargar Manual de Instalación Arduino y Driver

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.

Descargar Driver

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.

Descargar Arduino

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.

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

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

Seguidor de Linea Blanca

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.

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)
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;
}

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;
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550)
{
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);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

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

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

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

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

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

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

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

void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

Descargar código

Seguidor de Linea Negra

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.

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);
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)
{
l1 = f1;
l2 = f2;
l3 = f3;
cont1=cont1-1;
}

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;
}
else
{
if(l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550)
{
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);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

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

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

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

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

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

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

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

void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

Descargar código

Evasor de Obstáculos

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.

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

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

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

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

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

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

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

void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

Descargar código

Robot Sumo Autónomo para Fondo Blanco

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

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

// ================== SENSORES DE LÍNEA ==================
int sensorleft   = A7;
int sensorcenter = A6;
int sensorright  = A5;

// Ajusta estos valores viendo el Monitor Serial
int umbralLeft   = 550;
int umbralCenter = 550;
int umbralRight  = 550;

// Para fondo blanco con borde negro:
// normalmente el negro da valores BAJOS, por eso está en false.
bool lineaConValorAlto = false;

// ================== BUZZER ==================
int buzzer = 6;

// ================== ULTRASÓNICO ==================
int echo = 8;
int triger = 7;

// Distancia para atacar al oponente
int distanciaAtaque = 25; // cm

// Variables de sensores
int lLeft = 0;
int lCenter = 0;
int lRight = 0;

unsigned long tiempoDebug = 0;

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

  pinMode(motA0, OUTPUT);
  pinMode(motA1, OUTPUT);
  pinMode(motB0, OUTPUT);
  pinMode(motB1, OUTPUT);

  pinMode(buzzer, OUTPUT);

  pinMode(echo, INPUT);
  pinMode(triger, OUTPUT);
  digitalWrite(triger, LOW);

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

  alto();

  Serial.println("Robot Sumo Fondo Blanco iniciado");
  Serial.println("Ajusta los umbrales si los sensores no detectan bien el borde.");
}

void loop()
{
  leerSensores();
  imprimirDebug();

  // Primero revisa si detecta el borde negro
  if (hayLinea())
  {
    escaparLinea();
    return;
  }

  // Después busca al oponente con el ultrasónico
  long d = distancia();

  if (d > 0 && d <= distanciaAtaque)
  {
    adelanteFuerte();
  }
  else
  {
    buscarOponente();
  }
}

// ================== LECTURA DE SENSORES ==================

void leerSensores()
{
  lLeft   = leerPromedio(sensorleft);
  lCenter = leerPromedio(sensorcenter);
  lRight  = leerPromedio(sensorright);
}

int leerPromedio(int pin)
{
  long suma = 0;

  for (int i = 0; i < 8; i++)
  {
    suma += analogRead(pin);
    delayMicroseconds(500);
  }

  return suma / 8;
}

bool detectaLinea(int valor, int umbral)
{
  if (lineaConValorAlto)
  {
    return valor > umbral;
  }
  else
  {
    return valor < umbral;
  }
}

bool hayLinea()
{
  bool izquierda = detectaLinea(lLeft, umbralLeft);
  bool centro    = detectaLinea(lCenter, umbralCenter);
  bool derecha   = detectaLinea(lRight, umbralRight);

  if (izquierda || centro || derecha)
  {
    return true;
  }

  return false;
}

// ================== ULTRASÓNICO ==================

long distancia()
{
  long tiempo;
  long distanciaCm;

  digitalWrite(triger, LOW);
  delayMicroseconds(2);

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

  tiempo = pulseIn(echo, HIGH, 25000UL);

  if (tiempo == 0)
  {
    return 999;
  }

  distanciaCm = tiempo / 58;

  if (distanciaCm <= 1 || distanciaCm > 150)
  {
    return 999;
  }

  return distanciaCm;
}

// ================== COMPORTAMIENTO ==================

void escaparLinea()
{
  alto();
  tone(buzzer, 1000, 100);
  delay(150);

  atras();
  delay(500);

  // Si el sensor izquierdo detecta borde, gira a la derecha
  if (detectaLinea(lLeft, umbralLeft))
  {
    derecha();
    delay(500);
  }
  // Si el sensor derecho detecta borde, gira a la izquierda
  else if (detectaLinea(lRight, umbralRight))
  {
    izquierda();
    delay(500);
  }
  // Si detecta el centro, retrocede y gira
  else
  {
    derecha();
    delay(500);
  }

  alto();
  delay(100);
}

void buscarOponente()
{
  // Giro de búsqueda
  derecha();
}

// ================== MOTORES ==================

void alto()
{
  digitalWrite(motA0, LOW);
  digitalWrite(motA1, LOW);
  digitalWrite(motB0, LOW);
  digitalWrite(motB1, LOW);
}

void adelanteFuerte()
{
  digitalWrite(motA1, HIGH);
  digitalWrite(motA0, LOW);

  digitalWrite(motB0, HIGH);
  digitalWrite(motB1, LOW);
}

void atras()
{
  digitalWrite(motA0, HIGH);
  digitalWrite(motA1, LOW);

  digitalWrite(motB1, HIGH);
  digitalWrite(motB0, LOW);
}

void izquierda()
{
  digitalWrite(motA0, LOW);
  digitalWrite(motA1, HIGH);

  digitalWrite(motB0, LOW);
  digitalWrite(motB1, HIGH);
}

void derecha()
{
  digitalWrite(motA1, LOW);
  digitalWrite(motA0, HIGH);

  digitalWrite(motB0, HIGH);
  digitalWrite(motB1, LOW);
}

// ================== DEBUG ==================

void imprimirDebug()
{
  if (millis() - tiempoDebug >= 250)
  {
    tiempoDebug = millis();

    Serial.print("Izq: ");
    Serial.print(lLeft);

    Serial.print(" | Centro: ");
    Serial.print(lCenter);

    Serial.print(" | Der: ");
    Serial.print(lRight);

    Serial.print(" | Distancia: ");
    Serial.println(distancia());
  }
}

Descargar código

Robot Sumo Autónomo para Fondo Negro

Comportamiento del programa.

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

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

// ================== SENSORES DE LÍNEA ==================
int sensorleft   = A7;
int sensorcenter = A6;
int sensorright  = A5;

// Ajusta estos valores viendo el Monitor Serial
int umbralLeft   = 550;
int umbralCenter = 550;
int umbralRight  = 550;

// Si tus sensores detectan la línea con valores ALTOS, déjalo en true.
// Si detectan la línea con valores BAJOS, cambia a false.
bool lineaConValorAlto = true;

// ================== BUZZER ==================
int buzzer = 6;

// ================== ULTRASÓNICO ==================
int echo = 8;
int triger = 7;

// Distancia para atacar al oponente
int distanciaAtaque = 25; // cm

// Variables de sensores
int lLeft = 0;
int lCenter = 0;
int lRight = 0;

unsigned long tiempoDebug = 0;

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

  pinMode(motA0, OUTPUT);
  pinMode(motA1, OUTPUT);
  pinMode(motB0, OUTPUT);
  pinMode(motB1, OUTPUT);

  pinMode(buzzer, OUTPUT);

  pinMode(echo, INPUT);
  pinMode(triger, OUTPUT);
  digitalWrite(triger, LOW);

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

  alto();

  Serial.println("Robot iniciado");
  Serial.println("Revisa los valores de los sensores para ajustar los umbrales.");
}

void loop()
{
  leerSensores();

  imprimirDebug();

  // Primero se revisa la línea del borde
  if (hayLinea())
  {
    escaparLinea();
    return;
  }

  // Después se revisa si hay objeto al frente
  long d = distancia();

  if (d > 0 && d <= distanciaAtaque)
  {
    adelanteFuerte();
  }
  else
  {
    buscarOponente();
  }
}

// ================== LECTURA DE SENSORES ==================

void leerSensores()
{
  lLeft   = leerPromedio(sensorleft);
  lCenter = leerPromedio(sensorcenter);
  lRight  = leerPromedio(sensorright);
}

int leerPromedio(int pin)
{
  long suma = 0;

  for (int i = 0; i < 8; i++)
  {
    suma += analogRead(pin);
    delayMicroseconds(500);
  }

  return suma / 8;
}

bool detectaLinea(int valor, int umbral)
{
  if (lineaConValorAlto)
  {
    return valor > umbral;
  }
  else
  {
    return valor < umbral;
  }
}

bool hayLinea()
{
  bool izquierda = detectaLinea(lLeft, umbralLeft);
  bool centro    = detectaLinea(lCenter, umbralCenter);
  bool derecha   = detectaLinea(lRight, umbralRight);

  if (izquierda || centro || derecha)
  {
    return true;
  }

  return false;
}

// ================== ULTRASÓNICO ==================

long distancia()
{
  long tiempo;
  long distanciaCm;

  digitalWrite(triger, LOW);
  delayMicroseconds(2);

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

  tiempo = pulseIn(echo, HIGH, 25000UL);

  if (tiempo == 0)
  {
    return 999;
  }

  distanciaCm = tiempo / 58;

  if (distanciaCm <= 1 || distanciaCm > 150)
  {
    return 999;
  }

  return distanciaCm;
}

// ================== COMPORTAMIENTO ==================

void escaparLinea()
{
  alto();
  tone(buzzer, 1000, 100);
  delay(150);

  atras();
  delay(500);

  // Si el sensor izquierdo detecta línea, gira a la derecha
  if (detectaLinea(lLeft, umbralLeft))
  {
    derecha();
    delay(500);
  }
  // Si el sensor derecho detecta línea, gira a la izquierda
  else if (detectaLinea(lRight, umbralRight))
  {
    izquierda();
    delay(500);
  }
  // Si detecta el centro, retrocede y gira
  else
  {
    derecha();
    delay(500);
  }

  alto();
  delay(100);
}

void buscarOponente()
{
  // Giro de búsqueda
  derecha();
}

// ================== MOTORES ==================

void alto()
{
  digitalWrite(motA0, LOW);
  digitalWrite(motA1, LOW);
  digitalWrite(motB0, LOW);
  digitalWrite(motB1, LOW);
}

void adelanteFuerte()
{
  digitalWrite(motA1, HIGH);
  digitalWrite(motA0, LOW);

  digitalWrite(motB0, HIGH);
  digitalWrite(motB1, LOW);
}

void atras()
{
  digitalWrite(motA0, HIGH);
  digitalWrite(motA1, LOW);

  digitalWrite(motB1, HIGH);
  digitalWrite(motB0, LOW);
}

void izquierda()
{
  digitalWrite(motA0, LOW);
  digitalWrite(motA1, HIGH);

  digitalWrite(motB0, LOW);
  digitalWrite(motB1, HIGH);
}

void derecha()
{
  digitalWrite(motA1, LOW);
  digitalWrite(motA0, HIGH);

  digitalWrite(motB0, HIGH);
  digitalWrite(motB1, LOW);
}

// ================== DEBUG ==================

void imprimirDebug()
{
  if (millis() - tiempoDebug >= 250)
  {
    tiempoDebug = millis();

    Serial.print("Izq: ");
    Serial.print(lLeft);

    Serial.print(" | Centro: ");
    Serial.print(lCenter);

    Serial.print(" | Der: ");
    Serial.print(lRight);

    Serial.print(" | Distancia: ");
    Serial.println(distancia());
  }
}

Descargar código

Robot Sumo Autónomo Sin Bordes

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.

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

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

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

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

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

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

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

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

void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

Descargar código

Robot Sumo Bluetooth

RETIRA EL MÓDULO BLUETOOTH PARA SUBIR EL CÓDIGO.

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.

Descargar aplicació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;

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);
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'))
{
vali = 'i';
adelanter();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 's' && penultimo == 'd' && valorBoton == 'h')
|| (antepenultimo == 's' && penultimo == 'a' && valorBoton == 'f'))
{
vali = 'k';
atras();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 'a' && penultimo == 'w' && valorBoton == 't')
|| (antepenultimo == 'a' && penultimo == 's' && valorBoton == 'g'))
{
vali = 'j';
izquierda();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 'd' && penultimo == 'w' && valorBoton == 't')
|| (antepenultimo == 'd' && penultimo == 's' && valorBoton == 'g'))
{
vali = 'l';
derecha();
penultimo = 'n';
antepenultimo = 'm';
}
else if(vali == 'i')
{
adelanter();
if(valorBoton == 't')
{
vali = 'b';
alto();
}
else if(valorBoton == 'd') {
derecha();
}
else if(valorBoton == 'a') {
izquierda();
}
}
else if(vali == 'k')
{
atras();
if(valorBoton == 'g')
{
vali = 'b';
alto();
}
else if(valorBoton == 'd') {
atrasderecha();
}
else if(valorBoton == 'a') {
atrasizquierda();
}
}
else if(vali == 'j')
{
izquierda();
if(valorBoton == 'f')
{
vali = 'b';
alto();
}
else if(valorBoton == 'w') {
izquierda();
}
else if(valorBoton == 'a') {
atrasderecha();
}
}
else if(vali == 'l')
{
derecha();
if(valorBoton == 'h')
{
vali = 'b';
alto();
}
else if(valorBoton == 'w') {
derecha();
}
else if(valorBoton == 'a') {
atrasizquierda();
}
}
else if(valorBoton == 'w') {
adelanter();
}
else if(valorBoton == 's') {
atras();
}
else if(penultimo != 's' && valorBoton == 'a') {
izquierda();
}
else if(penultimo != 's' && valorBoton == 'd') {
derecha();
}
else if(penultimo == 'w' && valorBoton == 'a') {
izquierda();
}
else if(penultimo == 'w' && valorBoton == 'd') {
derecha();
}
else if(penultimo == 'w' && valorBoton == 'f') {
adelanter();
}
else if(penultimo == 'w' && valorBoton == 'h') {
adelanter();
}
else if(penultimo == 't' && valorBoton == 'a') {
izquierda();
}
else if(penultimo == 't' && valorBoton == 'd') {
derecha();
}
else if(penultimo == 's' && valorBoton == 'a') {
atrasizquierda();
}
else if(penultimo == 's' && valorBoton == 'd') {
atrasderecha();
}
else if(penultimo == 's' && valorBoton == 'f') {
atras();
}
else if(penultimo == 's' && valorBoton == 'h') {
atras();
}
else if(penultimo == 'g' && valorBoton == 'a') {
atrasderecha();
}
else if(penultimo == 'g' && valorBoton == 'd') {
atrasizquierda();
}
else if(penultimo == 'a' && valorBoton == 'w') {
izquierda();
}
else if(penultimo == 'd' && valorBoton == 'w') {
derecha();
}
else if(penultimo == 'f' && valorBoton == 'w') {
adelanter();
}
else if(penultimo == 'h' && valorBoton == 'w') {
adelanter();
}
else if(penultimo == 'a' && valorBoton == 't') {
izquierda();
}
else if(penultimo == 'd' && valorBoton == 't') {
derecha();
}
else if(penultimo == 'a' && valorBoton == 's') {
atrasderecha();
}
else if(penultimo == 'd' && valorBoton == 's') {
atrasizquierda();
}
else if(penultimo == 'f' && valorBoton == 's') {
atras();
}
else if(penultimo == 'h' && valorBoton == 's') {
atras();
}
else if(penultimo == 'a' && valorBoton == 'g') {
atrasderecha();
}
else if(penultimo == 'd' && valorBoton == 'g') {
atrasizquierda();
}
else {
alto();
penultimo = 'n';
antepenultimo = 'm';
}

Serial.print(antepenultimo);
Serial.print(" ");
Serial.print(penultimo);
Serial.print(" ");
Serial.print(valorBoton);
Serial.print(" ");
Serial.print(vali);
Serial.println(" ");

antepenultimo = 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);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

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

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

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

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

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

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

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

void atrasizquierda(){
digitalWrite(motA0, 1);
digitalWrite(motA1, 0);
digitalWrite(motB0, 0);
digitalWrite(motB1, 0);
}

Descargar código

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

Descargar aplicación

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

Sumo Autónomo para Fondo Negro

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

Sumo Bluetooth

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

Evasor de Obstáculos

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

Ver Código

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

int lec0=A2;
int lec1=A1;

long cont1 = 0;

int sensorleft = A7;
int sensorcenter = A6;
int sensorright = A5;
 
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;

int led= 13;

char valorBoton;
char penultimo = 'n';
char antepenultimo = 'm';
char vali = 'b';

void setup()
{
  Serial.begin(9600);
  pinMode(led, OUTPUT);
  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=analogRead(sensorleft);
l2=analogRead(sensorcenter);
l1=analogRead(sensorright);

if(digitalRead(lec0)==0){
    if(digitalRead(lec1)==0){

      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) //left turn
      {
        izquierda();
      }
      else if (l1 < 550 && l2 < 550 && l3 > 550 || l1 < 550 && l2 > 550 && l3 > 550) //right turn
      {
        derecha();
      }
      else if (l1 < 550 && l2 > 550 && l3 < 550) //go forward straight
      {
        adelante();
        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;

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

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

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

void derecha()
{
  digitalWrite(motA1,50);
  analogWrite(motA0, 1); //PWM
  analogWrite(motB0, 0); //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);
}

Descargar código