Guías · 11 min de lectura

Alarma de terremoto con Arduino y MPU6050: guía completa

Cómo hacer una alarma de terremoto con Arduino: calibra el MPU6050, fija el umbral, filtra falsas alarmas como portazos, añade buzzer y LED, SW-420 y ESP32.

Una alarma de terremoto con Arduino es un proyecto sencillo pero muy didáctico: un acelerómetro mide sin parar la vibración de la superficie donde está fijado y, cuando la sacudida supera cierta intensidad y duración, activa un buzzer y un LED. En esta guía aprenderás paso a paso a calibrar el sensor MPU6050, a encontrar el umbral correcto según el ruido de tu entorno, a descartar por software falsas alarmas como un portazo o los pasos de alguien que pasa, y a dar un aviso sonoro y luminoso. Al final montarás la misma lógica con el económico sensor de vibración SW-420, con una versión ESP32 que te envía una notificación al móvil y con una Raspberry Pi Pico con MicroPython.

Dejémoslo claro desde el principio: este dispositivo no es un sismógrafo ni un sistema oficial de alerta temprana de terremotos. No puede predecir un sismo; solo puede avisarte cuando la sacudida ya ha empezado y, con suerte, unos segundos antes de que lleguen las ondas más fuertes. Aun así, es un proyecto genial para notar un temblor leve mientras duermes, para aprender qué es la aceleración y para entender el procesamiento y el filtrado de señales; además, se elige a menudo para ferias de ciencia y presentaciones escolares.

Módulo acelerómetro y giroscopio MPU6050 GY-521
Módulo MPU6050 (GY-521): acelerómetro de 3 ejes y giroscopio de 3 ejes, conexión I2C, dirección 0x68.

¿Cómo funciona una alarma de terremoto?

Cuando ocurre un terremoto, desde el foco se propagan dos tipos principales de ondas. Primero llegan las ondas P (primarias, de compresión), que viajan por la corteza a unos 6 km/s y suelen sentirse más débiles. Después llegan las ondas S (secundarias, de cizalla), a unos 3,5 km/s, que causan la mayor parte de los daños. Si estás a 50 km del epicentro, la diferencia entre ambas es de unos 6 segundos; si estás justo encima, es casi cero. Nuestra alarma usa un acelerómetro fijado al suelo para medir los pequeños cambios de aceleración que provocan estas ondas. En reposo, el sensor solo ve la gravedad (1 g ≈ 9,81 m/s²); cuando empieza la sacudida, los valores de los tres ejes oscilan alrededor de esa posición de reposo. En este artículo llamaremos aceleración dinámica a la magnitud de esa oscilación. Para conocer el sensor en detalle, consulta el artículo acelerómetro y giroscopio MPU6050.

CaracterísticaValor del MPU6050
Tipo de sensorAcelerómetro de 3 ejes + giroscopio de 3 ejes (IMU de 6 ejes)
Rangos de aceleración±2 / ±4 / ±8 / ±16 g
Sensibilidad (±2 g)16384 LSB/g (1 paso ≈ 0,061 mg)
Resolución del ADC16 bits
Filtro paso bajo interno (DLPF)Seleccionable entre unos 5 y 260 Hz
ComunicaciónI2C, hasta 400 kHz
Dirección I2C0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V)
Alimentación (módulo GY-521)3,3–5 V (regulador de 3,3 V en la placa)
CorrienteUnos 4 mA

Intensidad de la sacudida y aceleración: ¿qué valor equivale a qué?

