Construyendo un Droide Evasor de Obstáculos con Radar

Construyendo un Droide Evasor de Obstáculos con Radar

La robótica móvil permite dotar a las máquinas de capacidad de percepción y toma de decisiones autónomas en entornos cambiantes. En este manual práctico, construiremos un droide explorador dotado de un sistema de radar giratorio que combina un sensor ultrasónico de medición de distancia con un servomotor de alta precisión. A través de este proyecto, los jóvenes estudiantes aprenderán a coordinar la lectura de sensores, la navegación con motores de corriente continua y el control de posiciones angulares mediante la placa Arduino.

1. El Equipo de Exploración: Componentes y Conexiones
Para que el droide pueda desplazarse y percibir su entorno de forma independiente, se requiere una arquitectura integrada por un cerebro electrónico, un sensor de eco, una articulación giratoria y un controlador de potencia para las ruedas. Como se especifica en la arquitectura del droide, cada elemento se vincula a un pin digital determinado en la placa de control.
El sensor ultrasónico de modelo HC-SR04 actúa como los ojos del robot, emitiendo pulsos de sonido inaudibles para calcular la proximidad de los objetos. Este sensor va montado directamente sobre las paletas del servomotor SG90, el cual gira a izquierda y derecha simulando el barrido de un radar. Finalmente, el módulo puente H L298N recibe las instrucciones lógicas desde Arduino y suministra la corriente necesaria a los motores de tracción izquierdo y derecho.

#include <Servo.h> // Librería estándar para Arduino Uno

Servo sRadar;
const int Trig = 4; // Pin que dispara el pulso
const int Echo = 5; // Pin que recibe el rebote[cite: 7]
const int IN1 = 8, IN2 = 9, IN3 = 10, IN4 = 11; // Músculos L298N

void setup() {
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);

pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);

sRadar.attach(12); // Vincular el pin físico al cable de señal
sRadar.write(90); // Mirar al frente
}

int medirDistancia() {
digitalWrite(Trig, LOW);
delayMicroseconds(2);
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);
long duracion = pulseIn(Echo, HIGH);
return duracion * 0.034 / 2; // Convertir a centímetros
}

void loop() {
sRadar.write(90);
delay(100);
int distancia = medirDistancia();

if (distancia > 0 && distancia < 20) { // Obstáculo a menos de 20 cm
// Freno Total
digitalWrite(IN1, LOW); digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW); digitalWrite(IN4, LOW);

sRadar.write(0); // Escanear derecha
delay(500); // Pausa obligatoria para que el motor alcance la posición
int distDer = medirDistancia();

sRadar.write(180); // Escanear izquierda
delay(500);
int distIzq = medirDistancia();

if (distDer > distIzq) {
// Girar Derecha (Motor A retrocede, Motor B avanza)
digitalWrite(IN1, HIGH); digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH);
} else {
// Girar Izquierda (Motor A avanza, Motor B retrocede)
digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
digitalWrite(IN3, HIGH); digitalWrite(IN4, LOW);
}
delay(1000); // 1000 milisegundos = 1 segundo humano
} else {
// Motor A y B Avanzan
digitalWrite(IN1, LOW); digitalWrite(IN2, HIGH);
digitalWrite(IN3, LOW); digitalWrite(IN4, HIGH);
}
}

Manual de Ingeniería Droide Servo Motores

Manual de Ingeniería Droide Servo Motores

#include <Servo.h>

Servo myservo; // crea el objeto servo

int pos = 0; // posicion del servo

void setup() {
myservo.attach(9); // vincula el servo al pin digital 9
}

void loop() {
//varia la posicion de 0 a 180, con esperas de 15ms
for (pos = 0; pos <= 180; pos += 1)
{
myservo.write(pos);
delay(15);
}

//varia la posicion de 180 a 0, con esperas de 15ms
for (pos = 180; pos >= 0; pos -= 1)
{
myservo.write(pos);
delay(15);
}
}

Sensor Ultrasónico  HC-SR04

Sensor Ultrasónico HC-SR04

Plantilla Básica para Sensor Ultrasónico

// Definición de pines para el sensor ultrasónico
const int Trig = 4; // Pin que dispara el pulso
const int Echo = 5; // Pin que recibe el rebote

long duracion;
int distancia;

