Alarme de terremoto com Arduino: guia de detecção de tremores com MPU6050
Monte um alarme de terremoto com Arduino e MPU6050: calibração, definição do limite, filtragem de batidas de porta, alertas com buzzer e LED, além das versões com SW-420 e ESP32.
Um alarme de terremoto com Arduino é um projeto simples, mas muito didático: um acelerômetro mede continuamente a vibração da superfície onde está e, quando o tremor ultrapassa certa intensidade e duração, aciona um buzzer e um LED. Neste guia você vai aprender passo a passo a calibrar o sensor MPU6050, encontrar o limite certo para o ruído do seu ambiente, filtrar alarmes falsos, como uma porta batendo ou alguém passando perto, e dar um aviso sonoro e visual. No final, você vai montar a mesma lógica com o barato sensor de vibração SW-420, com uma versão em ESP32 que envia notificações para o seu celular e com um Raspberry Pi Pico rodando MicroPython.
Vamos deixar claro desde o início: este dispositivo não é um sismógrafo nem um sistema oficial de alerta antecipado de terremotos. Ele não consegue prever um terremoto; só pode avisar você depois que o tremor começou e, com sorte, alguns segundos antes de chegarem as ondas mais fortes. Mesmo assim, é um ótimo projeto para perceber um tremor leve enquanto você dorme, aprender o conceito de aceleração e entender processamento e filtragem de sinais, e é uma escolha comum em apresentações de feiras de ciências.

