Arduino Erdbebenalarm: Erschütterung erkennen mit MPU6050
Arduino Erdbebenalarm bauen: MPU6050 kalibrieren, Schwelle festlegen, Fehlalarme durch Türknallen filtern, Buzzer und LED, SW-420 und ESP32-Nachricht.
Ein Arduino Erdbebenalarm ist ein einfaches, aber sehr lehrreiches Projekt: Ein Beschleunigungssensor misst ständig die Vibration seiner Unterlage und schaltet Buzzer und LED ein, sobald die Erschütterung eine bestimmte Stärke und Dauer überschreitet. In dieser Anleitung lernst du Schritt für Schritt, den MPU6050 zu kalibrieren, den passenden Schwellenwert für die Störgeräusche deiner Umgebung zu finden, Fehlalarme wie Türknallen oder Schritte per Software auszufiltern und akustisch und optisch zu warnen. Am Ende baust du dieselbe Logik auch mit dem günstigen Vibrationssensor SW-420, mit einem ESP32, der dir eine Nachricht aufs Handy schickt, und mit dem Raspberry Pi Pico unter MicroPython.
Vorab ganz klar: Dieses Gerät ist kein Seismograph und kein offizielles Erdbebenfrühwarnsystem. Es kann ein Erdbeben nicht vorhersagen; es warnt dich erst, wenn die Erschütterung beginnt, mit etwas Glück ein paar Sekunden vor den stärksten Wellen. Trotzdem ist es ein tolles Projekt, um nachts eine leichte Erschütterung mitzubekommen, den Begriff Beschleunigung zu verstehen und Signalverarbeitung und Filterung kennenzulernen. Auch für Schulprojekte und Wettbewerbe wie Jugend forscht ist es gut geeignet.

