Vibrationssensor SW-420 am Arduino: Erschütterung und Alarm

Bei Projekten mit einem Vibrationssensor am Arduino kommt meist das günstige und einfache Modul SW-420 zum Einsatz. Über einen einzigen Digitalpin meldet es, dass eine Fläche erschüttert wurde, jemand an eine Tür klopft, eine Schublade aufgeht oder eine Maschine anläuft. Auf dem Modul sitzen ein federbasierter Erschütterungsschalter, ein Komparator LM393 und ein kleines Poti für die Empfindlichkeit. Die Bedienung ist einfach, doch beim ersten Versuch stoßen die meisten auf dieselben zwei Probleme: Der Sensor verpasst manche Erschütterungen und löst manchmal ohne jeden Grund aus.

In dieser Anleitung erfährst du, wie der Federkontakt im SW-420 funktioniert, warum sein Ausgang in kurzen Impulsen kommt und wie du die Empfindlichkeit richtig einstellst. Danach zählen wir die Impulse per Interrupt, messen, wie lange und wie stark eine Erschütterung ist, und bauen eine Alarmanlage, die Fehlalarme reduziert. Wir klären auch, warum die Idee eines Erdbebenwarners nicht so einfach ist, wie sie klingt, und was ein MPU6050-Beschleunigungssensor dazu beiträgt. Zum Schluss schickt ein ESP32 bei Erschütterung eine Telegram-Nachricht ans Handy, und wir schreiben MicroPython-Code für den Raspberry Pi Pico.

Was ist der Vibrationssensor SW-420 und wie funktioniert er?

Das eigentliche Sensorelement ist ein Öffner (NC), also ein im Ruhezustand geschlossener Erschütterungsschalter in einem kleinen zylindrischen Metallgehäuse. Darin sitzen eine Feder und ein leitendes Teil; ist der Sensor in Ruhe, berühren sie sich und der Kontakt ist geschlossen. Wird er erschüttert, schwingt die Feder, und der Kontakt öffnet und schließt sich in sehr kurzen Stößen von jeweils unter einer Millisekunde. Der Schalter ist richtungsunabhängig und reagiert auf Erschütterungen aus jeder Richtung. Der LM393 auf dem Modul vergleicht die Spannung am Schalter mit einer per Poti eingestellten Schwelle und liefert einen sauberen Digitalausgang (DO). Bei den meisten Modulen ist DO in Ruhe LOW und bei Erschütterung HIGH, und die Signal-LED erlischt oder flackert mit; bei manchen Nachbauten ist die Logik umgekehrt, teste dein Modul also zuerst mit dem seriellen Monitor.

SW-420 am Arduino anschließen

Empfindlichkeit: Wie stellt man das Poti ein?

Das Poti legt die Schwelle des Komparators fest. Ist sie zu empfindlich, erkennt der Sensor schon ein abgestelltes Glas, einen vorbeifahrenden Lkw oder sogar das Vibrieren seines eigenen Buzzers; ist sie zu grob, reagiert er nur auf harte Schläge. Für die richtige Einstellung schraubst du das Modul an die spätere Fläche und beobachtest die Signal-LED. Dreh das Poti bis zu dem Punkt, an dem die LED in Ruhe stabil bleibt, aber auf leichtes Klopfen mit dem Finger reagiert; dann nimm die Empfindlichkeit ein klein wenig zurück, als Sicherheitsreserve. Die Einstellung hängt vom Material ab: Dieselbe Einstellung kann auf einem Holztisch sehr empfindlich und an einer Betonwand taub sein.

Erster Test: Erschütterung erkennen und kurze Impulse einfangen

Der erste Anfängercode liest den Pin meist mit digitalRead() in loop() und schaltet bei HIGH eine LED ein. Bei einem harten Schlag klappt das, bei leichten Erschütterungen passiert aber oft nichts: Der Ausgang des SW-420 bleibt manchmal nur einige hundert Mikrosekunden HIGH, und ist loop() gerade mit Serial.print() oder delay() beschäftigt, geht der Impuls verloren. Die Lösung ist ein Interrupt, der den Impuls fängt und den Zeitpunkt festhält. Der Code unten speichert bei jedem Impuls die Zeit und hält die LED nach dem letzten Impuls 1 Sekunde lang an; so sieht das Auge selbst eine winzige Erschütterung.

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}

Der Interrupt läuft bei jeder Flanke, an der der Pin von LOW auf HIGH wechselt; beim Uno bieten nur D2 und D3 diesen externen Interrupt. Ist die Logik deines Moduls umgekehrt, schreib FALLING statt RISING; die Impulsfolgen bestehen aus steigenden und fallenden Flanken, die Zählung ändert sich also nicht. Die Interrupt-Funktion ist so kurz wie möglich und benutzt kein Serial; die Ausgabe erledigt loop(). Werden die Variablen in loop() gelesen, sperren wir kurz die Interrupts, damit sich eine Mehrbyte-Variable nicht mitten im Lesen ändert und falsch gelesen wird.

