Cómo utilizar un sensor de distancia ultrasónico HC-SR04 con Arduino

The HC-SR04 is an inexpensive, easy to use ultrasonic distance sensor, with a range of 2cm to 400 cm. It is commonly used in obstacle avoiding robots and automation projects. In this tutorial, you will learn how the sensor works and how to use it with Arduino.

He incluido 5 ejemplos con un diagrama de cableado y código para que puedas empezar a experimentar con tu sensor. Primero veremos un ejemplo que no utiliza una biblioteca de Arduino. A continuación, le mostraré cómo puede utilizar la biblioteca NewPing para crear un código más compacto.

Los sensores ultrasónicos de distancia/proximidad baratos son estupendos, pero en algunos proyectos puede que necesites un sensor resistente al agua como el JSN-SR04T o un sensor IR que no se vea influenciado por los cambios de temperatura. En ese caso, los artículos siguientes pueden ser útiles:

• Sensor de distancia ultrasónico impermeable JSN-SR04T con tutorial de Arduino
• Cómo utilizar un sensor de distancia IR SHARP GP2Y0A21YK0F con Arduino
• Cómo utilizar un sensor de distancia IR SHARP GP2Y0A710K0F con Arduino
• Tutorial del sensor de distancia resistente a la intemperie MaxBotix MB7389
• Tutorial Arduino del sensor de distancia ultrasónico MaxBotix MB1240

Suministros

Componentes de hardware

	Sensor HC-SR04	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Tablero de pruebas	× 1	Amazon
	Cables de puente	~ 10	Amazon
	Cable USB tipo A/B	× 1	Amazon
	LCD I2C de 20×4 caracteres (opcional)	× 1	Amazon
	Sensor DHT11 (opcional)	× 1	Amazon

Software

Arduino IDE

Makerguides.com is a participant in the Amazon Services LLC Associates Program, an affiliate advertising program designed to provide a means for sites to earn advertising fees by advertising and linking to products on Amazon.com. As an Amazon Associate we earn from qualifying purchases.

¿Cómo funciona un sensor de distancia por ultrasonidos?

Los sensores ultrasónicos funcionan emitiendo ondas sonoras con una frecuencia demasiado alta para que el ser humano las oiga. Estas ondas sonoras viajan por el aire con la velocidad del sonido, aproximadamente 343 m/s. Si hay un objeto delante del sensor, las ondas sonoras se reflejan y el receptor del sensor ultrasónico las detecta. Midiendo el tiempo transcurrido entre el envío y la recepción de las ondas sonoras, se puede calcular la distancia entre el sensor y el objeto.

A 20°C, la velocidad del sonido es de aproximadamente 343 m/s o 0,034 cm/µs. Digamos que el tiempo entre el envío y la recepción de las ondas sonoras es de 2000 microsegundos. Si multiplicas la velocidad del sonido por el tiempo que recorrieron las ondas sonoras, obtienes la distancia que recorrieron las ondas sonoras.

Distancia = Velocidad x Tiempo

Pero ese no es el resultado que buscamos. La distancia entre el sensor y el objeto es, en realidad, sólo la mitad de esta distancia porque las ondas sonoras viajaron del sensor al objeto y de vuelta del objeto al sensor. Así que hay que dividir el resultado por dos.

Distancia (cm) = Velocidad del sonido (cm/µs) × Tiempo (µs) / 2

Y así para el ejemplo esto se convierte:

Distancia (cm) = 0,0343 (cm/µs) × 2000 (µs) / 2 = 34,3 cm

Dependencia de la temperatura de la velocidad del sonido

En realidad, la velocidad del sonido depende en gran medida de la temperatura y, en mucho menor grado, de la humedad del aire. Wikipedia afirma que la velocidad del sonido aumenta aproximadamente 0,6 m/s por grado Celsius. Para la mayoría de los casos, a 20°C puedes utilizar simplemente 343 m/s, pero si quieres obtener lecturas más precisas, puedes calcular la velocidad del sonido con la siguiente fórmula:

V (m/s) = 331,3 + (0,606 × T)

V = Velocidad del sonido (m/s)
T = Temperatura del aire (°C)

