Sensore di vibrazione SW-420 con Arduino: urti, allarme, avvisi

Nei progetti con un sensore di vibrazione e Arduino il componente più usato è il modulo SW-420, economico e semplice. Con un solo pin digitale ti dice che una superficie è stata scossa, che qualcuno ha bussato a una porta, che un cassetto è stato aperto o che una macchina si è messa in moto. Sul modulo ci sono un interruttore di vibrazione a molla, un comparatore LM393 e un piccolo trimmer per la sensibilità. È facile da usare, ma al primo tentativo quasi tutti incontrano gli stessi due problemi: il sensore perde alcune vibrazioni e a volte fa scattare l'allarme senza motivo.

In questa guida scoprirai come funziona il contatto a molla dell'SW-420, perché la sua uscita arriva sotto forma di brevi impulsi e come regolare bene la sensibilità. Poi conteremo gli impulsi con un interrupt, misureremo quanto dura e quanto è forte una scossa e costruiremo un antifurto che riduce i falsi allarmi. Vedremo anche perché l'idea di un avvisatore di terremoti non è semplice come sembra e cosa aggiunge un accelerometro MPU6050. Infine, con un ESP32 invieremo un messaggio Telegram al telefono quando viene rilevata una vibrazione e scriveremo codice MicroPython per il Raspberry Pi Pico.

Che cos'è il sensore di vibrazione SW-420 e come funziona?

Il vero elemento sensibile del modulo è un interruttore di vibrazione normalmente chiuso (NC) dentro un piccolo involucro metallico cilindrico. All'interno ci sono una molla e una parte conduttiva; quando il sensore è fermo si toccano e il contatto è chiuso. Quando il sensore viene scosso, la molla oscilla e il contatto si apre e si chiude a raffiche brevissime, ciascuna di meno di un millisecondo. L'interruttore è omnidirezionale, quindi reagisce alle vibrazioni da qualsiasi direzione. L'LM393 del modulo confronta la tensione generata dall'interruttore con una soglia impostata dal trimmer e produce un'uscita digitale pulita (DO). Nella maggior parte dei moduli DO è LOW a riposo e HIGH durante la vibrazione, e il LED di segnale si spegne o lampeggia con la vibrazione; su alcune schede clone la logica può essere invertita, quindi prova prima il tuo modulo con il monitor seriale.

Collegamento dell'SW-420 ad Arduino

Sensibilità: come si regola il trimmer?

Il trimmer fissa la soglia del comparatore. Se è troppo sensibile, il sensore rileva un bicchiere appoggiato sul tavolo, un camion che passa o persino la vibrazione del suo stesso buzzer; se è troppo grossolano, reagisce solo a un colpo forte. Per la regolazione giusta avvita il modulo alla superficie su cui lo userai e osserva il LED di segnale. Gira il trimmer fino al punto in cui il LED resta fermo a riposo ma reagisce quando batti leggermente la superficie con un dito; poi riduci di pochissimo la sensibilità per lasciare un margine di sicurezza. La regolazione dipende dal materiale: la stessa può essere molto sensibile su un tavolo di legno e sorda su un muro di cemento.

Primo test: rilevare la vibrazione e catturare gli impulsi brevi

Il primo codice di un principiante di solito legge il pin con digitalRead() in loop() e accende un LED quando vede HIGH. Funziona con un colpo forte, ma con vibrazioni leggere spesso non succede nulla, perché l'uscita dell'SW-420 può restare HIGH solo qualche centinaio di microsecondi e, se in quel momento loop() è occupato con Serial.print() o delay(), l'impulso va perso. La soluzione è catturare l'impulso con un interrupt e annotarne l'istante. Il codice qui sotto registra l'ora di ogni impulso e tiene acceso il LED per 1 secondo dopo l'ultimo, così l'occhio vede anche una vibrazione brevissima.

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'interrupt viene eseguito a ogni fronte in cui il pin passa da LOW a HIGH; sull'Uno solo D2 e D3 offrono questo tipo di interrupt esterno. Se la logica del tuo modulo è invertita, scrivi FALLING al posto di RISING; dato che le raffiche hanno fronti di salita e di discesa, il conteggio non cambia. La funzione di interrupt è la più breve possibile e non usa Serial; la stampa avviene in loop(). Disattivare per un attimo gli interrupt mentre si leggono le variabili in loop() evita che una variabile di più byte cambi a metà lettura e venga letta male.

