Capteur de vibration SW-420 Arduino : chocs, alarme et alerte

Dans les projets de capteur de vibration Arduino, la pièce la plus utilisée est le module SW-420, bon marché et simple. Avec une seule broche numérique, il signale qu'une surface a été secouée, qu'on a frappé à une porte, qu'un tiroir s'est ouvert ou qu'une machine a démarré. Le module comporte un interrupteur de vibration à ressort, un comparateur LM393 et un petit potentiomètre de réglage de la sensibilité. Il est facile à utiliser, mais au premier essai la plupart des gens rencontrent les deux mêmes problèmes : le capteur rate certaines vibrations et déclenche parfois sans raison.

Dans ce guide, tu vas découvrir comment fonctionne le contact à ressort du SW-420, pourquoi sa sortie arrive sous forme de courtes impulsions et comment bien régler la sensibilité. Ensuite, nous compterons les impulsions par interruption, mesurerons la durée et la force d'un choc et construirons une alarme antivol qui limite les fausses alertes. Nous verrons aussi pourquoi l'idée d'un détecteur de séisme n'est pas aussi simple qu'elle en a l'air et ce qu'un accéléromètre MPU6050 apporte. Enfin, un ESP32 enverra un message Telegram sur ton téléphone en cas de vibration, et nous écrirons du code MicroPython pour le Raspberry Pi Pico.

Qu'est-ce que le capteur de vibration SW-420 et comment fonctionne-t-il ?

Le véritable élément sensible du module est un interrupteur de vibration normalement fermé (NF) logé dans un petit boîtier métallique cylindrique. À l'intérieur se trouvent un ressort et une pièce conductrice ; quand le capteur est immobile, ils se touchent et le contact est fermé. Quand le capteur est secoué, le ressort oscille et le contact s'ouvre et se ferme par très brèves rafales, chacune de moins d'une milliseconde. L'interrupteur est omnidirectionnel : il réagit aux vibrations venant de n'importe quelle direction. Le LM393 du module compare la tension créée par cet interrupteur à un seuil fixé par le potentiomètre et fournit une sortie numérique propre (DO). Sur la plupart des modules, DO est à LOW au repos et à HIGH pendant la vibration, et la LED de signal s'éteint ou clignote avec la vibration ; sur certaines cartes clones, la logique peut être inversée, teste donc d'abord ton module avec le moniteur série.

Branchement du SW-420 sur l'Arduino

Sensibilité : comment régler le potentiomètre ?

Le potentiomètre fixe le seuil du comparateur. Trop sensible, le capteur détecte un verre posé sur la table, un camion qui passe ou même la vibration de son propre buzzer ; trop grossier, il ne réagit qu'à un coup franc. Pour un bon réglage, visse le module sur la surface d'utilisation et observe la LED de signal. Tourne le potentiomètre jusqu'au point où la LED reste stable au repos mais réagit quand tu tapotes légèrement la surface du doigt ; puis diminue très légèrement la sensibilité pour garder une marge. Ce réglage dépend du matériau : le même réglage peut être très sensible sur une table en bois et sourd sur un mur en béton.

Premier test : détecter la vibration et capter les impulsions brèves

Le premier code d'un débutant lit souvent la broche avec digitalRead() dans loop() et allume une LED en voyant HIGH. Cela marche pour un choc franc, mais avec des vibrations légères il ne se passe souvent rien : la sortie du SW-420 peut ne rester à HIGH que quelques centaines de microsecondes, et si loop() est occupé par Serial.print() ou delay() à ce moment-là, l'impulsion est perdue. La solution consiste à capter l'impulsion par une interruption et à noter l'instant. Le code ci-dessous enregistre l'heure de chaque impulsion et garde la LED allumée 1 seconde après la dernière, pour que l'œil voie même une vibration très brève.

1const byte VIB_PIN = 2;                  // SW-420 DO (INT0)
2const byte LED_PIN = 13;                 // dahili LED / onboard LED
3const unsigned long HOLD_MS = 1000;      // son darbeden sonra LED süresi / LED time after the last pulse
4
5volatile unsigned long lastPulseMs = 0;
6volatile bool pulseSeen = false;
7
8void onVibration() {                     // her darbede çalışır / runs on every pulse
9  lastPulseMs = millis();
10  pulseSeen = true;
11}
12
13void setup() {
14  pinMode(VIB_PIN, INPUT);
15  pinMode(LED_PIN, OUTPUT);
16  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);   // LOW → HIGH geçişi / LOW to HIGH edge
17  Serial.begin(9600);
18}
19
20void loop() {
21  noInterrupts();
22  unsigned long last = lastPulseMs;
23  bool seen = pulseSeen;
24  pulseSeen = false;
25  interrupts();
26
27  if (seen) Serial.println(F("Titresim / vibration"));
28  digitalWrite(LED_PIN, (last > 0 && millis() - last < HOLD_MS) ? HIGH : LOW);
29}