Wie funktioniert ein Erdbebenalarm?
Bei einem Erdbeben breiten sich von der Quelle zwei Hauptwellentypen aus. Zuerst kommen die P-Wellen (Primärwellen, Kompressionswellen), die sich mit etwa 6 km/s durch die Erdkruste bewegen und meist schwächer zu spüren sind. Danach folgen die S-Wellen (Sekundärwellen, Scherwellen) mit etwa 3,5 km/s; sie verursachen den Großteil der Schäden. Bist du 50 km vom Epizentrum entfernt, liegen zwischen beiden Wellen grob 6 Sekunden; direkt über dem Epizentrum ist der Abstand fast null. Unser Alarm misst mit einem fest montierten Beschleunigungssensor die kleinen Beschleunigungsänderungen dieser Wellen. Im Ruhezustand sieht der Sensor nur die Erdbeschleunigung (1 g ≈ 9,81 m/s²); setzt die Erschütterung ein, schwanken die Werte aller drei Achsen um diese Ruhelage. Die Größe dieser Schwankung nennen wir in diesem Beitrag dynamische Beschleunigung. Eine ausführliche Vorstellung des Sensors findest du im Beitrag MPU6050 Beschleunigungssensor und Gyroskop.
| Eigenschaft | MPU6050-Wert |
|---|---|
| Sensortyp | 3-Achsen-Beschleunigungssensor + 3-Achsen-Gyroskop (6-Achsen-IMU) |
| Beschleunigungsbereiche | ±2 / ±4 / ±8 / ±16 g |
| Empfindlichkeit (±2 g) | 16384 LSB/g (1 Schritt ≈ 0,061 mg) |
| ADC-Auflösung | 16 Bit |
| Interner Tiefpassfilter (DLPF) | Wählbar von etwa 5 bis 260 Hz |
| Kommunikation | I2C, bis 400 kHz |
| I2C-Adresse | 0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V) |
| Versorgung (GY-521-Modul) | 3,3–5 V (3,3-V-Regler auf der Platine) |
| Stromaufnahme | Etwa 4 mA |
Erschütterungsstärke und Beschleunigung: Welcher Wert bedeutet was?
Seismologen geben die Stärke einer Erschütterung an einem Ort meist als Spitzenbodenbeschleunigung (PGA) an. Die folgende Tabelle zeigt den ungefähren Zusammenhang zwischen Bodenbeschleunigung und gefühlter Intensität nach der Modifizierten Mercalli-Skala. Schon eine Erschütterung, die Menschen als leicht empfinden, liegt bei 0,014–0,039 g; wir arbeiten also mit sehr kleinen Beschleunigungen von 14–39 mg. Da ein Schritt des MPU6050 im ±2-g-Bereich nur 0,061 mg beträgt, reicht die Auflösung locker aus; sein Eigenrauschen liegt im Ruhezustand aber bei einigen mg, deshalb muss die Schwelle über diesem Rauschen liegen. Die Werte in der Tabelle gelten für den Boden; in den oberen Stockwerken eines Gebäudes schaukelt es stärker, nutze sie also nur als Anhaltspunkt.
| Spitzenbodenbeschleunigung (g) | Mercalli-Intensität | Gefühlte Wirkung |
|---|---|---|
| < 0,0017 | I | Nicht spürbar |
| 0,0017 – 0,014 | II–III | Schwach; in ruhiger Umgebung und in oberen Stockwerken spürbar |
| 0,014 – 0,039 | IV | Leicht; die meisten bemerken es, Fenster klirren |
| 0,039 – 0,092 | V | Mäßig; Schlafende wachen auf, kleine Gegenstände fallen um |
| 0,092 – 0,18 | VI | Stark; alle spüren es, Putz kann reißen |
| 0,18 – 0,34 | VII | Sehr stark; Schäden an schwachen Bauten |
Benötigte Bauteile und Anschluss
- Board: Arduino Uno oder Nano; für Benachrichtigungen ein ESP32, für MicroPython ein Raspberry Pi Pico.
- MPU6050-Modul (GY-521): Der Beschleunigungssensor, der die Erschütterung misst.
- Aktiver Buzzer: Kleine aktive Buzzer ziehen etwa 20–30 mA; für mehr Lautstärke steuerst du ihn über einen NPN-Transistor.
- Rote LED und 220-Ω-Widerstand: Für die optische Warnung; den Widerstandswert kannst du mit dem LED-Widerstandsrechner prüfen.
- Taster: Zum Stummschalten des Alarms (mit internem Pull-up, kein zusätzlicher Widerstand nötig).
- Breadboard und Jumper-Kabel; für die einfache Variante optional ein SW-420-Vibrationssensor.
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| MPU6050 VCC | 5V | 3V3 | 3V3(OUT) |
| MPU6050 GND | GND | GND | GND |
| MPU6050 SCL | A5 | GPIO 22 | GP5 |
| MPU6050 SDA | A4 | GPIO 21 | GP4 |
| MPU6050 AD0 | GND (Adresse 0x68) | GND (Adresse 0x68) | GND (Adresse 0x68) |
| Aktiver Buzzer (+) | D8 | GPIO 25 | GP15 |
| LED (mit 220 Ω) | D7 | GPIO 26 | GP14 |
| Stummschalt-Taster (anderes Ende an GND) | D2 | GPIO 27 | GP13 |
| SW-420 DO (einfache Variante) | D3 | - | - |
Kalibrierung und Schwellenwert festlegen
Die Kalibrierung ermittelt die Werte der drei Achsen im Ruhezustand. Ein Sensor liegt nie perfekt waagerecht und jeder Chip hat einen kleinen Offset; die Z-Achse liest zum Beispiel 0,97 g statt 1,00 g und die X-Achse 0,02 g statt 0. Beim Start nimmt der Code etwa eine Sekunde lang 200 Messungen auf und speichert den Mittelwert als Basiswert. Bei jeder weiteren Messung wird dieser Basiswert von jeder Achse abgezogen und der Vektorbetrag des Rests berechnet: dynamische Beschleunigung = √(dx² + dy² + dz²). Das Schöne daran: Ob du den Sensor waagerecht, senkrecht oder schräg montierst, ändert nichts am Ergebnis, weil die Schwerkraft im Basiswert steckt und automatisch herausfällt. Mit der Temperatur driftet der Offset des Sensors sehr langsam; der Code verfolgt diese Drift, indem er den Basiswert bei ruhiger Umgebung mit jeder Messung zu einem Tausendstel nachführt.
- Befestige den Sensor fest an seinem endgültigen Platz, lade den Code hoch und berühre den Aufbau nicht, bis die Kalibriermeldung durch ist.
- Öffne im Menü Werkzeuge den Serial Plotter (115200 Baud). In ruhiger Umgebung schwankt die dynamische Beschleunigung meist zwischen 0,002 und 0,008 g; das ist dein Rauschpegel.
- Notiere über einige Minuten den höchsten Wert des Rauschens und wähle die Schwelle als das 3- bis 5-Fache davon. Der Standardwert von 0,03 g im Code entspricht der leichten Intensität IV.
- Klopfe leicht auf den Tisch, schließe die Tür, geh durchs Zimmer und beobachte, wie hoch und wie lang der Ausschlag im Plotter jeweils ist.
- Um ein echtes Beben nachzustellen, rüttle das Brett, an dem der Sensor festgeschraubt ist, einige Sekunden lang ein- bis dreimal pro Sekunde hin und her; der Alarm sollte nach etwa 1–2 Sekunden losgehen.
- Bekommst du Fehlalarme, ändere THRESHOLD_G, bemerkt der Alarm die Erschütterung zu spät, ändere SCORE_ALARM; verändere die Werte in kleinen Schritten und wiederhole die Tests.
Fehlalarme ausfiltern: Türknallen und Schritte
Knallt eine Tür, sieht der Sensor einen großen, aber sehr kurzen Stoß von 0,1–0,5 g und 50–200 ms. Ein Erdbeben dagegen schwingt mit kleineren Beschleunigungen, aber sekundenlang im Bereich von 1–10 Hz. Das Unterscheidungsmerkmal ist also nicht die Amplitude, sondern die Dauer. Im Code lösen wir das mit einem Punktezähler nach dem Leaky-Bucket-Prinzip: Es gibt 100 Messungen pro Sekunde, jede Messung über der Schwelle erhöht die Punkte um 2, jede unter der Schwelle verringert sie um 1, und bei 100 Punkten ertönt der Alarm. Ein 150 ms langes Türknallen erzeugt höchstens 15 Messwerte, also 30 Punkte, und baut sich schnell wieder ab. Eine Erschütterung, die bei etwa der Hälfte der Messwerte die Schwelle überschreitet, sammelt netto 50 Punkte pro Sekunde und löst den Alarm nach etwa 2 Sekunden aus. Außerdem läuft das Signal durch den 21-Hz-Tiefpassfilter im Sensor, sodass hochfrequente Vibrationen wie Lüfter-, Motor- und Kompressorbrummen weitgehend unterdrückt werden. Weitere Filtermethoden findest du im Beitrag Sensordaten filtern.
| Quelle des Fehlalarms | Signalmerkmal | Lösung |
|---|---|---|
| Türknallen | Großer Einzelstoß von 50–200 ms | Der Punktezähler filtert kurze Stöße; halte den Sensor vom Türrahmen fern |
| Gehen, Springen | Rhythmisch 1–2 Hz, nahe am Sensor 0,01–0,05 g | Montiere den Sensor in einer ruhigen Ecke an einer tragenden Wand und erhöhe die Schwelle leicht |
| Waschmaschine, Klimaanlage | Lang anhaltende Vibration mit konstanter Frequenz | Stelle das Gerät in einen Raum abseits dieser Maschinen und teste bei laufendem Betrieb die Schwelle |
| Vorbeifahrende Lkw | Mehrere Sekunden lang schwache Vibration | Teste nachts und tagsüber getrennt und setze die Schwelle über die Straßenvibration |
| Sensor verrutscht | Dauerhafter Offset, Punkte steigen ständig | Festschrauben; falls verrutscht, Board zurücksetzen und neu kalibrieren |
Arduino-Erdbebenalarm-Code (MPU6050 + Buzzer + LED)
1#include <Wire.h>
2
3const int MPU_ADDR = 0x68; // AD0 = GND / AD0 = GND
4const int BUZZER_PIN = 8; // aktif buzzer / active buzzer
5const int LED_PIN = 7; // LED + 220 ohm
6const int BUTTON_PIN = 2; // susturma butonu / silence button
7
8const float THRESHOLD_G = 0.03; // dinamik ivme eşiği (g) / dynamic acceleration threshold (g)
9const int SCORE_ALARM = 100; // alarm puanı / alarm score
10const unsigned long SAMPLE_MS = 10; // 100 Hz örnekleme / 100 Hz sampling
11const unsigned long ALARM_HOLD_MS = 30000; // son sarsıntıdan sonra 30 s / 30 s after the last shake
12const bool DEBUG_PLOT = true; // Seri Çizici çıktısı / Serial Plotter output
13
14float baseX, baseY, baseZ; // durağan taban değerleri / resting baseline
15int score = 0;
16bool alarmOn = false;
17float peakG = 0;
18unsigned long lastSample = 0;
19unsigned long lastShake = 0;
20
21void writeReg(uint8_t reg, uint8_t val) {
22 Wire.beginTransmission(MPU_ADDR);
23 Wire.write(reg);
24 Wire.write(val);
25 Wire.endTransmission();
26}
27
28void readAccel(float &ax, float &ay, float &az) {
29 Wire.beginTransmission(MPU_ADDR);
30 Wire.write(0x3B); // ACCEL_XOUT_H
31 Wire.endTransmission(false);
32 Wire.requestFrom(MPU_ADDR, 6);
33 uint8_t b[6];
34 for (int i = 0; i < 6; i++) b[i] = Wire.read();
35 ax = (int16_t)((b[0] << 8) | b[1]) / 16384.0; // ±2 g: 16384 LSB/g
36 ay = (int16_t)((b[2] << 8) | b[3]) / 16384.0;
37 az = (int16_t)((b[4] << 8) | b[5]) / 16384.0;
38}
39
40void calibrate() {
41 float sx = 0, sy = 0, sz = 0;
42 for (int i = 0; i < 200; i++) {
43 float ax, ay, az;
44 readAccel(ax, ay, az);
45 sx += ax; sy += ay; sz += az;
46 delay(5);
47 }
48 baseX = sx / 200; baseY = sy / 200; baseZ = sz / 200;
49}
50
51void setup() {
52 Serial.begin(115200);
53 pinMode(BUZZER_PIN, OUTPUT);
54 pinMode(LED_PIN, OUTPUT);
55 pinMode(BUTTON_PIN, INPUT_PULLUP);
56 Wire.begin();
57 writeReg(0x6B, 0x00); // uyku modundan çık / wake up
58 writeReg(0x1C, 0x00); // ±2 g aralığı / ±2 g range
59 writeReg(0x1A, 0x04); // DLPF ~21 Hz
60 delay(100);
61 Serial.println(F("Kalibrasyon, dokunma / Calibrating, do not touch"));
62 calibrate();
63 lastSample = millis();
64}
65
66void loop() {
67 if (millis() - lastSample >= SAMPLE_MS) {
68 lastSample += SAMPLE_MS;
69 float ax, ay, az;
70 readAccel(ax, ay, az);
71 float dx = ax - baseX, dy = ay - baseY, dz = az - baseZ;
72 float dyn = sqrt(dx * dx + dy * dy + dz * dz); // dinamik ivme (g) / dynamic acceleration (g)
73 if (DEBUG_PLOT) Serial.println(dyn, 4);
74
75 if (dyn > THRESHOLD_G) {
76 score = min(score + 2, 200); // eşik üstü: +2 / above threshold: +2
77 if (dyn > peakG) peakG = dyn;
78 } else if (score > 0) {
79 score--; // eşik altı: -1 / below threshold: -1
80 }
81
82 if (score == 0 && !alarmOn) { // sakin: tabanı yavaşça izle / quiet: track baseline slowly
83 baseX += (ax - baseX) * 0.001;
84 baseY += (ay - baseY) * 0.001;
85 baseZ += (az - baseZ) * 0.001;
86 peakG = 0;
87 }
88
89 if (score >= SCORE_ALARM) {
90 if (!alarmOn && !DEBUG_PLOT) {
91 Serial.print(F("SARSINTI! Tepe / Peak: "));
92 Serial.print(peakG, 3);
93 Serial.println(F(" g"));
94 }
95 alarmOn = true;
96 lastShake = millis();
97 }
98 }
99
100 if (alarmOn && (millis() - lastShake > ALARM_HOLD_MS || digitalRead(BUTTON_PIN) == LOW)) {
101 alarmOn = false; // süre doldu ya da susturuldu / timeout or silenced
102 score = 0;
103 }
104
105 bool on = alarmOn && ((millis() / 250) % 2); // 2 Hz yanıp sönme / 2 Hz blinking
106 digitalWrite(LED_PIN, on);
107 digitalWrite(BUZZER_PIN, on);
108}| Codeabschnitt | Aufgabe |
|---|---|
| writeReg(0x6B, 0x00) | Der MPU6050 startet im Schlafmodus; dieser Befehl weckt den Sensor auf |
| writeReg(0x1C, 0x00) | Stellt den Beschleunigungsbereich auf ±2 g ein; in diesem Bereich entspricht 1 g dem Wert 16384 |
| writeReg(0x1A, 0x04) | Stellt den internen Tiefpassfilter auf etwa 21 Hz ein |
| calibrate() | Ermittelt die Ruhe-Basiswerte als Mittelwert aus 200 Messungen |
| dyn | Vektorbetrag der Abweichung vom Basiswert, also die dynamische Beschleunigung (g) |
| score | +2 bei jeder Messung über der Schwelle, -1 darunter; bei 100 ertönt der Alarm |
| ALARM_HOLD_MS | Der Alarm läuft nach der letzten Erschütterung noch 30 s weiter; der Taster schaltet ihn früher stumm |
| millis()-Zeitsteuerung | Sorgt ohne delay für eine feste Abtastrate von 100 Hz |
Einfacher Erdbebenalarm mit dem SW-420

