Sensor de vibração SW-420 com Arduino: detecção de impacto e alarme

Em projetos com sensor de vibração no Arduino, a peça mais usada é o módulo SW-420, barato e simples. Com um único pino digital, ele avisa que uma superfície foi sacudida, que alguém bateu em uma porta, que uma gaveta foi aberta ou que uma máquina começou a funcionar. O módulo traz uma chave de vibração com mola, um chip comparador LM393 e um pequeno potenciômetro que ajusta a sensibilidade. É fácil de usar, mas na primeira tentativa a maioria das pessoas esbarra nos mesmos dois problemas: o sensor deixa passar algumas vibrações e às vezes dispara o alarme sem motivo nenhum.

Neste guia você vai aprender como funciona o contato de mola dentro do SW-420, por que a saída chega em pulsos curtos e como ajustar a sensibilidade corretamente. Depois vamos contar os pulsos com uma interrupção, medir quanto tempo dura e quão forte é um impacto e montar um alarme antifurto que reduz os alarmes falsos. Também vamos falar sobre por que a ideia do alarme de terremoto não é tão simples quanto parece e o que um acelerômetro MPU6050 acrescenta a essa tarefa. Por fim, vamos enviar uma mensagem do Telegram para o seu celular com um ESP32 quando houver vibração e escrever o código em MicroPython para o Raspberry Pi Pico.

O que é o sensor de vibração SW-420 e como ele funciona?

O verdadeiro elemento sensor do módulo é uma chave de vibração normalmente fechada (NF) dentro de um pequeno invólucro metálico cilíndrico. Dentro dele há uma mola e uma peça condutora; com o sensor parado, as duas se tocam e o contato fica fechado. Quando o sensor é sacudido, a mola oscila e o contato abre e fecha em rajadas muito curtas, cada uma durando menos de um milissegundo. A chave em si não tem direção, então reage à vibração vinda de qualquer lado. O LM393 do módulo compara a tensão produzida por essa chave com um limiar definido pelo potenciômetro e gera uma saída digital limpa (DO). Na maioria dos módulos, DO fica em LOW com o sensor parado e em HIGH durante a vibração, e o LED de sinal da placa apaga ou pisca junto com a vibração; em algumas placas clones a lógica pode ser invertida, então teste primeiro o seu módulo com o Monitor Serial.

Ligação do SW-420 no Arduino

Sensibilidade: como ajustar o potenciômetro?

O potenciômetro define o limiar do comparador. Se estiver sensível demais, o sensor capta um copo sendo colocado na mesa, um caminhão passando ou até a vibração do próprio buzzer; se estiver grosseiro demais, só reage a uma batida forte. Para acertar o ajuste, parafuse o módulo na superfície onde ele será usado e observe o LED de sinal da placa. Gire o potenciômetro até o ponto em que o LED fica estável em repouso, mas reage quando você bate de leve na superfície com o dedo; depois reduza um pouquinho a sensibilidade para deixar uma margem de segurança. Esse ajuste depende do material da superfície: o mesmo ajuste pode ser muito sensível em uma mesa de madeira e surdo em uma parede de concreto.

Primeiro teste: detectar vibração e capturar pulsos curtos

O primeiro código de quem está começando costuma ler o pino com digitalRead() no loop() e acender um LED quando vê HIGH. Isso funciona com uma batida forte, mas com vibrações leves quase sempre nada acontece, porque a saída do SW-420 pode ficar em HIGH por apenas algumas centenas de microssegundos e, se o loop() estiver ocupado com Serial.print() ou delay() nesse momento, o pulso se perde. A solução é capturar o pulso com uma interrupção e anotar o tempo até o próximo. O código abaixo registra o instante de cada pulso e mantém o LED aceso por 1 segundo depois do último pulso, para que seu olho consiga ver até uma vibração muito breve.

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}

A interrupção é executada a cada borda em que o pino passa de LOW para HIGH; no Uno, só D2 e D3 oferecem esse tipo de interrupção externa. Se a lógica do seu módulo for invertida, escreva FALLING em vez de RISING; como as rajadas de pulsos têm bordas de subida e de descida, a contagem não muda. A função de interrupção é mantida o mais curta possível e não usa Serial; a impressão é feita no loop(). Desativar as interrupções por um instante enquanto as variáveis são lidas no loop() impede que uma variável de vários bytes mude no meio da leitura e seja lida corrompida.