L'interruption s'exécute à chaque front où la broche passe de LOW à HIGH ; sur l'Uno, seules D2 et D3 offrent ce type d'interruption externe. Si la logique de ton module est inversée, écris FALLING au lieu de RISING ; comme les rafales comportent des fronts montants et descendants, le comptage ne change pas. La fonction d'interruption est la plus courte possible et n'utilise pas Serial ; l'affichage se fait dans loop(). Couper brièvement les interruptions pendant la lecture des variables dans loop() évite qu'une variable de plusieurs octets change en pleine lecture et soit lue de travers.

Compter les impulsions et mesurer la durée : combien de temps et quelle force ?

Le SW-420 ne mesure pas l'accélération, mais le nombre d'impulsions qu'il produit donne une bonne idée de la force d'un choc : une petite tape donne quelques impulsions, une porte claquée des dizaines et la vibration d'une perceuse des centaines par seconde. Le code ci-dessous compte les impulsions par interruption et les regroupe en événements : la première impulsion ouvre un événement et, si aucune nouvelle n'arrive pendant 500 ms, il se termine. À la fin de chaque événement, il affiche la durée, le nombre total d'impulsions et leur densité par seconde. Tu peux ainsi établir l'« empreinte » des événements de ton environnement et fonder ton seuil d'alarme sur des mesures plutôt que sur des suppositions.

1const byte VIB_PIN = 2;                   // SW-420 DO (INT0)
2const unsigned long QUIET_MS = 500;       // bu kadar sessizlik olayı bitirir / this much silence ends an event
3
4volatile unsigned long pulseCount = 0;
5volatile unsigned long lastPulseMs = 0;
6
7bool inEvent = false;
8unsigned long eventStart = 0;
9unsigned long eventStartCount = 0;
10
11void onVibration() {
12  pulseCount++;
13  lastPulseMs = millis();
14}
15
16void setup() {
17  pinMode(VIB_PIN, INPUT);
18  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
19  Serial.begin(9600);
20  Serial.println(F("Sure(ms)  Darbe/pulses  Darbe/sn  (pulses/s)"));
21}
22
23void loop() {
24  noInterrupts();
25  unsigned long count = pulseCount;
26  unsigned long last = lastPulseMs;
27  interrupts();
28
29  if (!inEvent && count != eventStartCount) {      // yeni olay başladı / a new event started
30    inEvent = true;
31    eventStart = last;
32  }
33  if (inEvent && millis() - last > QUIET_MS) {     // olay bitti / the event is over
34    unsigned long duration = last - eventStart;
35    unsigned long pulses = count - eventStartCount;
36    float density = duration > 0 ? pulses * 1000.0 / duration : pulses;
37    Serial.print(duration);
38    Serial.print(F("        "));
39    Serial.print(pulses);
40    Serial.print(F("           "));
41    Serial.println(density, 0);
42    eventStartCount = count;
43    inEvent = false;
44  }
45}

Lance le code, tape sur la table de différentes façons, ouvre un tiroir, ferme la porte et note les nombres obtenus. Pour une petite tape isolée, la durée est souvent proche de zéro et le nombre d'impulsions ne dépasse pas une dizaine ; une vibration longue fait grimper à la fois la durée et le nombre d'impulsions. Combiner ces deux valeurs est bien plus efficace qu'un simple « vibration oui ou non » : sur un capteur placé dans un coffre-fort, par exemple, la règle « événement d'au moins 300 ms et d'au moins 20 impulsions » écarte les pas de quelqu'un qui passe à côté tout en repérant celui qui force le coffre.

Alarme antivol avec le SW-420 et réduction des fausses alarmes

Un SW-420 posé sur une vitre, un vélo, un tiroir ou un coffre-fort peut être le cœur d'une alarme antivol simple. Ce qui distingue une bonne alarme d'une mauvaise, c'est moins la détection que la façon d'écarter les fausses alarmes. Le code ci-dessous procède en trois niveaux : après la mise en service, il accorde 10 secondes de temporisation de sortie, il ne se déclenche pas sur un coup isolé mais quand il voit au moins 5 impulsions en 1 seconde, et il ignore les nouvelles impulsions pendant les 15 secondes où la sirène retentit. L'alarme s'active et se désactive avec le bouton sur D4, le buzzer actif est sur D8 et la LED d'état sur D13. Pour un système plus complet, consulte le guide système d'alarme Arduino.