void setup() {
Serial.begin(9600); // Iniciamos comunicación para ver los datos en la computadora

// Configuramos el Trigger como salida y el Echo como entrada
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);
}

void loop() {
// 1. Limpiamos el pulso asegurando que el Trigger esté apagado
digitalWrite(Trig, LOW);
delayMicroseconds(2);

// 2. Disparamos un pulso de sonido de 10 microsegundos
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);

// 3. Calculamos el tiempo que tardó el pulso en regresar
duracion = pulseIn(Echo, HIGH);

// 4. Convertimos el tiempo en distancia (centímetros)
distancia = duracion * 0.034 / 2;

// Mostramos el resultado en el Monitor Serie
Serial.print(«Distancia al obstáculo: «);
Serial.print(distancia);
Serial.println(» cm»);

delay(100); // Pausa corta antes del próximo escaneo
}

Evasor de Obstáculos 

// Pines de los «músculos» (Módulo L298N)
const int IN1 = 8;
const int IN2 = 9;
const int IN3 = 10;
const int IN4 = 11;

// Pin del «ojo» o LED indicador
const int ojoDroide = 13;

// Pines del sensor ultrasónico
const int Trig = 4;
const int Echo = 5;

long duracion;
int distancia;

void setup() {
// Iniciamos comunicación para el Monitor Serie
Serial.begin(9600);

// Configuramos el ojo del droide
pinMode(ojoDroide, OUTPUT);

// Configuramos los músculos (L298N)[cite: 2]
pinMode(IN1, OUTPUT); // Conectado a IN1 (Motor A);
pinMode(IN2, OUTPUT); // Conectado a IN2 (Motor A);
pinMode(IN3, OUTPUT); // Conectado a IN3 (Motor B);
pinMode(IN4, OUTPUT); // Conectado a IN4 (Motor B);

// Configuramos el sensor ultrasónico
pinMode(Trig, OUTPUT);
pinMode(Echo, INPUT);
}

void loop() {
// 1. Escanear distancia con el sensor ultrasónico
digitalWrite(Trig, LOW);
delayMicroseconds(2);
digitalWrite(Trig, HIGH);
delayMicroseconds(10);
digitalWrite(Trig, LOW);

duracion = pulseIn(Echo, HIGH);
distancia = duracion * 0.034 / 2;

// 2. Toma de decisiones (El cerebro en acción)
if (distancia > 0 && distancia < 20) {
// ¡Obstáculo detectado a menos de 20 cm!
digitalWrite(ojoDroide, HIGH); // ENCENDER sensor óptico[cite: 2]

// Freno Total para ambos motores[cite: 2]
digitalWrite(IN1, LOW); //[cite: 2]
digitalWrite(IN2, LOW); //[cite: 2]
digitalWrite(IN3, LOW); //[cite: 2]
digitalWrite(IN4, LOW); //[cite: 2]
delay(1000); // 1000 milisegundos = 1 segundo humano[cite: 2]

// Girar a la Derecha para esquivar (Motor A retrocede, Motor B avanza)[cite: 2]
digitalWrite(IN1, HIGH); //[cite: 2]
digitalWrite(IN2, LOW); //[cite: 2]
digitalWrite(IN3, LOW); //[cite: 2]
digitalWrite(IN4, HIGH); //[cite: 2]
delay(1000); // Gira durante 1 segundo[cite: 2]

} else {
// Camino libre, avanzar por defecto
digitalWrite(ojoDroide, LOW); // APAGAR sensor óptico[cite: 2]

// Motor A y B Avanzan[cite: 2]
digitalWrite(IN1, LOW); //[cite: 2]
digitalWrite(IN2, HIGH); //[cite: 2]
digitalWrite(IN3, LOW); //[cite: 2]
digitalWrite(IN4, HIGH); //[cite: 2]
}

delay(50); // Pequeña pausa antes de volver a medir
}

Del Código a la Vida: 5 Secretos Fascinantes Detrás de la Programación de Droides

Del Código a la Vida: 5 Secretos Fascinantes Detrás de la Programación de Droides