Contagem de pulsos e duração: quanto tempo durou e quão forte foi o impacto?

O SW-420 não mede aceleração, mas o número de pulsos que ele gera dá uma boa ideia da força de um impacto: uma batidinha leve produz poucos pulsos, uma porta batendo dezenas e a vibração de uma furadeira centenas por segundo. O código abaixo conta os pulsos com uma interrupção e os agrupa em eventos: o primeiro pulso inicia um evento e, se nenhum pulso novo chegar em 500 ms, o evento termina. Ao fim de cada evento, ele imprime a duração, o total de pulsos e a densidade de pulsos por segundo. Assim você consegue montar uma “impressão digital” dos eventos do seu próprio ambiente e basear o limite do alarme em medição, não em chute.

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}

Rode o código e depois bata na mesa de jeitos diferentes, abra uma gaveta, feche a porta e anote os números que aparecem. Em uma única batida curta, a duração costuma ficar perto de zero e a contagem de pulsos tem um dígito só; uma vibração longa faz crescer tanto a duração quanto a contagem de pulsos. Usar esses dois valores juntos é muito mais eficaz do que um simples “vibrou ou não vibrou”: por exemplo, em um sensor instalado em um cofre, uma regra como “evento com pelo menos 300 ms de duração e pelo menos 20 pulsos” consegue filtrar os passos de alguém passando ao lado e ainda pegar quem estiver forçando o cofre.

Alarme antifurto com o SW-420 e como reduzir alarmes falsos

Um SW-420 instalado em um vidro de janela, em uma bicicleta, em uma gaveta ou em um cofre pode ser o coração de um alarme antifurto simples. O que separa um alarme bom de um ruim tem menos a ver com a detecção e mais com a forma como ele filtra os alarmes falsos. O código abaixo faz isso em três camadas: depois de armado, dá 10 segundos de tempo de saída; dispara não com uma única batida, mas quando vê pelo menos 5 pulsos em 1 segundo; e ignora pulsos novos durante os 15 segundos em que a sirene toca. O alarme é armado e desarmado pelo botão em D4, o buzzer ativo fica em D8 e o LED de status em D13. Para um sistema mais completo, veja o guia Sistema de alarme com 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}

Há muita coisa que você pode fazer além do código para reduzir alarmes falsos:

• Fixação firme: prenda o módulo na superfície com um parafuso M3 ou um adesivo rígido; uma placa solta, balançando, vibra sozinha.
• Afaste o buzzer: se a sirene estiver montada na mesma placa ou na mesma caixa do sensor, a própria vibração dela pode disparar o alarme de novo.
• Ajuste a sensibilidade no local: regule o potenciômetro na superfície onde o sensor vai ficar de vez, não na sua bancada.
• Cabos curtos e fixos: cabos longos balançando no ar captam ruído; se precisar, coloque 100 nF entre DO e GND.
• Use dois sensores: em um ponto importante, exigir que dois sensores disparem juntos em pouco tempo reduz muito os alarmes falsos.
• Confirme com outro sensor: combinar a vibração com um sensor de movimento PIR ou um sensor de porta aumenta a confiabilidade.

Dá para fazer um alarme de terremoto com o SW-420? Limites e o MPU6050

O alarme de terremoto é uma das ideias de projeto mais populares com sensor de vibração, e é um projeto didático; mas é importante conhecer os limites dele. O SW-420 só diz “algo sacudiu”: ele não consegue medir a aceleração, a direção nem a frequência do tremor. Por isso, reage do mesmo jeito a uma porta batendo, a um caminhão passando, a uma máquina de lavar centrifugando ou a um terremoto de verdade. Mais importante ainda: um único sensor só detecta o tremor quando o tremor já chegou até onde ele está. Os sistemas oficiais de alerta antecipado de terremotos combinam medições de muitas estações próximas ao epicentro e levam o alerta a regiões distantes antes de o tremor chegar; um Arduino em casa não substitui isso e não deve ser usado como dispositivo de segurança de vida.

