Guides · 11 min de lecture

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.

Module accéléromètre et gyroscope MPU6050 GY-521
Module MPU6050 (GY-521) : accéléromètre 3 axes et gyroscope 3 axes, liaison I2C, adresse 0x68.

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éristiqueValeur du MPU6050
Type de capteurAccé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 CAN16 bits
Filtre passe-bas interne (DLPF)Réglable d'environ 5 à 260 Hz
CommunicationI2C, jusqu'à 400 kHz
Adresse I2C0x68 (AD0 = GND), 0x69 (AD0 = 3,3 V)
Alimentation (module GY-521)3,3–5 V (régulateur 3,3 V sur la carte)
CourantEnviron 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é MercalliEffet ressenti
< 0,0017INon ressentie
0,0017 – 0,014II–IIIFaible ; ressentie dans un endroit calme et aux étages élevés
0,014 – 0,039IVLégère ; la plupart des gens la remarquent, les vitres tremblent
0,039 – 0,092VModérée ; les dormeurs se réveillent, de petits objets tombent
0,092 – 0,18VIForte ; tout le monde la ressent, le plâtre peut se fissurer
0,18 – 0,34VIITrès forte ; dégâts sur les constructions fragiles
Ce projet n'est pas un système officiel d'alerte précoce aux séismes et ne le remplace pas. Un capteur fait maison peut déclencher de fausses alertes ou rater une vraie secousse. Ne base pas tes décisions d'évacuation et de sécurité sur cet appareil ; pour les alertes et informations officielles, suis les annonces des organismes compétents et garde toujours ton sac d'urgence prêt.

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.
BranchementArduino UnoESP32Raspberry Pi Pico
MPU6050 VCC5V3V33V3(OUT)
MPU6050 GNDGNDGNDGND
MPU6050 SCLA5GPIO 22GP5
MPU6050 SDAA4GPIO 21GP4
MPU6050 AD0GND (adresse 0x68)GND (adresse 0x68)GND (adresse 0x68)
Buzzer actif (+)D8GPIO 25GP15
LED (avec 220 Ω)D7GPIO 26GP14
Bouton de coupure (autre borne à GND)D2GPIO 27GP13
SW-420 DO (version simple)D3--
L'erreur la plus fréquente est de brancher SDA et SCL sur des broches numériques de l'Uno ; sur l'Uno, le bus I2C se trouve sur les broches A4 (SDA) et A5 (SCL). La puce du GY-521 fonctionne en 3,3 V ; grâce au régulateur de la carte, tu peux relier VCC au 5V sur l'Uno, mais utilise impérativement 3V3 sur l'ESP32 et la Pico. Si tu relies AD0 à 3,3 V, l'adresse devient 0x69 et tu dois aussi modifier MPU_ADDR dans le code. Tous les composants doivent partager la même masse (GND).

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.

  1. 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é.
  2. 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.
  3. 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).
  4. 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.
  5. 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.
  6. 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 alerteCaractéristique du signalSolution
Porte qui claqueUn seul choc important de 50–200 msLe compteur de score élimine les chocs brefs ; éloigne le capteur du cadre de porte
Marche, sautsRythme de 1–2 Hz, 0,01–0,05 g près du capteurMonte le capteur sur un mur porteur dans un coin peu fréquenté, relève un peu le seuil
Lave-linge, climatisationVibration longue à fréquence constantePlace l'appareil dans une pièce éloignée de ces machines, teste le seuil pendant leur fonctionnement
Passage de poids lourdsVibration de faible amplitude durant quelques secondesTeste 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 continuFixe-le avec des vis ; s'il a glissé, réinitialise la carte et recalibre

Code d'alarme séisme Arduino (MPU6050 + buzzer + LED)

