Sensor de vibración SW-420 con Arduino: golpes, alarma y aviso

En los proyectos con un sensor de vibración y Arduino, la pieza más usada es el módulo SW-420, barato y sencillo. Con un solo pin digital te avisa de que una superficie se ha movido, alguien ha golpeado una puerta, se ha abierto un cajón o una máquina se ha puesto en marcha. El módulo lleva un interruptor de vibración de muelle, un comparador LM393 y un pequeño potenciómetro para ajustar la sensibilidad. Es fácil de usar, pero al primer intento casi todo el mundo choca con los mismos dos problemas: el sensor pierde algunas vibraciones y a veces da la alarma sin motivo.

En esta guía aprenderás cómo funciona el contacto de muelle del SW-420, por qué su salida llega en forma de pulsos cortos y cómo ajustar bien la sensibilidad. Después contaremos los pulsos con una interrupción, mediremos cuánto dura y qué fuerza tiene una sacudida y montaremos una alarma antirrobo que reduce las falsas alarmas. También veremos por qué la idea de un avisador de terremotos no es tan sencilla como parece y qué aporta un acelerómetro MPU6050. Por último, enviaremos un mensaje de Telegram al móvil con un ESP32 cuando se detecte vibración y escribiremos código MicroPython para la Raspberry Pi Pico.

¿Qué es el sensor de vibración SW-420 y cómo funciona?

El verdadero elemento sensor del módulo es un interruptor de vibración normalmente cerrado (NC) dentro de una pequeña cápsula metálica cilíndrica. Dentro hay un muelle y una pieza conductora; cuando el sensor está quieto se tocan y el contacto está cerrado. Cuando el sensor se sacude, el muelle oscila y el contacto se abre y se cierra en ráfagas muy cortas, cada una de menos de un milisegundo. El interruptor no tiene dirección preferente, así que reacciona a la vibración venga de donde venga. El LM393 del módulo compara la tensión que genera este interruptor con un umbral fijado por el potenciómetro y produce una salida digital limpia (DO). En la mayoría de los módulos DO está a LOW en reposo y a HIGH durante la vibración, y el LED de señal se apaga o parpadea con la vibración; en algunas placas clónicas la lógica puede ir al revés, así que prueba antes tu módulo con el Monitor Serie.

Conexión del SW-420 a Arduino

Sensibilidad: ¿cómo se ajusta el potenciómetro?

El potenciómetro fija el umbral del comparador. Si queda demasiado sensible, el sensor detecta un vaso que se deja en la mesa, un camión que pasa o incluso la vibración de su propio zumbador; si queda demasiado basto, solo reacciona a golpes fuertes. Para ajustarlo bien, atornilla el módulo a la superficie donde lo vas a usar y observa el LED de señal. Gira el potenciómetro hasta el punto en que el LED se mantiene fijo en reposo pero reacciona cuando das un golpecito suave con el dedo; después baja un poquito la sensibilidad para dejar un margen de seguridad. Este ajuste depende del material: el mismo ajuste puede ser muy sensible en una mesa de madera y sordo en una pared de hormigón.

Primera prueba: detectar la vibración y captar pulsos cortos

El primer código de un principiante suele leer el pin con digitalRead() dentro de loop() y encender un LED al ver HIGH. Funciona con un golpe fuerte, pero con vibraciones suaves casi nunca pasa nada, porque la salida del SW-420 puede estar a HIGH solo unos cientos de microsegundos y, si en ese momento loop() está ocupado con Serial.print() o delay(), el pulso se pierde. La solución es atrapar el pulso con una interrupción y anotar el momento. El código de abajo guarda la hora de cada pulso y mantiene el LED encendido 1 segundo tras el último, así tu ojo puede ver incluso una vibración brevísima.

1const byte VIB_PIN = 2;                  // SW-420 DO (INT0)
2const byte LED_PIN = 13;                 // dahili LED / onboard LED
3const unsigned long HOLD_MS = 1000;      // son darbeden sonra LED süresi / LED time after the last pulse
4
5volatile unsigned long lastPulseMs = 0;
6volatile bool pulseSeen = false;
7
8void onVibration() {                     // her darbede çalışır / runs on every pulse
9  lastPulseMs = millis();
10  pulseSeen = true;
11}
12
13void setup() {
14  pinMode(VIB_PIN, INPUT);
15  pinMode(LED_PIN, OUTPUT);
16  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);   // LOW → HIGH geçişi / LOW to HIGH edge
17  Serial.begin(9600);
18}
19
20void loop() {
21  noInterrupts();
22  unsigned long last = lastPulseMs;
23  bool seen = pulseSeen;
24  pulseSeen = false;
25  interrupts();
26
27  if (seen) Serial.println(F("Titresim / vibration"));
28  digitalWrite(LED_PIN, (last > 0 && millis() - last < HOLD_MS) ? HIGH : LOW);
29}

