Alarme séisme Arduino : détecteur de secousses MPU6050
Fabrique une alarme séisme Arduino avec MPU6050 : calibrage, seuil, fausses alertes filtrées, buzzer et LED, version SW-420 et notification ESP32.
Une alarme séisme Arduino est un projet simple mais très instructif : un accéléromètre mesure en continu les vibrations de la surface sur laquelle il est fixé, et quand la secousse dépasse une certaine intensité pendant une certaine durée, un buzzer et une LED se déclenchent. Dans ce guide, tu vas apprendre pas à pas à calibrer le capteur MPU6050, à trouver le bon seuil selon le bruit ambiant, à écarter par logiciel les fausses alertes (une porte qui claque, des pas à côté du capteur) et à déclencher un avertissement sonore et lumineux. À la fin, tu monteras la même logique avec le capteur de vibration SW-420 bon marché, avec une version ESP32 qui t'envoie une notification sur ton téléphone, et avec une Raspberry Pi Pico sous MicroPython.
Soyons clairs dès le départ : cet appareil n'est ni un sismographe ni un système officiel d'alerte précoce aux séismes. Il ne peut pas prédire un séisme ; il peut seulement t'avertir quand la secousse commence et, avec de la chance, quelques secondes avant l'arrivée des ondes les plus fortes. C'est quand même un excellent projet pour remarquer une légère secousse pendant que tu dors, comprendre la notion d'accélération et le traitement du signal, et il est très apprécié dans les expo-sciences et les concours scientifiques.

