Sensor ultrasónico HC-SR04 y Arduino

24 junio, 2020 | Actualizado: 2 junio, 2023
Comentarios: 0

El sensor HC-SR04 es un sensor de distancia de baja precisión basado en ultrasonidos. Se puede utilizar en multitud de proyectos, como sistema de detección de obstáculos para vehiculos o robots, sensores de presencia, etc.

Contenido

1 ¿Cómo funciona el sensor HC-SR04?
2 ¿Cómo se calcula la distancia hasta el obstáculo?
3 ¿Cómo se conecta un sensor HC-SR04 con Arduino?
4 Programación para sensor ultrasónico HC-SR04 y Arduino utilizando librería.
5 Programación para sensor ultrasónico sin usar librería.

¿Cómo funciona el sensor HC-SR04?

El módulo HC-SR04 es un sensor de distancia de uso frecuente para proyectos de robótica que incorpora un emisor de ultrasonidos y un receptor. Se utiliza para determinar a qué distancia se encuentra un objeto colocado enfrente del sensor. El emisor emitirá ultrasonidos que rebotarán en un objeto y serán captados por el receptor. El tiempo que trascurre mientras la señal es emitida y devuelta al receptor es la distancia que existe entre el emisor y el objeto.

Funcionamien de un emisor de ultrasonidos cuando encuentra un objeto

¿Cómo se calcula la distancia hasta el obstáculo?

La fórmula de la velocidad es:

Velocidad = Superficie recorrida/Tiempo

Sabemos que la velocidad del sonido es de 343 m/s a 20 ºC, con un 50% de humedad y al nivel del mar. Si transformamos las unidades:

343 (m/s) x 100 (cm/m) x 1/1000000 (s/µs) = 0,0343 cm/µs

El sonido recorre 0,0343 cm cada microsegundo, y tarda 29,2 microsegundos en recorrer un centímetro. Por lo que podemos obtener la distancia existente a partir del tiempo que trascurre entre la emisión del pulso y la recepción de este. Hay que tener en cuenta que el pulso primero llega al objeto y tiene que volver, el recorrido es el doble de lo que se quiere medir.

Superficie recorrida = Velocida x Tiempo

Distancia al objeto = (Velocidad x Tiempo)/2

Supongamos que recibimos un pulso del sensor de 200 µs, si aplicamos la fórmula: (200 µs x 0,0343 cm/µs) /2, lo que nos daría como resultado 3,43 cm de distancia.

¿Cómo se conecta un sensor HC-SR04 con Arduino?

Material necesario:

Sensor HC-SR04.
Placa Arduino.
Cables.
Protoboard.

El sensor tiene 4 pines:

Alimentación de 5 volts.
Tierra o masa del circuito.
Emisor de señal (triger). Conectados al pin digital 12.
Receptor de señal (echo). Conectado al pin digital 11.

La siguiente imagen muestra cómo queda conectado el sensor a la placa Arduino:

Esquema de conexión del sensor HC-SR04 con Arduino

Programación para sensor ultrasónico HC-SR04 y Arduino utilizando la librería NewPing.

La NewPing es una librería externa que mejora el rendimiento y evita algunos problemas encontrados en algunos tipos de sensores de detección de distancias. Además, incluye algunas funciones que facilitan la obtención de las distancias. El primer paso es descargarla e instalarla.

Código:

// incluimos la librería NewPing
#include "NewPing.h"

/* Configuramos los pines donde debemos conectar el sensor */
#define PIN_TRIG 12   // Pin del Arduino conectado al pin Trigger del sensor de ultrasonidos
#define PIN_ECHO 11   // Pin del Arduino conectado al pin Echo del sensor de ultrasonidos
#define MAX_DISTANCIA 100  // Distancia máxima a detectar en cm.

/*Crear el objeto de la clase NewPing, indicamos el pin utilizado para el Trigger, el pin para la entrada
Echo y la máxima distancia, que es opcional */
NewPing sonar(PIN_TRIG, PIN_ECHO, MAX_DISTANCIA);

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

void loop() {
  // Esperar 1 segundo entre mediciones
  delay(1000);
  // Obtener medición de tiempo de viaje del sonido y guardar en la variable tiempo
  int tiempo = sonar.ping_median();
  // Imprimir el tiempo medido en la consola
  Serial.print("Tiempo: ");
  Serial.print(tiempo);
  Serial.println(" microsegundos");
  // Imprimir la distancia medida en la consola
  Serial.print("Distancia: ");
  // US_ROUNDTRIP_CM constante para determinar la distancia. Convertir el tiempo en distancia (0 = indica fuera de rango)
  Serial.print(tiempo / US_ROUNDTRIP_CM);
  Serial.println(" cm");
}