La interrupción se ejecuta en cada flanco en que el pin pasa de LOW a HIGH; en el Uno solo D2 y D3 ofrecen este tipo de interrupción externa. Si la lógica de tu módulo va al revés, escribe FALLING en vez de RISING; como las ráfagas tienen flancos de subida y de bajada, el recuento no cambia. La función de interrupción es lo más corta posible y no usa Serial; la impresión se hace en loop(). Desactivar un momento las interrupciones al leer las variables en loop() evita que una variable de varios bytes cambie a mitad de lectura y se lea corrupta.

Contar pulsos y medir la duración: ¿cuánto duró y qué fuerza tuvo la sacudida?

El SW-420 no mide la aceleración, pero el número de pulsos que genera da una buena idea de la fuerza de una sacudida: un golpecito produce unos pocos pulsos, un portazo decenas y la vibración de un taladro cientos por segundo. El código de abajo cuenta los pulsos con una interrupción y los agrupa en eventos: el primer pulso abre un evento y, si no llega otro en 500 ms, el evento termina. Al final de cada evento muestra la duración, el total de pulsos y la densidad de pulsos por segundo. Así puedes sacar la «huella» de los eventos de tu entorno y basar el umbral de alarma en medidas y no en suposiciones.

1const byte VIB_PIN = 2;                   // SW-420 DO (INT0)
2const unsigned long QUIET_MS = 500;       // bu kadar sessizlik olayı bitirir / this much silence ends an event
3
4volatile unsigned long pulseCount = 0;
5volatile unsigned long lastPulseMs = 0;
6
7bool inEvent = false;
8unsigned long eventStart = 0;
9unsigned long eventStartCount = 0;
10
11void onVibration() {
12  pulseCount++;
13  lastPulseMs = millis();
14}
15
16void setup() {
17  pinMode(VIB_PIN, INPUT);
18  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
19  Serial.begin(9600);
20  Serial.println(F("Sure(ms)  Darbe/pulses  Darbe/sn  (pulses/s)"));
21}
22
23void loop() {
24  noInterrupts();
25  unsigned long count = pulseCount;
26  unsigned long last = lastPulseMs;
27  interrupts();
28
29  if (!inEvent && count != eventStartCount) {      // yeni olay başladı / a new event started
30    inEvent = true;
31    eventStart = last;
32  }
33  if (inEvent && millis() - last > QUIET_MS) {     // olay bitti / the event is over
34    unsigned long duration = last - eventStart;
35    unsigned long pulses = count - eventStartCount;
36    float density = duration > 0 ? pulses * 1000.0 / duration : pulses;
37    Serial.print(duration);
38    Serial.print(F("        "));
39    Serial.print(pulses);
40    Serial.print(F("           "));
41    Serial.println(density, 0);
42    eventStartCount = count;
43    inEvent = false;
44  }
45}

Ejecuta el código, golpea la mesa de distintas formas, abre un cajón, cierra la puerta y apunta los números. Con un golpe corto, la duración suele ser casi cero y los pulsos son de una cifra; una vibración larga hace crecer tanto la duración como el número de pulsos. Usar los dos valores juntos es mucho más potente que un simple «hay vibración o no»: por ejemplo, en un sensor montado en una caja fuerte, la regla «evento de al menos 300 ms con al menos 20 pulsos» puede descartar los pasos de alguien que pasa al lado y aun así detectar a quien intenta forzar la caja.

Alarma antirrobo con el SW-420 y cómo reducir las falsas alarmas

Un SW-420 colocado en el cristal de una ventana, una bici, un cajón o una caja fuerte puede ser el corazón de una alarma antirrobo sencilla. Lo que distingue una buena alarma de una mala no es tanto detectar como saber descartar las falsas alarmas. El código de abajo lo hace en tres capas: tras activarla da 10 segundos de salida, no salta con un solo golpe sino cuando ve al menos 5 pulsos en 1 segundo e ignora los pulsos nuevos durante los 15 segundos que suena la sirena. La alarma se activa y desactiva con el botón de D4, el zumbador activo está en D8 y el LED de estado en D13. Para un sistema más completo, mira la guía de sistema de alarma con Arduino.

