Allarme terremoto Arduino: guida al sensore MPU6050
Costruisci un allarme terremoto con Arduino: calibrazione dell'MPU6050, soglia, filtro dei falsi allarmi (porta che sbatte), buzzer e LED, SW-420 ed ESP32.
Un allarme terremoto con Arduino è un progetto semplice ma molto istruttivo: un accelerometro misura di continuo le vibrazioni della superficie su cui è fissato e, quando la scossa supera una certa intensità e una certa durata, attiva buzzer e LED. In questa guida imparerai passo passo a calibrare il sensore MPU6050, a trovare la soglia giusta in base al rumore dell'ambiente, a eliminare via software i falsi allarmi (una porta che sbatte, i passi di chi cammina vicino) e a dare un avviso acustico e luminoso. Alla fine userai la stessa logica con l'economico sensore di vibrazione SW-420, con una versione ESP32 che ti manda una notifica sul telefono e con un Raspberry Pi Pico in MicroPython.
Chiariamolo subito: questo dispositivo non è un sismografo né un sistema ufficiale di allerta sismica precoce. Non può prevedere un terremoto; può solo avvisarti quando la scossa è già iniziata e, con un po' di fortuna, qualche secondo prima che arrivino le onde più forti. È comunque un progetto ottimo per accorgerti di una lieve scossa mentre dormi, per capire il concetto di accelerazione e per imparare l'elaborazione e il filtraggio dei segnali; è anche una scelta frequente per fiere scientifiche e presentazioni scolastiche.

