KIT Mini Sumo 10×10 v2

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA 
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA 

// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;

// ===============================
// PINES DE LOS 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;

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;


// ===============================
// SENSOR ULTRASÓNICO Y BUZZER
// ===============================

int buzzer = 6;

int echo = 8;
int triger = 7;
void setup() {

  Serial.begin(9600);

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

  // Buzzer
  pinMode(buzzer, OUTPUT);

  // Ultrasónico
  pinMode(echo, INPUT);
  pinMode(triger, OUTPUT);

  digitalWrite(triger, LOW);

  // Sensores de línea
  pinMode(sensorright, INPUT);
  pinMode(sensorcenter, INPUT);
  pinMode(sensorleft, INPUT);


  // ===============================
  // MOTORES DETENIDOS AL INICIAR
  // ===============================

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

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

void loop() {

  adelante();
}


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

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


// ===============================
// ALTO
// ===============================

void alto() {

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

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


// ===============================
// ATRÁS
// ===============================

void atras() {

  digitalWrite(motA0, HIGH);
  digitalWrite(motA1, LOW);

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


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante() {

  digitalWrite(motA1, HIGH);
  analogWrite(
    motA0,
    255 - velocidadMotorA
  );
  digitalWrite(motB0, HIGH);
  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// IZQUIERDA
// ===============================

void izquierda() {

  digitalWrite(motA0, LOW);
  digitalWrite(motA1, HIGH);

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


// ===============================
// DERECHA
// ===============================

void derecha() {

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

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


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha() {

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

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


// ===============================
// ATRÁS IZQUIERDA
// ===============================

void atrasizquierda() {

  digitalWrite(motA0, HIGH);
  digitalWrite(motA1, LOW);

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

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ===============================
// PINES DE LOS 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;

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;


// ===============================
// BUZZER
// ===============================

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


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

int echo = 8;
int triger = 7;

int vel = 200;


// ===============================
// SETUP
// ===============================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

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; // Numero de ciclos para mantener la memoria
  }

  else
  {
    if (l1 > 550 && l2 > 550 && l3 > 550 ||
        l1 < 550 && l2 < 550 && l3 < 550)
    {
      alto();
    }
  }

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

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


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

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


// ===============================
// ALTO
// ===============================

void alto()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// ADELANTE RÁPIDO
// ===============================
// Se conserva porque el LOOP utiliza adelanter().
// Ahora utiliza la función adelante() para aplicar
// el control de velocidad.

void adelanter()
{
  adelante();
}


// ===============================
// ADELANTE SUAVE
// ===============================

void adelantes()
{
  digitalWrite(motA1, 1);

  analogWrite(motA0, 80);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 0);
  digitalWrite(motA0, 0);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ===============================
// PINES DE LOS 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;

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;


// ===============================
// BUZZER
// ===============================

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


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

int echo = 8;
int triger = 7;

int vel = 200;


// ===============================
// SETUP
// ===============================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

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; // Número de ciclos para mantener la memoria
  }

  else
  {
    if (l1 > 550 && l2 > 550 && l3 > 550 || l1 < 550 && l2 < 550 && l3 < 550)
    {
      alto();
    }
  }

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

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


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

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


// ===============================
// ALTO
// ===============================

void alto()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// ADELANTE RÁPIDO
// ===============================
// Se conserva porque el LOOP utiliza adelanter().
// Ahora utiliza la función adelante() para aplicar
// el control de velocidad.

void adelanter()
{
  adelante();
}


// ===============================
// ADELANTE SUAVE
// ===============================

void adelantes()
{
  digitalWrite(motA1, 1);

  analogWrite(motA0, 80);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 0);
  digitalWrite(motA0, 0);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ===============================
// PINES DE LOS 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;

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;


// ===============================
// BUZZER
// ===============================

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


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

int echo = 8;
int triger = 7;

int vel = 200;


// ===============================
// SETUP
// ===============================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

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


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

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


// ===============================
// ALTO
// ===============================

void alto()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// ADELANTE RÁPIDO
// ===============================
// Se conserva porque el LOOP utiliza adelanter().
// Ahora utiliza la función adelante() para aplicar
// el control de velocidad.

void adelanter()
{
  adelante();
}


// ===============================
// IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 0);
  digitalWrite(motA0, 0);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ================== 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;


// ================== SETUP ==================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);


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


// ================== LOOP ==================

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


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// ADELANTE FUERTE
// ===============================
// Se conserva esta función porque el LOOP la utiliza.
// Ahora utiliza adelante() para aplicar el control de velocidad.

void adelanteFuerte()
{
  adelante();
}


// ================== ATRÁS ==================

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

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


// ================== IZQUIERDA ==================

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

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


// ================== DERECHA ==================

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

// ================== VELOCIDAD HACIA ADELANTE ==================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
//
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ================== TIEMPO DE ESPERA AL INICIAR ==================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ================== 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;


// ================== SETUP ==================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);


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


// ================== LOOP ==================

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


// ================== ADELANTE CON CONTROL DE VELOCIDAD ==================

void adelante()
{
  // MOTOR DERECHO
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );


  // MOTOR IZQUIERDO
  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// Se conserva esta función porque es utilizada en el LOOP.
void adelanteFuerte()
{
  adelante();
}


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

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ===============================
// PINES DE LOS MOTORES
// ===============================

int motB0 = 2;
int motB1 = 3; // PWM

int motA1 = 4;
int motA0 = 5; // PWM


// ===============================
// SELECTORES
// ===============================

int lec0 = A2;
int lec1 = A1;


// ===============================
// SENSORES DE LÍNEA
// ===============================

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;


// ===============================
// BUZZER
// ===============================

int buzzer = 6;


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

int echo = 8;
int triger = 7;

int vel = 200;


// ===============================
// VARIABLES
// ===============================

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


// ===============================
// SETUP
// ===============================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

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

  if (distancia() < 150)
  {
    adelanter();
  }
  else
  {
    derecha();
  }
}


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

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


// ===============================
// ALTO
// ===============================

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


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}

void adelanter()
{
  adelante();
}


// ===============================
// ADELANTE SUAVE
// ===============================

void adelantes()
{
  digitalWrite(motA1, 1);
  analogWrite(motA0, 80);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 0);
  digitalWrite(motA0, 0);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA


// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;


// ===============================
// PINES DE LOS 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;

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;


// ===============================
// BUZZER
// ===============================

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


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

int echo = 8;
int triger = 7;

int vel = 200;


// ===============================
// VARIABLES DE CONTROL
// ===============================

char valorBoton;

char penultimo = 'n';
char antepenultimo = 'm';

char vali = 'b';


// ===============================
// SETUP
// ===============================

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


  // ===============================
  // ESPERA ANTES DE COMENZAR
  // ===============================

  delay(tiempoEsperaInicio);
}


// ===============================
// LOOP
// ===============================

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') // Validación: no se suelta adelante
    {
      adelanter();

      if (valorBoton == 't')
      {
        vali = 'b';

        alto();
      }

      else if (valorBoton == 'd')
      {
        derecha();
      }

      else if (valorBoton == 'a')
      {
        izquierda();
      }
    }

    else if (vali == 'k') // Validación: no se suelta atrás
    {
      atras();

      if (valorBoton == 'g')
      {
        vali = 'b';

        alto();
      }

      else if (valorBoton == 'd')
      {
        atrasderecha();
      }

      else if (valorBoton == 'a')
      {
        atrasizquierda();
      }
    }

    else if (vali == 'j') // Validación: no se suelta izquierda
    {
      izquierda();

      if (valorBoton == 'f')
      {
        vali = 'b';

        alto();
      }

      else if (valorBoton == 'w')
      {
        izquierda();
      }

      else if (valorBoton == 'a')
      {
        atrasderecha();
      }
    }

    else if (vali == 'l') // Validación: no se suelta derecha
    {
      derecha();

      if (valorBoton == 'h')
      {
        vali = 'b';

        alto();
      }

      else if (valorBoton == 'w')
      {
        derecha();
      }

      else if (valorBoton == 'a')
      {
        atrasizquierda();
      }
    }


    // ===============================
    // COMBINACIONES DE DOS BOTONES
    // ===============================

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


    // ===============================
    // ESPEJO
    // ===============================

    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
    {
      // Si se presionan más de dos botones
      // o no se presionan los adecuados

      alto();

      penultimo = 'n';
      antepenultimo = 'm';
    }


    // ===============================
    // ACTUALIZAR VALORES
    // ===============================

    Serial.print(antepenultimo);
    Serial.print("  ");

    Serial.print(penultimo);
    Serial.print("  ");

    Serial.print(valorBoton);
    Serial.print("  ");

    Serial.print(vali);
    Serial.println("  ");

    antepenultimo = penultimo;
    penultimo = valorBoton;
  }
}


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

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


// ===============================
// ALTO
// ===============================

void alto()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}