El código realizado con la librería NewPing es bastante sencillo y además de aceptar el sensor ultrasónico HC-SR04 permite utilizar la gran mayoría de los sensores que usan la interfaz del tipo Interfaz “con medición de pulsos” con 3 y 4 pines.

Programación para sensor ultrasónico sin usar librería.

Puede resultarnos útil saber utilizar el sensor HC-SR04 sin la necesidad de usar una librería. Para crear un disparo limpio primero programamos durante 4 µs la instrucción Low, y después, para la activación del sensor, generamos un pulso eléctrico de 10 µs.

Para obtener el intervalo de tiempo en el que el pulso vuelve de nuevo al sensor, hemos utilizado la función pulseIn y, por último, calculamos la distancia en cm.

Primero configuramos los pines, se crean dos constantes para recibir las señales. «EchoPin» se configura como pin de entrada y «TriggerPin» como salida.

const int EchoPin = 11;
const int TriggerPin = 12;
 
void setup() {
   Serial.begin(9600);
   // configurar los pines de salida y entrada
   pinMode(TriggerPin, OUTPUT);
   pinMode(EchoPin, INPUT);
}

Ahora creamos una función que nos retornará la distancia al objeto:

int ping(int TriggerPin, int EchoPin) {
   long duracion, distanciaCm;    // variables para cálculos
   // pulso para generar un disparo limpio
   digitalWrite(TriggerPin, LOW);  // generar un pulso en el pin trigger a LOW 4us
   delayMicroseconds(4);
   // pulso para activación del sensor
   digitalWrite(TriggerPin, HIGH);  //generar Trigger (disparo) de 10us
   delayMicroseconds(10);
   digitalWrite(TriggerPin, LOW);
   
   duracion = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos
   // La velocidad del sonido es de 343 m/s o 29,2 microsegundos por centímetro
   distanciaCm = duracion * 10 / 292/ 2;   //convertimos la distancia, en cm
   return distanciaCm;  // retornamos la distancia
}

En la línea 5 iniciamos el ciclo con el TriggerPin apagado (LOW), pasados 4 microsegundos, activamos el pin TriggerPin durante 10 microsegundos. En la línea 12 medimos el tiempo que el sonido tarda en llegar al receptor y lo almacenamos en la variable duracion. Por fin calculamos la distancia en cm y devolvemos la distancia con la orden return.

En la función loop() primero se hace una llamada a la función ping(), la cual le envía las variable TriggerPin y EchoPin. Esta función nos devuelve la distancia al objeto en cm, la cual se mostrará por el monitor serial.

void loop() {
   int cm = ping(TriggerPin, EchoPin);  // llamada la función ping
   Serial.print("Distancia: ");
   Serial.println(cm);
   delay(1000);
}

A continuación mostramos el código completo:

const int EchoPin = 11;
const int TriggerPin = 12;
 
void setup() {
   Serial.begin(9600);
   // configurar los pines de salida y entrada
   pinMode(TriggerPin, OUTPUT);
   pinMode(EchoPin, INPUT);
}
 
void loop() {
   int cm = ping(TriggerPin, EchoPin);  // llamada la función ping
   Serial.print("Distancia: ");
   Serial.println(cm);
   delay(1000);
}
 
int ping(int TriggerPin, int EchoPin) {
   long duracion, distanciaCm;    // variables para cálculos

   // pulso para generar un disparo limpio
   digitalWrite(TriggerPin, LOW);  // generar un pulso en el pin trigger a LOW 4us
   delayMicroseconds(4);
   // pulso para activación del sensor
   digitalWrite(TriggerPin, HIGH);  //generar Trigger (disparo) de 10us
   delayMicroseconds(10);
   digitalWrite(TriggerPin, LOW);
   
   duracion = pulseIn(EchoPin, HIGH);  //medimos el tiempo entre pulsos, en microsegundos

   // La velocidad del sonido es de 343 m/s o 29,2 microsegundos por centímetro
   distanciaCm = duracion * 10 / 292/ 2;   //convertimos la distancia, en cm
   return distanciaCm;  // retornamos la distancia
}

En el monitor serial aparecerán las medidas realizadas por el sensor HC-SR04, variando la distancia del objeto podremos ver como cambia la distancia y podremos verificar la distancia mostrada midiendo con una regla el espacio de separación.