#include <Servo.
h> // Librería necesaria para poder controlar el
servomotor
// DECLARACIÓN DE VARIABLES Y PINES
// En este apartado se configuran los pines y variables que utilizará el
robot para funcionar correctamente.
int pinservo = 2; // Variable donde se guarda el pin conectado al servo
Servo miservo; // Crear el objeto servo para controlar sus movimientos
#define Trig 13 // Pin Trigger del sensor ultrasónico encargado de enviar
la señal
#define Eco 12 // Pin Echo del sensor ultrasónico encargado de recibir la
señal
#define m1a 10 // Pin del motor 1 para movimiento hacia adelante
#define m1r 9 // Pin del motor 1 para movimiento en reversa
#define m2a 6 // Pin del motor 2 para movimiento hacia adelante
#define m2r 5 // Pin del motor 2 para movimiento en reversa
int distancia, valorizq, valorder, valorcen; // Variables donde se
almacenan las distancias medidas
long tiempoMS; // Variable donde se almacena el tiempo del eco
ultrasónico
// ==========================
// FUNCIÓN SETUP
// Sirve para configurar sensores, motores y comunicación serial.
// ==========================
void setup() {
[Link](9600); // Inicializa la comunicación serial para monitorear
datos
[Link](pinservo); // Conecta el servo al pin previamente
definido
pinMode(Trig, OUTPUT); // Configura el pin Trigger como salida
pinMode(Eco, INPUT); // Configura el pin Echo como entrada
// ==========================
// FUNCIÓN LOOP
// Esta función se ejecuta continuamente.
// Aquí se encuentra toda la lógica de evasión de obstáculos.
// ==========================
void loop() {
[Link](90); // Coloca el servo al frente del robot en posición de
90 grados
delay(300); // Espera para que el servo alcance correctamente la
posición
medir(); // Llama la función para medir la distancia frontal
// ==========================
// MOVIMIENTO HACIA ADELANTE
// Si el camino está libre o no detecta obstáculos, el robot avanzará
hacia adelante.
// ==========================
if (distancia >= 35 || distancia == 0) { // Si la distancia es mayor o
igual a 35 cm o no detecta objetos
adelante(150); // El robot avanza hacia adelante con velocidad
analógica de 150
delay(100); // Mantiene el movimiento durante un pequeño tiempo
// ==========================
// DETECCIÓN DE OBSTÁCULO
// Si el robot detecta un obstáculo cercano,
// primero se detiene para analizar el entorno.
// ==========================
else if (distancia < 35) { // Si detecta un objeto a menos de 35 cm
detener(0); // Detiene completamente los motores del robot
delay(350); // Mantiene el robot detenido durante 350 milisegundos
decide(); // Llama la función que revisa izquierda, derecha y centro
// ==========================
// REVERSA DE SEGURIDAD
// Si ambos lados están bloqueados o el objeto
// está demasiado cerca, el robot retrocede.
// ==========================
if (valorizq <= 55 && valorder <= 55 || valorcen < 10) { // Si ambos
lados están bloqueados o el objeto está demasiado cerca
reversa(125); // El robot se mueve en reversa con velocidad de 125
delay(170); // Mantiene la reversa durante 170 milisegundos
detener(0); // Detiene nuevamente el robot
delay(425); // Espera 425 milisegundos antes de continuar
// ==========================
// GIRO HACIA LA IZQUIERDA
// Si existe más espacio libre del lado izquierdo,
// el robot gira hacia esa dirección.
// ==========================
else if (valorizq > valorder) { // Si existe más espacio libre en la
izquierda
giroizq(200); // El robot gira hacia la izquierda con velocidad de 200
delay(200); // Mantiene el giro durante 200 milisegundos
// ==========================
// GIRO HACIA LA DERECHA
// Si existe más espacio libre del lado derecho,
// el robot gira hacia esa dirección.
// ==========================
else if (valorder > valorizq) { // Si existe más espacio libre en la
derecha
giroder(200); // El robot gira hacia la derecha con velocidad de 200
delay(200); // Mantiene el giro durante 200 milisegundos
// ==========================
// EMPATE DE DISTANCIAS
// Si ambos lados tienen la misma distancia,
// el robot girará hacia la derecha.
// ==========================
else if (valorizq == valorder) { // Si ambos lados tienen la misma
distancia
giroder(200); // En caso de empate gira hacia la derecha
delay(200); // Mantiene el giro durante 200 milisegundos
// ==========================
// FUNCIÓN ADELANTE
// Esta función permite mover ambos motores hacia adelante utilizando
velocidad PWM.
// ==========================
void adelante(byte vel) {
analogWrite(m1r, 0); // Apaga el movimiento en reversa del motor 1
analogWrite(m2r, 0); // Apaga el movimiento en reversa del motor 2
analogWrite(m1a, vel); // Activa el avance del motor 1 con la velocidad
indicada
analogWrite(m2a, vel); // Activa el avance del motor 2 con la velocidad
indicada
// ==========================
// FUNCIÓN REVERSA
// Esta función mueve ambos motores en dirección hacia atrás.
// ==========================
void reversa(byte vel) {
analogWrite(m1a, 0); // Apaga el avance del motor 1
analogWrite(m2a, 0); // Apaga el avance del motor 2
analogWrite(m1r, vel); // Activa la reversa del motor 1
analogWrite(m2r, vel); // Activa la reversa del motor 2
// ==========================
// FUNCIÓN GIRO IZQUIERDA
// Esta función hace que el robot realice un giro hacia la izquierda.
// ==========================
void giroizq(byte vel) {
analogWrite(m1a, 0); // Apaga el avance del motor 1
analogWrite(m1r, 0); // Apaga la reversa del motor 1
analogWrite(m2r, 0); // Apaga la reversa del motor 2
analogWrite(m2a, vel); // Activa el avance del motor 2 para realizar el
giro
// ==========================
// FUNCIÓN GIRO DERECHA
// Esta función hace que el robot realice un giro hacia la derecha.
// ==========================
void giroder(byte vel) {
analogWrite(m2a, 0); // Apaga el avance del motor 2
analogWrite(m1r, 0); // Apaga la reversa del motor 1
analogWrite(m2r, 0); // Apaga la reversa del motor 2
analogWrite(m1a, vel); // Activa el avance del motor 1 para realizar el
giro
// ==========================
// FUNCIÓN DETENER
// Esta función apaga todos los motores para detener completamente el
robot.
// ==========================
void detener(byte vel) {
analogWrite(m1a, vel); // Detiene el avance del motor 1
analogWrite(m2a, vel); // Detiene el avance del motor 2
analogWrite(m1r, vel); // Detiene la reversa del motor 1
analogWrite(m2r, vel); // Detiene la reversa del motor 2
// ==========================
// FUNCIÓN MEDIR
// Esta función utiliza el sensor ultrasónico para calcular la distancia de
un objeto.
// ==========================
void medir() {
digitalWrite(Trig, LOW); // Apaga el Trigger para iniciar correctamente la
señal
delayMicroseconds(2); // Espera 2 microsegundos
digitalWrite(Trig, HIGH); // Envía el pulso ultrasónico
delayMicroseconds(10); // Mantiene el pulso durante 10 microsegundos
digitalWrite(Trig, LOW); // Finaliza el pulso ultrasónico
tiempoMS = pulseIn(Eco, HIGH); // Mide el tiempo que tarda el eco en
regresar
distancia = tiempoMS * 0.01715; // Convierte el tiempo medido en
centímetros
// ==========================
// FUNCIÓN DECIDE
// Esta función mueve el servo para revisar izquierda, derecha y frente
del robot.
// ==========================
void decide() {
[Link](180); // Mueve el servo hacia la izquierda
medir(); // Realiza la medición izquierda
valorizq = distancia; // Guarda la distancia izquierda
[Link](0); // Mueve el servo hacia la derecha
medir(); // Realiza la medición derecha
valorder = distancia; // Guarda la distancia derecha
[Link](90); // Regresa el servo al frente
medir(); // Realiza la medición frontal
valorcen = distancia; // Guarda la distancia frontal