Impulse zählen und Dauer messen: Wie lange und wie stark war die Erschütterung?

Der SW-420 misst keine Beschleunigung, aber die Zahl seiner Impulse sagt viel über die Stärke einer Erschütterung: Ein leichtes Klopfen erzeugt wenige Impulse, eine zugeschlagene Tür Dutzende, das Vibrieren einer Bohrmaschine Hunderte pro Sekunde. Der Code zählt die Impulse per Interrupt und fasst sie zu Ereignissen zusammen: Der erste Impuls startet ein Ereignis, kommt 500 ms lang kein neuer, endet es. Am Ende jedes Ereignisses gibt er Dauer, Impulszahl und Impulsdichte pro Sekunde aus. So erstellst du einen „Fingerabdruck“ der Ereignisse in deiner Umgebung und stützt die Alarmschwelle auf Messungen statt auf Schätzungen.

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}

Starte den Code, klopf auf verschiedene Arten auf den Tisch, öffne eine Schublade, schließ die Tür und notiere die Zahlen. Bei einem einzelnen kurzen Klopfen liegt die Dauer oft nahe null und die Impulszahl im einstelligen Bereich; eine lange Erschütterung lässt beide Werte wachsen. Beide zusammen sind viel aussagekräftiger als ein bloßes „Erschütterung ja oder nein“: In einem Tresor filtert etwa die Regel „Ereignis von mindestens 300 ms mit mindestens 20 Impulsen“ die Schritte eines Vorbeigehenden heraus und erkennt trotzdem jemanden, der den Tresor aufbrechen will.

Einbruchalarm mit dem SW-420 und weniger Fehlalarme

Ein SW-420 an einer Fensterscheibe, einem Fahrrad, einer Schublade oder einem Tresor kann das Herz einer einfachen Alarmanlage sein. Eine gute Alarmanlage unterscheidet sich von einer schlechten weniger durch das Erkennen als dadurch, wie sie Fehlalarme aussortiert. Der Code macht das in drei Stufen: Nach dem Scharfschalten gibt es 10 Sekunden Verlassenszeit, ausgelöst wird nicht bei einem einzelnen Klopfen, sondern bei mindestens 5 Impulsen innerhalb von 1 Sekunde, und während die Sirene 15 Sekunden lang tönt, werden neue Impulse ignoriert. Scharf- und unscharf geschaltet wird mit dem Taster an D4, der aktive Buzzer hängt an D8, die Status-LED an D13. Für ein umfassenderes System sieh dir Arduino-Alarmanlage an.

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}

Auch außerhalb des Codes kannst du viel gegen Fehlalarme tun:

• Feste Montage: Befestige das Modul mit einer M3-Schraube oder hartem Kleber; eine wackelnde Platine schwingt von selbst.
• Buzzer weg vom Sensor: Sitzt die Sirene auf derselben Platine oder im selben Gehäuse, kann ihr eigenes Vibrieren den Alarm erneut auslösen.
• Empfindlichkeit vor Ort einstellen: Stell das Poti an der endgültigen Montagefläche ein, nicht auf dem Schreibtisch.
• Kabel kurz und fixiert halten: Lange, frei schwingende Kabel fangen Störungen ein; notfalls 100 nF zwischen DO und GND setzen.
• Zwei Sensoren verwenden: An wichtigen Stellen verringert die Bedingung, dass zwei Sensoren kurz nacheinander auslösen, Fehlalarme deutlich.
• Mit einem weiteren Sensor bestätigen: Erschütterung plus PIR-Bewegungsmelder oder Türkontakt erhöht die Zuverlässigkeit.

Erdbebenwarner mit dem SW-420? Grenzen und der MPU6050

Ein Erdbebenwarner ist eine der beliebtesten Projektideen mit Vibrationssensoren und ein lehrreiches Projekt; seine Grenzen solltest du aber kennen. Der SW-420 sagt nur „etwas hat gewackelt“: Beschleunigung, Richtung oder Frequenz der Erschütterung kann er nicht messen. Er reagiert also auf eine zugeschlagene Tür, einen vorbeifahrenden Lkw, eine schleudernde Waschmaschine und ein echtes Erdbeben gleich. Noch wichtiger: Ein einzelner Sensor bemerkt das Beben erst, wenn es bei ihm angekommen ist. Offizielle Erdbebenfrühwarnsysteme verknüpfen die Messungen vieler Stationen nahe dem Epizentrum und warnen entfernte Gebiete, bevor die Erschütterung dort eintrifft; ein Arduino zu Hause ersetzt das nicht und darf nicht als lebenswichtige Sicherheitseinrichtung dienen.