C++ (Arduino IDE)
1#include <Wire.h>
2
3const int MPU_ADDR = 0x68;                  // AD0 = GND / AD0 = GND
4const int BUZZER_PIN = 8;                   // aktif buzzer / active buzzer
5const int LED_PIN = 7;                      // LED + 220 ohm
6const int BUTTON_PIN = 2;                   // susturma butonu / silence button
7
8const float THRESHOLD_G = 0.03;             // dinamik ivme eşiği (g) / dynamic acceleration threshold (g)
9const int SCORE_ALARM = 100;                // alarm puanı / alarm score
10const unsigned long SAMPLE_MS = 10;         // 100 Hz örnekleme / 100 Hz sampling
11const unsigned long ALARM_HOLD_MS = 30000;  // son sarsıntıdan sonra 30 s / 30 s after the last shake
12const bool DEBUG_PLOT = true;               // Seri Çizici çıktısı / Serial Plotter output
13
14float baseX, baseY, baseZ;                  // durağan taban değerleri / resting baseline
15int score = 0;
16bool alarmOn = false;
17float peakG = 0;
18unsigned long lastSample = 0;
19unsigned long lastShake = 0;
20
21void writeReg(uint8_t reg, uint8_t val) {
22  Wire.beginTransmission(MPU_ADDR);
23  Wire.write(reg);
24  Wire.write(val);
25  Wire.endTransmission();
26}
27
28void readAccel(float &ax, float &ay, float &az) {
29  Wire.beginTransmission(MPU_ADDR);
30  Wire.write(0x3B);                         // ACCEL_XOUT_H
31  Wire.endTransmission(false);
32  Wire.requestFrom(MPU_ADDR, 6);
33  uint8_t b[6];
34  for (int i = 0; i < 6; i++) b[i] = Wire.read();
35  ax = (int16_t)((b[0] << 8) | b[1]) / 16384.0;   // ±2 g: 16384 LSB/g
36  ay = (int16_t)((b[2] << 8) | b[3]) / 16384.0;
37  az = (int16_t)((b[4] << 8) | b[5]) / 16384.0;
38}
39
40void calibrate() {
41  float sx = 0, sy = 0, sz = 0;
42  for (int i = 0; i < 200; i++) {
43    float ax, ay, az;
44    readAccel(ax, ay, az);
45    sx += ax; sy += ay; sz += az;
46    delay(5);
47  }
48  baseX = sx / 200; baseY = sy / 200; baseZ = sz / 200;
49}
50
51void setup() {
52  Serial.begin(115200);
53  pinMode(BUZZER_PIN, OUTPUT);
54  pinMode(LED_PIN, OUTPUT);
55  pinMode(BUTTON_PIN, INPUT_PULLUP);
56  Wire.begin();
57  writeReg(0x6B, 0x00);                     // uyku modundan çık / wake up
58  writeReg(0x1C, 0x00);                     // ±2 g aralığı / ±2 g range
59  writeReg(0x1A, 0x04);                     // DLPF ~21 Hz
60  delay(100);
61  Serial.println(F("Kalibrasyon, dokunma / Calibrating, do not touch"));
62  calibrate();
63  lastSample = millis();
64}
65
66void loop() {
67  if (millis() - lastSample >= SAMPLE_MS) {
68    lastSample += SAMPLE_MS;
69    float ax, ay, az;
70    readAccel(ax, ay, az);
71    float dx = ax - baseX, dy = ay - baseY, dz = az - baseZ;
72    float dyn = sqrt(dx * dx + dy * dy + dz * dz);   // dinamik ivme (g) / dynamic acceleration (g)
73    if (DEBUG_PLOT) Serial.println(dyn, 4);
74
75    if (dyn > THRESHOLD_G) {
76      score = min(score + 2, 200);          // eşik üstü: +2 / above threshold: +2
77      if (dyn > peakG) peakG = dyn;
78    } else if (score > 0) {
79      score--;                              // eşik altı: -1 / below threshold: -1
80    }
81
82    if (score == 0 && !alarmOn) {           // sakin: tabanı yavaşça izle / quiet: track baseline slowly
83      baseX += (ax - baseX) * 0.001;
84      baseY += (ay - baseY) * 0.001;
85      baseZ += (az - baseZ) * 0.001;
86      peakG = 0;
87    }
88
89    if (score >= SCORE_ALARM) {
90      if (!alarmOn && !DEBUG_PLOT) {
91        Serial.print(F("SARSINTI! Tepe / Peak: "));
92        Serial.print(peakG, 3);
93        Serial.println(F(" g"));
94      }
95      alarmOn = true;
96      lastShake = millis();
97    }
98  }
99
100  if (alarmOn && (millis() - lastShake > ALARM_HOLD_MS || digitalRead(BUTTON_PIN) == LOW)) {
101    alarmOn = false;                        // süre doldu ya da susturuldu / timeout or silenced
102    score = 0;
103  }
104
105  bool on = alarmOn && ((millis() / 250) % 2);   // 2 Hz yanıp sönme / 2 Hz blinking
106  digitalWrite(LED_PIN, on);
107  digitalWrite(BUZZER_PIN, on);
108}
Partie du codeRô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
dynNorme 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_MSL'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
Pendant le réglage, laisse DEBUG_PLOT = true et observe l'accélération dynamique en direct sur le traceur série ; choisir le seuil d'après ce graphique est bien plus fiable que le deviner. Une fois l'installation terminée, passe-le à false pour ne voir que les messages d'alarme. Nous avons expliqué pourquoi il est important d'utiliser millis plutôt que delay dans l'article millis et delay sur Arduino.

