Cpp
#include <Arduino.h>

// Definición de pines para el sensor HC-SR04
const int pinTrigger = 7; // D7 para TRIG
const int pinEcho = 8;    // D8 para ECHO

// Definición de pines para L298N
const int pinENA = 5;  // D5 controla la velocidad del motor en el canal A
const int pinIN1 = 3;  // D3
const int pinIN2 = 4;  // D4

void setup() {
    // Configura los pines del sensor como salida/entrada
    pinMode(pinTrigger, OUTPUT);
    pinMode(pinEcho, INPUT);
    // Configura los pines del motor como salida
    pinMode(pinENA, OUTPUT);
    pinMode(pinIN1, OUTPUT);
    pinMode(pinIN2, OUTPUT);
    // Inicia comunicación serial
    Serial.begin(9600);
}

void loop() {
    long duracion, distancia;
    digitalWrite(pinTrigger, LOW);   // Estabilizar el sensor
    delayMicroseconds(2);
    digitalWrite(pinTrigger, HIGH);  // Generar un pulso ultrasónico
    delayMicroseconds(10);
    digitalWrite(pinTrigger, LOW);
    
    duracion = pulseIn(pinEcho, HIGH); // Leer el eco
    distancia = duracion * 0.034 / 2;  // Calcular la distancia
    Serial.print("Distancia: ");
    Serial.println(distancia);

    if(distancia < 20){ // Si la distancia es menor a 20 cm
        // Enciende el motor
        digitalWrite(pinENA, HIGH); // Velocidad máxima (considera usar analogWrite para control de velocidad)
        digitalWrite(pinIN1, HIGH); 
        digitalWrite(pinIN2, LOW);  
    }else{
        // Apaga el motor
        digitalWrite(pinENA, LOW); 
    }

    delay(1000); // Espera un segundo antes de repetir el ciclo
}

Cpp
#include <Arduino.h>

// Definir los pines de Arduino conectados a los TCRT5000
const int emisorPin = 2;    // Pin conectado al emisor de U2 (cambia según tu diseño)
const int sensorPin = A2;   // Pin conectado al colector (C) de U2

void setup() {
  pinMode(emisorPin, OUTPUT); // Configura el pin del emisor como salida
  pinMode(sensorPin, INPUT);  // Configura el pin del sensor como entrada
  Serial.begin(9600);         // Inicia la comunicación serial
}

void loop() {
  digitalWrite(emisorPin, HIGH);   // Enciende el emisor IR
  delay(10);                       // Espera un momento para que el sensor se estabilice

  int sensorValue = analogRead(sensorPin); // Lee el valor del sensor
  Serial.print("Valor del sensor: ");
  Serial.println(sensorValue);             // Imprime el valor leído

  // Decisión basada en el valor del sensor (ajusta el umbral según tus necesidades)
  if(sensorValue > 500) {
    // Superficie reflectante detectada
    Serial.println("Línea detectada!");
  } else {
    // Superficie no reflectante
    Serial.println("Fuera de línea.");
  }

  digitalWrite(emisorPin, LOW); // Apaga el emisor IR para ahorrar energía

  delay(200); // Retraso antes de la próxima lectura
}

Cpp
#include <Arduino.h>

// Definir el pin de Arduino conectado a la salida del sensor de línea
const int lineSensorPin = 2; // Cambia el número '2' por el pin digital que uses

void setup() {
  pinMode(lineSensorPin, INPUT);    // Configura el pin del sensor como entrada
  Serial.begin(9600);               // Inicia la comunicación serial
}

void loop() {
  int sensorState = digitalRead(lineSensorPin); // Lee el estado del sensor

  if(sensorState == HIGH) {
    // Si el sensor detecta una línea (dependiendo de cómo esté configurado el sensor, esto podría ser inverso)
    Serial.println("Línea detectada!");
  } else {
    // Si el sensor no detecta una línea
    Serial.println("Fuera de línea.");
  }

  delay(200); // Retraso antes de la próxima lectura
}

1. Leer la distancia del sensor ultrasonido HC-SR04.
2. Utilizar los sensores ópticos TCRT5000 para detectar si estás sobre una línea o no.
3. Controlar un motor con el L298N basándote en las lecturas de los sensores.

Cpp
#include <Arduino.h>

// Definiciones para el HC-SR04
const int triggerPin = 7; // Reemplaza con tu pin real para TRIG
const int echoPin = 8; // Reemplaza con tu pin real para ECHO

// Definiciones para TCRT5000
const int tcrt5000Pin = A0; // Reemplaza con el pin analógico conectado a U2 (E)

// Definiciones para el L298N
const int enA = 5; // Habilitar motor A
const int in1 = 3; // Dirección 1 
const int in2 = 4; // Dirección 2

void setup() {
  // Inicialización de pines
  pinMode(triggerPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(tcrt5000Pin, INPUT);
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);

  // Inicia la comunicación serial
  Serial.begin(9600);
}