Los sismólogos suelen expresar la intensidad de la sacudida en un punto mediante la aceleración máxima del suelo (PGA). La tabla siguiente muestra la relación aproximada entre la aceleración del suelo y lo que sienten las personas según la escala de Mercalli modificada. Como ves, incluso una sacudida que la gente nota como leve está entre 0,014 y 0,039 g; es decir, trabajamos con aceleraciones muy pequeñas, de 14 a 39 mg. Como un paso del MPU6050 en el rango de ±2 g es de 0,061 mg, la resolución es más que suficiente; pero como el propio ruido del sensor en reposo ronda unos pocos mg, tenemos que poner el umbral por encima de ese ruido. Los valores de la tabla son aceleraciones medidas en el suelo; en los pisos altos de un edificio la oscilación se amplifica, así que úsalos solo como referencia.

Aceleración máxima del suelo (g)Intensidad MercalliEfecto percibido
< 0,0017INo se siente
0,0017 – 0,014II–IIIDébil; se nota en reposo y en pisos altos
0,014 – 0,039IVLeve; la mayoría lo nota, tiemblan los cristales
0,039 – 0,092VModerado; despierta a quien duerme, se caen objetos pequeños
0,092 – 0,18VIFuerte; todos lo sienten, puede agrietarse el yeso
0,18 – 0,34VIIMuy fuerte; daños en construcciones débiles
Este proyecto no es un sistema oficial de alerta temprana de terremotos y no lo sustituye. Un sensor casero puede dar falsas alarmas o no detectar una sacudida real. No bases tus decisiones de evacuación y seguridad en este dispositivo; para avisos e información oficiales sigue los comunicados de las autoridades competentes de tu país y ten siempre lista tu mochila de emergencia.

Materiales necesarios y conexión

  • Placa: Arduino Uno o Nano; ESP32 para la notificación y Raspberry Pi Pico para MicroPython.
  • Módulo MPU6050 (GY-521): el acelerómetro que mide la sacudida.
  • Buzzer activo: los buzzers activos pequeños consumen unos 20–30 mA; para más volumen, maneja el buzzer con un transistor NPN.
  • LED rojo y resistencia de 220 Ω: para el aviso visual; puedes comprobar el valor de la resistencia con la calculadora de resistencia para LED.
  • Pulsador: para silenciar la alarma (usa el pull-up interno, no hace falta resistencia extra).
  • Protoboard y cables dupont; opcionalmente, el sensor de vibración SW-420 para la versión simple.
ConexiónArduino UnoESP32Raspberry Pi Pico
MPU6050 VCC5V3V33V3(OUT)
MPU6050 GNDGNDGNDGND
MPU6050 SCLA5GPIO 22GP5
MPU6050 SDAA4GPIO 21GP4
MPU6050 AD0GND (dirección 0x68)GND (dirección 0x68)GND (dirección 0x68)
Buzzer activo (+)D8GPIO 25GP15
LED (con 220 Ω)D7GPIO 26GP14
Pulsador de silencio (otro extremo a GND)D2GPIO 27GP13
SW-420 DO (versión simple)D3--
El error más habitual es conectar SDA y SCL a pines digitales en el Uno; en el Uno el bus I2C está en los pines A4 (SDA) y A5 (SCL). El chip del GY-521 funciona a 3,3 V; gracias al regulador de la placa puedes conectar VCC a 5V en el Uno, pero en el ESP32 y la Pico usa siempre 3V3. Si conectas AD0 a 3,3 V, la dirección pasa a ser 0x69 y tendrás que cambiar también MPU_ADDR en el código. El GND de todos los componentes debe ser común.

Calibración y elección del umbral