Esta fórmula no incluye la humedad, ya que su efecto sobre la velocidad del sonido es muy pequeño.

A continuación puede encontrar un tutorial sobre cómo utilizar un sensor de temperatura y humedad DHT11 para calibrar la velocidad del sonido y obtener una lectura de distancia más precisa con el HC-SR04.

Cómo funciona el HC-SR04

At the front of the HC-SR04 sensor, you can find two silver cylinders (ultrasonic transducers), one is the transmitter of the sound waves and the other is the receiver. To let the sensor generate a sonic burst, you need to set the Trig pin high for at least 10 µs. The sensor then creates an 8 cycle burst of ultrasound at 40 kHz.

Esta ráfaga sónica viaja a la velocidad del sonido y rebota y es recibida por el receptor del sensor. La clavija Echo indica entonces el tiempo que han viajado las ondas sonoras en microsegundos.

Puede utilizar el pulseIn() en el código de Arduino para leer la longitud del pulso del pin Echo. Después de eso, puede utilizar la fórmula mencionada anteriormente para calcular la distancia entre el sensor y el objeto.

Especificaciones del HC-SR04

Tensión de funcionamiento	5 V
Corriente de trabajo	15 mA
Frecuencia	40 kHz
Rango de medición	2 - 400 cm
Resolución	3 mm
Ángulo de medición	15 grados
Señal de entrada de disparo	Pulso alto de 10 µs
Coste	Comprobar el precio

Para más información, puede consultar la hoja de datos que aparece a continuación:

Cableado - Conexión del HC-SR04 al Arduino UNO

El siguiente diagrama de cableado muestra cómo conectar el sensor HC-SR04 al Arduino.

Los ejemplos de código que siguen utilizan los pines digitales 2 y 3 para el disparador y el pin de eco respectivamente, pero por supuesto puedes cambiarlo por cualquier pin digital que quieras.

Conexiones HC-SR04

HC-SR04	Arduino
VCC	5 V
Trig	Clavija 2
Eco	Clavija 3
GND	GND

Código de ejemplo para HC-SR04 con Arduino

Ahora que has cableado el sensor es el momento de conectar el Arduino al ordenador y cargar algo de código. Puedes subir el siguiente código de ejemplo a tu Arduino utilizando el IDE de Arduino. A continuación, te explicaré cómo funciona el código.

/* Example code for HC-SR04 ultrasonic distance sensor with Arduino. 
   No library required. More info: https://www.makerguides.com */

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);
  // Calculate the distance:
  distance = duration * 0.034 / 2;

  // Print the distance on the Serial Monitor (Ctrl+Shift+M):
  Serial.print("Distance = ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(50);
}

Cómo funciona el código

En primer lugar, se definen el pin de disparo y el pin de eco. Los llamo trigPin y EchoPin. El pin de disparo se conecta al pin digital 2 y el pin de eco al pin digital 3 en el Arduino.

La declaración #define se utiliza para dar un nombre a un valor constante. El compilador sustituirá cualquier referencia a esta constante por el valor definido cuando se compile el programa. Por lo tanto, en todos los casos en los que se menciona trigPinel compilador lo sustituirá por el valor 2 al compilar el programa.

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

A continuación he definido dos variables: duration y distance. La duración almacena el tiempo entre el envío y la recepción de las ondas sonoras. La variable distancia se utiliza para almacenar la distancia calculada.

// Define variables:
long duration;
int distance;

En el setup()En este caso, se empieza por configurar el trigPin como salida y el echoPin como entrada. A continuación se inicializa la comunicación en serie a una velocidad de 9600 baudios. Más tarde mostrarás la distancia medida en el monitor serie, al que puedes acceder con Ctrl+Mayús+M o Herramientas > Monitor Serie. Asegúrate de que la tasa de baudios también está ajustada a 9600 en el monitor serie.

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  //Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

En el loop()En el caso de que el sensor se dispare, se debe poner el trigPin en HIGH durante 10 µs. Ten en cuenta que para obtener una señal limpia debes empezar por despejar el trigPin poniéndolo en LOW durante 5 microsegundos.

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

