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
}

Estructura Web

Estructura Web

  • Una página web es un archivo informático que se guarda con la terminación .html (por ejemplo, mipagina.html) y que está diseñado para abrirse y visualizarse directamente en un navegador web.
  • HTML es el código o lenguaje que proporciona la estructura básica obligatoria para construir esa página web. Su funcionamiento se puede entender fácilmente comparándolo con un sándwich o con el cuerpo humano:
1. La Estructura Principal (El Esqueleto)

  • <html> (La Caja Principal / El Terreno): Es la etiqueta que envuelve absolutamente todo. Le dice al navegador: «¡Atención, aquí empieza nuestra página web!».
    • <title> (El Nombre en la Pestaña): Va dentro de <head>. Es el texto que aparece arriba en la pestaña del navegador.head> (La Cabeza / El Cerebro): Guarda la información invisible para los visitantes, pero necesaria para el navegador (como las instrucciones o el nombre de la página). 
    •  

  • <body> (El Cuerpo Visible): Todo lo que se coloca aquí sí se ve en la pantalla: textos, imágenes, botones y videos.
  •  

2. Las Etiquetas de Contenido Más Comunes

<h1> a <h6> (Los Títulos):

     

    •  

       

    • <h1> es el título gigante (el nombre principal de la historia o tema).
    • <h2> a <h6> son subtítulos cada vez más pequeños para organizar la información 
    •  

       

  • <p> (El Párrafo): Sirve para escribir bloques de texto, oraciones o explicaciones.
  • <img> (La Fotografía / Dibujo): Coloca fotos o GIFs en la pantalla mediante el atributo src (la dirección de la imagen).
  • <a> (El Portal Mágico / Enlace): Crea un texto o botón en el que se puede hacer clic para viajar a otra página web.
  • <ul> y <li> (Las Listas de Listados): Sirven para hacer listas de cosas (como los ingredientes de una receta, personajes o pasatiempos). 
  •  

3. Ejemplo de «Mi Primera Página Web»
Este es el bloque de código básico para mostrarles cómo se juntan todas las piezas:
<!DOCTYPE html>
<html>
  <head>
    <title>Mi Super Página</title>
  </head>
  <body>
    <h1>¡Bienvenido a mi sitio web! 🚀</h1>
    <p>¡Hola! Soy un creador web y este es mi primer proyecto.</p>

    <h2>Mis pasatiempos favoritos:</h2>
    <ul>
      <li>Jugar videojuegos 🎮</li>
      <li>Aprender tecnología 💻</li>
      <li>Dibujar 🎨</li>
    </ul>

    <a href="https://www.wikipedia.org">¡Haz clic aquí para explorar el mundo!</a>
  </body>
</html>
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?
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.