Sensor Ultrasónico HC-SR04 y Arduino – Guía Completa

En este tutorial aprenderá cómo funciona el HC-SR04. Sensor ultrasónico Funciona y cómo usarlo con arduino. Este es el sensor más popular para medir distancias y construir robots para evitar obstáculos con Arduino.

Ya he usado el sensor ultrasónico HC-SR04 para construir varios proyectos geniales de Arduino y puedes verlos aquí:

• Radar Arduino (sonar)
• Telémetro y nivel de burbuja digital
• Proyecto de sistema de seguridad y alarma.
• Robot hexápodo hormiga Arduino

Puede ver el vídeo a continuación o leer el tutorial escrito a continuación. Contiene información adicional y ejemplos para el sensor, incluidas especificaciones, distribución de pines, esquemas, códigos y más.

Descripción general del hardware HC-SR04

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

El sensor consta de dos transductores ultrasónicos. Uno es el transmisor que emite pulsos ultrasónicos y el otro es el receptor que escucha las ondas reflejadas. Es básicamente un SONAR que se utiliza en submarinos para localizar objetos bajo el agua.

Aquí>

Tensión de funcionamiento	5 VCC
Corriente de funcionamiento	15mA
Frecuencia de trabajo	40kHz
rango mínimo	2 cm / 1 pulgada
Rango maximo	400 cm / 13 pies
exactitud	3mm
medir ángulos	<15°
Dimensiones	45x20x15mm

Asignación de pines del sensor ultrasónico HC-SR04

Aquí está el pinout del sensor:

El>VCC Y Dimensiones ir a 5V Y Dimensiones Pines en el Arduino y el trigonometría Y eco vaya a cualquier pin digital Arduino. Con el trigonometría Pluma enviamos la onda ultrasónica desde el transmisor, y con el eco Pin escuchamos la señal reflejada.

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

Emite ultrasonidos a 40.000 Hz que viajan por el aire y, si hay un objeto u obstáculo en su camino, rebota hacia el módulo. Teniendo en cuenta el tiempo de tránsito y la velocidad del sonido, se puede calcular la distancia.

Para>Velocidad del sonido. Los pines de eco aumentan inmediatamente después de que se envía la ráfaga ultrasónica de 8 ciclos y comienzan a escuchar o esperar a que la onda se refleje en un objeto.

Si no hay ningún objeto o pulso reflejado, el pin de eco se apagará después de 38 ms y volverá al estado bajo.

Cuando>

Para ello utilizamos la siguiente fórmula básica para calcular la distancia:

Distancia = velocidad x tiempo

De hecho, conocemos los valores de velocidad y tiempo. El tiempo es el momento en que el pin de eco estuvo ALTO y la velocidad es la velocidad del sonido que es 340 m/s. Aún nos falta hacer un paso adicional, que es dividir el resultado final por 2. Esto se debe a que medimos el tiempo que tarda la onda sonora en viajar hasta el objeto y rebotar.

Digamos>

Distancia = (Velocidad x Tiempo) / 2 = (34cm/ms x 1,5ms) / 2 = 25,5cm.

Entonces, si el pin de eco estuvo ALTO durante 2 ms (que es lo que hacemos con el pulsoEn() función), la distancia desde el sensor al objeto es de 34 cm.

Cómo conectar el sensor ultrasónico HC-SR04 a Arduino

Entonces necesitamos conectar el sensor HC-SR04 a una placa Arduino.

Los>

Puede obtener los componentes necesarios para este tutorial en uno de los siguientes sitios web:

• Sensor ultrasónico HC-SR04 ………… Amazon / Banggood / AliExpress
• Placa Arduino……………………………… Amazon / Banggood / AliExpress
• Cables de puente y placa de pruebas………… Amazon / Banggood / AliExpress

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

HC-SR04 Sensor Ultrasónico Código Arduino

Aquí hay un código para medir distancias usando el sensor ultrasónico HC-SR04 y Arduino.

/*
  Ultrasonic Sensor HC-SR04 and Arduino Tutorial

  by Dejan Nedelkovski,
  www.HowToMechatronics.com

*/
// defines pins numbers
const int trigPin = 9;
const int echoPin = 10;
// defines variables
long duration;
int distance;
void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  Serial.begin(9600); // Starts the serial communication
}
void loop() {
  // Clears the trigPin
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Sets the trigPin on HIGH state for 10 micro seconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  // Reads the echoPin, returns the sound wave travel time in microseconds
  duration = pulseIn(echoPin, HIGH);
  // Calculating the distance
  distance = duration * 0.034 / 2;
  // Prints the distance on the Serial Monitor
  Serial.print("Distance: ");
  Serial.println(distance);
}Code language: Arduino (arduino)