El objetivo de la calibración es hallar los valores de reposo de los tres ejes del sensor. Un sensor nunca está perfectamente horizontal y cada chip tiene un pequeño desfase; por ejemplo, el eje Z puede leer 0,97 g en lugar de 1,00 g y el eje X 0,02 g en lugar de 0. Al arrancar, el código toma 200 mediciones durante aproximadamente un segundo y guarda su media como valor base. En cada medición posterior se resta esa base a cada eje y se calcula la magnitud del vector resultante: aceleración dinámica = √(dx² + dy² + dz²). La ventaja de este método es que montar el sensor en horizontal, en vertical o inclinado no cambia el resultado; como la gravedad queda dentro de la base, se elimina sola del cálculo. Además, el desfase del sensor deriva muy despacio con la temperatura; el código sigue esa deriva actualizando la base en una milésima en cada medición mientras el entorno está tranquilo.

  1. Fija el sensor firmemente en su lugar definitivo, sube el código y no toques el montaje hasta que aparezca el mensaje de calibración.
  2. Abre el Serial Plotter desde el menú Herramientas (115200 baudios). En un entorno tranquilo verás que la aceleración dinámica suele oscilar entre 0,002 y 0,008 g; ese es tu nivel de ruido.
  3. Anota durante unos minutos el valor máximo que alcanza el ruido y elige un umbral de 3 a 5 veces ese valor. El 0,03 g por defecto del código corresponde a la intensidad leve (IV).
  4. Golpea suavemente la mesa, cierra la puerta, camina por la habitación y observa en el plotter qué altura y qué duración tiene el pico de cada evento.
  5. Para simular una sacudida real, mueve adelante y atrás la tabla donde está atornillado el sensor 1–3 veces por segundo durante unos segundos; la alarma debería sonar en 1–2 segundos aproximadamente.
  6. Si recibes falsas alarmas, ajusta THRESHOLD_G; si detecta la sacudida demasiado tarde, ajusta SCORE_ALARM, siempre en pasos pequeños, y repite las pruebas.

Descartar falsas alarmas: portazos y pasos

Cuando se cierra una puerta de golpe, el sensor ve un impacto grande, de 0,1–0,5 g, pero muy corto (50–200 ms). Un terremoto, en cambio, produce oscilaciones menores pero que duran segundos, en el rango de 1–10 Hz. Es decir, lo que distingue ambos casos no es la amplitud, sino la duración. En el código lo hacemos con un contador de puntos llamado cubo con fugas (leaky bucket): se toman 100 mediciones por segundo, cada medición por encima del umbral suma 2 puntos, cada una por debajo resta 1, y cuando la puntuación llega a 100 suena la alarma. Un portazo de 150 ms produce como máximo 15 muestras, es decir, 30 puntos, y se disipa enseguida. Una sacudida que supere el umbral en aproximadamente la mitad de las muestras acumula 50 puntos netos por segundo y dispara la alarma en unos 2 segundos. Además, como la señal pasa por el filtro paso bajo de 21 Hz del propio sensor, las vibraciones de alta frecuencia, como el zumbido de ventiladores, motores y compresores, se atenúan en gran medida. Para métodos de filtrado más avanzados, echa un vistazo al artículo filtrado de datos de sensores.

Fuente de falsa alarmaCaracterística de la señalSolución
PortazoUn solo impacto grande de 50–200 msEl contador de puntos descarta los impactos cortos; mantén el sensor alejado del marco de la puerta
Pasos, saltosRitmo de 1–2 Hz, 0,01–0,05 g si está cerca del sensorMonta el sensor en un muro de carga, en una esquina con poco tránsito, y sube un poco el umbral
Lavadora, aire acondicionadoVibración prolongada de frecuencia constanteColoca el dispositivo en una habitación alejada de esas máquinas y prueba el umbral con ellas funcionando
Paso de vehículos pesadosVibración de baja amplitud que dura unos segundosPrueba de noche y de día por separado y pon el umbral por encima de la vibración de la calle
El sensor se mueve de sitioDesfase permanente, la puntuación sube sin pararFíjalo con tornillos; si se ha movido, reinicia la placa y vuelve a calibrar

Código de la alarma de terremoto con Arduino (MPU6050 + buzzer + LED)