A continuación, hay que leer la longitud del pulso enviado por el echoPin. Yo uso la función pulseIn() para esto. Esta función espera que el pin pase de LOW a HIGH, inicia la temporización, luego espera que el pin pase a LOW y detiene la temporización.

Después, puedes calcular la distancia utilizando la fórmula mencionada en la introducción de este tutorial.

// Read the echoPin, pulseIn() returns the duration (length of the pulse) in microseconds:
duration = pulseIn(echoPin, HIGH);
// Calculate the distance:
distance = duration * 0.034 / 2;

Finalmente, la distancia calculada se imprime en el monitor de serie.

// Print the distance on the Serial Monitor (Ctrl+Shift+M):
Serial.print("Distance = ");
Serial.print(distance);
Serial.println(" cm");

delay(50);

Código de ejemplo HC-SR04 con Arduino y la biblioteca NewPing

La librería NewPing escrita por Tim Eckel puede utilizarse con muchos sensores de distancia ultrasónicos. La última versión de esta biblioteca se puede descargar aquí en bitbucket.org. Puedes notar que el código de abajo, que usa la librería NewPing, es mucho más corto que el código que usamos antes. Además de eso, la biblioteca NewPing incluye algunas otras buenas características. Te permite establecer una distancia máxima para leer, no se retrasa durante un segundo completo cuando no se recibe ningún eco y tiene un filtro de mediana incorporado.

Puedes instalar la librería yendo a Sketch > Include Library > Add .ZIP Library en el IDE de Arduino.

La librería incluye algunos ejemplos que puedes usar, pero tendrás que modificarlos para que coincidan con tu configuración de hardware. He incluido un código de ejemplo modificado a continuación que se puede utilizar con la misma configuración de cableado que antes.

/* HC-SR04 ultrasonic distance sensor with 
   NewPing library example code. 
   More info: www.www.makerguides.com */

// Include the library:
#include "NewPing.h"

// Define pins and max distance:
#define trigPin  2
#define echoPin  3
#define MAX_DISTANCE 350 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
float duration, distance;

void setup() {
  Serial.begin(9600); // Open serial monitor at 9600 baud to see ping results.
}

void loop() {
  delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  
  duration = sonar.ping();
  distance = (duration / 2) * 0.0343;
  
  Serial.print("Distance = ");
  Serial.print(distance); // Distance will be 0 when out of set max range.
  Serial.println(" cm");
}

También puede utilizar distance = sonar.ping_cm() o distance = sonar.ping_in() que devuelve la distancia medida en centímetros o pulgadas enteras. Con esta función no es necesario tomar una medida de duración y calcular la distancia.

Conexión de sensores de ultrasonidos en modo de 3 pines

La librería NewPing también hace que sea fácil interactuar con los sensores ultrasónicos mientras se utiliza sólo 1 pin de E/S. Esto puede ser útil si tienes muy pocos pines de E/S disponibles o si quieres usar un sensor ultrasónico de 3 pines como el Parallax Ping.

Para crear una configuración de 3 pines (GND, 5V y SIG) tienes que conectar tanto el pin de disparo como el pin de eco al mismo pin digital en el Arduino. En el código, lo único que tienes que cambiar es la línea 6-7 y definir el mismo pin para el trigPin y el echoPin. Por ejemplo el pin digital 2.

//Define Trig and Echo pin
#define trigPin 2
#define echoPin 2

Cómo utilizar el filtro digital ping_median()

Lo que más me gusta de la biblioteca NewPing es que tiene un filtro de mediana incorporado. Este filtro puede mejorar en gran medida la precisión de las lecturas del HC-SR04. El ping_median() toma muchas mediciones de duración seguidas, desecha las lecturas fuera de rango y luego promedia las restantes. Por defecto tomará 5 lecturas, pero se puede especificar cuántas debe tomar. Sustituya la línea 19 por las siguientes.

int iteraciones = 5;
duration = sonar.ping_median(iteraciones);

Código de ejemplo HC-SR04 con LCD I2C y Arduino

Para mostrar la distancia medida en una pantalla LCD I2C 2004 o 1602, todo lo que tiene que hacer es realizar las siguientes conexiones y cargar el código que aparece a continuación. El sensor HC-SR04 se conecta de la misma manera que antes.