Contare gli impulsi e misurare la durata: quanto è durata e quanto era forte la scossa?

L'SW-420 non misura l'accelerazione, ma il numero di impulsi che genera dà un'idea precisa della forza di una scossa: un colpetto produce pochi impulsi, una porta sbattuta decine e la vibrazione di un trapano centinaia al secondo. Il codice qui sotto conta gli impulsi con un interrupt e li raggruppa in eventi: il primo impulso apre un evento e, se per 500 ms non ne arrivano altri, l'evento si chiude. Alla fine di ogni evento scrive la durata, il numero totale di impulsi e la loro densità al secondo. Così puoi ricavare l'«impronta» degli eventi nel tuo ambiente e basare la soglia d'allarme su misure invece che su supposizioni.

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}

Avvia il codice, batti sul tavolo in modi diversi, apri un cassetto, chiudi la porta e annota i numeri. Con un singolo colpetto la durata è spesso vicina a zero e gli impulsi sono a una cifra; una vibrazione lunga fa crescere sia la durata sia il numero di impulsi. Usare i due valori insieme è molto più efficace di un semplice «vibrazione sì o no»: per esempio, su un sensore montato in una cassaforte, la regola «evento di almeno 300 ms con almeno 20 impulsi» può scartare i passi di chi passa accanto e riconoscere comunque chi sta forzando la cassaforte.

Antifurto con l'SW-420 e come ridurre i falsi allarmi

Un SW-420 montato sul vetro di una finestra, su una bici, in un cassetto o in una cassaforte può essere il cuore di un semplice antifurto. Ciò che distingue un buon allarme da uno cattivo non è tanto il rilevamento, quanto il modo in cui scarta i falsi allarmi. Il codice qui sotto lo fa su tre livelli: dopo l'inserimento concede 10 secondi per uscire, non scatta con un solo colpo ma quando vede almeno 5 impulsi in 1 secondo e ignora i nuovi impulsi per i 15 secondi in cui suona la sirena. L'allarme si inserisce e disinserisce con il pulsante su D4, il buzzer attivo è su D8 e il LED di stato su D13. Per un sistema più completo guarda la guida al sistema d'allarme con 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}

Oltre al codice, puoi fare molto per ridurre i falsi allarmi:

• Montaggio solido: Fissa il modulo con una vite M3 o una colla rigida; una scheda che balla vibra da sola.
• Allontana il buzzer: Se la sirena è montata sulla stessa scheda o nella stessa scatola del sensore, la sua vibrazione può far ripartire l'allarme.
• Regola la sensibilità sul posto: Imposta il trimmer sulla superficie definitiva del sensore, non sulla scrivania.
• Cavi corti e fissati: I cavi lunghi che penzolano raccolgono disturbi; se serve, metti 100 nF tra DO e GND.
• Usa due sensori: In un punto importante, richiedere che due sensori scattino insieme in poco tempo riduce molto i falsi allarmi.
• Conferma con un altro sensore: Abbinare la vibrazione a un sensore di movimento PIR o a un sensore porta aumenta l'affidabilità.

Si può fare un allarme sismico con l'SW-420? Limiti e MPU6050

L'allarme sismico è una delle idee di progetto più popolari con un sensore di vibrazione ed è un progetto istruttivo; ma è importante conoscerne i limiti. L'SW-420 dice soltanto «qualcosa si è mosso»: non misura accelerazione, direzione né frequenza della scossa. Per questo reagisce allo stesso modo a una porta sbattuta, a un camion che passa, a una lavatrice in centrifuga o a un vero terremoto. Soprattutto, un singolo sensore rileva la scossa solo quando questa è già arrivata fin lì. I sistemi ufficiali di allerta sismica precoce combinano le misure di molte stazioni vicine all'epicentro e avvisano le zone lontane prima che arrivi la scossa; un Arduino in casa non può sostituirli e non va usato come dispositivo salvavita.