C++ (Arduino IDE)
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}
Fragmento de códigoFunción
writeReg(0x6B, 0x00)El MPU6050 arranca en modo suspensión; este comando despierta el sensor
writeReg(0x1C, 0x00)Fija el rango de aceleración en ±2 g; en este rango 1 g = 16384 cuentas
writeReg(0x1A, 0x04)Ajusta el filtro paso bajo interno a unos 21 Hz
calibrate()Halla los valores base de reposo con la media de 200 mediciones
dynMagnitud vectorial de la desviación respecto a la base, es decir, la aceleración dinámica (g)
score+2 por cada muestra sobre el umbral, -1 por cada una por debajo; la alarma salta al llegar a 100
ALARM_HOLD_MSLa alarma dura 30 s más tras la última sacudida; el pulsador la silencia antes
Temporización con millis()Consigue un muestreo fijo de 100 Hz sin usar delay
Al ajustar, deja DEBUG_PLOT = true y observa la aceleración dinámica en vivo en el Serial Plotter; elegir el umbral mirando esa gráfica es mucho más fiable que hacerlo a ojo. Cuando termines la instalación, ponlo en false para ver solo los mensajes de alarma. Explicamos por qué es importante usar millis en lugar de delay en el artículo Arduino millis y delay.

Alarma de terremoto sencilla con SW-420

Módulo sensor de vibración SW-420
Sensor de vibración SW-420: interruptor de vibración con muelle, comparador LM393 y potenciómetro de sensibilidad.

El módulo SW-420 consta de un interruptor de vibración sencillo con un contacto de muelle en su interior y un comparador LM393. En reposo el contacto está cerrado y la salida DO se mantiene en LOW; a medida que la vibración abre y cierra el contacto, el pin DO genera pulsos HIGH. El potenciómetro del módulo ajusta la sensibilidad. No mide aceleración, solo informa de si hay vibración o no; por eso no distingue la intensidad, pero es muy barato y el código es sencillo. El código siguiente cuenta los pulsos con una interrupción (interrupt); si durante 2 segundos seguidos llegan 15 o más pulsos por segundo, inicia una alarma de 20 segundos. Así, un solo portazo también se descarta aquí. Para más detalles del módulo, consulta el artículo sensor de vibración SW-420.

C++ (Arduino IDE)
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}

Alarma de terremoto con ESP32 que envía notificaciones al móvil

El ESP32 puede ejecutar la misma lógica de detección y, además, enviar un mensaje de Telegram a tu móvil por Wi-Fi. Para ello, instala desde el Gestor de bibliotecas UniversalTelegramBot y su dependencia ArduinoJson, crea un bot con BotFather y escribe en el código el token y tu propio chat ID; todos los pasos están en el artículo bot de Telegram con ESP32. Aquí hay una decisión de diseño importante: la conexión Wi-Fi no es requisito previo de la alarma. Durante un terremoto puede cortarse la luz o internet; por eso el buzzer y el LED funcionan siempre de forma local, y el mensaje solo se envía si hay conexión y una sola vez por evento. Respaldar el dispositivo con una pila 18650, un módulo de carga TP4056 y un regulador de tensión adecuado hace que siga funcionando cuando se corta la electricidad.

C++ (Arduino IDE)
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}

Versión MicroPython con Raspberry Pi Pico

En la Pico no hace falta ninguna biblioteca adicional; la clase I2C integrada de MicroPython y el módulo struct bastan para leer los datos brutos del MPU6050. La lógica es idéntica a la del código de Arduino: calibración, aceleración dinámica, contador de puntos y alarma de 30 segundos. Como los pines de la Pico dan 3,3 V, los buzzers activos pequeños de 5 V suenan más flojo; si quieres más volumen, maneja el buzzer con un transistor NPN desde 5 V (VBUS). Si eres nuevo en MicroPython, echa antes un vistazo al artículo fundamentos de MicroPython.

MicroPython
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 Hz

