Hace unos días, mientras programaba un robot móvil, recordé mi primer proyecto con sensores. No sabía cómo detectar obstáculos, y siempre terminaba chocando. Fue entonces cuando descubrí el sensor ultrasónico, un módulo económico y fácil de usar. En este tutorial, te enseñaré paso a paso cómo conectar y programar este sensor para que tu robot también pueda medir distancias y evitar colisiones de manera inteligente.
Tabla de contenidos
Lista de materiales
Lista de materiales para conectar y programar el sensor ultrasónico HC-SR04 con Arduino en proyectos de robótica.
| Cantidad | Material | Función |
|---|---|---|
| 1 | Arduino Uno | Controlador principal del proyecto |
| 1 | Sensor ultrasónico HC-SR04 | Mide la distancia hasta un objeto u obstáculo |
| 1 | Protoboard | Facilita las conexiones sin soldadura |
| 4 | Jumpers macho-macho | Realizar conexiones entre el Arduino y el sensor |
| 1 | Cable USB | Conecta Arduino a la computadora para programación |
Diagrama de Conexiones
Paso 1: Preparar materiales y espacio de trabajo
Reúne el Arduino, el sensor ultrasónico, los jumpers y la protoboard. Asegúrate de trabajar en una superficie limpia y ordenada para evitar confusiones en las conexiones.
Paso 2: Identificar los pines del sensor HC-SR04
Ubica los cuatro pines del sensor: VCC, TRIG, ECHO y GND. Generalmente están marcados en la parte inferior del módulo, revisa antes de conectar.
Paso 3: Conectar VCC del sensor a 5V de Arduino
Usa un jumper para conectar el pin VCC del sensor al pin de 5V en el Arduino, proporcionando la alimentación necesaria para su funcionamiento.
Paso 4: Conectar GND del sensor a GND de Arduino
Conecta el pin GND del sensor al pin GND del Arduino para completar el circuito de alimentación y asegurar un funcionamiento estable.
Paso 5: Conectar TRIG del sensor al pin digital 9 de Arduino
Conecta el pin TRIG del sensor al pin digital 9 del Arduino. Este pin se encargará de enviar el pulso ultrasónico para medir distancias.
Paso 6: Conectar ECHO del sensor al pin digital 8 de Arduino
Conecta el pin ECHO del sensor al pin digital 8 del Arduino. Este pin recibirá la señal de retorno que permite calcular la distancia.
Código Arduino
Aquí te presento el código completo para usar el sensor ultrasónico Arduino y medir distancias en tus proyectos de robótica.
// -------------------------------
// SENSOR ULTRASÓNICO HC-SR04
// USO EN ROBÓTICA
// -------------------------------
// En robótica, este sensor se usa para detectar obstáculos y medir distancias.
// Por ejemplo, en un robot móvil evita chocar contra objetos,
// o en un brazo robótico mide si hay algo frente a la pinza.
// 1. Definimos los pines de conexión del sensor.
#define trigPin 9 // Pin digital 9 conectado al pin TRIG del sensor
#define echoPin 8 // Pin digital 8 conectado al pin ECHO del sensor
// 2. Variable para almacenar la duración del pulso y la distancia calculada
long duration; // Duración del pulso en microsegundos
int distance; // Distancia calculada en centímetros
void setup() {
// 3. Iniciamos la comunicación serial para ver resultados en la computadora
Serial.begin(9600);
// 4. Configuramos los pines
pinMode(trigPin, OUTPUT); // TRIG se configura como salida, envía el pulso
pinMode(echoPin, INPUT); // ECHO se configura como entrada, recibe el eco
}
void loop() {
// 5. Para medir distancia, primero limpiamos el pin TRIG por 2 microsegundos
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
// 6. Enviamos un pulso de 10 microsegundos para activar el sensor
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// 7. Medimos el tiempo que tarda en regresar el eco
duration = pulseIn(echoPin, HIGH);
// 8. Calculamos la distancia:
// La velocidad del sonido es 0.034 cm/us
// Dividimos entre 2 porque el pulso va y regresa
distance = duration * 0.034 / 2;
// 9. Mostramos la distancia en el monitor serial
Serial.print("Distancia: ");
Serial.print(distance);
Serial.println(" cm");
// 10. Pausa de medio segundo antes de la siguiente medición
delay(500);
// -----------------------------------------
// RELACIÓN CON ROBÓTICA
// Este código puede usarse en un robot móvil autónomo
// para evitar chocar con paredes u objetos.
// También en brazos robóticos para calcular la distancia a un objeto
// antes de cerrar la pinza.
// -----------------------------------------
}
Explicación del código
Paso 1: Definición de pines
#define trigPin 9
#define echoPin 8
Aquí se definen los pines digitales que se usan para conectar el sensor. trigPin (9) enviará el pulso ultrasónico y echoPin (8) recibirá el eco reflejado. Es importante porque si cambias los pines físicos en tu Arduino debes modificar estos valores aquí para que el programa funcione correctamente.
Paso 2: Configurar pines
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
Se configuran los pines declarados. trigPin se configura como salida porque enviará el pulso ultrasónico y echoPin como entrada porque recibirá el eco. Esta configuración es esencial para que el sensor cumpla su función de enviar y recibir señales al medir distancias.
Paso 3: Enviar el pulso ultrasónico
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
Este bloque primero limpia el TRIG poniéndolo en LOW, espera 2 microsegundos, luego envía un pulso de 10 microsegundos con HIGH y lo apaga. Esto activa el sensor ultrasónico para emitir la señal y detectar objetos al frente. Es la base de la medición.
Paso 4: Medir la duración del eco
duration = pulseIn(echoPin, HIGH);
Aquí se mide el tiempo (en microsegundos) que tarda el eco en regresar al sensor después de chocar contra un objeto. Este dato se usa luego para calcular la distancia, siendo la base de todo el funcionamiento del sensor ultrasónico.
Paso 5: Calcular la distancia
distance = duration * 0.034 / 2;
Calcula la distancia con la fórmula basada en la velocidad del sonido (0.034 cm/us) y dividiéndolo entre 2, ya que el pulso va y regresa. Es fundamental entender esta fórmula para ajustar el sensor a distintas aplicaciones en robótica educativa.
Pruebas Experimentales
Realiza estas pruebas para verificar el funcionamiento del sensor ultrasónico con Arduino de forma correcta y segura.
Paso 1: Preparar el circuito
Verifica que todas las conexiones entre el Arduino y el sensor ultrasónico estén correctas según el diagrama y no haya cables sueltos.
Paso 2: Abrir Arduino IDE
Abre el Arduino IDE en tu computadora y asegúrate de haber seleccionado el puerto y placa correctos antes de cargar el programa.
Paso 3: Cargar el código al Arduino
Haz clic en el botón «Subir» en Arduino IDE y espera a que termine la compilación y carga. Revisa que aparezca el mensaje de carga exitosa.
Paso 4: Abrir el Monitor Serial
Ve al menú Herramientas > Monitor Serial o haz clic en su icono para abrirlo y observar las mediciones de distancia que realiza el sensor.
Paso 5: Colocar objetos frente al sensor
Acerca y aleja objetos frente al sensor ultrasónico HC-SR04 y observa cómo los valores de distancia cambian en tiempo real en el monitor serial.
Paso 6: Verificar el rango de medición
Prueba con objetos a diferentes distancias para verificar que el sensor detecte de forma adecuada dentro de su rango de trabajo (2cm a 400cm).
Paso 7: Revisar posibles errores
Si no aparecen mediciones, revisa las conexiones de VCC, GND, TRIG y ECHO, así como los pines definidos en el código para corregir errores.