Alarma con Arduino y Sensor Ultrasónico HC-SR04 (Tutorial paso a paso)

Introducción

Crear un sistema de seguridad o detección de movimiento no tiene que ser complicado ni caro. En este tutorial vamos a construir una alarma con Arduino y un sensor de ultrasonidos (el famoso HC-SR04). Este proyecto es ideal para principiantes porque aprendes a leer sensores externos y a generar una respuesta física (encender un LED y hacer sonar un buzzer) cuando alguien se acerca demasiado.

A continuación, te explico cómo funciona el sensor, qué materiales necesitas, cómo montar el circuito y te desgloso el código línea por línea para que realmente entiendas lo que estás programando.

¿Cómo funciona el Sensor Ultrasónico HC-SR04?

Este sensor funciona igual que un sonar o los delfines: emite un sonido imperceptible para el humano (ultrasonido) y espera a que ese sonido choque contra un objeto y regrese (eco).

• Pin Trig (Trigger - Disparo): Le dice al sensor que debe "gritar" y emitir el pulso de ultrasonido.
• Pin Echo (Eco - Recepción): Se queda escuchando y nos devuelve un valor que representa el tiempo que tardó el sonido en ir y volver.

Como conocemos la velocidad del sonido en el aire (aprox. 340 metros por segundo), si sabemos el tiempo que tardó en volver, podemos calcular la distancia al objeto usando una simple fórmula matemática que veremos en el código.

Materiales necesarios

Para montar esta alarma necesitarás componentes muy básicos de electrónica. A continuación te dejo el listado con los componentes exactos que utilizo en mis tutoriales y dónde puedes conseguirlos:

COMPONENTE / HERRAMIENTA	DESCRIPCIÓN	ENLACE
Arduino UNO R3 / R4	Placa de desarrollo base para el procesamiento lógico del circuito y la alarma.	VER EN AMAZON
Sensor Ultrasónico HC-SR04	Módulo encargado de emitir y recibir los ultrasonidos para medir la distancia.	VER EN AMAZON
Buzzer / Zumbador	Zumbador piezoeléctrico utilizado para emitir el tono acústico de la alarma.	VER EN AMAZON
Protoboard (400 / 830 ptos)	Placa de prototipado esencial para montar todos los componentes sin soldar.	VER EN AMAZON
Kit de LEDs variados	Diodos LED para aviso visual de la alarma. Se aconseja utilizar el color rojo.	VER EN AMAZON

Adicionalmente, recuerda tener a mano una resistencia de 220 ohms para proteger el LED y cables jumper para realizar las conexiones de la protoboard.

Esquema de Montaje (Conexiones)

Es fundamental conectar bien el sensor, ya que un pin cruzado hará que las lecturas sean erróneas (0 cm o valores locos). Conecta los componentes de la siguiente manera:

• VCC del sensor: Al pin de 5V de Arduino.
• GND del sensor: Al pin GND de Arduino.
• Trig del sensor: Al Pin Digital 3 de Arduino.
• Echo del sensor: Al Pin Digital 2 de Arduino.
• LED: Pin largo (ánodo) al Pin Digital 13 de Arduino (mediante la resistencia de 220Ω). Pin corto (cátodo) a GND.
• Buzzer: Pin positivo (+) al Pin Digital 8 de Arduino. Pin negativo (-) a GND.

Código de Arduino para la Alarma

Aquí tienes el código completo. Cópialo y pégalo en tu IDE de Arduino. He incluido comentarios para que veas qué hace cada bloque.

alarma_ultrasonidos.ino

// Definimos los pines que vamos a utilizar
const int pinTrig = 3;    // Pin de disparo del sensor
const int pinEcho = 2;   // Pin de recepción del sensor
const int pinLED = 13;    // Pin para el LED de alarma
const int pinBuzzer = 8;  // Pin para el zumbador (buzzer)

// Variables para calcular la distancia
long duracion;
int distancia;

// Distancia límite para activar la alarma (en centímetros)
const int distanciaLimite = 50; 

void setup() {
  // Configuramos los pines
  pinMode(pinTrig, OUTPUT);   // Trig envía el pulso, es SALIDA
  pinMode(pinEcho, INPUT);    // Echo recibe el pulso, es ENTRADA
  pinMode(pinLED, OUTPUT);    // LED y Buzzer avisan, son SALIDA
  pinMode(pinBuzzer, OUTPUT);
  
  // Iniciamos la comunicación serial para ver la distancia en el PC
  Serial.begin(9600);
}