Conexiones I2C LCD

I2C LCD	Arduino
GND	GND
VCC	5 V
SDA	A4
SCL	A5

Si no estás usando un Arduino Uno, los pines SDA y SCL pueden estar en una ubicación diferente. Un Arduino UNO con la disposición R3 (pinout 1.0), también tiene las cabeceras de los pines SDA (línea de datos) y SCL (línea de reloj) cerca del pin AREF. Consulta la tabla siguiente para obtener más detalles.

Junta	SDA	SCL
Arduino Uno	A4	A5
Arduino Nano	A4	A5
Arduino Micro	2	3
Arduino Mega 2560	20	21
Arduino Leonardo	2	3
Arduino Due	20	21

El código utiliza la biblioteca LiquidCrystal_I2C, que puedes descargar aquí en GitHub. ¡Asegúrate de tener instalada exactamente esta librería! También incluye la librería Wire.h, que te permite comunicarte con dispositivos I2C. Esta biblioteca debería venir preinstalada con el IDE de Arduino.

If you want to learn more about how to control a I2C LCD with Arduino, you can check out our tutorial on How to control a character I2C LCD with Arduino.

/* HC-SR04 ultrasonic distance sensor with 
   Arduino and I2C LCD example code.
   More info: https://www.makerguides.com
*/

#include "Wire.h"
#include "LiquidCrystal_I2C.h"

// Define Trig and Echo pin:
#define trigPin 2
#define echoPin 3

// Define SDA and SCL pin for LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4); //Change to (0x27,16,2) for 1602 LCD 

// Define variables:
long duration;
int distance;

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance:
  distance = duration*0.034/2;

  // Display the distance on the LCD:
  lcd.setCursor(0,0); // Set the cursor to column 1, line 1 (counting starts at zero)
  lcd.print("Distance = "); // Prints string "Display = " on the LCD
  lcd.print(distance); // Prints the measured distance
  lcd.print(" cm  "); // Prints "cm" on the LCD, extra spaces are needed to clear previously displayed characters
  
  delay(50);
}

Tenga en cuenta que he utilizado una pantalla LCD de 20 x 4. Si usted tiene una pantalla LCD de diferente tamaño (16 x 2 también es común) debe cambiar la línea 20 a LiquidCrystal_I2C lcd(0x27,16,2);. Si tu LCD no tiene la dirección I2C por defecto, 0x27, consulta el tutorial completo de I2C donde explico cómo puedes averiguar cuál es la dirección.

Código de ejemplo HC-SR04 con sensor de temperatura DHT11 y Arduino

Como se ha mencionado anteriormente, la velocidad del sonido depende en gran medida de la temperatura del aire. Si quieres medir distancias largas (3-4 m) puede ser una buena idea añadir un sensor de temperatura y humedad DHT11 o DHT22 a tu configuración. Esto le permitirá calibrar la velocidad del sonido en tiempo real y así aumentar la precisión de sus mediciones.

Añadir un sensor DHT11 es realmente sencillo. El diagrama de cableado de abajo muestra las conexiones que necesitas hacer. Ten en cuenta que estoy utilizando un DHT11 con una placa de circuito impreso, por lo que sólo tengo que conectar 3 pines. Asegúrate de comprobar la etiqueta del sensor, el orden de los pines puede ser diferente dependiendo del fabricante. El sensor HC-SR04 se conecta de la misma manera que antes.

Conexiones DHT11

DHT11	Arduino
VCC (+)	5 V
Señal (s)	Clavija 4
GND (-)	GND

El código de abajo usa la librería Adafruit DHT Humidity & Temperature Sensor que puedes descargar aquí en GitHub. Esta biblioteca sólo funciona si también tienes instalada la biblioteca Adafruit_Sensor , que también está disponible en GitHub. También puedes descargar las dos librerías haciendo clic en los botones de abajo:

Puede hacer clic en el botón de la esquina superior derecha del campo de código para copiar el código.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11 and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" //https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" //https://github.com/adafruit/DHT-sensor-library

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Begin Serial communication:
  Serial.begin(9600); // Starts the serial communication
}