Comment fonctionne une alarme séisme ?
Lors d'un séisme, deux grands types d'ondes partent de la source. Les ondes P (primaires, ondes de compression) arrivent en premier, se propagent dans la croûte terrestre à environ 6 km/s et sont généralement ressenties plus faiblement. Les ondes S (secondaires, ondes de cisaillement) suivent à environ 3,5 km/s et causent l'essentiel des dégâts. À 50 km de l'épicentre, l'écart entre les deux est d'environ 6 secondes ; juste au-dessus de l'épicentre, il est presque nul. Notre alarme utilise un accéléromètre fixé au sol pour mesurer les petites variations d'accélération créées par ces ondes. À l'arrêt, le capteur ne voit que la gravité (1 g ≈ 9,81 m/s²) ; quand la secousse commence, les valeurs des trois axes oscillent autour de cette position de repos. Nous appellerons l'amplitude de cette oscillation l'accélération dynamique. Pour une présentation détaillée du capteur, consulte l'article accéléromètre et gyroscope MPU6050.
| Caractéristique | Valeur du MPU6050 |
|---|---|
| Type de capteur | Accéléromètre 3 axes + gyroscope 3 axes (IMU 6 axes) |
| Plages d'accélération | ±2 / ±4 / ±8 / ±16 g |
| Sensibilité (±2 g) | 16384 LSB/g (1 pas ≈ 0,061 mg) |
| Résolution du CAN | 16 bits |
| Filtre passe-bas interne (DLPF) | Réglable d'environ 5 à 260 Hz |
| Communication | I2C, jusqu'à 400 kHz |
| Adresse I2C | 0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V) |
| Alimentation (module GY-521) | 3,3–5 V (régulateur 3,3 V sur la carte) |
| Courant | Environ 4 mA |
Intensité de la secousse et accélération : quelle valeur correspond à quoi ?
Les sismologues expriment généralement l'intensité d'une secousse en un point par l'accélération maximale du sol (PGA). Le tableau ci-dessous montre la relation approximative entre l'accélération du sol et l'intensité ressentie par les gens, selon l'échelle de Mercalli modifiée. Comme tu le vois, même une secousse ressentie comme légère se situe entre 0,014 et 0,039 g, soit des accélérations minuscules de 14 à 39 mg. Dans la plage ±2 g du MPU6050, un pas vaut 0,061 mg, donc la résolution est largement suffisante ; en revanche, le bruit propre du capteur au repos est de l'ordre de quelques mg, et nous devons placer le seuil au-dessus de ce bruit. Les valeurs du tableau sont des accélérations mesurées au sol ; aux étages supérieurs d'un bâtiment, l'oscillation s'amplifie, donc prends-les seulement à titre indicatif.
| Accélération maximale du sol (g) | Intensité Mercalli | Effet ressenti |
|---|---|---|
| < 0,0017 | I | Non ressentie |
| 0,0017 – 0,014 | II–III | Faible ; ressentie dans un endroit calme et aux étages élevés |
| 0,014 – 0,039 | IV | Légère ; la plupart des gens la remarquent, les vitres tremblent |
| 0,039 – 0,092 | V | Modérée ; les dormeurs se réveillent, de petits objets tombent |
| 0,092 – 0,18 | VI | Forte ; tout le monde la ressent, le plâtre peut se fissurer |
| 0,18 – 0,34 | VII | Très forte ; dégâts sur les constructions fragiles |
Matériel nécessaire et branchements
- Carte : Arduino Uno ou Nano ; ESP32 pour les notifications, Raspberry Pi Pico pour MicroPython.
- Module MPU6050 (GY-521) : l'accéléromètre qui mesure la secousse.
- Buzzer actif : les petits buzzers actifs consomment environ 20–30 mA ; pour plus de volume, pilote le buzzer avec un transistor NPN.
- LED rouge et résistance de 220 Ω : pour l'alerte visuelle ; tu peux vérifier la valeur de la résistance avec le calculateur de résistance de LED.
- Bouton poussoir : pour couper l'alarme (pull-up interne utilisée, aucune résistance supplémentaire nécessaire).
- Breadboard et fils de connexion ; pour la version simple, un capteur de vibration SW-420 en option.
| Branchement | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| MPU6050 VCC | 5V | 3V3 | 3V3(OUT) |
| MPU6050 GND | GND | GND | GND |
| MPU6050 SCL | A5 | GPIO 22 | GP5 |
| MPU6050 SDA | A4 | GPIO 21 | GP4 |
| MPU6050 AD0 | GND (adresse 0x68) | GND (adresse 0x68) | GND (adresse 0x68) |
| Buzzer actif (+) | D8 | GPIO 25 | GP15 |
| LED (avec 220 Ω) | D7 | GPIO 26 | GP14 |
| Bouton de coupure (autre borne à GND) | D2 | GPIO 27 | GP13 |
| SW-420 DO (version simple) | D3 | - | - |
Calibrage et choix du seuil
Le calibrage sert à trouver les valeurs des trois axes du capteur au repos. Un capteur n'est jamais parfaitement horizontal et chaque puce a un petit décalage ; par exemple, l'axe Z peut lire 0,97 g au lieu de 1,00 g, et l'axe X 0,02 g au lieu de 0. À l'allumage, le code effectue 200 mesures pendant environ une seconde et en garde la moyenne comme valeur de base. À chaque mesure suivante, on soustrait cette base de chaque axe et on calcule la norme du vecteur restant : accélération dynamique = √(dx² + dy² + dz²). L'avantage de cette méthode est que monter le capteur à plat, à la verticale ou en biais ne change pas le résultat ; la gravité reste incluse dans la base et disparaît d'elle-même du calcul. Avec la température, le décalage du capteur dérive aussi très lentement ; le code suit cette dérive en mettant la base à jour d'un millième à chaque mesure quand l'environnement est calme.
- Fixe solidement le capteur à son emplacement définitif, téléverse le code et ne touche pas au montage tant que le message de calibrage n'est pas passé.
- Ouvre le traceur série dans le menu Outils (115200 bauds). Dans un environnement calme, tu verras l'accélération dynamique fluctuer généralement entre 0,002 et 0,008 g ; c'est ton niveau de bruit.
- Note pendant quelques minutes la valeur maximale atteinte par le bruit et choisis un seuil de 3 à 5 fois cette valeur. Les 0,03 g par défaut dans le code correspondent à l'intensité légère (IV).
- Tapote la table, ferme la porte, marche dans la pièce et observe, pour chaque événement, la hauteur et la durée du pic sur le traceur.
- Pour simuler une vraie secousse, secoue d'avant en arrière la planche sur laquelle le capteur est vissé, 1 à 3 fois par seconde pendant quelques secondes ; l'alarme doit se déclencher en 1 à 2 secondes environ.
- Si tu as de fausses alertes, modifie THRESHOLD_G ; si la secousse est détectée trop tard, modifie SCORE_ALARM, par petites étapes, et refais les tests.
Écarter les fausses alertes : porte qui claque et pas
Quand une porte claque, le capteur voit un choc important, de 0,1 à 0,5 g, mais très bref (50 à 200 ms). Un séisme, lui, provoque des accélérations plus faibles mais des oscillations de 1 à 10 Hz qui durent plusieurs secondes. Ce qui distingue les deux n'est donc pas l'amplitude mais la durée. Dans le code, on le fait avec un compteur de score de type seau percé (leaky bucket) : on prend 100 mesures par seconde, chaque mesure au-dessus du seuil ajoute 2 points, chaque mesure en dessous en retire 1, et l'alarme sonne quand le score atteint 100. Une porte qui claque pendant 150 ms produit au maximum 15 échantillons, soit 30 points, et le score retombe vite. Une secousse qui dépasse le seuil sur environ la moitié des échantillons accumule en revanche 50 points nets par seconde et déclenche l'alarme en 2 secondes environ. De plus, le signal passe par le filtre passe-bas de 21 Hz du capteur, ce qui atténue fortement les vibrations haute fréquence comme le bourdonnement d'un ventilateur, d'un moteur ou d'un compresseur. Pour des méthodes de filtrage plus avancées, jette un œil à l'article filtrage des données de capteur.
| Source de fausse alerte | Caractéristique du signal | Solution |
|---|---|---|
| Porte qui claque | Un seul choc important de 50–200 ms | Le compteur de score élimine les chocs brefs ; éloigne le capteur du cadre de porte |
| Marche, sauts | Rythme de 1–2 Hz, 0,01–0,05 g près du capteur | Monte le capteur sur un mur porteur dans un coin peu fréquenté, relève un peu le seuil |
| Lave-linge, climatisation | Vibration longue à fréquence constante | Place l'appareil dans une pièce éloignée de ces machines, teste le seuil pendant leur fonctionnement |
| Passage de poids lourds | Vibration de faible amplitude durant quelques secondes | Teste de nuit et de jour séparément, place le seuil au-dessus des vibrations de la route |
| Capteur qui a bougé | Décalage permanent, le score monte en continu | Fixe-le avec des vis ; s'il a glissé, réinitialise la carte et recalibre |
Code d'alarme séisme 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}| Partie du code | Rôle |
|---|---|
| writeReg(0x6B, 0x00) | Le MPU6050 démarre en veille ; cette commande le réveille |
| writeReg(0x1C, 0x00) | Règle la plage d'accélération sur ±2 g ; dans cette plage, 1 g = 16384 |
| writeReg(0x1A, 0x04) | Règle le filtre passe-bas interne à environ 21 Hz |
| calibrate() | Trouve les valeurs de base au repos avec la moyenne de 200 mesures |
| dyn | Norme de l'écart par rapport à la base, donc l'accélération dynamique (g) |
| score | +2 à chaque échantillon au-dessus du seuil, -1 en dessous ; alarme à 100 |
| ALARM_HOLD_MS | L'alarme dure encore 30 s après la dernière secousse ; le bouton la coupe plus tôt |
| Temporisation avec millis() | Assure un échantillonnage fixe à 100 Hz sans utiliser delay |
Alarme séisme simple avec le SW-420