1const byte VIB_PIN = 2;                       // SW-420 DO (INT0)
2const byte BUTTON_PIN = 4;                    // kur / kapat butonu, D4 ile GND arası / arm-disarm button
3const byte BUZZER_PIN = 8;                    // aktif buzzer / active buzzer
4const byte LED_PIN = 13;                      // durum LED'i / status LED
5const unsigned int MIN_PULSES = 5;            // pencerede gereken darbe / pulses needed in the window
6const unsigned long WINDOW_MS = 1000;         // sayım penceresi / counting window
7const unsigned long EXIT_DELAY_MS = 10000;    // kurduktan sonra çıkış süresi / exit delay after arming
8const unsigned long ALARM_MS = 15000;         // siren süresi / siren duration
9
10enum AlarmState { DISARMED, ARMING, ARMED, ALARM };
11AlarmState state = DISARMED;
12
13volatile unsigned int pulses = 0;
14unsigned long stateTime = 0;
15unsigned long windowStart = 0;
16unsigned long lastPress = 0;
17bool lastButton = HIGH;
18
19void onVibration() {
20  pulses++;
21}
22
23void setState(AlarmState s) {
24  state = s;
25  stateTime = millis();
26  digitalWrite(BUZZER_PIN, LOW);
27  noInterrupts();
28  pulses = 0;                                 // eski darbeleri sil / discard old pulses
29  interrupts();
30  windowStart = millis();
31}
32
33void setup() {
34  pinMode(VIB_PIN, INPUT);
35  pinMode(BUTTON_PIN, INPUT_PULLUP);
36  pinMode(BUZZER_PIN, OUTPUT);
37  pinMode(LED_PIN, OUTPUT);
38  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
39  Serial.begin(9600);
40}
41
42void loop() {
43  bool button = digitalRead(BUTTON_PIN);
44  if (button == LOW && lastButton == HIGH && millis() - lastPress > 200) {
45    lastPress = millis();
46    setState(state == DISARMED ? ARMING : DISARMED);
47    Serial.println(state == ARMING ? F("Kuruluyor / arming") : F("Kapatildi / disarmed"));
48  }
49  lastButton = button;
50
51  if (millis() - windowStart >= WINDOW_MS) {  // her saniye darbe sayısına bak / check the pulse count every second
52    noInterrupts();
53    unsigned int n = pulses;
54    pulses = 0;
55    interrupts();
56    windowStart = millis();
57    if (state == ARMED && n >= MIN_PULSES) {
58      setState(ALARM);
59      Serial.print(F("ALARM! darbe / pulses: "));
60      Serial.println(n);
61    }
62  }
63
64  switch (state) {
65    case DISARMED:
66      digitalWrite(LED_PIN, LOW);
67      break;
68    case ARMING:                              // hızlı yanıp sönme: çıkış süresi / fast blink: exit delay
69      digitalWrite(LED_PIN, (millis() / 250) % 2);
70      if (millis() - stateTime >= EXIT_DELAY_MS) setState(ARMED);
71      break;
72    case ARMED:
73      digitalWrite(LED_PIN, HIGH);
74      break;
75    case ALARM:                               // kesik kesik siren / intermittent siren
76      digitalWrite(BUZZER_PIN, (millis() / 300) % 2);
77      if (millis() - stateTime >= ALARM_MS) setState(ARMED);
78      break;
79  }
80}

Además del código, puedes hacer mucho para reducir las falsas alarmas:

• Montaje firme: Fija el módulo a la superficie con un tornillo M3 o un adhesivo rígido; una placa suelta vibra por sí sola.
• Aleja el zumbador: Si la sirena va en la misma placa o caja que el sensor, su propia vibración puede volver a disparar la alarma.
• Ajusta la sensibilidad en su sitio: Regula el potenciómetro en la superficie donde quedará el sensor, no en la mesa de trabajo.
• Cables cortos y sujetos: Los cables largos que cuelgan recogen ruido; si hace falta, pon 100 nF entre DO y GND.
• Usa dos sensores: En un punto importante, exigir que dos sensores se activen juntos en poco tiempo reduce mucho las falsas alarmas.
• Confirma con otro sensor: Combinar la vibración con un sensor de movimiento PIR o un sensor de puerta aumenta la fiabilidad.