void adelanter()
{
  adelante();
}


// ===============================
// ADELANTE SUAVE
// ===============================

void adelantes()
{
  digitalWrite(motA1, 1);

  analogWrite(motA0, 80);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 0);
  digitalWrite(motA0, 0);

  digitalWrite(motB0, 1);
  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}

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

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:

// ===============================
// VELOCIDAD HACIA ADELANTE
// ===============================
// Rango: 0 - 255
// 0   = detenido
// 255 = máxima velocidad
// Si el robot se desvía ligeramente hacia un lado,
// ajuste la velocidad del motor correspondiente.
// Se recomienda disminuir la velocidad en pasos de 5 unidades.
// Después, puede ajustar de 1 en 1 hasta obtener
// el desplazamiento deseado.

int velocidadMotorA = 255; // MOTOR DERECHO - Ajustar si el robot gira hacia la IZQUIERDA
int velocidadMotorB = 255; // MOTOR IZQUIERDO - Ajustar si el robot gira hacia la DERECHA
                                                                                              
// ===============================
// TIEMPO DE ESPERA AL INICIAR
// ===============================
// Tiempo en milisegundos
// 0    = sin espera
// 1000 = 1 segundo
// 3000 = 3 segundos
// 5000 = 5 segundos

unsigned long tiempoEsperaInicio = 0;

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

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

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

        cont1=cont1-1;
      }

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

      if (l1 > 550 && l2 < 550 && l3 < 550 ||
          l1 > 550 && l2 > 550 && l3 < 550)
      {
        izquierda();
      }

      else if (l1 < 550 && l2 < 550 && l3 > 550 ||
               l1 < 550 && l2 > 550 && l3 > 550)
      {
        derecha();
      }

      else if (l1 < 550 && l2 > 550 && l3 < 550)
      {
        adelante();

        cont1 = 20000;
      }

      else
      {
        if(l1 > 550 && l2 > 550 && l3 > 550 ||
           l1 < 550 && l2 < 550 && l3 < 550)
        {
          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 revés
        // 3 señales o 3 botones al mismo tiempo

        if((antepenultimo == 'w' &&
            penultimo == 'd' &&
            valorBoton == 'h')

            ||

           (antepenultimo == 'w' &&
            penultimo == 'a' &&
            valorBoton == 'f'))
        {
          vali = 'i';

          adelante();

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

          derecha();

          penultimo = 'n';
          antepenultimo = 'm';
        }

        else if((antepenultimo == 'd' &&
                 penultimo == 'w' &&
                 valorBoton == 't')

                 ||

                (antepenultimo == 'd' &&
                 penultimo == 's' &&
                 valorBoton == 'g'))
        {
          vali = 'l';

          izquierda();

          penultimo = 'n';
          antepenultimo = 'm';
        }

        else if(vali == 'i')
        {
          adelante();

          if(valorBoton == 't')
          {
            vali = 'b';

            alto();
          }

          else if(valorBoton == 'd')
          {
            izquierda();
          }

          else if(valorBoton == 'a')
          {
            derecha();
          }
        }

        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')
        {
          derecha();

          if(valorBoton == 'f')
          {
            vali = 'b';

            alto();
          }

          else if(valorBoton == 'w')
          {
            derecha();
          }

          else if(valorBoton == 'a')
          {
            atrasderecha();
          }
        }

        else if(vali == 'l')
        {
          izquierda();

          if(valorBoton == 'h')
          {
            vali = 'b';

            alto();
          }

          else if(valorBoton == 'w')
          {
            izquierda();
          }

          else if(valorBoton == 'a')
          {
            atrasizquierda();
          }
        }

        // ===============================
        // COMBINACIONES DE DOS BOTONES
        // ===============================

        else if(valorBoton == 'w')
        {
          adelante();
        }

        else if(valorBoton == 's')
        {
          atras();
        }

        else if(penultimo != 's' && valorBoton == 'a')
        {
          derecha();
        }

        else if(penultimo != 's' && valorBoton == 'd')
        {
          izquierda();
        }

        else if(penultimo == 'w' && valorBoton == 'a')
        {
          derecha();
        }

        else if(penultimo == 'w' && valorBoton == 'd')
        {
          izquierda();
        }

        else if(penultimo == 'w' && valorBoton == 'f')
        {
          adelante();
        }

        else if(penultimo == 'w' && valorBoton == 'h')
        {
          adelante();
        }

        else if(penultimo == 't' && valorBoton == 'a')
        {
          derecha();
        }

        else if(penultimo == 't' && valorBoton == 'd')
        {
          izquierda();
        }

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

        // ===============================
        // ESPEJO
        // ===============================

        else if(penultimo == 'a' && valorBoton == 'w')
        {
          derecha();
        }

        else if(penultimo == 'd' && valorBoton == 'w')
        {
          izquierda();
        }

        else if(penultimo == 'f' && valorBoton == 'w')
        {
          adelante();
        }

        else if(penultimo == 'h' && valorBoton == 'w')
        {
          adelante();
        }

        else if(penultimo == 'a' && valorBoton == 't')
        {
          derecha();
        }

        else if(penultimo == 'd' && valorBoton == 't')
        {
          izquierda();
        }

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


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

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


// ===============================
// ALTO
// ===============================

void alto()
{
  digitalWrite(motA0, 0);

  analogWrite(motA1, 0);

  analogWrite(motB0, 0);

  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS
// ===============================

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

  digitalWrite(motB1, 1);
  digitalWrite(motB0, 0);
}


// ===============================
// ADELANTE CON CONTROL DE VELOCIDAD
// ===============================

void adelante()
{
  digitalWrite(motA1, HIGH);

  analogWrite(
    motA0,
    255 - velocidadMotorA
  );

  digitalWrite(motB0, HIGH);

  analogWrite(
    motB1,
    255 - velocidadMotorB
  );
}


// ===============================
// ADELANTE RÁPIDO
// ===============================
// Se conserva porque algunos modos utilizan adelanter().
// Ahora utiliza adelante() para aplicar las mismas
// variables de velocidad.

void adelanter()
{
  adelante();
}


// ===============================
// IZQUIERDA
// ===============================

void izquierda()
{
  digitalWrite(motA0, 0);

  analogWrite(motA1, 0);

  analogWrite(motB0, 200);

  digitalWrite(motB1, 0);
}


// ===============================
// DERECHA
// ===============================

void derecha()
{
  digitalWrite(motA1, 50);

  analogWrite(motA0, 1);

  analogWrite(motB0, 0);

  digitalWrite(motB1, 0);
}


// ===============================
// ATRÁS DERECHA
// ===============================

void atrasderecha()
{
  digitalWrite(motA0, 0);
  digitalWrite(motA1, 0);

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 1);
}


// ===============================
// ATRÁS IZQUIERDA
// ===============================

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

  digitalWrite(motB0, 0);
  digitalWrite(motB1, 0);
}