Tutorial Arduino: Sensor ultrasonidos HC-SR04

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

El HC-SR04 es un sensor de distancia ultrasónico barato y fácil de usar, con un rango de 2 a 400 cm. Se utiliza comúnmente en proyectos de automatización y robots para evitar obstáculos. En este tutorial, aprenderás cómo funciona el sensor y cómo usarlo con Arduino.

Los sensores ultrasónicos de distancia/proximidad baratos son excelentes, pero en algunos proyectos, puede que necesites un sensor a prueba de agua como el JSN-SR04T o un sensor IR que no esté influenciado por los cambios de temperatura.

Un sensor ultrasónico como el HC-SR04 tiene muchas aplicaciones debido a su bajo coste y su facilidad de uso.

Ultrasonido significa literalmente “sonido más allá de lo que los humanos escuchan“, que es la señal emitida por el módulo. Midiendo cuándo se emite la señal y cuándo se devuelve al receptor, podemos medir la distancia entre el sensor de ultrasonidos y el cuerpo que reflejó la señal. En este tutorial, usaremos el HC-SR04 con un Arduino para medir la distancia de un obstáculo.

Qué vas a necesitar

Rebajas
AmazonBasics - Cable USB 2.0 de tipo A macho a tipo B macho (3 m)
Distribuido por Amazon; garantía de un año de AmazonBasics; Se envía en un paquete abrefácil de Amazon
AZDelivery DHT11 Modulo de Conexion Sensor de Temperatura y Humedad con Placa y Cable para Arduino con eBook incluido
✔️ El DHT11 es un sensor confiable para medir la temperatura y la humedad.
  • Arduino IDE

Características del HC-SR04