Explicación del código

Primero necesitamos definir los pines Trig y Echo. En este caso, se trata de los pines número 9 y 10 de la placa Arduino y se denominan trigPin y echoPin. Luego necesitamos una variable larga llamada «duración» para el tiempo de viaje que obtenemos del sensor y una variable entera para la distancia.

// defines pins numbers
const int trigPin = 9;
const int echoPin = 10;

// defines variables
long duration;
int distance;Code language: Arduino (arduino)

En la configuración, debemos definir TrigPin como salida y EchoPin como entrada y también iniciar la comunicación en serie para mostrar los resultados en el monitor en serie.

void setup() {
  pinMode(trigPin, OUTPUT); // Sets the trigPin as an Output
  pinMode(echoPin, INPUT); // Sets the echoPin as an Input
  Serial.begin(9600); // Starts the serial communication
}Code language: Arduino (arduino)

En el bucle, primero debemos asegurarnos de que TrigPin esté libre. Para hacer esto, necesita configurar este pin en el estado BAJO durante solo 2 µs. Ahora, para generar la onda ultrasónica, tenemos que configurar el TrigPin en el estado ALTO durante 10 µs.

// Clears the trigPin
digitalWrite(trigPin, LOW);
delayMicroseconds(2);

// Sets the trigPin on HIGH state for 10 micro seconds
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);Code language: Arduino (arduino)

Uso de pulsoEn() función Leemos el tiempo de viaje e ingresamos este valor en la variable “Duración”. Esta función tiene dos parámetros, el primero es el nombre del pin de eco y el segundo es el estado del pulso que estamos leyendo, ya sea alto o bajo.

// Reads the echoPin, returns the sound wave travel time in microseconds
duration = pulseIn(echoPin, HIGH);Code language: Arduino (arduino)

En este caso, debemos configurarlo en ALTO porque los sensores HC-SR04 configuran el pin de eco en alto después de enviar la ráfaga ultrasónica de 8 ciclos desde el transmisor. Esto inicia la sincronización y tan pronto como recibimos la onda de sonido reflejada, el pin de eco se ajusta a nivel bajo, lo que detiene la sincronización. Al final, la función devuelve la duración del pulso en microsegundos.

Para obtener la distancia, multiplicamos la duración por 0,034 y la dividimos por 2 como explicamos esta ecuación antes.

// Calculating the distance
distance= duration*0.034/2;

// Prints the distance on the Serial Monitor
Serial.print("Distance: ");
Serial.println(distance);Code language: Arduino (arduino)

Al final imprimimos el valor de la distancia en el monitor serie.

Ejemplo de pantalla LCD y sensor ultrasónico Arduino

Aquí hay otro ejemplo de cómo usar el sensor ultrasónico con Arduino y mostrar los resultados en una pantalla LCD.

Puede>

El>

/*
  Ultrasonic Sensor HC-SR04 and Arduino Tutorial

  by Dejan Nedelkovski,
  www.HowToMechatronics.com

*/
#include <LiquidCrystal.h> // includes the LiquidCrystal Library
LiquidCrystal lcd(1, 2, 4, 5, 6, 7); // Creates an LCD object. Parameters: (rs, enable, d4, d5, d6, d7)
const int trigPin = 9;
const int echoPin = 10;
long duration;
int distanceCm, distanceInch;
void setup() {
  lcd.begin(16, 2); // Initializes the interface to the LCD screen, and specifies the dimensions (width and height) of the display
  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); // Sets the location at which subsequent text written to the LCD will be displayed
  lcd.print("Distance: "); // Prints string "Distance" on the LCD
  lcd.print(distanceCm); // Prints the distance value from the sensor
  lcd.print(" cm");
  delay(10);
  lcd.setCursor(0, 1);
  lcd.print("Distance: ");
  lcd.print(distanceInch);
  lcd.print(" inch");
  delay(10);
}Code language: Arduino (arduino)

Código de muestra usando la biblioteca NewPing

En realidad, existe una manera mejor y más fácil de programar el Arduino para medir distancias con el sensor ultrasónico HC-SR04 y es con el Nuevo ping Biblioteca.

En el código explicado anteriormente, activamos manualmente el sensor y medimos la duración del pulso de la señal recibida. Luego utilizamos estos resultados para calcular la distancia en función de ellos. Usando la biblioteca NewPing, podemos determinar la distancia con una sola línea de código.

