Dominando el sensor ultrasónico HC-SR04 con Arduino: Tutorial completo

En este tutorial aprenderemos cómo funciona el sensor ultrasónico HC-SR04 y cómo usarlo con Arduino. Es el sensor más popular para medir distancia y crear robots esquiva-obstáculos con Arduino.

Ya he usado el HC-SR04 en varios proyectos geniales:

• Radar (Sonar) Arduino
• Medidor de Distancia y Nivel Digital
• Proyecto Sistema de Seguridad y Alarma
• Robot Hexápodo Hormiga Arduino

Puedes ver el vídeo o leer el tutorial escrito. Incluye especificaciones, pinouts, diagramas de conexión, códigos y más.

Visión general hardware HC-SR04

El HC-SR04 es un sensor de medición de distancia asequible y fácil de usar, con rango de 2 cm a 400 cm (~1 pulgada a 13 pies).

Está compuesto por dos transductores ultrasónicos: uno transmisor (emite pulsos ultrasónicos) y otro receptor (escucha ondas reflejadas). Es básicamente un SONAR como el usado en submarinos para detectar objetos submarinos.

Especificaciones principales:

Pinout del sensor ultrasónico HC-SR04

Pinout del sensor:

Tiene 4 pines: VCC y GND a 5V y GND de Arduino; Trig y Echo a pines digitales cualquiera. Por Trig enviamos la onda ultrasónica; por Echo escuchamos la señal reflejada.

¿Cómo funciona el sensor de distancia ultrasónico HC-SR04?

Emite ultrasónidos a 40 kHz que viajan por el aire. Si hay un objeto en su camino, rebotan hacia el módulo. Conociendo el tiempo de viaje y la velocidad del sonido, calculamos la distancia.

Para generar el ultrasónico, ponemos el pin Trig en HIGH durante 10 µs. Eso envía una ráfaga de 8 ciclos ultrasónicos que viaja a la velocidad del sonido. El pin Echo pasa a HIGH justo después y empieza a esperar el eco.

Si no hay objeto, Echo hace timeout tras 38 ms y vuelve a LOW.

Si recibimos eco, Echo baja antes de 38 ms. Según el tiempo que Echo estuvo HIGH, determinamos la distancia recorrida por la onda, es decir, la distancia sensor-objeto.

Fórmula básica:

Distancia = Velocidad × Tiempo

Conocemos ambos valores: el tiempo es la duración del pulso HIGH en Echo; la velocidad del sonido es 340 m/s. Un paso extra: dividir entre 2, porque medimos ida y vuelta.

Ejemplo: Echo HIGH 2 ms. Convertimos velocidad a 34 cm/ms.

Distancia = (34 cm/ms × 2 ms) / 2 = 34 cm

Si Echo estuvo HIGH 2 ms (medido con pulseIn()), la distancia es 34 cm.

Cómo conectar HC-SR04 a Arduino

Diagrama de conexiones:

GND y VCC del módulo a GND y 5V de Arduino; Trig y Echo a pines digitales cualesquiera.

Componentes necesarios:

• Sensor Ultrasónico HC-SR04 …………
• Placa Arduino ……………………………
• Protoboard y cables jumpers ………

Código Arduino para sensor HC-SR04

/* Sensor Ultrasónico HC-SR04 y Arduino por Dejan Nedelkovski, www.HowToMechatronics.com */

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  // Limpia trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Pulso HIGH 10 µs
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Lee tiempo de viaje en µs
  duration = pulseIn(echoPin, HIGH);

  // Calcula distancia
  distance = duration * 0.034 / 2;

  // Muestra en Monitor Serial
  Serial.print("Distancia: ");
  Serial.println(distance);
}

Explicación del código

Definimos pines Trig y Echo (9 y 10). Variable long duration para tiempo de viaje, int distance para distancia.

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;

En setup(): Trig como OUTPUT, Echo como INPUT, iniciamos comunicación serial.

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

En loop(): limpiamos Trig (LOW 2 µs), generamos pulso HIGH 10 µs.

digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

pulseIn(echoPin, HIGH) lee la duración del pulso HIGH y la guarda en duration. Parámetros: pin Echo y estado del pulso (HIGH). El sensor pone Echo HIGH tras enviar la ráfaga; al recibir el eco, Echo baja a LOW, deteniendo el temporizador. Devuelve longitud del pulso en µs.

duration = pulseIn(echoPin, HIGH);

Calculamos distancia: duration * 0.034 / 2 (explicado antes).

distance = duration * 0.034 / 2;
Serial.print("Distancia: ");
Serial.println(distance);

Ejemplo: Sensor ultrasónico Arduino y display LCD

Ejemplo mostrando resultados en LCD:

Conexión sensor ultrasónico y LCD:

El código de medición es igual al básico; en vez de Serial, imprimimos en LCD. Para más detalles de LCD con Arduino, consulta mi tutorial dedicado.

/* Sensor HC-SR04 y Arduino con LCD por Dejan Nedelkovski, www.HowToMechatronics.com */
#include <LiquidCrystal.h>
LiquidCrystal lcd(1, 2, 4, 5, 6, 7);

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distanceCm, distanceInch;

void setup() {
  lcd.begin(16, 2);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distanceCm = duration * 0.034 / 2;
  distanceInch = duration * 0.0133 / 2;
  lcd.setCursor(0, 0);
  lcd.print("Distancia: ");
  lcd.print(distanceCm);
  lcd.print(" cm");
  delay(10);
  lcd.setCursor(0, 1);
  lcd.print("Distancia: ");
  lcd.print(distanceInch);
  lcd.print(" inch");
  delay(10);
}

Código de ejemplo usando librería NewPing

Forma más simple y mejor: librería NewPing. En el código anterior disparábamos manualmente y medíamos el pulso. Con NewPing, obtenemos distancia en una sola línea.

#include <NewPing.h>
#define TRIGGER_PIN 9
#define ECHO_PIN 10
#define MAX_DISTANCE 400 // Distancia máxima a medir (cm)

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {
  Serial.begin(9600);
}

void loop() {
  delay(50); // 50ms entre pings (~20 pings/seg). Mín 29ms.
  int distance = sonar.ping_cm(); // Envía ping, obtiene distancia en cm (0 = fuera de rango)
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println("cm");
}

Mucho más simple: sonar.ping_cm() devuelve distancia en cm. Para pulgadas: ping_in().

La librería tiene más funciones útiles. ping_median(iteraciones[, max_cm]) devuelve la mediana de varias mediciones para mayor precisión. Parámetro iteraciones = número de muestras (por defecto 5). Devuelve duración del pulso en µs.

Para más info, consulta la wiki de NewPing.

Mejorando la precisión del HC-SR04 con sensor de temperatura DHT22

El HC-SR04 es bastante preciso, pero al depender de la velocidad del sonido, para mayor precisión debemos considerar la temperatura del aire. Esta cambia significativamente con la temperatura: a 20°C ~340 m/s, a -20°C ~315 m/s. La humedad relativa también afecta.

Implementamos compensación de temperatura con:

Velocidad = 331.4 + 0.6 × Temperatura + 0.0124 × Humedad_Relativa

Ejemplo:

Junto al HC-SR04 usamos DHT11/DHT22 para medir temperatura y humedad, y ajustar la velocidad del sonido.

Código Arduino

/* Ejemplo por Dejan, How To Mechatronics, https://howtomechatronics.com/ */
#include <NewPing.h> // https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home
#include "dht.h"    // https://github.com/RobTillaart/DHTlib

#define TRIGGER_PIN 9
#define ECHO_PIN 10
#define MAX_DISTANCE 400
#define dht22 5 // DHT22 pin

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
dht DHT;

int readDHT, temp, hum;
float speedOfSound, distance, duration;

void setup() {
  Serial.begin(9600);
}

void loop() {
  delay(100);
  // Lee temperatura y humedad DHT22
  readDHT = DHT.read22(dht22);
  temp = DHT.temperature;
  hum = DHT.humidity;
  // Calcula velocidad sonido en m/s
  speedOfSound = 331.4 + (0.6 * temp) + (0.0124 * hum);
  // Duración viaje sonido en µs (mediana 10 iteraciones)
  duration = sonar.ping_median(10);
  duration = duration / 1000000; // µs a segundos
  distance = (speedOfSound * duration) / 2;
  distance = distance * 100; // metros a cm
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println("cm");
}

Leemos temp/humedad del DHT22, calculamos velocidad del sonido, obtenemos duración en µs, convertimos a segundos, calculamos distancia en cm.

Dimensiones y modelo 3D del HC-SR04

He hecho un modelo 3D del HC-SR04 por si lo necesitas en tus proyectos. Descargable en el enlace.

Modelo 3D disponible en Thangs.

Dimensiones del HC-SR04:

Nota: pueden variar ligeramente según fabricante.

Conclusión

Hemos cubierto todo lo necesario sobre el HC-SR04 con Arduino. Es un sensor genial para proyectos DIY que requieren medición de distancia sin contacto, detección de presencia/objetos, nivel, posición, etc.

Proyectos mencionados al inicio y otros más:

• Cubo de Basura Automático Sin Contacto
• Control Luz Inteligente por Gestos
• Levitación Acústica Mini
• Robot Esquiva-Obstáculos

¡Espero que hayas disfrutado y aprendido! Pregunta en comentarios y revisa mi colección de 30+ proyectos Arduino.