¿Se puede hacer un avisador de terremotos con el SW-420? Límites y MPU6050

El avisador de terremotos es una de las ideas de proyecto más populares con un sensor de vibración y es un proyecto didáctico; pero conviene conocer sus límites. El SW-420 solo dice «algo se ha movido»: no puede medir la aceleración, la dirección ni la frecuencia de la sacudida. Por eso reacciona igual a un portazo, a un camión que pasa, a una lavadora centrifugando o a un terremoto real. Y lo más importante: un solo sensor solo detecta la sacudida cuando ya ha llegado hasta él. Los sistemas oficiales de alerta sísmica temprana combinan las medidas de muchas estaciones cercanas al epicentro y avisan a las zonas lejanas antes de que llegue la sacudida; un Arduino en casa no puede sustituirlos y no debe usarse como dispositivo de seguridad vital.

Si quieres que un proyecto sísmico tenga más sentido, pasa al módulo acelerómetro y giroscopio MPU6050. El MPU6050 mide la aceleración en tres ejes con 16 bits de resolución y rangos seleccionables de ±2 g a ±16 g. Así puedes calcular la aceleración máxima del suelo (PGA), distinguir un portazo de un movimiento del suelo largo mirando cuántos segundos dura la aceleración y su frecuencia, y guardar los datos para estudiarlos después. También tiene sentido usar los dos sensores juntos: el SW-420 espera consumiendo muy poco y despierta al microcontrolador con la primera vibración, y el MPU6050 hace la medida detallada.

Aviso por Telegram desde un ESP32 al detectar vibración

Con un ESP32, el sensor de vibración puede avisar a tu móvil cuando le pasa algo a una caja fuerte, una bici o una máquina mientras estás fuera de casa. Para ello crea un bot con BotFather en Telegram, consigue el token y tu propio chat ID e instala en el Arduino IDE las librerías UniversalTelegramBot y ArduinoJson; explicamos estos pasos en detalle en la guía del bot de Telegram con ESP32. El código de abajo cuenta los pulsos con una interrupción, envía un mensaje cuando ve al menos 5 pulsos en 1 segundo y espera al menos 60 segundos entre dos mensajes para que el móvil no se llene con decenas de avisos por minuto. Como el ESP32 tiene dos núcleos, el contador se protege con un cerrojo portMUX.

1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";               // Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
7const char* WIFI_PASS = "Sifre123";            // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // BotFather'ın verdiği token / token from BotFather
9#define CHAT_ID   "123456789"                  // kendi Telegram ID'n / your own Telegram ID
10
11const int VIB_PIN = 27;                        // SW-420 DO (modül 3V3 ile) / module powered from 3V3
12const unsigned long MIN_PULSES = 5;            // 1 sn'de gereken darbe / pulses needed in 1 s
13const unsigned long WINDOW_MS = 1000;
14const unsigned long COOLDOWN_MS = 60000;       // iki mesaj arası en az 60 sn / at least 60 s between messages
15
16volatile unsigned long pulseCount = 0;
17portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
18unsigned long windowStart = 0;
19unsigned long lastAlert = 0;
20bool alertSent = false;
21
22WiFiClientSecure client;
23UniversalTelegramBot bot(BOT_TOKEN, client);
24
25void IRAM_ATTR onVibration() {                 // kesme fonksiyonu RAM'de / interrupt handler in RAM
26  portENTER_CRITICAL_ISR(&mux);
27  pulseCount++;
28  portEXIT_CRITICAL_ISR(&mux);
29}
30
31void setup() {
32  Serial.begin(115200);
33  pinMode(VIB_PIN, INPUT);
34  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
35
36  WiFi.mode(WIFI_STA);
37  WiFi.begin(WIFI_SSID, WIFI_PASS);
38  while (WiFi.status() != WL_CONNECTED) {
39    delay(500);
40    Serial.print(".");
41  }
42  Serial.println();
43  client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org kök sertifikası / root certificate
44  bot.sendMessage(CHAT_ID, "Titreşim alarmı hazır / vibration alarm ready", "");
45  windowStart = millis();
46}
47
48void loop() {
49  if (millis() - windowStart < WINDOW_MS) return;
50  windowStart = millis();
51
52  portENTER_CRITICAL(&mux);                    // sayacı güvenle oku ve sıfırla / read and reset safely
53  unsigned long n = pulseCount;
54  pulseCount = 0;
55  portEXIT_CRITICAL(&mux);
56
57  if (n >= MIN_PULSES && (!alertSent || millis() - lastAlert >= COOLDOWN_MS)) {
58    lastAlert = millis();
59    alertSent = true;
60    String msg = "Titreşim algılandı / vibration detected: " + String(n) + " darbe / pulses";
61    Serial.println(msg);
62    if (!bot.sendMessage(CHAT_ID, msg, "")) {
63      Serial.println("Mesaj gonderilemedi / message failed");
64    }
65  }
66}