Come funziona un allarme sismico?
Quando avviene un terremoto, dalla sorgente si propagano due tipi principali di onde. Per prime arrivano le onde P (primarie, di compressione), che viaggiano nella crosta a circa 6 km/s e di solito si avvertono meno. Poi arrivano le onde S (secondarie, di taglio), con velocità di circa 3,5 km/s, che causano la maggior parte dei danni. A 50 km dall'epicentro tra le due onde ci sono circa 6 secondi di differenza; subito vicino all'epicentro la differenza è quasi nulla. Il nostro allarme usa un accelerometro fissato al suolo per misurare le piccole variazioni di accelerazione create da queste onde. Da fermo il sensore vede solo la gravità (1 g ≈ 9,81 m/s²); quando inizia la scossa, i valori sui tre assi oscillano attorno a questa posizione di riposo. In questo articolo chiameremo l'ampiezza di tale oscillazione accelerazione dinamica. Per una presentazione dettagliata del sensore, leggi l'articolo accelerometro e giroscopio MPU6050.
| Caratteristica | Valore dell'MPU6050 |
|---|---|
| Tipo di sensore | Accelerometro a 3 assi + giroscopio a 3 assi (IMU a 6 assi) |
| Fondo scala accelerazione | ±2 / ±4 / ±8 / ±16 g |
| Sensibilità (±2 g) | 16384 LSB/g (1 passo ≈ 0,061 mg) |
| Risoluzione ADC | 16 bit |
| Filtro passa-basso interno (DLPF) | Selezionabile da circa 5 a 260 Hz |
| Comunicazione | I2C, fino a 400 kHz |
| Indirizzo I2C | 0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V) |
| Alimentazione (modulo GY-521) | 3,3–5 V (regolatore da 3,3 V sulla scheda) |
| Corrente | Circa 4 mA |
Intensità della scossa e accelerazione: quale valore corrisponde a cosa?
I sismologi esprimono spesso l'intensità di una scossa in un punto con l'accelerazione di picco al suolo (PGA). La tabella seguente mostra il rapporto approssimativo tra accelerazione del suolo e intensità percepita dalle persone secondo la scala Mercalli modificata. Come vedi, anche una scossa percepita come lieve rientra nell'intervallo 0,014–0,039 g, cioè accelerazioni minuscole di 14–39 mg. Nel fondo scala ±2 g dell'MPU6050 un passo vale 0,061 mg, quindi la risoluzione è più che sufficiente; ma il rumore del sensore a riposo è di qualche mg, per cui dobbiamo mettere la soglia sopra questo rumore. I valori in tabella sono accelerazioni misurate al suolo; ai piani alti di un edificio l'oscillazione aumenta, quindi usali solo come indicazione.
| Accelerazione di picco al suolo (g) | Intensità Mercalli | Effetto percepito |
|---|---|---|
| < 0,0017 | I | Non avvertita |
| 0,0017 – 0,014 | II–III | Debole; avvertita in ambienti tranquilli e ai piani alti |
| 0,014 – 0,039 | IV | Lieve; la maggior parte delle persone se ne accorge, i vetri tintinnano |
| 0,039 – 0,092 | V | Moderata; chi dorme si sveglia, piccoli oggetti cadono |
| 0,092 – 0,18 | VI | Forte; la sentono tutti, l'intonaco può creparsi |
| 0,18 – 0,34 | VII | Molto forte; danni alle strutture deboli |
Materiali necessari e collegamenti
- Scheda: Arduino Uno o Nano; ESP32 per le notifiche, Raspberry Pi Pico per MicroPython.
- Modulo MPU6050 (GY-521): l'accelerometro che misura la scossa.
- Buzzer attivo: i piccoli buzzer attivi assorbono circa 20–30 mA; per un volume più alto pilota il buzzer con un transistor NPN.
- LED rosso e resistenza da 220 Ω: per l'avviso visivo; puoi verificare il valore della resistenza con il calcolatore di resistenza per LED.
- Pulsante: per silenziare l'allarme (si usa il pull-up interno, non serve nessuna resistenza aggiuntiva).
- Breadboard e cavi jumper; per la versione semplice, il sensore di vibrazione SW-420 (facoltativo).
| Collegamento | 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 (indirizzo 0x68) | GND (indirizzo 0x68) | GND (indirizzo 0x68) |
| Buzzer attivo (+) | D8 | GPIO 25 | GP15 |
| LED (con 220 Ω) | D7 | GPIO 26 | GP14 |
| Pulsante di silenziamento (altro capo a GND) | D2 | GPIO 27 | GP13 |
| SW-420 DO (versione semplice) | D3 | - | - |
Calibrazione e scelta della soglia
Lo scopo della calibrazione è trovare i valori dei tre assi a sensore fermo. Il sensore non è mai perfettamente orizzontale e ogni chip ha un piccolo offset; per esempio l'asse Z può leggere 0,97 g invece di 1,00 g e l'asse X 0,02 g invece di 0. All'accensione il codice esegue 200 misure in circa un secondo e ne salva la media come valore di base. A ogni misura successiva sottrae questa base da ciascun asse e calcola il modulo del vettore risultante: accelerazione dinamica = √(dx² + dy² + dz²). Il bello di questo metodo è che montare il sensore in orizzontale, in verticale o inclinato non cambia il risultato; la gravità resta nella base e sparisce da sola dal calcolo. Con le variazioni di temperatura anche l'offset del sensore deriva molto lentamente; quando l'ambiente è tranquillo il codice aggiorna la base di un millesimo a ogni misura e segue così anche questa deriva.
- Fissa bene il sensore nella sua posizione definitiva, carica il codice e non toccare il circuito finché non compare il messaggio di calibrazione.
- Apri il Serial Plotter dal menu Strumenti (115200 baud). In un ambiente tranquillo vedrai l'accelerazione dinamica oscillare in genere tra 0,002 e 0,008 g: è il tuo livello di rumore.
- Annota per qualche minuto il valore massimo raggiunto dal rumore e scegli la soglia pari a 3–5 volte quel valore. Il valore predefinito nel codice, 0,03 g, corrisponde a un'intensità lieve (IV).
- Dai un colpetto al tavolo, chiudi la porta, cammina per la stanza e osserva sul plotter quanto è alto e quanto dura il picco di ogni evento.
- Per simulare una scossa vera, scuoti avanti e indietro 1–3 volte al secondo, per qualche secondo, la tavola a cui è avvitato il sensore; l'allarme dovrebbe scattare entro circa 1–2 secondi.
- Se ricevi falsi allarmi, modifica a piccoli passi THRESHOLD_G; se la scossa viene rilevata in ritardo, modifica SCORE_ALARM, poi ripeti i test.
Eliminare i falsi allarmi: porta che sbatte e passi
Quando una porta sbatte, il sensore vede un urto grande (0,1–0,5 g) ma brevissimo (50–200 ms). Un terremoto invece produce accelerazioni più piccole ma oscillazioni che durano secondi, nella banda 1–10 Hz. La caratteristica distintiva quindi non è l'ampiezza ma la durata. Nel codice lo facciamo con un contatore di punti detto leaky bucket (secchio che perde): si campiona 100 volte al secondo, a ogni misura sopra la soglia il punteggio sale di 2, a ogni misura sotto scende di 1 e quando arriva a 100 suona l'allarme. Una porta che sbatte per 150 ms produce al massimo 15 campioni, cioè 30 punti, che si esauriscono in fretta. Una scossa che supera la soglia in circa metà dei campioni accumula invece 50 punti netti al secondo e fa scattare l'allarme in circa 2 secondi. Inoltre il segnale passa per il filtro passa-basso interno al sensore a 21 Hz, quindi le vibrazioni ad alta frequenza come il ronzio di ventole, motori e compressori vengono in gran parte attenuate. Per metodi di filtraggio più avanzati dai un'occhiata all'articolo sul filtraggio dei dati dei sensori.
| Fonte di falso allarme | Caratteristica del segnale | Soluzione |
|---|---|---|
| Porta che sbatte | Un unico urto grande, di 50–200 ms | Il contatore di punti scarta gli impulsi brevi; tieni il sensore lontano dallo stipite |
| Passi, salti | Ritmico a 1–2 Hz, 0,01–0,05 g se il sensore è vicino | Monta il sensore su un muro portante in un angolo poco trafficato e alza un po' la soglia |
| Lavatrice, climatizzatore | Vibrazione prolungata a frequenza costante | Metti il dispositivo in una stanza lontana da queste macchine e prova la soglia mentre funzionano |
| Passaggio di mezzi pesanti | Vibrazione di bassa ampiezza che dura alcuni secondi | Prova di notte e di giorno separatamente e metti la soglia sopra la vibrazione stradale |
| Sensore che si sposta | Offset permanente, il punteggio sale di continuo | Fissalo con le viti; se si è spostato, resetta la scheda e ricalibra |
Codice dell'allarme terremoto 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}| Parte di codice | Funzione |
|---|---|
| writeReg(0x6B, 0x00) | L'MPU6050 si accende in modalità sleep; questo comando risveglia il sensore |
| writeReg(0x1C, 0x00) | Imposta il fondo scala a ±2 g; in questo intervallo 1 g = 16384 conteggi |
| writeReg(0x1A, 0x04) | Imposta il filtro passa-basso interno a circa 21 Hz |
| calibrate() | Trova i valori di base a riposo con la media di 200 misure |
| dyn | Modulo dello scostamento dalla base, cioè l'accelerazione dinamica (g) |
| score | +2 a ogni campione sopra la soglia, -1 sotto; l'allarme scatta a 100 |
| ALARM_HOLD_MS | L'allarme dura altri 30 s dopo l'ultima scossa; il pulsante lo silenzia prima |
| Temporizzazione con millis() | Garantisce un campionamento fisso a 100 Hz senza usare delay |
Allarme sismico semplice con SW-420