Se quiser dar mais sentido a um projeto de terremoto, passe para o módulo acelerômetro e giroscópio MPU6050. O MPU6050 mede a aceleração em três eixos com resolução de 16 bits e faixas selecionáveis de ±2 g a ±16 g. Com isso você pode calcular a aceleração de pico do solo (PGA) de um tremor, diferenciar uma porta batendo de um movimento longo do solo olhando por quantos segundos a aceleração dura e qual é a frequência dela, e registrar os dados para analisar depois. Usar os dois sensores juntos também faz sentido: o SW-420 fica esperando com pouquíssimo consumo e acorda o microcontrolador na primeira vibração, enquanto o MPU6050 faz a medição detalhada.

Notificação no Telegram pelo ESP32 quando houver vibração

Com um ESP32, o sensor de vibração pode avisar o seu celular quando algo acontecer com um cofre, uma bicicleta ou uma máquina enquanto você está fora de casa. Para isso, você precisa criar um bot com o BotFather no Telegram, obter o token e o seu chat ID e instalar as bibliotecas UniversalTelegramBot e ArduinoJson no Arduino IDE; explicamos esses passos em detalhes no guia Bot do Telegram com ESP32. O código abaixo conta os pulsos com uma interrupção, envia uma mensagem quando vê pelo menos 5 pulsos em 1 segundo e espera pelo menos 60 segundos entre duas mensagens, para que o seu celular não se encha de dezenas de notificações por minuto. Como o ESP32 tem dois núcleos, o contador é protegido com uma trava 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}

Enviar uma mensagem ao Telegram pode levar 1–2 segundos; o loop fica esperando nesse tempo, mas como a interrupção continua funcionando, os pulsos que chegam se acumulam no contador e não se perdem. Se quiser rodar o sensor com bateria, coloque o ESP32 em deep sleep e transforme o pino DO do SW-420 em fonte de despertar com esp_sleep_enable_ext0_wakeup(); assim o ESP32 só acorda com vibração, envia a mensagem e volta a dormir. Nesse caso, escolha um dos GPIOs RTC como pino de despertar; o GPIO 27 faz parte desse grupo.

SW-420 com o Raspberry Pi Pico (MicroPython)

No Pico, alimente o módulo pelo pino 3V3(OUT) e ligue o DO ao GP15. O código abaixo usa a mesma lógica de eventos da versão para Arduino: conta os pulsos com uma interrupção, acende o LED integrado da placa no primeiro pulso e, depois de 500 ms de silêncio, imprime a duração do evento e a contagem de pulsos. O nome Pin("LED") seleciona o LED integrado tanto no Pico quanto no 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)

Ideias de projetos com sensor de vibração

• Alarme para bicicleta e moto: uma caixinha que apita quando o veículo estacionado é sacudido e avisa o seu celular via ESP32.
• Aviso de máquina de lavar pronta: um sensor que envia a mensagem “lavagem concluída” quando a vibração para por 5 minutos.
• Detector de batida secreta: uma fechadura que abre quando alguém bate em um certo ritmo; funciona comparando os intervalos entre os eventos de impacto.
• Contador de horas de máquina: um contador que registra quantas horas por dia um compressor, uma bomba ou uma impressora 3D funciona.
• Cofre eletrônico: uma proteção que dispara o alarme quando o cofre é forçado, funcionando junto com uma fechadura com senha; combine com o guia fechadura com senha usando teclado matricial.
• Jogo e mesa interativa: uma bateria ou um jogo de reflexo que acende luzes e faz som quando você bate na mesa.

Erros comuns e como resolvê-los

O SW-420 é o jeito mais barato e fácil de saber que uma superfície foi sacudida; a força dele aparece quando você captura e conta os pulsos com uma interrupção e interpreta os resultados junto com a duração e a densidade. Ajuste a sensibilidade no local, filtre os alarmes falsos no software e passe para o MPU6050 quando precisar da força ou da direção do tremor. No app BlueGrays você encontra os projetos Uso do buzzer, Detector de movimento e Sistema de alarme de movimento com ESP32 e Telegram, junto com o Cofre eletrônico inteligente, com esquemas do circuito e códigos passo a passo.