Enviar un mensaje a Telegram puede tardar 1–2 segundos; durante ese tiempo el bucle espera, pero como la interrupción sigue funcionando, los pulsos que llegan se acumulan en el contador y no se pierden. Si quieres alimentar el sensor con pilas, pon el ESP32 en sueño profundo y convierte el pin DO del SW-420 en fuente de despertar con esp_sleep_enable_ext0_wakeup(); así el ESP32 solo se despierta con la vibración, envía el mensaje y vuelve a dormir. En ese caso elige como pin de despertar uno de los GPIO RTC; el GPIO 27 está en ese grupo.

SW-420 con la Raspberry Pi Pico (MicroPython)

En la Pico alimenta el módulo desde el pin 3V3(OUT) y conecta DO a GP15. El código de abajo usa la misma lógica de eventos que la versión de Arduino: cuenta los pulsos con una interrupción, enciende el LED integrado con el primer pulso y, tras 500 ms de silencio, muestra la duración y el número de pulsos del evento. El nombre Pin("LED") elige el LED integrado tanto en la Pico como en la Pico W.

1from machine import Pin, disable_irq, enable_irq
2import time
3
4vib = Pin(15, Pin.IN)                  # SW-420 DO (modül 3V3 ile) / module powered from 3V3
5led = Pin("LED", Pin.OUT)              # dahili LED / onboard LED
6QUIET_MS = 500                         # olayı bitiren sessizlik / silence that ends an event
7
8pulses = 0
9def on_vibration(pin):
10    global pulses
11    pulses += 1
12
13vib.irq(trigger=Pin.IRQ_RISING, handler=on_vibration)
14
15event_start = None
16event_pulses = 0
17last_pulse = 0
18while True:
19    state = disable_irq()              # sayacı güvenle oku / read the counter safely
20    n = pulses
21    pulses = 0
22    enable_irq(state)
23
24    now = time.ticks_ms()
25    if n:
26        if event_start is None:        # yeni olay / new event
27            event_start = now
28            event_pulses = 0
29            led.on()
30        event_pulses += n
31        last_pulse = now
32    elif event_start is not None and time.ticks_diff(now, last_pulse) > QUIET_MS:
33        duration = time.ticks_diff(last_pulse, event_start)
34        print("Titresim / vibration: %d ms, %d darbe / pulses" % (duration, event_pulses))
35        event_start = None
36        led.off()
37    time.sleep_ms(20)

Ideas de proyectos con un sensor de vibración

• Alarma para bici y moto: Una cajita que suena cuando el vehículo aparcado se mueve y avisa al móvil mediante un ESP32.
• Aviso de lavadora terminada: Un sensor que envía «lavado terminado» cuando la vibración lleva 5 minutos parada.
• Detector de golpe secreto: Una cerradura que se abre cuando llamas con un ritmo concreto; se hace comparando los tiempos entre eventos.
• Contador de horas de máquina: Un contador que registra cuántas horas al día funciona un compresor, una bomba o una impresora 3D.
• Caja fuerte electrónica: Una protección que da la alarma si se fuerza la caja y trabaja junto a una cerradura con clave; combínala con la guía de cerradura con teclado.
• Juego y mesa interactiva: Un tambor o un juego de reflejos que da luz y sonido al golpear la mesa.

Errores frecuentes y cómo solucionarlos

El SW-420 es la forma más barata y sencilla de saber que una superficie se ha movido; su verdadera fuerza aparece cuando captas y cuentas los pulsos con una interrupción y lees los resultados junto con la duración y la densidad. Ajusta la sensibilidad en su sitio, filtra las falsas alarmas por software y pasa al MPU6050 cuando necesites la fuerza o la dirección de la sacudida. En la app BlueGrays encontrarás los proyectos Uso del zumbador, Detector de movimiento y Sistema de alarma con Telegram y ESP32, junto con la Caja fuerte electrónica inteligente, con esquemas y código paso a paso.