El módulo de medición ultrasónico HC – SR04

  • Ofrece una función de medición sin contacto de 2cm – 400cm, la precisión de medición puede alcanzar los 3mm.
  • Los módulos incluyen transmisores ultrasónicos, receptor y circuito de control.
  • El principio básico del trabajo: (1) Usando el disparador IO para al menos 10us de señal de alto nivel, (2) El módulo envía automáticamente ocho 40 kHz y detecta si hay una señal de pulso de vuelta. (3) Si la señal de retorno, a través del nivel alto, el tiempo de duración de la E/S de salida alta es el tiempo que transcurre entre el envío del ultrasonido y el retorno. Distancia de prueba = (tiempo de nivel alto×velocidad del sonido (340M/S) / 2,
  • El cable se conecta directamente de la siguiente manera.
  • 5V Alimentación Trigger Pulse Input Echo Pulse Output 0V Ground
  • Voltaje de trabajo DC 5 V
  • Corriente de trabajo 15mA
  • Frecuencia de trabajo 40Hz
  • Rango máximo 4m
  • Alcance mínimo 2 cm
  • Ángulo de medición 15 grados
  • Señal de entrada de disparo 10uS pulso TTL Salida de eco Señal de entrada Señal de palanca TTL y el alcance en proporción
  • Dimensión 45*20*15mm

El módulo HC-SR04 tiene cuatro pines (Vcc, Trigger, Echo, Gnd) como se muestra:

módulo HC SR04 - Tutorial Arduino: Sensor ultrasonidos HC-SR04

Cuando el perno del disparador se mantiene en alto, el módulo comienza a emitir señal ultrasónica hasta que el perno se tira hacia abajo. Si la señal encuentra un obstáculo, volverá al módulo. Como resultado, el “eco” de la señal se utiliza para medir la distancia: la duración entre el envío de la señal y el retorno de la señal se puede leer en el pin de eco como un pulso.

La distancia en centímetros entre el HC-SR04 y el obstáculo puede calcularse utilizando

formula - Tutorial Arduino: Sensor ultrasonidos HC-SR04

donde 0.034 se deriva de la velocidad del sonido: 340 m/s

¿Cómo funciona un sensor de distancia ultrasónico?

Los sensores ultrasónicos funcionan emitiendo ondas de sonido con una frecuencia demasiado alta para que un humano las escuche. Estas ondas sonoras viajan por el aire a la velocidad del sonido, aproximadamente 343 m/s. Si hay un objeto delante del sensor, las ondas sonoras se reflejan de nuevo 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.

Principio de funcionamiento de los sensores de distancia ultrasónicos - Tutorial Arduino: Sensor ultrasonidos HC-SR04

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 multiplicamos la velocidad del sonido por el tiempo en que viajaron las ondas sonoras, obtenemos 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 tienes que dividir el resultado por dos.

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

Y así, por ejemplo, esto se convierte en:

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

La dependencia de la temperatura de la velocidad del sonido

La velocidad del sonido en realidad depende fuertemente de la temperatura y en mucho menor grado de la humedad del aire. Wikipedia afirma que la velocidad del sonido aumenta con aproximadamente 0,6 m/s por grado centígrado. Para la mayoría de los casos a 20°C sólo se puede usar 343 m/s pero si se quiere obtener lecturas más precisas, se puede 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 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

En la parte delantera del sensor HC-SR04 se encuentran dos cilindros de plata (transductores ultrasónicos), uno es el transmisor de las ondas sonoras y el otro es el receptor. Para que el sensor genere una ráfaga sónica, hay que poner la clavija de disparo en alto durante al menos 10 µs. El sensor crea entonces una ráfaga de 8 ciclos de ultrasonido a 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 de eco entonces da salida al tiempo que las ondas sonoras viajaron en microsegundos.

Puedes usar la función pulseIn() en el código de Arduino para leer la longitud del pulso de la aguja de eco. Después de eso, puedes usar la fórmula mencionada anteriormente para calcular la distancia entre el sensor y el objeto.

Especificaciones del HC-SR04

Voltaje5 V
Corriente de funcionamiento15 mA
Frecuencia40 kHz
Rango de medición2 – 400 cm
Resolución3 mm
Ángulo de medición15 degrees
Señal de entrada del disparador10 µs high pulse

Cómo conectar el sensor ultrasonico HC-SR04 a Arduino UNO

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

como conectar el sensor ultrasonico a arduino - Tutorial Arduino: Sensor ultrasonidos HC-SR04

Los ejemplos de código que se muestran a continuación utilizan la clavija digital 2 y 3 para el disparador y la clavija de eco respectivamente, pero por supuesto puedes cambiar esto a cualquier clavija digital que desees.

Conexiones HC-SR04

HC-SR04Arduino
VCC5 V
TrigPin 2
EchoPin 3
GNDGND

Código de ejemplo para HC-SR04 con Arduino

Ahora que has conectado el sensor es el momento de conectar el Arduino al ordenador y subir algún código. Puedes subir el siguiente código de ejemplo a tu Arduino usando el IDE de Arduino. A continuación, te explicaremos cómo funciona el código.

/* Example code for HC-SR04 ultrasonic distance sensor with Arduino. No library required. More info: https://www.descubrearduino.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

Primero, se definen el pin del triger y el pin del eco. Los llamamos trigPin y EchoPin. El pin de disparo está conectado al pin digital 2 y el pin de eco al pin digital 3 en el Arduino.

La frase #define se usa para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando el programa sea compilado. Así que en cualquier lugar que se mencione el trigPin, el compilador lo reemplazará con el valor 2 cuando el programa sea compilado.

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

A continuación definimos dos variables: duration y distance (duración y distancia). 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(), se empieza por configurar el trigPin como una salida y el echoPin como una entrada. A continuación se inicia la comunicación en serie a una velocidad de 9600 baudios. Más tarde mostrará la distancia medida en el monitor serial, al que se puede acceder con Ctrl+Mayús+M o Herramientas > Monitor Serial. Asegúrese de que la velocidad en baudios también esté configurada a 9600 en el monitor en 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(), se activa el sensor ajustando el trigPin HIGH para 10 µs. Observa que para obtener una señal limpia se empieza por borrar el trigPin fijá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, tienes que leer la longitud del pulso enviado por el echoPin. 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 de eso, puedes calcular la distancia usando 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 biblioteca NewPing escrita por Tim Eckel puede ser usada con muchos sensores de distancia ultrasónicos. La última versión de esta biblioteca puede ser descargada aquí en bitbucket.org. Verás que el código de abajo, que utiliza la biblioteca NewPing, es mucho más corto que el código que usamos antes. Además de eso, la biblioteca NewPing incluye algunas otras características interesantes. Te permite establecer una distancia máxima para leer, no se retrasará ni un segundo completo cuando no se reciba ningún eco y tiene un filtro de mediana incorporado.

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

La biblioteca incluye algunos ejemplos que puede utilizar, pero tendrá que modificarlos para que coincidan con la configuración de su hardware. He incluido un código de ejemplo modificado a continuación que puede ser utilizado con la misma configuración de cableado que antes.

/* HC-SR04 ultrasonic distance sensor with NewPing library example code. More info: www.descubrearduino.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 puedes usar distance = sonar.ping_cm() o distancia = 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.

Interfaz de los sensores ultrasónicos en el modo de 3 pines

La biblioteca NewPing también facilita la interfaz con los sensores de ultrasonidos, usando sólo un 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 Ping de Parallax.

Para crear una configuración de 3 pines (GND, 5V y SIG) tienes que conectar tanto el pin de disparo como el 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 la misma clavija tanto para el trigPin como para el echoPin. Por ejemplo, el pin digital 2.

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

Cómo usar el filtro digital ping_median()

Lo que más nos gusta de la biblioteca de NewPing es que tiene un filtro de mediana incorporado. Este filtro puede mejorar enormemente la precisión de sus lecturas de HC-SR04. La función ping_median() toma muchas medidas de duración en una fila, tira las lecturas fuera de rango y luego promedia las restantes. Por defecto tomará 5 lecturas pero puede especificar cuántas debería tomar. Reemplaza la línea 19 por las líneas de abajo.

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

Ejemplo de código HC-SR04 con Pantalla I2C LCD y Arduino

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

HC SR04 con Arduino y I2C LCD - Tutorial Arduino: Sensor ultrasonidos HC-SR04

Conexiones de I2C LCD

I2C LCDArduino
GNDGND
VCC5 V
SDAA4
SCLA5

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

PlacaSDASCL
Arduino UnoA4A5
Arduino NanoA4A5
Arduino Micro23
Arduino Mega 25602021
Arduino Leonardo23
Arduino Due2021

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

Si quieres saber más sobre cómo controlar un LCD de I2C con Arduino, puedes ver el tutorial completo aquí. Cómo controlar un pantalla de caracteres I2C LCD con Arduino

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

// Include the libraries:
#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);
}

Ten en cuenta que usamos una pantalla LCD de 20 x 4. Si tienes un tamaño diferente de LCD (16 x 2 es también habitual) necesitas cambiar la línea 20 a LiquidCrystal_I2C lcd(0x27,16,2);. Si tu LCD no tiene la dirección de I2C por defecto, 0x27, consulta el tutorial completo de I2C donde explicamos cómo puede averiguar cuál es la dirección.

Ejemplo de código HC-SR04 con el sensor de temperatura DHT11 y Arduino

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

Agregar un sensor DHT11 es realmente simple. El siguiente diagrama de cableado le muestra las conexiones que necesitas hacer. Ten en cuenta que estamos usando un DHT11 con una placa de conexión, así que sólo necesitamos cablear 3 pines. Asegúrate de revisar 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.

HC SR04 con DHT11 - Tutorial Arduino: Sensor ultrasonidos HC-SR04

Conexiones con el DHT11

DHT11Arduino
VCC (+)5 V
Signal (s)Pin 4
GND (-)GND

El código de abajo utiliza la biblioteca de sensores de humedad y temperatura de Adafruit DHT 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.

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

// Include Adafruit sensor library:
#include <Adafruit_Sensor.h> //https://github.com/adafruit/Adafruit_Sensor
// Include Adafruit DHT library:
#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);
}

Ejemplo de código HC-SR04 con DHT11 y I2C LCD

HC SR04 con DHT11 y I2C LCD - Tutorial Arduino: Sensor ultrasonidos HC-SR04El código que se muestra a continuación puede utilizarse para combinar los 3 ejemplos anteriores. Muestra tanto la temperatura, la velocidad del sonido y la distancia medida en la LCD.

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

// Include Adafruit sensor library:
#include <Adafruit_Sensor.h> // https://github.com/adafruit/Adafruit_Sensor
// Include Adafruit DHT library:
#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 puedes ver las dimensiones del sensor ultrasónico HC-SR04. Puedes notar que hay algunas pequeñas diferencias entre los fabricantes, por lo que recomiendamos hacer una doble comprobación con tu propio sensor.

medidas HC SR04 - Tutorial Arduino: Sensor ultrasonidos HC-SR04

 

 

Última actualización el 2020-07-07 / Enlaces de afiliados / Imágenes de la API para Afiliados

Pin It on Pinterest

Shares