¿Alguna vez te has preguntado cómo un simple conjunto de cables, plástico y metal de repente… cobra vida? ¡BOOM! No es magia, es programación. En el Taller de Droides, nos dedicamos a hackear la realidad para que una placa inerte comience a pensar y a moverse. Pasar de un montón de componentes a una entidad con «voluntad» propia es un viaje épico. ¡Let’s go!
A continuación, te revelo los cinco pilares para convertir texto en pantalla en electricidad real y movimiento autónomo.

1. El Arduino no es solo una placa; es un Sistema Nervioso Central
Para entender a un droide, hay que conocer su «corazón»: la Tarjeta de Desarrollo. Nuestro estándar de oro es el Arduino Uno, cuya «Habilidad Especial» es su resistencia y sencillez extrema, ideal para movimientos básicos y sensores de proximidad. Actúa como un Sistema Nervioso Central (SNC) permitiendo que el hardware entienda tus órdenes.
Este sistema cumple tres funciones vitales:
    •  Cerebro: Ejecuta cálculos a una velocidad increíble.
    • Puertos: Los puntos de conexión para los sensores (sus «ojos») y los actuadores (sus músculos).
    • Puente: El traductor que convierte el código humano en impulsos eléctricos.
    • «Por sí solo, es como un droide dormido. No sabe qué hacer. Nuestro trabajo como ingenieros es escribirle un manual de instrucciones.»

 

2. Las «Dos Habitaciones» de la Consciencia Artificial
Dentro del Arduino IDE, la mente del robot se organiza en una estructura dual. Esta división es la razón por la cual un robot puede reaccionar a un obstáculo móvil en tiempo real, a diferencia de un manual de instrucciones estático.

     

  • El Despertar (void setup): Esta configuración ocurre solo UNA vez al arrancar. Es el momento en que el droide se estira y reconoce su cuerpo, preparando los pines que funcionarán como ojos (entradas) y brazos (salidas).
  • La Misión Infinita (void loop): El bucle eterno. Aquí es donde el droide procesa su entorno miles de veces por segundo. Si el código dice «avanza», el droide lo repetirá hasta que una nueva orden o un obstáculo lo detenga.
3. La Relatividad del Tiempo: 1000 ms = 1 Segundo Humano
Los droides piensan a una velocidad que dejaría a un humano en pausa. Por eso, en programación, el tiempo se mide en milisegundos. En la Misión 1: Latido Estándar, aprendemos que 1000ms equivalen a un segundo de parpadeo.
Sin embargo, el verdadero reto de ingeniería surge en la Misión 2: Alerta de Colisión. Aquí, reducimos el delay() a solo 100ms. ¿El resultado? Un efecto estrobo frenético que indica peligro inminente. Ajustar estos tiempos es fundamental; si los milisegundos son demasiados, el robot es lento; si son muy pocos, sus movimientos serán bruscos y torpes.

4. Tracción de Tanque: El Arte de Girar Invirtiendo la Realidad
Hacer que un robot gire requiere una lógica de «tracción de tanque». Para lograrlo, usamos el módulo L298N, que funciona como la interfaz de potencia entre el «Cerebro» (baja energía) y los «músculos» (alta energía de los motores).
Para girar, invertimos la dirección de los motores manipulando los pines IN1 a IN4 en estados HIGH (encendido) o LOW (apagado):

  • Giro a la Izquierda: El Motor A empuja hacia adelante (activando el pin IN2 en HIGH), mientras que el Motor B tira hacia atrás (activando el pin IN3 en HIGH).
  • Giro a la Derecha: El Motor A tira hacia atrás (activando el pin IN1 en HIGH), mientras que el Motor B empuja hacia adelante (activando el pin IN4 en HIGH).

5. El Mapa Mental antes que el Código
Antes de tocar el teclado, un ingeniero dibuja el pensamiento del droide en un Diagrama de Flujo. Este es el mapa del tesoro que evita cortocircuitos lógicos. Usamos tres símbolos clave:

  • Óvalo: Donde despierta el sistema.
  • Rectángulo: Una acción directa (Avanzar o Detenerse).
  • Rombo: Una decisión crítica basada en una pregunta: ¿Hay un obstáculo cerca?

Una vez que el mapa es claro, aplicamos la Gramática Droid. No olvides las llaves { } que definen las «habitaciones» de las órdenes, y jamás olvides el Punto Final ;. El punto y coma es la señal para que el droide pase a la siguiente línea de comando. ¡Sin él, el sistema se bloquea!