Como funciona um alarme de terremoto?
Quando ocorre um terremoto, dois tipos principais de ondas se espalham a partir da origem. As ondas P (primárias, de compressão) chegam primeiro, atravessam a crosta a cerca de 6 km por segundo e geralmente são sentidas com menos força. As ondas S (secundárias, de cisalhamento) que vêm em seguida viajam a cerca de 3,5 km/s e causam a maior parte dos danos. Se você está a 50 km do epicentro, há uma diferença de aproximadamente 6 segundos entre as duas ondas; se está bem ao lado do epicentro, essa diferença é quase zero. Nosso alarme usa um acelerômetro fixado no piso para medir as pequenas variações de aceleração que essas ondas provocam. Com o sensor parado, ele vê apenas a gravidade (1 g ≈ 9,81 m/s²); quando o tremor começa, os valores nos três eixos oscilam em torno dessa posição de repouso. Neste artigo, vamos chamar o tamanho dessa oscilação de aceleração dinâmica. Para uma introdução detalhada ao sensor, veja MPU6050: acelerômetro e giroscópio.
| Característica | Valor do MPU6050 |
|---|---|
| Tipo de sensor | Acelerômetro de 3 eixos + giroscópio de 3 eixos (IMU de 6 eixos) |
| Faixas de aceleração | ±2 / ±4 / ±8 / ±16 g |
| Sensibilidade (±2 g) | 16384 LSB/g (1 passo ≈ 0,061 mg) |
| Resolução do ADC | 16 bits |
| Filtro passa-baixa integrado (DLPF) | Selecionável de cerca de 5 a 260 Hz |
| Comunicação | I2C, até 400 kHz |
| Endereço I2C | 0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V) |
| Alimentação (módulo GY-521) | 3,3–5 V (regulador de 3,3 V na placa) |
| Corrente | Cerca de 4 mA |
Intensidade do tremor e aceleração: o que cada valor significa?
Os sismólogos costumam expressar a força do tremor em um local como aceleração máxima do solo (PGA). A tabela abaixo mostra a relação aproximada entre a aceleração do solo e a intensidade que as pessoas sentem, com base na escala de Mercalli Modificada. Como você pode ver, até um tremor que as pessoas sentem como leve fica na faixa de 0,014–0,039 g; ou seja, estamos lidando com acelerações minúsculas, de 14–39 mg. Como um passo do MPU6050 na faixa de ±2 g é 0,061 mg, a resolução é mais do que suficiente; mas, como o ruído do próprio sensor em repouso é de alguns mg, precisamos colocar o limite acima desse ruído. Os valores da tabela são acelerações do solo; nos andares superiores de um prédio o tremor é amplificado, então use-os apenas como referência aproximada.
| Aceleração máxima do solo (g) | Intensidade Mercalli | Efeito sentido |
|---|---|---|
| < 0,0017 | I | Não é sentido |
| 0,0017 – 0,014 | II–III | Fraco; sentido em ambientes silenciosos e em andares altos |
| 0,014 – 0,039 | IV | Leve; a maioria das pessoas percebe, as janelas chacoalham |
| 0,039 – 0,092 | V | Moderado; quem está dormindo acorda, objetos pequenos caem |
| 0,092 – 0,18 | VI | Forte; todos sentem, o reboco pode rachar |
| 0,18 – 0,34 | VII | Muito forte; danos em estruturas frágeis |
Materiais e ligações
- Placa: Arduino Uno ou Nano; um ESP32 para notificações, um Raspberry Pi Pico para MicroPython.
- Módulo MPU6050 (GY-521): o acelerômetro que mede o tremor.
- Buzzer ativo: buzzers ativos pequenos consomem cerca de 20–30 mA; para um som mais alto, acione o buzzer com um transistor NPN.
- LED vermelho e resistor de 220 Ω: para o aviso visual; você pode conferir o valor do resistor com a calculadora Resistor para LED.
- Botão: para silenciar o alarme (usa o pull-up interno, sem resistor extra).
- Protoboard e jumpers; opcionalmente um sensor de vibração SW-420 para a versão simples.
| Ligação | 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 (endereço 0x68) | GND (endereço 0x68) | GND (endereço 0x68) |
| Buzzer ativo (+) | D8 | GPIO 25 | GP15 |
| LED (com 220 Ω) | D7 | GPIO 26 | GP14 |
| Botão de silenciar (outro terminal no GND) | D2 | GPIO 27 | GP13 |
| SW-420 DO (versão simples) | D3 | - | - |
Calibração e definição do limite
O objetivo da calibração é encontrar os valores do sensor nos três eixos em repouso. Um sensor nunca fica perfeitamente nivelado e todo chip tem um pequeno offset; por exemplo, o eixo Z pode ler 0,97 g em vez de 1,00 g e o eixo X, 0,02 g em vez de 0. Quando o código inicia, ele faz 200 leituras ao longo de cerca de um segundo e guarda a média como valor de referência. Em cada leitura seguinte, essa referência é subtraída de cada eixo e calcula-se o módulo do vetor que sobra: aceleração dinâmica = √(dx² + dy² + dz²). A beleza desse método é que montar o sensor na horizontal, na vertical ou inclinado não muda o resultado; a gravidade fica dentro da referência e sai do cálculo automaticamente. O offset do sensor também deriva muito lentamente conforme a temperatura muda; enquanto o ambiente está calmo, o código atualiza a referência em um milésimo a cada leitura para acompanhar também essa deriva.
- Fixe o sensor firmemente no local definitivo, carregue o código e não toque na montagem até a mensagem de calibração passar.
- Abra o Plotter Serial pelo menu Ferramentas (115200 baud). Em um ambiente calmo, você vai ver a aceleração dinâmica oscilando geralmente entre 0,002 e 0,008 g; esse é o seu nível de ruído.
- Anote o valor mais alto que o ruído atinge ao longo de alguns minutos e escolha um limite de 3–5 vezes esse valor. O padrão de 0,03 g no código corresponde à intensidade leve (IV).
- Bata de leve na mesa, feche a porta, ande pelo cômodo e observe quão alto e quão longo é o pico que cada evento cria no plotter.
- Para imitar um tremor real, mova a tábua onde o sensor está parafusado para frente e para trás 1–3 vezes por segundo, durante alguns segundos; o alarme deve tocar em cerca de 1–2 segundos.
- Se tiver alarmes falsos, aumente THRESHOLD_G; se o tremor for detectado tarde demais, diminua SCORE_ALARM; mude em pequenos passos e repita os testes.
Filtrando alarmes falsos: portas batendo e passos
Quando uma porta bate, o sensor vê um impacto grande, mas muito curto (50–200 ms), de 0,1–0,5 g. Um terremoto, por outro lado, produz acelerações menores, mas oscila por segundos, na faixa de 1–10 Hz. Então a característica que diferencia não é a amplitude, e sim a duração. No código, tratamos isso com um contador de pontos chamado balde furado (leaky bucket): são feitas 100 leituras por segundo, a pontuação sobe 2 a cada leitura acima do limite, cai 1 a cada leitura abaixo dele, e o alarme toca quando a pontuação chega a 100. Uma batida de porta de 150 ms gera no máximo 15 amostras, ou seja, 30 pontos, e se esvai rapidamente. Já um tremor que ultrapassa o limite em cerca de metade das amostras acumula 50 pontos líquidos por segundo e dispara o alarme em cerca de 2 segundos. Além disso, como o sinal passa pelo filtro passa-baixa integrado de 21 Hz do sensor, vibrações de alta frequência, como o zumbido de ventiladores, motores e compressores, são em grande parte atenuadas. Para métodos de filtragem mais avançados, dê uma olhada em filtragem de dados de sensores.
| Fonte de alarme falso | Característica do sinal | Solução |
|---|---|---|
| Porta batendo | Um único impacto grande de 50–200 ms | O contador de pontos filtra impactos curtos; mantenha o sensor longe do batente da porta |
| Caminhar, pular | Rítmico de 1–2 Hz, 0,01–0,05 g se estiver perto do sensor | Monte o sensor em uma parede estrutural, num canto de pouca circulação, e aumente um pouco o limite |
| Máquina de lavar, ar-condicionado | Vibração longa, de frequência constante | Coloque o dispositivo em um cômodo longe dessas máquinas e teste o limite com elas funcionando |
| Passagem de veículo pesado | Vibração de baixa amplitude que dura alguns segundos | Teste de dia e de noite separadamente e coloque o limite acima da vibração da rua |
| Sensor saindo do lugar | Offset permanente, a pontuação não para de subir | Fixe com parafusos; se ele se mexeu, reinicie a placa e calibre de novo |
Código do alarme de terremoto com 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}| Trecho do código | O que faz |
|---|---|
| writeReg(0x6B, 0x00) (acordar o sensor) | O MPU6050 inicia em modo de repouso; este comando acorda o sensor |
| writeReg(0x1C, 0x00) (faixa de aceleração) | Define a faixa de aceleração em ±2 g; nessa faixa, 1 g = 16384 contagens |
| writeReg(0x1A, 0x04) (filtro passa-baixa) | Ajusta o filtro passa-baixa integrado para cerca de 21 Hz |
| calibrate() (calibração) | Encontra os valores de referência em repouso pela média de 200 leituras |
| dyn (aceleração dinâmica) | Módulo do vetor do desvio em relação à referência, ou seja, a aceleração dinâmica (g) |
| score (pontuação) | +2 para cada amostra acima do limite, -1 para cada amostra abaixo; o alarme toca em 100 |
| ALARM_HOLD_MS (duração do alarme) | O alarme dura 30 s após o último tremor; o botão o silencia antes |
| Temporização com millis() | Garante amostragem constante de 100 Hz sem usar delay |
Alarme de terremoto simples com SW-420