Das SW-420-Modul besteht aus einem einfachen Vibrationsschalter mit Federkontakt und einem LM393-Komparator. Im Ruhezustand ist der Kontakt geschlossen und der DO-Ausgang bleibt LOW; öffnet und schließt die Vibration den Kontakt, erzeugt der DO-Pin HIGH-Impulse. Das Potentiometer auf dem Modul stellt die Empfindlichkeit ein. Es misst keine Beschleunigung, sondern liefert nur die Information, ob eine Vibration da ist oder nicht; die Stärke kann es also nicht unterscheiden, es ist dafür sehr günstig und der Code ist simpel. Der folgende Code zählt die Impulse per Interrupt; kommen 2 Sekunden lang in Folge 15 oder mehr Impulse pro Sekunde, startet ein 20-Sekunden-Alarm. So wird auch hier ein einzelnes Türknallen herausgefiltert. Details zum Modul findest du im Beitrag SW-420 Vibrationssensor.
1const byte SENSOR_PIN = 3; // SW-420 DO (kesme pini / interrupt pin)
2const byte BUZZER_PIN = 8;
3const byte LED_PIN = 7;
4const unsigned int PULSE_LIMIT = 15; // saniyedeki darbe sınırı / pulses per second limit
5
6volatile unsigned int pulses = 0;
7unsigned long lastCheck = 0;
8unsigned long alarmUntil = 0;
9byte busySeconds = 0;
10
11void onPulse() {
12 pulses++; // her titreşim darbesini say / count each vibration pulse
13}
14
15void setup() {
16 Serial.begin(115200);
17 pinMode(SENSOR_PIN, INPUT);
18 pinMode(BUZZER_PIN, OUTPUT);
19 pinMode(LED_PIN, OUTPUT);
20 attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), onPulse, RISING);
21}
22
23void loop() {
24 if (millis() - lastCheck >= 1000) { // her saniye değerlendir / evaluate every second
25 lastCheck = millis();
26 noInterrupts();
27 unsigned int n = pulses;
28 pulses = 0;
29 interrupts();
30 Serial.println(n);
31 if (n >= PULSE_LIMIT) busySeconds++;
32 else busySeconds = 0;
33 if (busySeconds >= 2) alarmUntil = millis() + 20000; // 2 s sürekli titreşim / 2 s continuous vibration
34 }
35
36 bool alarm = (long)(alarmUntil - millis()) > 0;
37 bool on = alarm && ((millis() / 250) % 2);
38 digitalWrite(BUZZER_PIN, on);
39 digitalWrite(LED_PIN, on);
40}ESP32-Erdbebenalarm mit Benachrichtigung aufs Handy
Der ESP32 kann dieselbe Erkennungslogik ausführen und dir zusätzlich per WLAN eine Telegram-Nachricht aufs Handy schicken. Installiere dafür im Bibliotheksverwalter UniversalTelegramBot und die Abhängigkeit ArduinoJson, erstelle mit BotFather einen Bot und trage Token und deine eigene Chat-ID in den Code ein; alle Schritte stehen im Beitrag ESP32 Telegram-Bot. Wichtig ist hier eine Designentscheidung: Die WLAN-Verbindung ist keine Voraussetzung für den Alarm. Bei einem Erdbeben können Strom oder Internet ausfallen; deshalb laufen Buzzer und LED immer lokal, die Nachricht wird nur gesendet, wenn eine Verbindung besteht, und pro Ereignis nur einmal. Wenn du das Gerät mit einem 18650-Akku, einem TP4056-Lademodul und einem passenden Spannungsregler absicherst, funktioniert es auch bei Stromausfall.
1#include <Wire.h>
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h>
5
6const char* WIFI_SSID = "WIFI_ADI";
7const char* WIFI_PASS = "WIFI_SIFRESI";
8#define BOT_TOKEN "123456789:BOT_TOKENIN" // BotFather'dan / from BotFather
9#define CHAT_ID "123456789" // kendi chat ID'n / your chat ID
10
11const int MPU_ADDR = 0x68;
12const int BUZZER_PIN = 25;
13const int LED_PIN = 26;
14const int BUTTON_PIN = 27;
15const float THRESHOLD_G = 0.03;
16const int SCORE_ALARM = 100;
17const unsigned long ALARM_HOLD_MS = 30000;
18
19WiFiClientSecure client;
20UniversalTelegramBot bot(BOT_TOKEN, client);
21
22float baseX, baseY, baseZ;
23int score = 0;
24bool alarmOn = false;
25bool messageSent = false;
26float peakG = 0;
27unsigned long lastSample = 0, lastShake = 0;
28
29void writeReg(uint8_t reg, uint8_t val) {
30 Wire.beginTransmission(MPU_ADDR);
31 Wire.write(reg);
32 Wire.write(val);
33 Wire.endTransmission();
34}
35
36void readAccel(float &ax, float &ay, float &az) {
37 Wire.beginTransmission(MPU_ADDR);
38 Wire.write(0x3B);
39 Wire.endTransmission(false);
40 Wire.requestFrom(MPU_ADDR, 6);
41 uint8_t b[6];
42 for (int i = 0; i < 6; i++) b[i] = Wire.read();
43 ax = (int16_t)((b[0] << 8) | b[1]) / 16384.0;
44 ay = (int16_t)((b[2] << 8) | b[3]) / 16384.0;
45 az = (int16_t)((b[4] << 8) | b[5]) / 16384.0;
46}
47
48void setup() {
49 Serial.begin(115200);
50 pinMode(BUZZER_PIN, OUTPUT);
51 pinMode(LED_PIN, OUTPUT);
52 pinMode(BUTTON_PIN, INPUT_PULLUP);
53 Wire.begin(21, 22); // SDA, SCL
54 writeReg(0x6B, 0x00); // uyandır / wake up
55 writeReg(0x1C, 0x00); // ±2 g
56 writeReg(0x1A, 0x04); // DLPF ~21 Hz
57 delay(100);
58 float sx = 0, sy = 0, sz = 0; // kalibrasyon / calibration
59 for (int i = 0; i < 200; i++) {
60 float ax, ay, az;
61 readAccel(ax, ay, az);
62 sx += ax; sy += ay; sz += az;
63 delay(5);
64 }
65 baseX = sx / 200; baseY = sy / 200; baseZ = sz / 200;
66 client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
67 WiFi.begin(WIFI_SSID, WIFI_PASS); // bağlanmayı beklemez / does not block
68 lastSample = millis();
69}
70
71void loop() {
72 if (millis() - lastSample >= 10) { // 100 Hz örnekleme / 100 Hz sampling
73 lastSample += 10;
74 float ax, ay, az;
75 readAccel(ax, ay, az);
76 float dx = ax - baseX, dy = ay - baseY, dz = az - baseZ;
77 float dyn = sqrt(dx * dx + dy * dy + dz * dz);
78 if (dyn > THRESHOLD_G) {
79 score = min(score + 2, 200);
80 if (dyn > peakG) peakG = dyn;
81 } else if (score > 0) {
82 score--;
83 }
84 if (score == 0 && !alarmOn) {
85 baseX += (ax - baseX) * 0.001;
86 baseY += (ay - baseY) * 0.001;
87 baseZ += (az - baseZ) * 0.001;
88 peakG = 0;
89 }
90 if (score >= SCORE_ALARM) {
91 alarmOn = true;
92 lastShake = millis();
93 }
94 }
95
96 if (alarmOn && !messageSent && WiFi.status() == WL_CONNECTED) {
97 digitalWrite(LED_PIN, HIGH); // gönderirken de uyar / keep warning while sending
98 digitalWrite(BUZZER_PIN, HIGH);
99 String msg = String("Sarsinti algilandi! Tepe ivme: ") + String(peakG, 3) + " g";
100 bot.sendMessage(CHAT_ID, msg, "");
101 messageSent = true; // olay başına bir mesaj / one message per event
102 lastSample = millis(); // kaçan örnekleri atla / skip missed samples
103 }
104
105 if (alarmOn && (millis() - lastShake > ALARM_HOLD_MS || digitalRead(BUTTON_PIN) == LOW)) {
106 alarmOn = false;
107 messageSent = false;
108 score = 0;
109 }
110
111 bool on = alarmOn && ((millis() / 250) % 2);
112 digitalWrite(LED_PIN, on);
113 digitalWrite(BUZZER_PIN, on);
114}MicroPython-Version mit dem Raspberry Pi Pico
Auf dem Pico brauchst du keine zusätzliche Bibliothek; die eingebaute I2C-Klasse von MicroPython und das Modul struct genügen, um die Rohdaten des MPU6050 zu lesen. Die Logik ist identisch mit dem Arduino-Code: Kalibrierung, dynamische Beschleunigung, Punktezähler und 30 Sekunden Alarm. Weil die Pins des Pico 3,3 V ausgeben, piepen kleine 5-V-Buzzer leiser; willst du es lauter, steuere den Buzzer über einen NPN-Transistor mit 5 V (VBUS). Bist du neu bei MicroPython, wirf zuerst einen Blick auf den Beitrag MicroPython Grundlagen.
1from machine import Pin, I2C
2import struct, time, math
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5MPU = 0x68
6buzzer = Pin(15, Pin.OUT)
7led = Pin(14, Pin.OUT)
8button = Pin(13, Pin.IN, Pin.PULL_UP) # susturma butonu / silence button
9
10i2c.writeto_mem(MPU, 0x6B, b'\x00') # uyandır / wake up
11i2c.writeto_mem(MPU, 0x1C, b'\x00') # ±2 g
12i2c.writeto_mem(MPU, 0x1A, b'\x04') # DLPF ~21 Hz
13time.sleep_ms(100)
14
15def read_accel():
16 x, y, z = struct.unpack('>hhh', i2c.readfrom_mem(MPU, 0x3B, 6))
17 return x / 16384, y / 16384, z / 16384
18
19print("Kalibrasyon / Calibrating...")
20sx = sy = sz = 0
21for _ in range(200):
22 ax, ay, az = read_accel()
23 sx += ax; sy += ay; sz += az
24 time.sleep_ms(5)
25bx, by, bz = sx / 200, sy / 200, sz / 200
26
27THRESHOLD = 0.03 # eşik (g) / threshold (g)
28score = 0
29alarm = False
30last_shake = 0
31
32while True:
33 t0 = time.ticks_ms()
34 ax, ay, az = read_accel()
35 dyn = math.sqrt((ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2)
36 if dyn > THRESHOLD:
37 score = min(score + 2, 200)
38 elif score > 0:
39 score -= 1
40 if score == 0 and not alarm: # tabanı yavaşça izle / track baseline slowly
41 bx += (ax - bx) * 0.001
42 by += (ay - by) * 0.001
43 bz += (az - bz) * 0.001
44 if score >= 100:
45 alarm = True
46 last_shake = time.ticks_ms()
47 if alarm and (time.ticks_diff(time.ticks_ms(), last_shake) > 30000 or button.value() == 0):
48 alarm = False
49 score = 0
50 on = alarm and (time.ticks_ms() // 250) % 2 == 1
51 buzzer.value(on)
52 led.value(on)
53 time.sleep_ms(max(0, 10 - time.ticks_diff(time.ticks_ms(), t0))) # ~100 HzProjektideen zum Weiterentwickeln des Erdbebenalarms
- Mini-Seismometer mit Display: Zeichne die dynamische Beschleunigung als laufende Kurve auf einem OLED-Display und zeige den Spitzenwert des letzten Ereignisses und die geschätzte Mercalli-Intensität an.
- Ereignisprotokoll: Schreibe Zeitpunkt und Spitzenbeschleunigung jeder Erschütterung auf ein SD-Kartenmodul; mit einer RTC kannst du Datum und Uhrzeit ergänzen.
- Notbeleuchtung: Schalte bei einer Erschütterung über ein Relaismodul automatisch die Flurlampe ein.
- Integrierte Haussicherheit: Füge die Erdbebenerkennung zusammen mit Gas-, Rauch- und Bewegungssensoren in dasselbe Alarmsystem ein.
- Mehrere Benachrichtigungen: Sende statt Telegram oder zusätzlich dazu eine WhatsApp-Nachricht mit dem ESP32.
- Wissenschaftsprojekt: Miss mit Sensoren in verschiedenen Stockwerken, wie die Vibration mit der Etage zunimmt; Ideen findest du im Beitrag Arduino-Projektideen für Wettbewerbe.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Werte sind immer 0 oder ändern sich nie | Sensor schläft oder I2C-Verbindung falsch | Schreibzugriff auf 0x6B prüfen, SDA/SCL-Pins kontrollieren, Adresse mit I2C-Scanner finden |
| Alarm geht gleich nach dem Start los | Sensor hat sich während der Kalibrierung bewegt | Bei der Kalibrierung den Aufbau nicht berühren, Board zurücksetzen |
| Alarm hört nicht mehr auf | Buzzer-Vibration überträgt sich auf den Sensor oder Sensor ist verrutscht | Buzzer auf einer anderen Fläche als der Sensor montieren, Sensor festschrauben und neu kalibrieren |
| Keine Reaktion bei leichtem Rütteln | THRESHOLD_G oder SCORE_ALARM zu hoch | Rauschen im Serial Plotter messen, Schwelle schrittweise senken |
| Vom ESP32 kommt keine Nachricht | Token oder Chat-ID falsch, WLAN nicht verbunden | Angaben prüfen, WiFi.status() im Seriellen Monitor ausgeben |
| Zufällige Abstürze | Lange, lockere I2C-Kabel | Kabel unter 30 cm halten, Kontakte auf dem Breadboard prüfen |
| Buzzer zu leise | 3,3-V-Pin oder zu wenig Strom | Buzzer über einen NPN-Transistor mit 5 V ansteuern |
Jetzt hast du einen Erdbebenalarm, der Beschleunigung misst, sich selbst kalibriert, kurze Stöße ausfiltert und bei einer echten Erschütterung akustisch und optisch warnt; und dieselbe Logik kannst du auf Arduino, ESP32 und Pico aufbauen. Möchtest du Buzzer, LED und Alarmlogik vertiefen, findest du in der BlueGrays-App Projekte zur Buzzer-Nutzung, zum Polizeiblinklicht, zum Laser-Warnsystem und zum ESP32-Bewegungsalarm mit Schritt-für-Schritt-Schaltplänen und fertigem Code.
Häufige Fragen
Kann man mit Arduino einen Erdbebenalarm bauen und funktioniert er wirklich?
Ja, mit einem Beschleunigungssensor wie dem MPU6050 kannst du einen Alarm bauen, der spürbare Erschütterungen erkennt und per Buzzer und LED warnt. Er hilft besonders, nachts im Schlaf eine leichte Erschütterung zu bemerken, und ist ein lehrreiches Projekt. Er ist aber kein Seismograph und kein offizielles Frühwarnsystem; mach Sicherheitsentscheidungen nicht von ihm abhängig.
Warnt ein Erdbebenalarm vor einem Erdbeben?
Nein, kein Gerät kann ein Erdbeben vorhersagen. Ein lokaler Sensor schlägt erst an, wenn die Erschütterung beginnt. Bist du weiter vom Epizentrum entfernt, kann er die schwachen P-Wellen erfassen und einige Sekunden vor den starken S-Wellen warnen; in der Nähe des Epizentrums ist diese Zeit praktisch null.
MPU6050 oder SW-420 für den Erdbebenalarm: Was ist besser?
Der MPU6050 misst die Beschleunigung als Zahlenwert, sodass du die Schwelle fein einstellen und Stärke und Dauer der Erschütterung auswerten kannst; Fehlalarme lassen sich damit viel leichter ausfiltern. Der SW-420 liefert nur die Information, ob eine Vibration vorliegt; er ist günstig und einfach, kann aber die Stärke nicht unterscheiden. Für ein ernsthaftes Projekt solltest du den MPU6050 wählen.
Wo im Haus sollte der Erdbebensensor montiert werden?
Schraube den Sensor nicht an ein Möbelstück, sondern fest an eine tragende Wand oder den Boden. Eine bodennahe Ecke, möglichst im Erdgeschoss und weit weg von Türen, Waschmaschine und viel begangenen Wegen, liefert die wenigsten Fehlalarme. Montiere auch den Buzzer nicht auf derselben Fläche wie den Sensor, sondern getrennt davon.
Kann Arduino die Stärke eines Erdbebens messen?
Nein. Die Magnitude eines Erdbebens beschreibt die an der Quelle freigesetzte Energie und wird aus den Daten vieler Stationen berechnet. Der Arduino misst nur die Beschleunigung an seinem Standort; dieser Wert hängt stark von Entfernung zum Epizentrum, Untergrund und Stockwerk ab. Die gemessene Spitzenbeschleunigung kannst du höchstens grob in eine gefühlte Intensität (Mercalli) umrechnen.
Wie hoch sollte der Schwellenwert für den Erdbebenalarm in g sein?
Miss zuerst das Rauschen deiner Umgebung im Serial Plotter; der MPU6050 schwankt in ruhiger Umgebung meist zwischen 0,002 und 0,008 g. Wähle die Schwelle als das 3- bis 5-Fache dieses Rauschens, typischerweise 0,02–0,04 g; das entspricht der Intensität IV, die Menschen als leicht empfinden. Danach stimmst du sie mit Tür- und Geh-Tests fein ab.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Verwendung des Summers
Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

LED Blinken
Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

LED-Polizeilicht
Wie das Blaulicht am Polizeiauto: Die rote LED blitzt dreimal schnell hintereinander, dann blitzt die blaue dreimal, und das Ganze wiederholt sich ohne Pause.

Laser-Warnsystem
Du baust einen unsichtbaren Lichtschrankenzaun wie im Film. Ein Laser leuchtet auf einen Lichtsensor auf der anderen Seite; sobald jemand hindurchgeht und den Strahl unterbricht, leuchtet die LED und…

Flammen- und Gassensor-Alarm
Ein kleiner Wächter, der dich sofort warnt, wenn Gas austritt oder irgendwo eine Flamme auftaucht.

ESP32 MQ-2 Gas-/Rauchmelder-Alarm
In diesem Projekt wird die Erkennung brennbarer Gase (LPG, Methan, Propan) und Rauch mit einem MQ-2-Gassensormodul durchgeführt; bei Erkennung ertönt über einen passiven Summer ein sirenenähnlicher Alarmton. Der digitale Schwellenausgang (DO) des Sensors wird an GPIO 4 des ESP32 angeschlossen; überschreiten Gas oder Rauch den Schwellenwert, geht DO auf LOW und der Alarm wird ausgelöst. Die Empfindlichkeit wird über das Potentiometer eingestellt. Der passive Summer wird mit tone() angesteuert.

ESP32 Bewegungsalarmsystem (PIR + Buzzer + LED + Telegram)
Eine smarte Alarmanlage: Erkennt der PIR-Sensor eine Bewegung, ertönt der Summer, die LED leuchtet und der Besitzer bekommt sofort eine Telegram-Nachricht. Eine Sperrzeit von 30 Sekunden begrenzt, wie oft der Alarm wiederholt wird; Fehlauslösungen des PIR-Sensors verhindert sie nicht. Geeignet für Haus, Garage, Lager oder Arbeitszimmer.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