«Las llaves definen dónde empieza y termina una zona de órdenes. ¡No dejes puertas abiertas!»

Conclusión: El Futuro es Autónomo
Convertir texto en electricidad es el primer paso para hackear la realidad. Ya logramos que el droide tenga un «latido» y se mueva, pero el siguiente nivel es la autonomía total mediante sensores ultrasónicos para que el robot decida su propio camino.
Esto es solo el comienzo, constructores. Si quieres seguir inventando, te espero en el taller. Ahora, te dejo una pregunta para procesar:
Si pudieras darle a un objeto inanimado la capacidad de tomar una sola decisión por sí mismo, ¿cuál elegirías?
¡Misión Robótica! Descubre el Poder de la Tecnología.

¡Misión Robótica! Descubre el Poder de la Tecnología.

Que es la Robótica?

Si queremos aprender cómo funcionan los robots, ¡tenemos que usar nuestra imaginación! Vamos a aprender los conceptos básicos como si estuviéramos contando un cuento de magia y aventuras:

⚡ 1. La Magia Eléctrica (Cómo le damos vida a nuestro robot) Para que un robot despierte, necesita energía. Imagina que la electricidad es un parque de diversiones con estos tres amigos:

  • Voltaje (El Gran Empujón): Imagina que estás en un columpio y no te mueves. ¡Necesitas que alguien te empuje! El voltaje es ese empujón súper fuerte que hace que la energía comience a moverse por los cables.

  • Corriente (El Río Súper Rápido): Son millones de amiguitos diminutos llamados «electrones» que corren a toda velocidad por el cable como si fueran un río rápido. ¡Ellos son los encargados de encender las luces y mover los motores!

  • Resistencia (El Freno o la Presa de Castores): Si el río va demasiado rápido, nuestro robot se puede lastimar. La resistencia es como una pequeña presa construida por castores que frena un poquito a los electrones para que todo funcione perfecto y seguro.

  • La Batería: ¡Es la mochila de jugos y comida de nuestro robot! De ahí saca toda su energía para jugar.

👐 2. Plastilinas Tecnológicas (Construyendo caminos) ¿Sabías que no siempre necesitamos cables aburridos? ¡Podemos usar plastilina!

  • La Masa Mágica (Conductora): Si hacemos una masita con sal y limón, la electricidad puede viajar a través de ella. ¡Es como construir carreteras blanditas para que corra nuestro «Río» de electrones!

  • El Escudo Protector (Aislante): Si hacemos una masita con azúcar, la electricidad no puede pasar. Esta masa sirve como un muro o un escudo para que la energía no se escape por donde no queremos.

🗺️ 3. Mapas Mágicos para Robots (Programación) Los robots no hablan nuestro mismo idioma, así que tenemos que dibujarles «mapas» en un papel para que sepan qué hacer sin equivocarse. A esto le llamamos Diagramas de Flujo. Usamos figuras secretas:

  • 🟢 El Óvalo: Nos dice dónde «Empieza» y dónde «Termina» el juego.

  • 🟦 El Rectángulo: Es una orden directa. Ejemplo: «Da un paso al frente» o «Levanta el brazo».

  • 🔶 El Rombo: Es un detective que hace preguntas. Ejemplo: «¿Hay una pared enfrente?». Si la respuesta es SÍ, el robot gira. Si es NO, sigue caminando.

¡Un reto rápido para ti! 🚦 Imagina que tú eres el robot y tienes que cruzarte la calle. ¿Cómo dibujarías tu «Mapa Mágico» de pasos en un papel? (Pista: Inicio -> Mirar a la izquierda -> Mirar a la derecha -> ¿Viene un coche? (Sí/No) -> Caminar -> Fin).

¡Aprender robótica es como aprender a hacer trucos de magia con la tecnología! ¿Listos para construir cosas increíbles? 🚀🔧

Descarga Pdf Completo

¿Qué es la Robótica?

CEB  Bilingue Eben-Ezer
Resumen de privacidad

Esta web utiliza cookies para que podamos ofrecerte la mejor experiencia de usuario posible. La información de las cookies se almacena en tu navegador y realiza funciones tales como reconocerte cuando vuelves a nuestra web o ayudar a nuestro equipo a comprender qué secciones de la web encuentras más interesantes y útiles.