Ideas de proyecto para mejorar la alarma de terremoto

  • Minisismómetro con pantalla: dibuja la aceleración dinámica como gráfica deslizante en una pantalla OLED y muestra el valor máximo del último evento y la intensidad Mercalli estimada.
  • Registrador de eventos: escribe la hora y la aceleración máxima de cada sacudida en un módulo de tarjeta SD; añade fecha y hora con un RTC.
  • Iluminación de emergencia: enciende automáticamente la luz del pasillo con un módulo de relé cuando haya una sacudida.
  • Seguridad doméstica integrada: añade la detección de terremotos al mismo sistema de alarma con sensores de gas, humo y movimiento.
  • Notificación múltiple: en lugar de Telegram, o además de él, envía un mensaje de WhatsApp con ESP32.
  • Proyecto científico: mide cómo crece la vibración según la planta con sensores colocados en distintos pisos; para ideas, mira el artículo ideas de proyectos Arduino para ferias de ciencia.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
Los valores son siempre 0 o no cambianEl sensor está dormido o la conexión I2C es incorrectaRevisa la escritura en 0x6B, verifica los pines SDA/SCL y busca la dirección con un escáner I2C
La alarma suena nada más arrancarEl sensor se movió durante la calibraciónNo toques el montaje durante la calibración y reinicia la placa
La alarma no se apaga nuncaLa vibración del buzzer pasa al sensor o el sensor se ha movidoMonta el buzzer en una superficie distinta a la del sensor, fija el sensor y vuelve a calibrar
No reacciona a una sacudida leveTHRESHOLD_G o SCORE_ALARM demasiado altosMide el ruido en el Serial Plotter y baja el umbral poco a poco
No llegan mensajes desde el ESP32Token o chat ID incorrectos, o sin conexión Wi-FiRevisa los datos e imprime el valor de WiFi.status() en el Monitor Serie
Bloqueos aleatoriosCables I2C largos y flojosMantén los cables por debajo de 30 cm y revisa los contactos de la protoboard
El buzzer suena muy flojoPin de 3,3 V o corriente insuficienteManeja el buzzer con un transistor NPN desde 5 V
Atornilla el sensor directamente a un muro de carga o al suelo, no a un mueble ni a una estantería; la cinta de espuma de doble cara amortigua la vibración y reduce la sensibilidad. Un sensor montado cerca del suelo, en una esquina con poco tránsito, es el menos afectado por los pasos y las puertas. Los cables sueltos en la protoboard también generan ruido por sí solos; en una instalación permanente, pasa el circuito a una placa soldada.

Ya tienes una alarma de terremoto que mide la aceleración, se calibra sola, descarta los impactos cortos y da un aviso sonoro y luminoso ante una sacudida real; además, puedes montar la misma lógica en Arduino, ESP32 y Pico. Si quieres afianzar el uso del buzzer, el LED y la lógica de alarma, echa un vistazo en la app de BlueGrays a los proyectos de uso del buzzer, luz de policía, sistema de alerta con láser y alarma de movimiento con ESP32, con esquemas de circuito paso a paso y códigos listos.

Preguntas frecuentes

¿Se puede hacer una alarma de terremoto con Arduino y funciona de verdad?

Sí, con un acelerómetro como el MPU6050 se puede hacer una alarma que detecta sacudidas de intensidad perceptible y avisa con buzzer y LED. Te permite notar un temblor leve mientras duermes y es un proyecto muy didáctico. Pero no es un sismógrafo ni un sistema oficial de alerta temprana; no debes basar decisiones de seguridad en él.

¿La alarma de terremoto avisa antes de que ocurra el sismo?

No, ningún dispositivo puede predecir un terremoto. Un sensor local solo suena cuando la sacudida ya ha empezado. Si estás lejos del epicentro, puede captar las ondas P, más débiles, y avisarte unos segundos antes de las ondas S, más fuertes; si estás cerca del epicentro, ese margen es casi nulo.

¿Qué es mejor para una alarma de terremoto, el MPU6050 o el SW-420?