O módulo SW-420 é formado por uma chave de vibração simples, com um contato de mola por dentro, e um comparador LM393. Em repouso, o contato fica fechado e a saída DO permanece em LOW; conforme a vibração abre e fecha o contato, o pino DO gera pulsos em HIGH. O potenciômetro do módulo ajusta a sensibilidade. Ele não mede aceleração, só informa se há vibração ou não; por isso não diferencia a intensidade, mas é muito barato e o código é simples. O código abaixo conta os pulsos com uma interrupção; se chegarem 15 ou mais pulsos por segundo durante 2 segundos seguidos, ele inicia um alarme de 20 segundos. Assim, uma única batida de porta também é filtrada aqui. Para detalhes do módulo, veja sensor de vibração 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}Alarme de terremoto com ESP32 e notificações no celular
Enquanto roda a mesma lógica de detecção, o ESP32 também pode enviar uma mensagem do Telegram para o seu celular via Wi-Fi. Para isso, instale a biblioteca UniversalTelegramBot e sua dependência ArduinoJson pelo Gerenciador de Bibliotecas, crie um bot com o BotFather e coloque o token e o seu chat ID no código; todos os passos estão em bot do Telegram com ESP32. Há uma decisão de projeto importante aqui: a conexão Wi-Fi não é pré-requisito para o alarme. A energia ou a internet podem cair durante um terremoto; por isso, o buzzer e o LED sempre funcionam localmente, e a mensagem só é enviada se houver conexão, uma vez por evento. Garantir o dispositivo com uma bateria 18650, um módulo carregador TP4056 e um regulador de tensão adequado permite que ele continue funcionando durante uma falta de energia.
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}Versão em MicroPython com o Raspberry Pi Pico
No Pico não é preciso nenhuma biblioteca extra; a classe I2C nativa do MicroPython e o módulo struct bastam para ler os dados brutos do MPU6050. A lógica é idêntica à do código para Arduino: calibração, aceleração dinâmica, contador de pontos e alarme de 30 segundos. Como os pinos do Pico fornecem 3,3 V, buzzers ativos pequenos de 5 V soam mais baixo; se quiser mais volume, acione o buzzer a partir de 5 V (VBUS) com um transistor NPN. Se você é novo no MicroPython, leia primeiro noções básicas 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 HzIdeias de projeto para melhorar seu alarme de terremoto
- Minissismômetro com tela: desenhe a aceleração dinâmica como um gráfico rolante em um display OLED e mostre o valor de pico do último evento e sua intensidade Mercalli estimada.
- Registrador de eventos: grave o horário e a aceleração de pico de cada tremor em um módulo de cartão SD; adicione data e hora com um RTC.
- Iluminação de emergência: acenda automaticamente a luz do corredor com um módulo relé quando um tremor for detectado.
- Segurança residencial integrada: adicione a detecção de terremotos ao mesmo sistema de alarme dos sensores de gás, fumaça e movimento.
- Várias notificações: envie uma mensagem de WhatsApp com o ESP32 no lugar do Telegram ou além dele.
- Projeto de ciências: coloque sensores em andares diferentes e meça como a vibração aumenta com a altura; para ideias, veja ideias de projetos Arduino para feiras de ciências.
Erros comuns e como corrigir
| Sintoma | Causa provável | Solução |
|---|---|---|
| Os valores ficam sempre em 0 ou nunca mudam | O sensor está em repouso ou a ligação I2C está errada | Confira a escrita em 0x6B, verifique os pinos SDA/SCL e encontre o endereço com um sketch scanner I2C |
| O alarme toca logo depois de ligar | O sensor se mexeu durante a calibração | Não toque no circuito durante a calibração e reinicie a placa |
| O alarme nunca para | A vibração do buzzer está chegando ao sensor ou o sensor saiu do lugar | Monte o buzzer em uma superfície separada do sensor, fixe o sensor e calibre de novo |
| Nenhuma reação a um tremor leve | THRESHOLD_G ou SCORE_ALARM está alto demais | Meça o ruído no Plotter Serial e diminua o limite passo a passo |
| Nenhuma mensagem do ESP32 | Token ou chat ID errado, Wi-Fi não conectado | Confira os dados e imprima WiFi.status() no Monitor Serial |
| Travamentos aleatórios | Fios I2C longos e soltos | Mantenha os fios com menos de 30 cm e confira os contatos da protoboard |
| Buzzer muito baixo | Pino de 3,3 V ou corrente insuficiente | Acione o buzzer a partir de 5 V com um transistor NPN |
Agora você tem um alarme de terremoto que mede a aceleração, se calibra sozinho, filtra impactos curtos e dá um aviso sonoro e visual em um tremor real; e você consegue montar a mesma lógica no Arduino, no ESP32 e no Pico. Para reforçar a lógica de buzzer, LED e alarme, confira no app BlueGrays os projetos de uso do buzzer, luzes de polícia com LEDs, sistema de alarme a laser e alarme de movimento com ESP32, com esquemas do circuito passo a passo e códigos prontos.
Perguntas frequentes
Dá para fazer um alarme de terremoto com Arduino? Ele funciona de verdade?
Sim, com um acelerômetro como o MPU6050 você pode montar um alarme que detecta tremores de intensidade perceptível e avisa com buzzer e LED. Ele ajuda a perceber um tremor leve enquanto você dorme e é um projeto didático. Porém, não é um sismógrafo nem um sistema oficial de alerta antecipado, então você não deve basear decisões de segurança nele.
O alarme de terremoto avisa antes do terremoto?
Não, nenhum dispositivo consegue prever um terremoto com antecedência. Um sensor local só toca depois que o tremor começou. Se você está longe do epicentro, ele pode captar as ondas P fracas e avisar alguns segundos antes das ondas S fortes; se você está perto do epicentro, esse tempo é quase zero.
Qual é melhor para um alarme de terremoto, o MPU6050 ou o SW-420?
Como o MPU6050 mede a aceleração numericamente, você pode ajustar o limite com precisão e avaliar a intensidade e a duração do tremor, o que facilita muito filtrar alarmes falsos. O SW-420 só informa se há vibração ou não; é barato e simples, mas não diferencia a intensidade. Para um projeto sério, escolha o MPU6050.
Em que lugar da casa o sensor de terremoto deve ser instalado?
Parafuse o sensor firmemente em uma parede estrutural ou no piso, não em móveis. Um canto longe de portas, da máquina de lavar e das rotas de maior circulação, de preferência em um andar baixo e perto do chão, gera menos alarmes falsos. Monte também o buzzer em um ponto separado, não na mesma superfície do sensor.
O Arduino consegue medir a magnitude de um terremoto?
Não. A magnitude de um terremoto expressa a energia liberada na origem e é calculada com dados de muitas estações. O Arduino só mede a aceleração no próprio local; esse valor varia muito conforme a distância até o epicentro, o tipo de solo e o andar. Você só consegue converter, de forma aproximada, a aceleração de pico medida em intensidade sentida (Mercalli).
Qual deve ser o valor do limite, em g, para um alarme de terremoto?
Primeiro meça o ruído do seu ambiente no Plotter Serial; o MPU6050 costuma oscilar entre 0,002 e 0,008 g em um ambiente calmo. Você pode escolher um limite de 3–5 vezes esse ruído, normalmente 0,02–0,04 g; essa faixa corresponde à intensidade IV, que as pessoas sentem como leve. Depois, faça o ajuste fino com testes de porta e de passos.
Projetos para montar depois desta leitura
Ver todos os projetos
Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

LED piscante
O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

Luzes de polícia com LEDs
Como as luzes de uma viatura: o LED vermelho pisca três vezes rapidamente, depois o LED azul pisca três vezes, e a sequência se repete sem parar. Basta ligar dois LEDs e dois resistores ao Arduino.

Sistema de alerta com laser
Você monta uma barreira de luz invisível, como nos filmes. Um laser ilumina um sensor de luz do outro lado; assim que alguém passa e interrompe o feixe, o LED acende e o buzzer soa.

Alarme com sensores de chama e gás
Um pequeno guardião que avisa você imediatamente quando há um vazamento de gás ou surge uma chama.

Alarme detector de gás e fumaça com ESP32 e MQ-2
Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