Se vuoi rendere più sensato un progetto sismico, passa al modulo accelerometro e giroscopio MPU6050. L'MPU6050 misura l'accelerazione su tre assi con 16 bit di risoluzione e intervalli selezionabili da ±2 g a ±16 g. Così puoi calcolare l'accelerazione di picco del suolo (PGA), distinguere una porta sbattuta da un movimento del suolo prolungato guardando quanti secondi dura l'accelerazione e la sua frequenza, e registrare i dati per studiarli dopo. Ha senso anche usare i due sensori insieme: l'SW-420 aspetta consumando pochissimo e sveglia il microcontrollore alla prima vibrazione, poi l'MPU6050 fa la misura dettagliata.

Notifica Telegram da un ESP32 quando viene rilevata una vibrazione

Con un ESP32 il sensore di vibrazione può avvisare il telefono quando succede qualcosa a una cassaforte, a una bici o a una macchina mentre sei fuori casa. Per farlo crea un bot con BotFather su Telegram, ottieni il token e il tuo chat ID e installa nell'Arduino IDE le librerie UniversalTelegramBot e ArduinoJson; spieghiamo questi passaggi nella guida al bot Telegram con ESP32. Il codice qui sotto conta gli impulsi con un interrupt, invia un messaggio quando vede almeno 5 impulsi in 1 secondo e aspetta almeno 60 secondi tra due messaggi perché il telefono non si riempia di decine di notifiche al minuto. Poiché l'ESP32 ha due core, il contatore è protetto da un blocco 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}

Inviare un messaggio a Telegram può richiedere 1–2 secondi; nel frattempo il loop aspetta, ma l'interrupt continua a funzionare, quindi gli impulsi in arrivo si accumulano nel contatore e non vanno persi. Se vuoi alimentare il sensore a batteria, metti l'ESP32 in deep sleep e rendi il pin DO dell'SW-420 una sorgente di risveglio con esp_sleep_enable_ext0_wakeup(); l'ESP32 si sveglia solo alla vibrazione, invia il messaggio e torna a dormire. In questo caso scegli come pin di risveglio uno dei GPIO RTC; il GPIO 27 fa parte di questo gruppo.

SW-420 con il Raspberry Pi Pico (MicroPython)

Sul Pico alimenta il modulo dal pin 3V3(OUT) e collega DO a GP15. Il codice qui sotto usa la stessa logica a eventi della versione Arduino: conta gli impulsi con un interrupt, accende il LED integrato al primo impulso e, dopo 500 ms di silenzio, scrive durata e numero di impulsi dell'evento. Il nome Pin("LED") seleziona il LED integrato sia sul Pico sia sul 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)

Idee di progetti con un sensore di vibrazione

• Allarme per bici e moto: Una scatolina che suona quando il veicolo parcheggiato viene scosso e avvisa il telefono tramite ESP32.
• Avviso di lavatrice finita: Un sensore che invia «lavaggio finito» quando la vibrazione si è fermata da 5 minuti.
• Rilevatore di bussata segreta: Una serratura che si apre quando si bussa con un certo ritmo; si realizza confrontando i tempi tra gli eventi.
• Contaore di funzionamento: Un contatore che registra quante ore al giorno lavora un compressore, una pompa o una stampante 3D.
• Cassaforte elettronica: Una protezione che fa scattare l'allarme se la cassaforte viene forzata, insieme a una serratura a codice; abbinala alla guida serratura a codice con tastierino.
• Gioco e tavolo interattivo: Un tamburo o un gioco di riflessi che produce luce e suono quando si colpisce il tavolo.

Errori comuni e come risolverli

L'SW-420 è il modo più economico e semplice per sapere che una superficie è stata scossa; la sua vera forza emerge quando catturi e conti gli impulsi con un interrupt e leggi i risultati insieme a durata e densità. Regola la sensibilità sul posto, filtra i falsi allarmi via software e passa all'MPU6050 quando ti servono forza o direzione della scossa. Nell'app BlueGrays trovi i progetti Uso del buzzer, Rilevatore di movimento e Sistema d'allarme ESP32 con Telegram, insieme alla Cassaforte elettronica intelligente, con schemi e codice passo dopo passo.