void loop() {
  // 1. LIMPIAMOS el pin Trig para asegurar un pulso limpio
  digitalWrite(pinTrig, LOW);
  delayMicroseconds(2);
  
  // 2. DISPARAMOS el pulso de ultrasonido durante 10 microsegundos
  digitalWrite(pinTrig, HIGH);
  delayMicroseconds(10);
  digitalWrite(pinTrig, LOW);
  
  // 3. MEDIMOS el tiempo que tarda el eco en volver
  duracion = pulseIn(pinEcho, HIGH);
  
  // 4. CALCULAMOS la distancia en centímetros
  // Velocidad del sonido: 340 m/s = 0.034 cm/microsegundos
  // Dividimos por 2 porque el sonido va y vuelve (viaje doble)
  distancia = duracion * 0.034 / 2;
  
  // 5. MOSTRAMOS la distancia en el Monitor Serial
  Serial.print("Distancia: ");
  Serial.print(distancia);
  Serial.println(" cm");
  
  // 6. EVALUAMOS si alguien está demasiado cerca
  if (distancia < distanciaLimite && distancia > 0) {
    // Si la distancia es menor de 50 cm, ACTIVAMOS la alarma
    digitalWrite(pinLED, HIGH);   // Enciende LED
    digitalWrite(pinBuzzer, HIGH); // Enciende Buzzer
    Serial.println("¡ALARMA ACTIVADA! Intruso detectado.");
  } else {
    // Si no hay nadie cerca, DESACTIVAMOS la alarma
    digitalWrite(pinLED, LOW);    // Apaga LED
    digitalWrite(pinBuzzer, LOW); // Apaga Buzzer
  }
  
  // Pequeña pausa antes de la próxima medición
  delay(100);
}

Explicación del Código paso a paso

Si solo copias y pegas, no aprendes. Vamos a desglosar las partes más importantes del programa:

1. La función pulseIn(): Esta es la función estrella. Arduino la usa para medir el tiempo (en microsegundos) que el pin Echo está en estado HIGH (recibiendo sonido). Es decir, mide el tiempo exacto desde que el sonido sale hasta que vuelve.
2. La Fórmula Matemática: distancia = duracion * 0.034 / 2. ¿De dónde sale esto? La velocidad del sonido es 0.034 centímetros por cada microsegundo. Multiplicamos el tiempo por la velocidad. ¿Y por qué dividimos por 2? Porque el sonido hizo un viaje redondo: fue hasta el objeto y volvió al sensor. Solo queremos la mitad de ese tiempo (el viaje de ida).
3. La condición if(): Le decimos a Arduino: "Si la distancia calculada es menor que nuestra distanciaLimite (50 cm), significa que alguien está muy cerca. Enciende el LED y el Buzzer". También añadimos distancia > 0 para evitar falsas alarmas si el sensor da un error y lee 0 cm.

Ajustes y Mejoras

Este código es la base, pero puedes modificarlo fácilmente para adaptarlo a tus necesidades:

• Cambiar la sensibilidad: Si quieres que la alarma salte más lejos, cambia en el código const int distanciaLimite = 50; por 100 (1 metro) o cualquier valor.
• Que la alarma suene intermitentemente: En lugar de dejar el buzzer siempre encendido, puedes hacer que suene y pare usando delays dentro del if (pit-pit-pit), simulando una alarma real de coche.
• Falsas lecturas: Si en el Monitor Serial ves lecturas extrañas (saltos de 0 a 400cm sin motivo), asegúrate de que los cables de Trig y Echo no están cruzados y que el sensor está bien alimentado a 5V.

🎥 Vídeo relacionado

Conclusión

Montar una alarma con el sensor HC-SR04 es un ejercicio perfecto para entender cómo Arduino interactúa con el mundo físico, midiendo tiempos y distancias reales. Este proyecto es la puerta de entrada para crear sistemas antirrobo, robots que esquivan obstáculos o medidores de nivel de agua en tanques.

Si te ha funcionado y quieres seguir profundizando en el uso de sensores y temporizadores sin bloquear tu código, te recomiendo visitar nuestro tutorial sobre Cómo crear un temporizador no bloqueante en Arduino con millis().