Le module SW-420 se compose d'un simple interrupteur de vibration contenant un contact à ressort et d'un comparateur LM393. Au repos, le contact est fermé et la sortie DO reste à LOW ; quand une vibration ouvre et ferme le contact, la broche DO produit des impulsions HIGH. Le potentiomètre du module règle la sensibilité. Il ne mesure pas l'accélération, il indique seulement s'il y a vibration ou non ; il ne peut donc pas distinguer l'intensité, mais il coûte très peu et son code est simple. Le code ci-dessous compte les impulsions par interruption ; si 15 impulsions par seconde ou plus arrivent pendant 2 secondes consécutives, une alarme de 20 secondes démarre. Ainsi, une simple porte qui claque est écartée ici aussi. Pour les détails du module, consulte l'article capteur de vibration 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 séisme ESP32 avec notification sur le téléphone
L'ESP32 peut exécuter la même logique de détection tout en t'envoyant un message Telegram sur ton téléphone via le Wi-Fi. Pour cela, installe depuis le gestionnaire de bibliothèques UniversalTelegramBot et sa dépendance ArduinoJson, crée un bot avec BotFather et écris le token et ton propre chat ID dans le code ; toutes les étapes se trouvent dans l'article bot Telegram avec l'ESP32. Il y a ici un choix de conception important : la connexion Wi-Fi n'est pas une condition préalable de l'alarme. Pendant un séisme, le courant ou Internet peuvent être coupés ; le buzzer et la LED fonctionnent donc toujours en local, et le message n'est envoyé que si la connexion existe, une seule fois par événement. Sauvegarder l'appareil avec une pile 18650, un module de charge TP4056 et un régulateur de tension adapté lui permet de continuer à fonctionner en cas de coupure de courant.
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}Version MicroPython avec Raspberry Pi Pico
Sur la Pico, aucune bibliothèque supplémentaire n'est nécessaire ; la classe I2C intégrée de MicroPython et le module struct suffisent pour lire les données brutes du MPU6050. La logique est strictement la même que dans le code Arduino : calibrage, accélération dynamique, compteur de score et alarme de 30 secondes. Comme les broches de la Pico fournissent du 3,3 V, les petits buzzers actifs de 5 V sonnent plus faiblement ; si tu veux plus de volume, pilote le buzzer en 5 V (VBUS) avec un transistor NPN. Si tu débutes avec MicroPython, lis d'abord l'article bases 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 HzIdées de projets pour améliorer l'alarme séisme
- Mini sismomètre avec écran : trace l'accélération dynamique en graphique défilant sur un écran OLED et affiche le pic du dernier événement et l'intensité Mercalli estimée.
- Enregistreur d'événements : écris l'heure et l'accélération maximale de chaque secousse sur un module de carte SD ; ajoute la date et l'heure avec une RTC.
- Éclairage de secours : allume automatiquement la lampe du couloir lors d'une secousse avec un module relais.
- Sécurité domestique intégrée : ajoute la détection de séisme au même système d'alarme que tes capteurs de gaz, de fumée et de mouvement.
- Notifications multiples : à la place de Telegram, ou en plus, envoie un message WhatsApp avec l'ESP32.
- Projet scientifique : mesure comment la vibration s'amplifie selon l'étage avec des capteurs placés à différents niveaux ; pour des idées, consulte l'article idées de projets Arduino pour les concours scientifiques.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Les valeurs sont toujours à 0 ou ne changent pas | Capteur en veille ou connexion I2C incorrecte | Vérifie l'écriture en 0x6B, contrôle les broches SDA/SCL, trouve l'adresse avec un scanner I2C |
| L'alarme sonne dès l'allumage | Le capteur a bougé pendant le calibrage | Ne touche pas au montage pendant le calibrage, réinitialise la carte |
| L'alarme ne s'arrête jamais | La vibration du buzzer passe au capteur ou le capteur a glissé | Monte le buzzer sur une surface séparée du capteur, fixe le capteur et recalibre |
| Aucune réaction à une légère secousse | THRESHOLD_G ou SCORE_ALARM trop élevé | Mesure le bruit sur le traceur série, baisse le seuil par étapes |
| Aucun message n'arrive de l'ESP32 | Token ou chat ID incorrect, Wi-Fi non connecté | Vérifie les informations, affiche la valeur de WiFi.status() dans le moniteur série |
| Blocages aléatoires | Fils I2C longs et mal serrés | Garde les fils sous 30 cm, vérifie les contacts de la breadboard |
| Buzzer trop faible | Broche 3,3 V ou courant insuffisant | Pilote le buzzer en 5 V avec un transistor NPN |
Tu as maintenant une alarme séisme qui mesure l'accélération, se calibre toute seule, écarte les chocs brefs et donne un avertissement sonore et lumineux lors d'une vraie secousse ; et tu peux monter la même logique sur Arduino, ESP32 et Pico. Pour consolider le buzzer, la LED et la logique d'alarme, découvre dans l'application BlueGrays les projets d'utilisation du buzzer, de gyrophare de police, de système d'alerte laser et d'alarme de mouvement ESP32, avec schémas de circuit pas à pas et codes prêts à l'emploi.
Questions fréquentes
Peut-on faire une alarme séisme avec Arduino, et est-ce vraiment utile ?
Oui, avec un accéléromètre comme le MPU6050, tu peux faire une alarme qui détecte les secousses d'intensité perceptible et avertit avec un buzzer et une LED. Elle te permet notamment de remarquer une légère secousse pendant que tu dors, et c'est un projet pédagogique. Mais ce n'est ni un sismographe ni un système officiel d'alerte précoce ; tu ne dois pas y lier tes décisions de sécurité.
Une alarme séisme prévient-elle avant un tremblement de terre ?
Non, aucun appareil ne peut prédire un séisme. Un capteur local ne sonne qu'une fois la secousse commencée. Si tu es loin de l'épicentre, il peut détecter les ondes P plus faibles et t'avertir quelques secondes avant les fortes ondes S ; près de l'épicentre, ce délai est presque nul.
MPU6050 ou SW-420 : lequel est le meilleur pour une alarme séisme ?
Comme le MPU6050 mesure l'accélération numériquement, tu peux régler le seuil avec précision et évaluer l'intensité et la durée de la secousse ; il est donc bien plus facile d'écarter les fausses alertes. Le SW-420 indique seulement s'il y a vibration ou non : il est bon marché et simple, mais ne distingue pas l'intensité. Pour un projet sérieux, choisis le MPU6050.
Où installer un capteur de séisme dans la maison ?
Visse le capteur solidement sur un mur porteur ou sur le sol, pas sur un meuble. Un coin près du sol, si possible à un étage bas, loin des portes, du lave-linge et des passages fréquents, donne le moins de fausses alertes. Monte aussi le buzzer à part, pas sur la même surface que le capteur.
Arduino peut-il mesurer la magnitude d'un séisme ?
Non. La magnitude exprime l'énergie libérée à la source et se calcule avec les données de nombreuses stations. Arduino mesure seulement l'accélération à l'endroit où il se trouve ; cette valeur varie beaucoup selon la distance à l'épicentre, le sol et l'étage. Tu peux seulement convertir l'accélération maximale mesurée en intensité ressentie approximative (Mercalli).
Quelle valeur de seuil en g pour une alarme séisme ?
Mesure d'abord le bruit ambiant sur le traceur série ; dans un environnement calme, le MPU6050 fluctue généralement entre 0,002 et 0,008 g. Tu peux choisir un seuil de 3 à 5 fois ce bruit, typiquement 0,02–0,04 g, ce qui correspond à l'intensité IV ressentie comme légère. Affine ensuite avec des tests de porte et de marche.
Projets à réaliser après cet article
Voir tous les projets
Utilisation du buzzer
Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Gyrophare de police à LED
Comme le gyrophare d'une voiture de police : la LED rouge flashe trois fois très vite, puis la bleue flashe trois fois à son tour, et la séquence se répète sans fin.