1const byte VIB_PIN = 2;                       // SW-420 DO (INT0)
2const byte BUTTON_PIN = 4;                    // kur / kapat butonu, D4 ile GND arası / arm-disarm button
3const byte BUZZER_PIN = 8;                    // aktif buzzer / active buzzer
4const byte LED_PIN = 13;                      // durum LED'i / status LED
5const unsigned int MIN_PULSES = 5;            // pencerede gereken darbe / pulses needed in the window
6const unsigned long WINDOW_MS = 1000;         // sayım penceresi / counting window
7const unsigned long EXIT_DELAY_MS = 10000;    // kurduktan sonra çıkış süresi / exit delay after arming
8const unsigned long ALARM_MS = 15000;         // siren süresi / siren duration
9
10enum AlarmState { DISARMED, ARMING, ARMED, ALARM };
11AlarmState state = DISARMED;
12
13volatile unsigned int pulses = 0;
14unsigned long stateTime = 0;
15unsigned long windowStart = 0;
16unsigned long lastPress = 0;
17bool lastButton = HIGH;
18
19void onVibration() {
20  pulses++;
21}
22
23void setState(AlarmState s) {
24  state = s;
25  stateTime = millis();
26  digitalWrite(BUZZER_PIN, LOW);
27  noInterrupts();
28  pulses = 0;                                 // eski darbeleri sil / discard old pulses
29  interrupts();
30  windowStart = millis();
31}
32
33void setup() {
34  pinMode(VIB_PIN, INPUT);
35  pinMode(BUTTON_PIN, INPUT_PULLUP);
36  pinMode(BUZZER_PIN, OUTPUT);
37  pinMode(LED_PIN, OUTPUT);
38  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
39  Serial.begin(9600);
40}
41
42void loop() {
43  bool button = digitalRead(BUTTON_PIN);
44  if (button == LOW && lastButton == HIGH && millis() - lastPress > 200) {
45    lastPress = millis();
46    setState(state == DISARMED ? ARMING : DISARMED);
47    Serial.println(state == ARMING ? F("Kuruluyor / arming") : F("Kapatildi / disarmed"));
48  }
49  lastButton = button;
50
51  if (millis() - windowStart >= WINDOW_MS) {  // her saniye darbe sayısına bak / check the pulse count every second
52    noInterrupts();
53    unsigned int n = pulses;
54    pulses = 0;
55    interrupts();
56    windowStart = millis();
57    if (state == ARMED && n >= MIN_PULSES) {
58      setState(ALARM);
59      Serial.print(F("ALARM! darbe / pulses: "));
60      Serial.println(n);
61    }
62  }
63
64  switch (state) {
65    case DISARMED:
66      digitalWrite(LED_PIN, LOW);
67      break;
68    case ARMING:                              // hızlı yanıp sönme: çıkış süresi / fast blink: exit delay
69      digitalWrite(LED_PIN, (millis() / 250) % 2);
70      if (millis() - stateTime >= EXIT_DELAY_MS) setState(ARMED);
71      break;
72    case ARMED:
73      digitalWrite(LED_PIN, HIGH);
74      break;
75    case ALARM:                               // kesik kesik siren / intermittent siren
76      digitalWrite(BUZZER_PIN, (millis() / 300) % 2);
77      if (millis() - stateTime >= ALARM_MS) setState(ARMED);
78      break;
79  }
80}

En dehors du code, tu peux faire beaucoup pour limiter les fausses alarmes :

• Fixation solide : Fixe le module avec une vis M3 ou une colle rigide ; une carte qui ballotte vibre toute seule.
• Éloigne le buzzer : Si la sirène est montée sur la même carte ou dans le même boîtier que le capteur, sa propre vibration peut relancer l'alarme.
• Règle la sensibilité sur place : Ajuste le potentiomètre sur la surface définitive du capteur, pas sur ton bureau.
• Câbles courts et fixés : Des câbles longs qui pendent captent les parasites ; au besoin, place 100 nF entre DO et GND.
• Utilise deux capteurs : À un endroit important, exiger que deux capteurs se déclenchent ensemble en peu de temps réduit fortement les fausses alarmes.
• Confirme avec un autre capteur : Associer la vibration à un détecteur de mouvement PIR ou à un capteur de porte augmente la fiabilité.

Un détecteur de séisme avec le SW-420 ? Limites et MPU6050