Il modulo SW-420 è composto da un semplice interruttore di vibrazione con un contatto a molla e da un comparatore LM393. A riposo il contatto è chiuso e l'uscita DO resta LOW; quando la vibrazione apre e chiude il contatto, il pin DO genera impulsi HIGH. Il potenziometro sul modulo regola la sensibilità. Non misura l'accelerazione, dice soltanto se c'è vibrazione o no; per questo non distingue l'intensità, ma costa pochissimo e il codice è semplice. Il codice qui sotto conta gli impulsi con un interrupt; se per 2 secondi consecutivi arrivano 15 o più impulsi al secondo, fa partire un allarme di 20 secondi. In questo modo anche qui una singola porta che sbatte viene scartata. Per i dettagli del modulo leggi l'articolo sul sensore di vibrazione 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}Allarme terremoto con notifica sul telefono tramite ESP32
L'ESP32 può eseguire la stessa logica di rilevamento e in più inviarti un messaggio Telegram sul telefono via Wi-Fi. Per farlo, installa dal Gestore librerie UniversalTelegramBot e la sua dipendenza ArduinoJson, crea un bot con BotFather e scrivi nel codice il token e il tuo chat ID; tutti i passaggi sono nell'articolo bot Telegram con ESP32. Qui c'è una scelta di progetto importante: la connessione Wi-Fi non è un prerequisito dell'allarme. Durante un terremoto possono saltare la corrente o internet; per questo buzzer e LED funzionano sempre in locale, mentre il messaggio viene inviato solo se c'è connessione e una sola volta per evento. Alimentare il dispositivo con una batteria 18650, un modulo di ricarica TP4056 e un regolatore di tensione adatto lo fa funzionare anche in caso di blackout.
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}Versione MicroPython con Raspberry Pi Pico
Sul Pico non servono librerie aggiuntive: la classe I2C integrata di MicroPython e il modulo struct bastano per leggere i dati grezzi dell'MPU6050. La logica è identica a quella del codice Arduino: calibrazione, accelerazione dinamica, contatore di punti e allarme di 30 secondi. Poiché i pin del Pico escono a 3,3 V, i piccoli buzzer attivi da 5 V suonano più piano; se vuoi un volume alto, pilota il buzzer con un transistor NPN dai 5 V (VBUS). Se sei nuovo di MicroPython, dai prima un'occhiata all'articolo sulle basi di 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 HzIdee per migliorare l'allarme terremoto
- Mini sismometro con display: disegna l'accelerazione dinamica come grafico scorrevole su un display OLED e mostra il picco dell'ultimo evento e l'intensità Mercalli stimata.
- Registratore di eventi: scrivi data e picco di accelerazione di ogni scossa su un modulo SD; aggiungi data e ora con un RTC.
- Illuminazione di emergenza: accendi automaticamente la luce del corridoio durante la scossa con un modulo relè.
- Sicurezza domestica integrata: aggiungi il rilevamento del terremoto allo stesso sistema di allarme con sensori di gas, fumo e movimento.
- Notifiche multiple: al posto di Telegram, o in aggiunta, invia un messaggio WhatsApp con ESP32.
- Progetto scientifico: misura come la vibrazione cresce con il piano usando sensori posti a piani diversi; per spunti leggi l'articolo sulle idee di progetti Arduino per concorsi scientifici.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| I valori sono sempre 0 o non cambiano | Sensore in sleep o collegamento I2C sbagliato | Controlla la scrittura su 0x6B, verifica i pin SDA/SCL, trova l'indirizzo con lo scanner I2C |
| L'allarme suona appena acceso | Il sensore si è mosso durante la calibrazione | Non toccare il circuito durante la calibrazione, resetta la scheda |
| L'allarme non si spegne mai | La vibrazione del buzzer arriva al sensore o il sensore si è spostato | Monta il buzzer su una superficie separata dal sensore, fissa il sensore e ricalibra |
| Nessuna reazione a una scossa leggera | THRESHOLD_G o SCORE_ALARM troppo alti | Misura il rumore sul Serial Plotter e abbassa la soglia a piccoli passi |
| Dall'ESP32 non arriva nessun messaggio | Token o chat ID errati, Wi-Fi non connesso | Controlla i dati e stampa il valore di WiFi.status() sul Monitor Seriale |
| Blocchi casuali | Cavi I2C lunghi e allentati | Tieni i cavi sotto i 30 cm e controlla i contatti sulla breadboard |
| Buzzer troppo debole | Pin a 3,3 V o corrente insufficiente | Pilota il buzzer a 5 V con un transistor NPN |
Ora hai un allarme terremoto che misura l'accelerazione, si calibra da solo, scarta gli urti brevi e dà un avviso acustico e luminoso in caso di scossa vera; e puoi realizzare la stessa logica su Arduino, ESP32 e Pico. Se vuoi consolidare buzzer, LED e logica d'allarme, nell'app BlueGrays trovi i progetti sull'uso del buzzer, la sirena della polizia, il sistema d'allarme laser e l'allarme di movimento con ESP32, con schemi passo passo e codice pronto.
Domande frequenti
Si può fare un allarme terremoto con Arduino? Funziona davvero?
Sì, con un accelerometro come l'MPU6050 puoi rilevare scosse di intensità percepibile e avvisare con buzzer e LED. È utile soprattutto per accorgerti di una lieve scossa mentre dormi ed è un progetto istruttivo. Non è però un sismografo né un sistema ufficiale di allerta precoce; non devi basare su di esso le decisioni di sicurezza.
L'allarme terremoto avvisa prima che arrivi il sisma?
No, nessun dispositivo può prevedere un terremoto. Un sensore locale suona solo quando la scossa è già iniziata. Se sei lontano dall'epicentro può captare le deboli onde P e avvisarti alcuni secondi prima delle forti onde S; se sei vicino all'epicentro questo anticipo è quasi nullo.
Per un allarme terremoto è meglio l'MPU6050 o l'SW-420?
L'MPU6050 misura l'accelerazione in forma numerica, quindi puoi regolare con precisione la soglia e valutare intensità e durata della scossa; per questo è molto più facile eliminare i falsi allarmi. L'SW-420 dice solo se c'è vibrazione o no: è economico e semplice, ma non distingue l'intensità. Per un progetto serio conviene l'MPU6050.
Dove va installato il sensore sismico in casa?
Avvita il sensore saldamente a un muro portante o al pavimento, non a un mobile. Un angolo lontano da porte, lavatrice e zone di passaggio, se possibile ai piani bassi vicino al suolo, dà meno falsi allarmi. Monta anche il buzzer su un punto separato, non sulla stessa superficie del sensore.
Arduino può misurare la magnitudo di un terremoto?
No. La magnitudo esprime l'energia liberata alla sorgente e si calcola con i dati di molte stazioni. Arduino misura solo l'accelerazione nel punto in cui si trova, un valore che cambia molto con distanza dall'epicentro, terreno e piano. Puoi solo convertire l'accelerazione di picco misurata in un'intensità percepita approssimativa (Mercalli).
Quanti g deve valere la soglia per l'allarme terremoto?
Misura prima il rumore dell'ambiente sul Serial Plotter; in un ambiente tranquillo l'MPU6050 oscilla in genere tra 0,002 e 0,008 g. Puoi scegliere la soglia pari a 3–5 volte questo rumore, tipicamente 0,02–0,04 g, un intervallo che corrisponde all'intensità IV percepita come lieve. Poi affina con i test della porta e dei passi.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