void loop() {
  //  Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  float temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  Serial.print("Temperature = ");
  Serial.print(temperature);
  Serial.print(" Celsius");
  Serial.print(", Distance = ");
  Serial.print(distance);
  Serial.println("cm");
  delay(100);
}

Código de ejemplo HC-SR04 con DHT11 e I2C LCD

El código siguiente puede utilizarse para combinar los 3 ejemplos anteriores. Muestra tanto la temperatura como la velocidad del sonido y la distancia medida en la pantalla LCD.

/* HC-SR04 ultrasonic distance sensor with 
   DHT11, I2C LCD and Arduino example code.
   More info: https://www.makerguides.com */

#include "Adafruit_Sensor.h" // https://github.com/adafruit/Adafruit_Sensor
#include "DHT.h" // https://github.com/adafruit/DHT-sensor-library
#include "Wire.h" // Library for I2C communication
#include "LiquidCrystal_I2C.h" // Library for LCD

// Define Trig pin, Echo pin and DHTPin:
#define trigPin 2
#define echoPin 3
#define DHTPin 4

// Define SDA and SCL pin from LCD:
#define SDAPin A4 // Data pin
#define SCLPin A5 // Clock pin

// Connect to LCD via i2c, default address 0x27 (A0-A2 not jumpered):
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27,20,4);

// Define DHT sensor type:
#define DHTType DHT11

// Define variables:
long duration;
int distance;
float speedofsound;

// Create a DHT sensor object:
DHT dht = DHT(DHTPin,DHTType);

void setup() {
  // Define inputs and outputs:
  pinMode(trigPin, OUTPUT); 
  pinMode(echoPin, INPUT); 

  dht.begin();

  // Initiate the LCD:
  lcd.init();
  lcd.backlight();

  // Begin Serial communication at a baudrate of 9600:
  Serial.begin(9600);
}

void loop() {
  // Clear the trigPin by setting it LOW:
  digitalWrite(trigPin, LOW);
  delayMicroseconds(5);

  // Trigger the sensor by setting the trigPin high for 10 microseconds:
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the echoPin. This returns the duration (length of the pulse) in microseconds:
  duration = pulseIn(echoPin, HIGH);

  // Read the temperature:
  int temperature = dht.readTemperature();

  // Calculate speed of sound in m/s:
  speedofsound = 331.3+(0.606*temperature);

  // Calculate the distance in cm:
  distance = duration*(speedofsound/10000)/2;

  // Print the distance and temperature on the Serial Monitor:
  lcd.setCursor(0,0);
  lcd.print("Temperature: ");
  lcd.print(temperature);
  lcd.print(" " "\xDF" "C");
  lcd.setCursor(0,1);
  lcd.print("Speed: ");
  lcd.print(speedofsound);
  lcd.print(" m/s ");
  lcd.setCursor(0,2);
  lcd.print("Distance: ");
  lcd.print(distance);
  lcd.print(" cm  ");
  delay(100);
}

Dimensiones del HC-SR04

A continuación puede encontrar las dimensiones del sensor ultrasónico HC-SR04. He observado que hay algunas pequeñas diferencias entre los fabricantes, por lo que recomiendo volver a comprobarlo con su propio sensor.

HC-SR04 CAD

He creado dibujos CAD básicos del sensor ultrasónico HC-SR04 que puedes descargar a continuación.

Conclusión

En este artículo, te he mostrado cómo funciona el sensor de distancia ultrasónico HC-SR04 y cómo puedes utilizarlo con Arduino. Espero que te haya resultado útil e informativo. Si lo has hecho, ¡compártelo con un amigo al que también le guste la electrónica!

Proyecto personal: Hace un par de meses construí una instalación mural interactiva con unos amigos. Utilizamos unos 30 sensores de distancia ultrasónicos para detectar a las personas que pasaban por delante del muro. El muro incluía luces y efectos de sonido que cambiaban en función de la distancia a la que se encontraba la gente.

Me encantaría saber qué proyectos planeas construir (o has construido ya) con el sensor de distancia HC-SR04. Si tienes alguna pregunta, sugerencia o crees que faltan cosas en este tutorial, por favor deja un comentario abajo.

Tenga en cuenta que los comentarios son retenidos por la moderación para evitar el spam.