Le détecteur de séisme est l'une des idées de projet les plus populaires avec un capteur de vibration, et c'est un projet instructif ; mais il faut en connaître les limites. Le SW-420 dit seulement « quelque chose a bougé » : il ne mesure ni l'accélération, ni la direction, ni la fréquence de la secousse. Il réagit donc de la même façon à une porte qui claque, à un camion qui passe, à un lave-linge en essorage ou à un vrai séisme. Surtout, un capteur isolé ne détecte la secousse qu'une fois qu'elle l'a atteint. Les systèmes officiels d'alerte sismique précoce combinent les mesures de nombreuses stations proches de l'épicentre et préviennent les zones éloignées avant l'arrivée des secousses ; un Arduino à la maison ne peut pas les remplacer et ne doit pas servir de dispositif de sécurité vitale.

Pour donner plus de sens à un projet sismique, passe au module accéléromètre et gyroscope MPU6050. Le MPU6050 mesure l'accélération sur trois axes avec une résolution de 16 bits et des plages réglables de ±2 g à ±16 g. Tu peux ainsi calculer l'accélération maximale du sol (PGA), distinguer une porte qui claque d'un mouvement du sol prolongé en regardant la durée de l'accélération et sa fréquence, et enregistrer les données pour les étudier ensuite. Combiner les deux capteurs est aussi logique : le SW-420 attend en consommant très peu et réveille le microcontrôleur à la première vibration, puis le MPU6050 fait la mesure détaillée.

Notification Telegram depuis un ESP32 en cas de vibration

Avec un ESP32, le capteur de vibration peut prévenir ton téléphone quand il arrive quelque chose à un coffre-fort, un vélo ou une machine pendant ton absence. Pour cela, crée un bot avec BotFather dans Telegram, récupère le jeton et ton propre chat ID, puis installe dans l'IDE Arduino les bibliothèques UniversalTelegramBot et ArduinoJson ; nous détaillons ces étapes dans le guide bot Telegram avec ESP32. Le code ci-dessous compte les impulsions par interruption, envoie un message dès qu'il voit au moins 5 impulsions en 1 seconde et attend au moins 60 secondes entre deux messages pour que ton téléphone ne soit pas inondé de notifications. Comme l'ESP32 a deux cœurs, le compteur est protégé par un verrou portMUX.

1#include <WiFi.h>
2#include <WiFiClientSecure.h>
3#include <UniversalTelegramBot.h>
4#include <ArduinoJson.h>
5
6const char* WIFI_SSID = "AgAdi";               // Wi-Fi adın (2,4 GHz) / your Wi-Fi name (2.4 GHz)
7const char* WIFI_PASS = "Sifre123";            // Wi-Fi şifren / your Wi-Fi password
8#define BOT_TOKEN "1234567890:AAExxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"   // BotFather'ın verdiği token / token from BotFather
9#define CHAT_ID   "123456789"                  // kendi Telegram ID'n / your own Telegram ID
10
11const int VIB_PIN = 27;                        // SW-420 DO (modül 3V3 ile) / module powered from 3V3
12const unsigned long MIN_PULSES = 5;            // 1 sn'de gereken darbe / pulses needed in 1 s
13const unsigned long WINDOW_MS = 1000;
14const unsigned long COOLDOWN_MS = 60000;       // iki mesaj arası en az 60 sn / at least 60 s between messages
15
16volatile unsigned long pulseCount = 0;
17portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;
18unsigned long windowStart = 0;
19unsigned long lastAlert = 0;
20bool alertSent = false;
21
22WiFiClientSecure client;
23UniversalTelegramBot bot(BOT_TOKEN, client);
24
25void IRAM_ATTR onVibration() {                 // kesme fonksiyonu RAM'de / interrupt handler in RAM
26  portENTER_CRITICAL_ISR(&mux);
27  pulseCount++;
28  portEXIT_CRITICAL_ISR(&mux);
29}
30
31void setup() {
32  Serial.begin(115200);
33  pinMode(VIB_PIN, INPUT);
34  attachInterrupt(digitalPinToInterrupt(VIB_PIN), onVibration, RISING);
35
36  WiFi.mode(WIFI_STA);
37  WiFi.begin(WIFI_SSID, WIFI_PASS);
38  while (WiFi.status() != WL_CONNECTED) {
39    delay(500);
40    Serial.print(".");
41  }
42  Serial.println();
43  client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // api.telegram.org kök sertifikası / root certificate
44  bot.sendMessage(CHAT_ID, "Titreşim alarmı hazır / vibration alarm ready", "");
45  windowStart = millis();
46}
47
48void loop() {
49  if (millis() - windowStart < WINDOW_MS) return;
50  windowStart = millis();
51
52  portENTER_CRITICAL(&mux);                    // sayacı güvenle oku ve sıfırla / read and reset safely
53  unsigned long n = pulseCount;
54  pulseCount = 0;
55  portEXIT_CRITICAL(&mux);
56
57  if (n >= MIN_PULSES && (!alertSent || millis() - lastAlert >= COOLDOWN_MS)) {
58    lastAlert = millis();
59    alertSent = true;
60    String msg = "Titreşim algılandı / vibration detected: " + String(n) + " darbe / pulses";
61    Serial.println(msg);
62    if (!bot.sendMessage(CHAT_ID, msg, "")) {
63      Serial.println("Mesaj gonderilemedi / message failed");
64    }
65  }
66}