Système d'alerte laser
Tu installes une barrière de faisceau invisible, comme dans les films. Un laser éclaire un capteur de lumière de l'autre côté ; dès que quelqu'un passe et coupe le faisceau, la LED s'allume et le…

Alarme du capteur de flamme et de gaz
Un petit gardien qui te prévient tout de suite en cas de fuite de gaz ou de flamme quelque part.

Alarme de détection de gaz/fumée ESP32 MQ-2
Dans ce projet, la détection de gaz combustibles (GPL, méthane, propane) et de fumée est assurée par un module capteur de gaz MQ-2 ; dès la détection, une alarme sonore semblable à une sirène retentit via un buzzer passif. La sortie numérique de seuil (DO) du capteur est connectée au GPIO 4 de l'ESP32 ; quand le gaz ou la fumée dépasse le seuil, DO passe à LOW et l'alarme se déclenche. La sensibilité se règle via le potentiomètre du module. Le buzzer est piloté par tone().

Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
Une alarme de sécurité intelligente : quand le capteur PIR détecte un mouvement, le buzzer sonne, la LED s'allume et le propriétaire reçoit aussitôt une notification Telegram. Un délai de 30 secondes (cooldown) limite la répétition des alarmes ; il n'élimine pas les fausses détections du capteur PIR. À utiliser à la maison, au garage, dans une réserve ou un bureau.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