El MPU6050 mide la aceleración de forma digital, así que puedes ajustar el umbral con precisión y evaluar la intensidad y la duración de la sacudida; por eso es mucho más fácil descartar falsas alarmas. El SW-420 solo indica si hay vibración o no; es barato y sencillo, pero no distingue la intensidad. Para un proyecto serio, elige el MPU6050.

¿Dónde se debe colocar el sensor de terremotos en casa?

Atornilla el sensor firmemente a un muro de carga o al suelo, no a un mueble. Lo mejor para evitar falsas alarmas es una esquina cerca del suelo, lejos de puertas, de la lavadora y de zonas de mucho paso, si es posible en una planta baja. Monta también el buzzer en un lugar aparte, no en la misma superficie que el sensor.

¿Puede Arduino medir la magnitud de un terremoto?

No. La magnitud de un terremoto expresa la energía liberada en el foco y se calcula con datos de muchas estaciones. Arduino solo mide la aceleración en el punto donde está; ese valor varía mucho según la distancia al epicentro, el tipo de suelo y la planta. La aceleración máxima que midas solo puedes convertirla de forma aproximada en intensidad percibida (Mercalli).

¿Cuántos g debe tener el umbral de una alarma de terremoto?

Primero mide el ruido de tu entorno en el Serial Plotter; en un ambiente tranquilo, el MPU6050 suele oscilar entre 0,002 y 0,008 g. Puedes elegir un umbral de 3 a 5 veces ese ruido, normalmente entre 0,02 y 0,04 g, un rango que corresponde a la intensidad IV, que la gente percibe como leve. Después, afina con pruebas de puertas y pasos.

Ver todos los proyectos
Uso del zumbador
AR-13Principiante

Uso del zumbador

¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

4.7(92)
170
Parpadeo de LED
AR-1Principiante

Parpadeo de LED

El primer hola de la electrónica: encender y apagar un solo LED. El Arduino enciende y apaga el LED a intervalos cortos, así que la luz parpadea rápido.

4.6(200)
1246
Luces de policía LED
AR-4Principiante

Luces de policía LED

Como las luces de un coche de policía: el LED rojo destella tres veces muy rápido, después el azul destella otras tres, y la secuencia se repite sin parar.

4.7(105)
282
Sistema de alerta láser
AR-22Intermedio
Premium

Sistema de alerta láser

Montas una valla de rayos invisible, como en las películas. Un láser apunta a un sensor de luz al otro lado; en cuanto alguien pasa y corta el rayo, se enciende el LED y suena el zumbador, y cuando…

4.8(64)
83
Alarma con sensor de llama y gas
AR-52Avanzado
Premium

Alarma con sensor de llama y gas

Un pequeño vigilante que te avisa enseguida si hay una fuga de gas o aparece una llama en algún sitio.

4.8(52)
67
Alarma de detector de gas/humo ESP32 MQ-2
ES-20Intermedio

Alarma de detector de gas/humo ESP32 MQ-2

En este proyecto, la detección de gases combustibles (GLP, metano, propano) y humo se realiza mediante un módulo sensor de gas MQ-2; al detectarlos, se emite un sonido de alarma similar a una sirena a través de un zumbador pasivo. La salida digital de umbral (DO) del sensor se conecta al GPIO 4 del ESP32; cuando el gas o el humo superan el umbral, DO pasa a LOW y se activa la alarma. La sensibilidad se ajusta con el potenciómetro del módulo. El zumbador se controla con tone().

4.7(29)
44
Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avanzado
Premium

Sistema de Alarma de Movimiento ESP32 (PIR + Buzzer + LED + Telegram)

Una alarma de seguridad inteligente: cuando el sensor PIR detecta movimiento, suena el zumbador, se enciende el LED y el dueño recibe al instante una notificación por Telegram. Una espera de 30 segundos (cooldown) limita cada cuánto se repite la alarma; no elimina las falsas detecciones del sensor PIR. Sirve para casa, garaje, almacén o estudio.

9