"Cómo medir distancias con Arduino y el sensor ultrasónico HC-SR04

El sensor HC-SR04 es una excelente opción para proyectos de Arduino en los que necesites medir distancias de forma precisa. En este artículo, aprenderemos a conectar el sensor y programarlo para medir la distancia en centímetros, y además, te mostraré cómo visualizar los resultados en el monitor serie de Arduino. ¡Empecemos!

Materiales:

• Arduino Uno
• Sensor HC-SR04
• Cables de conexión
• Protoboard (opcional)

1. ¿Qué es el Sensor Ultrasónico HC-SR04?

Este sensor utiliza ondas ultrasónicas para calcular la distancia hasta un objeto. Envía un pulso de sonido y mide el tiempo que tarda en rebotar en el objeto y regresar, usando la fórmula distancia = tiempo * velocidad del sonido / 2 para calcular la distancia en centímetros.

2. Conexiones:

Aquí tienes la disposición de los pinos para conectar el HC-SR04 a Arduino:

3. Código básico:

A continuación, el código básico para medir la distancia usando el HC-SR04 y mostrar el resultado en el monitor serie de Arduino.

// Definir los pines del sensor
const int trigPin = 9;
const int echoPin = 10;

// Variable para almacenar la distancia calculada
long duration;
int distance;

void setup() {
  // Configurar los pines
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  
  // Iniciar la comunicación serie
  Serial.begin(9600);
}

void loop() {
  // Enviar un pulso al pin Trig
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Leer el pulso devuelto en el pin Echo
  duration = pulseIn(echoPin, HIGH);
  
  // Calcular la distancia en cm
  distance = duration * 0.034 / 2;
  
  // Imprimir el resultado
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  delay(500);  // Esperar un momento antes de la próxima medición
}

Explicación del Código:

• TrigPin : Activa el sensor enviando una señal ultrasónica al espacio.
• EchoPin : Recibe el rebote de la señal para calcular el tiempo de ida y vuelta.
• pulseIn() : Función que mide el tiempo en microsegundos que el pulso permanece en HIGH en el pin Echo.
• Cálculo de la distancia : Multiplicamos durationpor la velocidad del sonido en cm/us y dividimos entre 2 para obtener la distancia en cm.

4. Ideas para Mejorar este Proyecto:

Para dar más funcionalidad al proyecto, puedes hacer lo siguiente:

• Control de LED : Encienda un LED si la distancia es menor a un valor determinado.
• Alarma con Zumbador : Activa un zumbador cuando el objeto se encuentre a cierta distancia.

Actualización: Alarma de proximidad con LED y Zumbador

Con esta mejora, convertiremos nuestro proyecto en un sistema de alarma de proximidad. Cuando un objeto se acerca a menos de 10 cm, el LED se encenderá y el zumbador emitirá una señal de alerta.

Material adicional

• Led
• Resistencia de 220 ohmios para el LED
• Zumbador

Conexiones adicionales:

1. LED : Conecte el ánodo del LED a un pin digital, por ejemplo, el pin 8, y el cátodo a GND con una resistencia.
2. Zumbador : Conecte el positivo del zumbador a otro pin digital, como el pin 7, y el negativo a GND.

Código con Alarma de Proximidad

Aquí tienes el código actualizado con la alarma de proximidad:

// Definir los pines del sensor y los componentes adicionales
const int trigPin = 9;
const int echoPin = 10;
const int ledPin = 8;
const int buzzerPin = 7;

// Variables para medir y almacenar la distancia
long duration;
int distance;

void setup() {
  // Configurar los pines
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  // Iniciar la comunicación serie
  Serial.begin(9600);
}

void loop() {
  // Enviar un pulso al pin Trig
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Leer el pulso devuelto en el pin Echo
  duration = pulseIn(echoPin, HIGH);
  
  // Calcular la distancia en cm
  distance = duration * 0.034 / 2;
  
  // Imprimir el resultado
  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  // Activar alarma si la distancia es menor a 10 cm
  if (distance < 10) {
    digitalWrite(ledPin, HIGH); // Encender LED
    digitalWrite(buzzerPin, HIGH); // Activar zumbador
  } else {
    digitalWrite(ledPin, LOW); // Apagar LED
    digitalWrite(buzzerPin, LOW); // Desactivar zumbador
  }
  
  delay(500);  // Esperar un momento antes de la próxima medición
}

Explicación de la Alarma de Proximidad:

1. Condición de proximidad : Si la distancia medida es menor a 10 cm, el LED y el zumbador se activarán para indicar la cercanía de un objeto.
2. DigitalWrite(ledPin, HIGH) : enciende el LED.
3. DigitalWrite(buzzerPin, HIGH) : Activa el zumbador. Cuando la distancia es mayor, ambos se apagan.

Este sistema es ideal para proyectos de seguridad o como alarma de proximidad en robots o sistemas de monitoreo. Además, sirve como base para explorar sensores y actuadores con Arduino en proyectos más avanzados.

Personalización del Proyecto: Ajuste de Umbral y Señal de Alarma

Vamos a agregar variaciones para:

1. Ajustar el umbral de distancia en el cual la alarma se activa.
2. Personalice la señal del zumbador para emitir sonidos intermitentes en lugar de un sonido continuo.

1. Ajuste de la Umbral de Distancia

Podemos definir el umbral de distancia como una variable al inicio del código, de esta forma podrás cambiarlo fácilmente sin modificar el resto del código.

// Definir el umbral de distancia en centímetros
const int umbralDistancia = 10;

Luego, reemplaza if (distance < 10)por:

if (distance < umbralDistancia) {
    // Activar alarma
}

2. Señal Intermitente en el Zumbador

Para hacer que el zumbador emita una señal intermitente, podemos usar delay()dentro de un bucle, alternando entre encender y apagar el zumbador rápidamente.

Código modificado con señal intermitente

Este código incorpora el ajuste de umbral y la señal intermitente del zumbador:

// Definir pines y umbral de distancia
const int trigPin = 9;
const int echoPin = 10;
const int ledPin = 8;
const int buzzerPin = 7;
const int umbralDistancia = 10; // Ajustable

// Variables de medición
long duration;
int distance;

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

void loop() {
  // Enviar pulso en Trig
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  
  // Leer pulso en Echo
  duration = pulseIn(echoPin, HIGH);
  distance = duration * 0.034 / 2;

  Serial.print("Distancia: ");
  Serial.print(distance);
  Serial.println(" cm");
  
  // Alarma con LED y zumbador si distancia < umbral
  if (distance < umbralDistancia) {
    digitalWrite(ledPin, HIGH);
    for (int i = 0; i < 5; i++) { // Intermitente
      digitalWrite(buzzerPin, HIGH);
      delay(100); // Tiempo encendido
      digitalWrite(buzzerPin, LOW);
      delay(100); // Tiempo apagado
    }
  } else {
    digitalWrite(ledPin, LOW);
    digitalWrite(buzzerPin, LOW);
  }
  
  delay(500);  // Espera antes de la próxima medición
}

Explicación de las Modificaciones

1. Ajuste de Umbral : La variable umbralDistanciapermite cambiar el rango en el que se activa la alarma sin modificar el resto del código.
2. Señal intermitente : El bucle forhace que el zumbador emite 5 pitidos cortos cada vez que un objeto se encuentra bajo el umbral, dando una alerta más clara.

Esto proporciona más flexibilidad y puedes ajustarlo según el tipo de alarma que quieras.