Envoyer un message sur Telegram peut prendre 1 à 2 secondes ; la boucle attend pendant ce temps, mais l'interruption continue de tourner, donc les impulsions qui arrivent s'accumulent dans le compteur et ne sont pas perdues. Pour un fonctionnement sur piles, mets l'ESP32 en sommeil profond et fais de la broche DO du SW-420 une source de réveil avec esp_sleep_enable_ext0_wakeup() ; l'ESP32 ne se réveille alors qu'en cas de vibration, envoie le message et se rendort. Dans ce cas, choisis comme broche de réveil un GPIO RTC ; le GPIO 27 en fait partie.

SW-420 avec le Raspberry Pi Pico (MicroPython)

Sur la Pico, alimente le module par la broche 3V3(OUT) et relie DO à GP15. Le code ci-dessous reprend la logique d'événements de la version Arduino : il compte les impulsions par interruption, allume la LED intégrée à la première impulsion et, après 500 ms de silence, affiche la durée et le nombre d'impulsions de l'événement. Le nom Pin("LED") sélectionne la LED intégrée aussi bien sur la Pico que sur la Pico W.

1from machine import Pin, disable_irq, enable_irq
2import time
3
4vib = Pin(15, Pin.IN)                  # SW-420 DO (modül 3V3 ile) / module powered from 3V3
5led = Pin("LED", Pin.OUT)              # dahili LED / onboard LED
6QUIET_MS = 500                         # olayı bitiren sessizlik / silence that ends an event
7
8pulses = 0
9def on_vibration(pin):
10    global pulses
11    pulses += 1
12
13vib.irq(trigger=Pin.IRQ_RISING, handler=on_vibration)
14
15event_start = None
16event_pulses = 0
17last_pulse = 0
18while True:
19    state = disable_irq()              # sayacı güvenle oku / read the counter safely
20    n = pulses
21    pulses = 0
22    enable_irq(state)
23
24    now = time.ticks_ms()
25    if n:
26        if event_start is None:        # yeni olay / new event
27            event_start = now
28            event_pulses = 0
29            led.on()
30        event_pulses += n
31        last_pulse = now
32    elif event_start is not None and time.ticks_diff(now, last_pulse) > QUIET_MS:
33        duration = time.ticks_diff(last_pulse, event_start)
34        print("Titresim / vibration: %d ms, %d darbe / pulses" % (duration, event_pulses))
35        event_start = None
36        led.off()
37    time.sleep_ms(20)

Idées de projets avec un capteur de vibration

• Alarme de vélo et de moto : Un petit boîtier qui sonne quand le véhicule garé est secoué et prévient ton téléphone via un ESP32.
• Alerte de fin de lessive : Un capteur qui envoie « lessive terminée » quand la vibration s'est arrêtée depuis 5 minutes.
• Détecteur de frappe secrète : Une serrure qui s'ouvre quand on frappe selon un certain rythme ; on compare pour cela les temps entre les événements.
• Compteur d'heures de fonctionnement : Un compteur qui enregistre combien d'heures par jour tourne un compresseur, une pompe ou une imprimante 3D.
• Coffre-fort électronique : Une protection qui déclenche l'alarme si on force le coffre, en complément d'une serrure à code ; associe-la au guide serrure à code avec clavier.
• Jeu et table interactive : Un tambour ou un jeu de réflexes qui produit lumière et son quand on frappe la table.

Erreurs fréquentes et solutions

Le SW-420 est le moyen le moins cher et le plus simple de savoir qu'une surface a été secouée ; sa vraie force apparaît quand tu captes et comptes les impulsions par interruption et lis les résultats avec la durée et la densité. Règle la sensibilité sur place, écarte les fausses alarmes par logiciel et passe au MPU6050 quand il te faut la force ou la direction de la secousse. Dans l'application BlueGrays, tu trouveras les projets Buzzer, Détecteur de mouvement et Système d'alarme ESP32 avec Telegram, ainsi que le Coffre-fort électronique intelligent, avec schémas et code pas à pas.