Alarme séisme simple avec le SW-420

Module capteur de vibration SW-420
Capteur de vibration SW-420 : interrupteur de vibration à ressort, comparateur LM393 et potentiomètre de sensibilité.

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.

C++ (Arduino IDE)
1const byte SENSOR_PIN = 3;                  // SW-420 DO (kesme pini / interrupt pin)
2const byte BUZZER_PIN = 8;
3const byte LED_PIN = 7;
4const unsigned int PULSE_LIMIT = 15;        // saniyedeki darbe sınırı / pulses per second limit
5
6volatile unsigned int pulses = 0;
7unsigned long lastCheck = 0;
8unsigned long alarmUntil = 0;
9byte busySeconds = 0;
10
11void onPulse() {
12  pulses++;                                 // her titreşim darbesini say / count each vibration pulse
13}
14
15void setup() {
16  Serial.begin(115200);
17  pinMode(SENSOR_PIN, INPUT);
18  pinMode(BUZZER_PIN, OUTPUT);
19  pinMode(LED_PIN, OUTPUT);
20  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), onPulse, RISING);
21}
22
23void loop() {
24  if (millis() - lastCheck >= 1000) {       // her saniye değerlendir / evaluate every second
25    lastCheck = millis();
26    noInterrupts();
27    unsigned int n = pulses;
28    pulses = 0;
29    interrupts();
30    Serial.println(n);
31    if (n >= PULSE_LIMIT) busySeconds++;
32    else busySeconds = 0;
33    if (busySeconds >= 2) alarmUntil = millis() + 20000;   // 2 s sürekli titreşim / 2 s continuous vibration
34  }
35
36  bool alarm = (long)(alarmUntil - millis()) > 0;
37  bool on = alarm && ((millis() / 250) % 2);
38  digitalWrite(BUZZER_PIN, on);
39  digitalWrite(LED_PIN, on);
40}

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.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <UniversalTelegramBot.h>
5
6const char* WIFI_SSID = "WIFI_ADI";
7const char* WIFI_PASS = "WIFI_SIFRESI";
8#define BOT_TOKEN "123456789:BOT_TOKENIN"     // BotFather'dan / from BotFather
9#define CHAT_ID "123456789"                   // kendi chat ID'n / your chat ID
10
11const int MPU_ADDR = 0x68;
12const int BUZZER_PIN = 25;
13const int LED_PIN = 26;
14const int BUTTON_PIN = 27;
15const float THRESHOLD_G = 0.03;
16const int SCORE_ALARM = 100;
17const unsigned long ALARM_HOLD_MS = 30000;
18
19WiFiClientSecure client;
20UniversalTelegramBot bot(BOT_TOKEN, client);
21
22float baseX, baseY, baseZ;
23int score = 0;
24bool alarmOn = false;
25bool messageSent = false;
26float peakG = 0;
27unsigned long lastSample = 0, lastShake = 0;
28
29void writeReg(uint8_t reg, uint8_t val) {
30  Wire.beginTransmission(MPU_ADDR);
31  Wire.write(reg);
32  Wire.write(val);
33  Wire.endTransmission();
34}
35
36void readAccel(float &ax, float &ay, float &az) {
37  Wire.beginTransmission(MPU_ADDR);
38  Wire.write(0x3B);
39  Wire.endTransmission(false);
40  Wire.requestFrom(MPU_ADDR, 6);
41  uint8_t b[6];
42  for (int i = 0; i < 6; i++) b[i] = Wire.read();
43  ax = (int16_t)((b[0] << 8) | b[1]) / 16384.0;
44  ay = (int16_t)((b[2] << 8) | b[3]) / 16384.0;
45  az = (int16_t)((b[4] << 8) | b[5]) / 16384.0;
46}
47
48void setup() {
49  Serial.begin(115200);
50  pinMode(BUZZER_PIN, OUTPUT);
51  pinMode(LED_PIN, OUTPUT);
52  pinMode(BUTTON_PIN, INPUT_PULLUP);
53  Wire.begin(21, 22);                         // SDA, SCL
54  writeReg(0x6B, 0x00);                       // uyandır / wake up
55  writeReg(0x1C, 0x00);                       // ±2 g
56  writeReg(0x1A, 0x04);                       // DLPF ~21 Hz
57  delay(100);
58  float sx = 0, sy = 0, sz = 0;               // kalibrasyon / calibration
59  for (int i = 0; i < 200; i++) {
60    float ax, ay, az;
61    readAccel(ax, ay, az);
62    sx += ax; sy += ay; sz += az;
63    delay(5);
64  }
65  baseX = sx / 200; baseY = sy / 200; baseZ = sz / 200;
66  client.setCACert(TELEGRAM_CERTIFICATE_ROOT);
67  WiFi.begin(WIFI_SSID, WIFI_PASS);           // bağlanmayı beklemez / does not block
68  lastSample = millis();
69}
70
71void loop() {
72  if (millis() - lastSample >= 10) {          // 100 Hz örnekleme / 100 Hz sampling
73    lastSample += 10;
74    float ax, ay, az;
75    readAccel(ax, ay, az);
76    float dx = ax - baseX, dy = ay - baseY, dz = az - baseZ;
77    float dyn = sqrt(dx * dx + dy * dy + dz * dz);
78    if (dyn > THRESHOLD_G) {
79      score = min(score + 2, 200);
80      if (dyn > peakG) peakG = dyn;
81    } else if (score > 0) {
82      score--;
83    }
84    if (score == 0 && !alarmOn) {
85      baseX += (ax - baseX) * 0.001;
86      baseY += (ay - baseY) * 0.001;
87      baseZ += (az - baseZ) * 0.001;
88      peakG = 0;
89    }
90    if (score >= SCORE_ALARM) {
91      alarmOn = true;
92      lastShake = millis();
93    }
94  }
95
96  if (alarmOn && !messageSent && WiFi.status() == WL_CONNECTED) {
97    digitalWrite(LED_PIN, HIGH);              // gönderirken de uyar / keep warning while sending
98    digitalWrite(BUZZER_PIN, HIGH);
99    String msg = String("Sarsinti algilandi! Tepe ivme: ") + String(peakG, 3) + " g";
100    bot.sendMessage(CHAT_ID, msg, "");
101    messageSent = true;                       // olay başına bir mesaj / one message per event
102    lastSample = millis();                    // kaçan örnekleri atla / skip missed samples
103  }
104
105  if (alarmOn && (millis() - lastShake > ALARM_HOLD_MS || digitalRead(BUTTON_PIN) == LOW)) {
106    alarmOn = false;
107    messageSent = false;
108    score = 0;
109  }
110
111  bool on = alarmOn && ((millis() / 250) % 2);
112  digitalWrite(LED_PIN, on);
113  digitalWrite(BUZZER_PIN, on);
114}

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.

