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.

¿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ística | Valor del MPU6050 |
|---|---|
| Tipo de sensor | Aceleró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 ADC | 16 bits |
| Filtro paso bajo interno (DLPF) | Seleccionable entre unos 5 y 260 Hz |
| Comunicación | I2C, hasta 400 kHz |
| Dirección I2C | 0x68 (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) |
| Corriente | Unos 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 Mercalli | Efecto percibido |
|---|---|---|
| < 0,0017 | I | No se siente |
| 0,0017 – 0,014 | II–III | Débil; se nota en reposo y en pisos altos |
| 0,014 – 0,039 | IV | Leve; la mayoría lo nota, tiemblan los cristales |
| 0,039 – 0,092 | V | Moderado; despierta a quien duerme, se caen objetos pequeños |
| 0,092 – 0,18 | VI | Fuerte; todos lo sienten, puede agrietarse el yeso |
| 0,18 – 0,34 | VII | Muy fuerte; daños en construcciones débiles |
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ón | 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 (dirección 0x68) | GND (dirección 0x68) | GND (dirección 0x68) |
| Buzzer activo (+) | D8 | GPIO 25 | GP15 |
| LED (con 220 Ω) | D7 | GPIO 26 | GP14 |
| Pulsador de silencio (otro extremo a GND) | D2 | GPIO 27 | GP13 |
| SW-420 DO (versión simple) | D3 | - | - |
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.
- 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.
- 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.
- 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).
- 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.
- 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.
- 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 alarma | Característica de la señal | Solución |
|---|---|---|
| Portazo | Un solo impacto grande de 50–200 ms | El contador de puntos descarta los impactos cortos; mantén el sensor alejado del marco de la puerta |
| Pasos, saltos | Ritmo de 1–2 Hz, 0,01–0,05 g si está cerca del sensor | Monta el sensor en un muro de carga, en una esquina con poco tránsito, y sube un poco el umbral |
| Lavadora, aire acondicionado | Vibración prolongada de frecuencia constante | Coloca el dispositivo en una habitación alejada de esas máquinas y prueba el umbral con ellas funcionando |
| Paso de vehículos pesados | Vibración de baja amplitud que dura unos segundos | Prueba 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 sitio | Desfase permanente, la puntuación sube sin parar | Fí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)
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ódigo | Funció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 |
| dyn | Magnitud 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_MS | La 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 |
Alarma de terremoto sencilla con SW-420

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.
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.
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.
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 HzIdeas 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íntoma | Causa probable | Solución |
|---|---|---|
| Los valores son siempre 0 o no cambian | El sensor está dormido o la conexión I2C es incorrecta | Revisa 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 arrancar | El sensor se movió durante la calibración | No toques el montaje durante la calibración y reinicia la placa |
| La alarma no se apaga nunca | La vibración del buzzer pasa al sensor o el sensor se ha movido | Monta el buzzer en una superficie distinta a la del sensor, fija el sensor y vuelve a calibrar |
| No reacciona a una sacudida leve | THRESHOLD_G o SCORE_ALARM demasiado altos | Mide el ruido en el Serial Plotter y baja el umbral poco a poco |
| No llegan mensajes desde el ESP32 | Token o chat ID incorrectos, o sin conexión Wi-Fi | Revisa los datos e imprime el valor de WiFi.status() en el Monitor Serie |
| Bloqueos aleatorios | Cables I2C largos y flojos | Mantén los cables por debajo de 30 cm y revisa los contactos de la protoboard |
| El buzzer suena muy flojo | Pin de 3,3 V o corriente insuficiente | Maneja el buzzer con un transistor NPN desde 5 V |
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.
Proyectos para hacer después de leer esto
Ver todos los proyectos
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.

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.

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.

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…

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.

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().

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.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