Willst du ein Erdbebenprojekt aussagekräftiger machen, steig auf das Modul MPU6050 (Beschleunigungssensor und Gyroskop) um. Der MPU6050 misst die Beschleunigung in drei Achsen mit 16 Bit Auflösung und wählbaren Bereichen von ±2 g bis ±16 g. So berechnest du die Spitzenbodenbeschleunigung (PGA), unterscheidest anhand von Dauer und Frequenz eine zugeschlagene Tür von einer langen Bodenbewegung und zeichnest die Daten zur späteren Auswertung auf. Beide Sensoren zu kombinieren ist ebenfalls sinnvoll: Der SW-420 wartet mit sehr wenig Strom und weckt beim ersten Rütteln den Mikrocontroller, der MPU6050 übernimmt die genaue Messung.

Telegram-Benachrichtigung vom ESP32 bei Erschütterung

Mit einem ESP32 meldet der Vibrationssensor deinem Handy, wenn unterwegs etwas mit dem Tresor, dem Fahrrad oder einer Maschine passiert. Dazu erstellst du in Telegram mit BotFather einen Bot, holst Token und eigene Chat-ID und installierst in der Arduino IDE die Bibliotheken UniversalTelegramBot und ArduinoJson; die Schritte erklären wir ausführlich im Beitrag ESP32-Telegram-Bot. Der Code zählt Impulse per Interrupt, sendet bei mindestens 5 Impulsen in 1 Sekunde eine Nachricht und wartet zwischen zwei Nachrichten mindestens 60 Sekunden, damit dein Handy nicht mit Dutzenden Meldungen pro Minute überflutet wird. Weil der ESP32 zwei Kerne hat, schützt eine portMUX-Sperre den Zähler.

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}

Eine Telegram-Nachricht zu senden kann 1–2 Sekunden dauern; die Schleife wartet so lange, aber der Interrupt läuft weiter, sodass ankommende Impulse im Zähler landen und nicht verloren gehen. Für Batteriebetrieb schickst du den ESP32 in den Deep Sleep und machst den DO-Pin des SW-420 mit esp_sleep_enable_ext0_wakeup() zur Weckquelle; der ESP32 wacht dann nur bei Erschütterung auf, sendet die Nachricht und schläft wieder ein. Als Weckpin brauchst du dann einen RTC-GPIO; GPIO 27 gehört dazu.

SW-420 am Raspberry Pi Pico (MicroPython)

Am Pico versorgst du das Modul aus 3V3(OUT) und verbindest DO mit GP15. Der Code nutzt dieselbe Ereignislogik wie die Arduino-Version: Er zählt Impulse per Interrupt, schaltet beim ersten Impuls die Board-LED ein und gibt nach 500 ms Ruhe Dauer und Impulszahl des Ereignisses aus. Pin("LED") wählt sowohl beim Pico als auch beim Pico W die eingebaute LED.

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)

Projektideen mit einem Vibrationssensor

• Fahrrad- und Motorradalarm: Eine kleine Box, die bei Erschütterung des geparkten Fahrzeugs piept und per ESP32 dein Handy benachrichtigt.
• Waschmaschine-fertig-Melder: Ein Sensor, der „Wäsche fertig“ meldet, wenn die Vibration 5 Minuten lang aufgehört hat.
• Geheimes Klopfschloss: Ein Schloss, das sich bei einem bestimmten Klopfrhythmus öffnet; dazu vergleichst du die Zeiten zwischen den Ereignissen.
• Betriebsstundenzähler: Ein Zähler, der aufzeichnet, wie viele Stunden am Tag ein Kompressor, eine Pumpe oder ein 3D-Drucker läuft.
• Elektronischer Tresor: Ein Schutz, der beim Aufbrechen Alarm schlägt und mit einem Codeschloss zusammenarbeitet; kombiniere ihn mit Keypad-Codeschloss.
• Spiel und interaktiver Tisch: Eine Trommel oder ein Reaktionsspiel, das beim Schlag auf den Tisch Licht und Ton erzeugt.

Häufige Fehler und ihre Lösungen

Der SW-420 ist der billigste und einfachste Weg zu erfahren, dass eine Fläche erschüttert wurde; seine Stärke zeigt sich, wenn du die Impulse per Interrupt fängst, zählst und zusammen mit Dauer und Dichte auswertest. Stell die Empfindlichkeit vor Ort ein, filtere Fehlalarme per Software heraus und nimm den MPU6050, wenn Stärke oder Richtung der Erschütterung gefragt sind. In der BlueGrays-App findest du die Projekte Buzzer, Bewegungsmelder und ESP32-Alarmanlage mit Telegram sowie den intelligenten Elektroniktresor, mit Schritt-für-Schritt-Schaltplänen und Code.