Aquí hay un código de ejemplo:

#include <NewPing.h>

#define TRIGGER_PIN  9
#define ECHO_PIN     10
#define MAX_DISTANCE 400 // Maximum distance we want to measure (in centimeters).


NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

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

void loop() {
  delay(50);                    // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.

  int distance = sonar.ping_cm(); // Send ping, get distance in cm and print result (0 = outside set distance range)

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");
}Code language: Arduino (arduino)

Es mucho más sencillo que el ejemplo anterior. Sólo usamos la llamada ping_cm() Método sobre el objeto de sonda NewPing y obtenemos la distancia en centímetros. Si queremos la distancia en pulgadas podemos ping_in() en cambio.

La biblioteca también tiene otras características útiles. Por ejemplo con esto ping_median(Iteraciones [, max_cm_distance]) Con este método podemos lograr resultados más precisos porque devuelve un valor mediano o el promedio de múltiples mediciones. Con el Iteraciones Establecemos el número de muestras que utiliza el programa para calcular la media. El valor predeterminado es 5 iteraciones. El ping_mediana() Devuelve la duración del pulso recibido en microsegundos.

Más información y detalles se pueden encontrar en el Nueva página wiki de Ping.

Mejora de la precisión del sensor de distancia HC-SR04 con el sensor de temperatura DHT22

El sensor HC-SR04 es bastante preciso, pero como su funcionamiento depende de la velocidad del sonido, también debemos considerar la temperatura del aire para obtener resultados más precisos. La velocidad del sonido puede cambiar significativamente con un cambio en la temperatura del aire. Por ejemplo, la velocidad del sonido a 20 °C es de unos 340 m/s, pero a -20 °C es de unos 315 m/s. La humedad relativa también afecta la velocidad.

Entonces, si usamos este sensor para medir distancias a diferentes temperaturas, deberíamos implementar una compensación de temperatura. Esto lo podemos hacer con la siguiente fórmula:

Velocidad = 331,4 + 0,6 x Temperatura + 0,0124 x Humedad Relativa

Aquí hay un ejemplo:

Junto>

código arduino

/*
  Example made by Dejan, How To Mechatronics,
  
Home


*/

#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 temperature and humidity sensor

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
dht DHT; // Creats a DHT object

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

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

void loop() {
  delay(100);

  // Read temperature and humidity from DHT22 sensor
  readDHT = DHT.read22(dht22); // Reads the data from the sensor
  temp = DHT.temperature; // Gets the values of the temperature
  hum = DHT.humidity; // Gets the values of the humidity


  speedOfSound = 331.4 + (0.6 * temp) + (0.0124 * hum); // Calculate speed of sound in m/s

  duration = sonar.ping_median(10); // 10 interations - returns duration in microseconds
  duration = duration/1000000; // Convert mircroseconds to seconds
  distance = (speedOfSound * duration)/2;
  distance = distance * 100; // meters to centimeters

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println("cm");

}Code language: Arduino (arduino)

Entonces, primero leemos los valores de temperatura y humedad del sensor DHT22 y luego usamos estos valores para calcular la velocidad del sonido. Luego determinamos la duración de la onda sonora en microsegundos, la convertimos a segundos y calculamos la distancia desde el sensor hasta los objetos en centímetros.

Dimensiones HC-SR04 y modelo 3D

Creé un modelo 3D del sensor ultrasónico HC-SR04 en caso de que necesites uno para tu próximo proyecto. Puedes descargarlo desde el siguiente enlace.

Lo>Modelo 3D en Thangs.

Estas son las dimensiones del sensor HC-SR04:

Tenga>

Diploma

Hemos cubierto prácticamente todo lo que necesitamos saber sobre el uso del sensor ultrasónico HC-SR04 con Arduino. Es un gran sensor para muchos proyectos de electrónica de bricolaje donde necesitamos medición de distancia sin contacto, detección de presencia o detección de objetos, detección de nivelación o posición, etc.

Ya mencioné los proyectos que hice con este sensor al principio del post. Aquí hay algunos proyectos más interesantes que utilizan el sensor HC-SR04 y Arduino:

• Papelera automática sin contacto con sensor de movimiento
• Control inteligente de la iluminación mediante gestos con la mano
• Mini levitación acústica
• Robots para evitar obstáculos

Espero que hayas disfrutado este tutorial y hayas aprendido algo nuevo. No dudes en hacer tus preguntas en la sección de comentarios a continuación y no olvides consultar mi colección completa de más de 30 proyectos Arduino.