Lampeggiante della polizia a LED
Proprio come le luci di un'auto della polizia: il LED rosso lampeggia tre volte velocissimo, poi tocca al blu per altre tre volte, e la sequenza si ripete senza sosta.

Sistema di allarme laser
Costruisci una barriera di raggi invisibile, proprio come nei film. Un laser punta su un sensore di luce dall'altra parte; appena qualcuno passa e interrompe il raggio, il LED si accende e il buzzer…

Allarme del sensore di fiamma e gas
Un piccolo guardiano che ti avvisa subito se c'è una fuga di gas o compare una fiamma da qualche parte.

Allarme rilevatore di gas/fumo ESP32 MQ-2
In questo progetto, il rilevamento di gas combustibili (GPL, metano, propano) e fumo viene effettuato tramite un modulo sensore di gas MQ-2; al rilevamento viene emesso un segnale acustico simile a una sirena tramite un cicalino passivo. L'uscita digitale di soglia (DO) del sensore viene collegata al GPIO 4 dell'ESP32; quando gas o fumo superano la soglia, DO passa a LOW e l'allarme si attiva. La sensibilità si regola tramite il potenziometro del modulo. Il cicalino è pilotato con tone().

Sistema di Allarme Movimento ESP32 (PIR + Buzzer + LED + Telegram)
Un allarme di sicurezza smart: quando il sensore PIR rileva un movimento, suona il buzzer, si accende il LED e il proprietario riceve subito una notifica su Telegram. Un'attesa di 30 secondi (cooldown) limita la frequenza degli allarmi ripetuti; non elimina i falsi rilevamenti del sensore PIR. Adatto a casa, garage, magazzino o studio.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