void loop() {
  // Leer distancia del HC-SR04
  long duration, distance;
  digitalWrite(triggerPin, LOW);  
  delayMicroseconds(2); 
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10); 
  digitalWrite(triggerPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = $(duration / 2) * 0.03432$; // Calcula la distancia en cm
  Serial.print("Distancia: ");
  Serial.println(distance);

  // Leer valor del TCRT5000
  int tcrtRead = analogRead(tcrt5000Pin);
  Serial.print("TCRT5000 Lectura: ");
  Serial.println(tcrtRead);

  // Control de motor basado en la lectura de TCRT5000
  if(tcrtRead > 600) { // Suponiendo un umbral para "detectar línea"
    // Gira el motor
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    analogWrite(enA, 200); // Velocidad del motor (modifica según necesidad)
  } else {
    // Detiene el motor
    digitalWrite(enA, LOW);
  }

  delay(1000); // Retardo de un segundo antes de la próxima lectura
}

• Lee la distancia desde el HC-SR04 y la imprime a la consola serial.
• Lee el valor del TCRT5000 y lo imprime en la consola serial. Podrías ajustar el umbral de "tcrtRead > 600" basado en tus pruebas para determinar cuándo el sensor está sobre una línea.
• Controla un motor con el L298N, donde el motor gira a una velocidad determinada si el TCRT5000 detecta una línea, y se detiene si no.

Cpp
#include <Arduino.h>

// Definir el pin al que está conectado el sensor de línea
const int lineSensorPin = 2; // Cambia este número por el pin que estés usando

void setup() {
  // Inicializar el pin del sensor como entrada
  pinMode(lineSensorPin, INPUT);
  // Iniciar comunicación serial
  Serial.begin(9600);
}

void loop() {
  // Leer el estado del sensor de línea
  int sensorState = digitalRead(lineSensorPin);

  // Imprimir el estado del sensor
  if(sensorState == HIGH) {
    // Suponiendo que HIGH significa fuera de la línea
    Serial.println("Fuera de la línea");
  } else {
    // LOW significa encima de la línea
    Serial.println("Encima de la línea");
  }

  // Esperar un poco antes de la próxima lectura
  delay(200); // 200 milisegundos
}

• Conexión: Asegúrate de conectar correctamente el módulo de sensor de línea a tu Arduino. El pin de salida digital del módulo (a menudo etiquetado como "D0" o "OUT") debe conectarse al pin definido en lineSensorPin en tu Arduino.
• Configuración del módulo: Muchos módulos de sensor de línea tienen potenciómetros para ajustar la sensibilidad del sensor. Puede que necesites experimentar con este ajuste hasta que encuentres el punto óptimo donde el sensor distingue claramente entre la línea y el fondo.
• Interpretación de HIGH y LOW: Dependiendo de tu módulo sensor, podrías necesitar invertir la lógica en el código (cambia HIGH por LOW y viceversa en los if y else del loop) para que coincida con la manera en que tu sensor indica la presencia de una línea versus la ausencia.

• Conecta la salida +5V del Arduino Nano (U1:+5V) a VCC en los sensores TCRT5000 (U2 y U3:V), HC-SR04 (US1:VCC), y al pin +5V (VSS) en el L298N (U5).
• Conecta GND del Arduino Nano (U1:COM/GND) a GND en los sensores TCRT5000 (U2 y U3:G), HC-SR04 (US1:GND), y al pin GND en el L298N (U5).

• Conectar Arduino Nano A2 (U1:A2) a los emisores (E) de los TCRT5000 (U2:E y U3:E).

• Conecta el pin TRIG del HC-SR04 (US1:TRIG) a D7 en el Arduino (U1:D7).
• Conecta el pin ECHO del HC-SR04 (US1:ECHO) a D8 en el Arduino (U1:D8).

• Conecta ENA y ENB en el L298N (U5:ENA y U5:ENB) a los pines D5 y D6 en el Arduino (U1:D5 y U1:D6) para habilitar los canales de los motores.
• Conecta IN1 y IN2 en el L298N (U5:IN1 y U5:IN2) a los pines D3 y D4 en el Arduino (U1:D3 y U1:D4) para controlar el motor 1 (M1).
• Conecta IN3 y IN4 en el L298N (U5:IN3 y U5:IN4) a otros pines disponibles en el Arduino para controlar el motor 2 (M2). Por ejemplo, podrías usar D9 y D10 (Esta parte necesita que elijas los pines específicos).

• Conecta el Motor 1 (M1) a OUT1 y OUT2 en el L298N (U5:OUT1 y U5:OUT2).
• Conecta el Motor 2 (M2) a OUT3 y OUT4 en el L298N (U5:OUT3 y U5:OUT4).

• Alimentación: Asegúrate de que la fuente de alimentación que utilices pueda suministrar suficiente corriente para todos los componentes, especialmente los motores que pueden consumir bastante corriente cuando están bajo carga.
• Programación y Pruebas: Empieza con programas básicos para probar cada componente individualmente antes de unirlos en un programa más complejo. Esto te ayudará a identificar problemas específicos más fácilmente.
• Diseño Mecánico del Robot: Para un robot minisumo, el centro de gravedad bajo es clave. Asegúrate de que los sensores estén bien posicionados para detectar a tu oponente eficazmente y considera el uso de materiales ligeros pero robustos para la estructura.
• Estrategia de Combate: Considera diferentes estrategias de lucha. Por ejemplo, algunos robots minisumo utilizan sensores para buscar a su oponente activamente, mientras que otros pueden esperar y reaccionar cuando detectan a su oponente cerca.