MicroPython
1from machine import Pin, I2C
2import struct, time, math
3
4i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
5MPU = 0x68
6buzzer = Pin(15, Pin.OUT)
7led = Pin(14, Pin.OUT)
8button = Pin(13, Pin.IN, Pin.PULL_UP)        # susturma butonu / silence button
9
10i2c.writeto_mem(MPU, 0x6B, b'\x00')          # uyandır / wake up
11i2c.writeto_mem(MPU, 0x1C, b'\x00')          # ±2 g
12i2c.writeto_mem(MPU, 0x1A, b'\x04')          # DLPF ~21 Hz
13time.sleep_ms(100)
14
15def read_accel():
16    x, y, z = struct.unpack('>hhh', i2c.readfrom_mem(MPU, 0x3B, 6))
17    return x / 16384, y / 16384, z / 16384
18
19print("Kalibrasyon / Calibrating...")
20sx = sy = sz = 0
21for _ in range(200):
22    ax, ay, az = read_accel()
23    sx += ax; sy += ay; sz += az
24    time.sleep_ms(5)
25bx, by, bz = sx / 200, sy / 200, sz / 200
26
27THRESHOLD = 0.03                              # eşik (g) / threshold (g)
28score = 0
29alarm = False
30last_shake = 0
31
32while True:
33    t0 = time.ticks_ms()
34    ax, ay, az = read_accel()
35    dyn = math.sqrt((ax - bx) ** 2 + (ay - by) ** 2 + (az - bz) ** 2)
36    if dyn > THRESHOLD:
37        score = min(score + 2, 200)
38    elif score > 0:
39        score -= 1
40    if score == 0 and not alarm:              # tabanı yavaşça izle / track baseline slowly
41        bx += (ax - bx) * 0.001
42        by += (ay - by) * 0.001
43        bz += (az - bz) * 0.001
44    if score >= 100:
45        alarm = True
46        last_shake = time.ticks_ms()
47    if alarm and (time.ticks_diff(time.ticks_ms(), last_shake) > 30000 or button.value() == 0):
48        alarm = False
49        score = 0
50    on = alarm and (time.ticks_ms() // 250) % 2 == 1
51    buzzer.value(on)
52    led.value(on)
53    time.sleep_ms(max(0, 10 - time.ticks_diff(time.ticks_ms(), t0)))   # ~100 Hz

Idé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ômeCause probableSolution
Les valeurs sont toujours à 0 ou ne changent pasCapteur en veille ou connexion I2C incorrecteVérifie l'écriture en 0x6B, contrôle les broches SDA/SCL, trouve l'adresse avec un scanner I2C
L'alarme sonne dès l'allumageLe capteur a bougé pendant le calibrageNe touche pas au montage pendant le calibrage, réinitialise la carte
L'alarme ne s'arrête jamaisLa 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 secousseTHRESHOLD_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'ESP32Token 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éatoiresFils I2C longs et mal serrésGarde les fils sous 30 cm, vérifie les contacts de la breadboard
Buzzer trop faibleBroche 3,3 V ou courant insuffisantPilote le buzzer en 5 V avec un transistor NPN
Visse le capteur directement sur un mur porteur ou sur le sol, pas sur un meuble ou une étagère ; le ruban adhésif double face amortit les vibrations et réduit la sensibilité. Un capteur monté dans un coin près du sol et peu fréquenté est le moins sensible aux pas et aux portes. Les fils lâches sur la breadboard produisent aussi du bruit à eux seuls ; pour une installation permanente, transfère le circuit sur une carte soudée.

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.

Voir tous les projets
Utilisation du buzzer
AR-13Débutant

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.

4.7(92)
171
Clignotement d'une LED
AR-1Débutant

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.

4.6(200)
1246
Gyrophare de police à LED
AR-4Débutant

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.

4.7(105)
283
Système d'alerte laser
AR-22Intermédiaire
Premium

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…

4.8(64)
83
Alarme du capteur de flamme et de gaz
AR-52Avancé
Premium

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.

4.8(52)
67
Alarme de détection de gaz/fumée ESP32 MQ-2
ES-20Intermédiaire

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

4.7(29)
44
Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
ES-41Avancé
Premium

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.

9