Alarme de aproximação com Arduino

O que o aluno constrói

Um alarme de aproximação: o sensor mede a distância o tempo todo e dispara quando alguém chega perto. A intensidade muda conforme a proximidade — igual ao sensor de ré do carro. Serve como alarme de porta, guardião da mesa ou sistema de segurança de uma maquete.

O que vem no projeto

• Código-base comentado em português — linha por linha, feito para quem nunca programou
• Guia do zero absoluto — instalar o programa, reconhecer a placa, resolver o driver, fazer o primeiro teste
• Mapa de ligação pino a pino, com foto de cada peça
• Plano de aula de 50 minutos, com as perguntas que conduzem a investigação
• Adaptação para Fundamental I e para Fundamental II / Médio
• Amarração com a BNCC (Competências Gerais, Matemática, Ciências e Computação)
• Tabela de erros comuns — sintoma, causa e solução
• 5 variações para o projeto render mais de uma aula

Lista de peças

• Arduino Uno (ou Nano)
• Sensor ultrassônico HC-SR04
• Buzzer
• Jumpers macho-fêmea
• Cabo USB

Se você já tem um kit iniciante de Arduino, provavelmente tem tudo. Não precisa de protoboard nem de solda.

Passo a passo da montagem

Faça sempre com o cabo USB desconectado. Conecte só no final.

1. Ligue o sensor HC-SR04 (4 fios)

Os nomes estão impressos na plaquinha: Vcc → 5V · Trig → pino 9 · Echo → pino 10 · Gnd → GND.

2. Ligue o buzzer (2 fios)

Um fio (o +, se houver marcação) no pino 8; o outro em qualquer GND. O Uno tem três pinos GND — um pra cada peça, sem aperto.

3. Carregue o código

Conecte o USB, abra a Arduino IDE, confira Ferramentas → Placa → Arduino Uno e a porta COM, e clique na seta de Carregar. Não precisa instalar biblioteca nenhuma.

4. Teste

Abra o Monitor Serial (9600) e aproxime a mão do sensor: a distância aparece na tela, os bipes aceleram e, bem perto, o som fica contínuo.

Atenção ao erro clássico: nunca use os pinos 0 e 1 — são da comunicação USB. Se o sensor não responder, confira se Trig/Echo não foram trocados.

A matemática que aparece sozinha

O sensor manda um som agudo demais para o ouvido humano, mede quanto tempo ele leva para bater e voltar, e converte isso em distância — o mesmo princípio do morcego e do golfinho.

Quando o aluno vê o número da distância mudando na tela junto com o ritmo do bipe, a proporcionalidade inversa deixa de ser conteúdo de quadro e vira uma coisa que ele acabou de provocar com a própria mão.

Para quem é

Professor de Ciências, Matemática, Robótica ou de projeto integrador do Fundamental II e Ensino Médio — com adaptação pronta para o Fundamental I. Não precisa saber programar. O caminho foi montado e testado do zero absoluto.

O código-base (copie e cole)

Abra a Arduino IDE, cole este código, escolha Ferramentas → Placa → Arduino Uno e a porta COM. Depois clique na seta de Carregar. Não precisa instalar biblioteca nenhuma.

Está todo comentado em português — inclusive explicando o que mexer para adaptar à sua sala.

/*
  ALARME DE APROXIMAÇÃO — sensor ultrassônico HC-SR04
  luisfilipegdc.com.br

  O alarme fica MAIS INTENSO conforme a pessoa se aproxima:
    - longe  -> bipes lentos e mais graves
    - perto  -> bipes rápidos e mais agudos
    - muito perto -> som contínuo

  ---------------------------------------------------------------------------
  LIGAÇÃO
    Sensor HC-SR04:  Vcc -> 5V | Trig -> pino 9 | Echo -> pino 10 | Gnd -> GND
    Alarme:          um fio -> pino 8 | outro fio -> GND
  ---------------------------------------------------------------------------

  SOBRE O VOLUME (leia, é importante):
  O Arduino não consegue "abaixar o volume" do buzzer — o comando tone() sempre
  manda na força máxima. O que muda o volume DE VERDADE é a FREQUÊNCIA: todo
  buzzer tem uma frequência em que ele grita (chamada de ressonância), quase
  sempre entre 2000 e 3000 Hz.

  Por isso este código trabalha nessa faixa — e não nos 880 Hz de antes.

  QUER ACHAR A FREQUÊNCIA MAIS ALTA DO SEU BUZZER?
  Troque a linha abaixo para 1, carregue, ouça qual trecho fica mais alto,
  e depois ajuste FREQ_PERTO. Depois volte para 0.
*/
#define TESTE_DE_VOLUME 0

const int PINO_TRIG   = 9;
const int PINO_ECHO   = 10;
const int PINO_ALARME = 8;
const int PINO_LED    = 13;

// ---- ajustes principais ----
const int LIMITE_CM   = 60;   // a partir de quantos cm começa a avisar
const int MUITO_PERTO = 10;   // abaixo disso, som contínuo (invasão!)

// Faixa de ressonância: mais alto do que tons graves. Ajuste se quiser.
const int FREQ_LONGE = 1800;  // Hz quando está no limite
const int FREQ_PERTO = 2800;  // Hz quando está bem perto (mais estridente)

// Ritmo dos bipes (milissegundos entre eles)
const int RITMO_LENTO  = 500;  // longe
const int RITMO_RAPIDO = 60;   // perto

const unsigned long LIMITE_ECHO = 30000UL;
const long MUITO_LONGE = 999;

// controle do bipe sem travar o programa
unsigned long marcaBipe = 0;
bool somLigado = false;
bool avisou = false;

void setup() {
  pinMode(PINO_TRIG, OUTPUT);
  pinMode(PINO_ECHO, INPUT);
  pinMode(PINO_ALARME, OUTPUT);
  pinMode(PINO_LED, OUTPUT);

  Serial.begin(9600);
  Serial.println();
  Serial.println("=== ALARME DE APROXIMACAO ===");

#if TESTE_DE_VOLUME
  Serial.println("TESTE DE VOLUME: ouca qual frequencia fica MAIS ALTA.");
  for (int f = 500; f <= 4000; f += 250) {
    Serial.print("tocando ");
    Serial.print(f);
    Serial.println(" Hz");
    tone(PINO_ALARME, f);
    delay(700);
  }
  noTone(PINO_ALARME);
  Serial.println("Fim do teste. Anote a mais alta e ajuste FREQ_PERTO.");
  delay(1000);
#endif

  Serial.print("Avisa a partir de ");
  Serial.print(LIMITE_CM);
  Serial.println(" cm. Aproxime a mao.");
  Serial.println();
}

/* Mede a distância em cm. MUITO_LONGE se não voltar eco. */
long medirDistancia() {
  digitalWrite(PINO_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PINO_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PINO_TRIG, LOW);

  unsigned long duracao = pulseIn(PINO_ECHO, HIGH, LIMITE_ECHO);
  if (duracao == 0) return MUITO_LONGE;
  return (long)(duracao / 58);
}

void loop() {
  long distancia = medirDistancia();

  // ---------- longe: silêncio ----------
  if (distancia >= LIMITE_CM) {
    noTone(PINO_ALARME);
    digitalWrite(PINO_LED, LOW);
    somLigado = false;
    if (avisou) {
      Serial.println("... area livre");
      avisou = false;
    }
    delay(60);
    return;
  }

  if (!avisou) {
    Serial.println(">>> ALGUEM SE APROXIMANDO");
    avisou = true;
  }

  // quanto mais perto, mais agudo (mais alto) e mais rápido
  int freq   = map(distancia, MUITO_PERTO, LIMITE_CM, FREQ_PERTO, FREQ_LONGE);
  int ritmo  = map(distancia, MUITO_PERTO, LIMITE_CM, RITMO_RAPIDO, RITMO_LENTO);
  freq  = constrain(freq, FREQ_LONGE, FREQ_PERTO);
  ritmo = constrain(ritmo, RITMO_RAPIDO, RITMO_LENTO);

  Serial.print("distancia = ");
  Serial.print(distancia);
  Serial.print(" cm  |  ");

  // ---------- muito perto: som contínuo ----------
  if (distancia <= MUITO_PERTO) {
    Serial.println("INVASAO! (som continuo)");
    tone(PINO_ALARME, FREQ_PERTO);
    digitalWrite(PINO_LED, HIGH);
    delay(60);
    return;
  }

  // ---------- faixa de aviso: bipes no ritmo ----------
  Serial.print(freq);
  Serial.print(" Hz | bipe a cada ");
  Serial.print(ritmo);
  Serial.println(" ms");

  if (millis() - marcaBipe >= (unsigned long)ritmo) {
    marcaBipe = millis();
    somLigado = !somLigado;
    if (somLigado) {
      tone(PINO_ALARME, freq);
      digitalWrite(PINO_LED, HIGH);
    } else {
      noTone(PINO_ALARME);
      digitalWrite(PINO_LED, LOW);
    }
  }

  delay(30);
}

Os 4 ajustes que você vai querer mexer

• LIMITE_CM — a partir de quantos centímetros o alarme começa a avisar. Use 30 para uma gaveta, 100 para vigiar a porta da sala.
• MUITO_PERTO — abaixo dessa distância o som fica contínuo (a "invasão").
• FREQ_PERTO / FREQ_LONGE — as frequências do alarme. Entre 2000 e 3000 Hz é onde o buzzer soa mais alto.
• RITMO_RAPIDO / RITMO_LENTO — a velocidade dos bipes perto e longe.

Entendendo o código (sem ser programador)

Você não precisa entender tudo pra usar — mas entender estas quatro partes te deixa livre pra adaptar o projeto sozinho. É também a explicação que você dá pra turma.

1. Os pinos: onde cada peça está ligada

As primeiras linhas só dão nomes aos números dos pinos. PINO_TRIG = 9 quer dizer "o disparo do sensor está no pino 9". Trocou de pino na protoboard? Muda só esse número aqui e o resto do código continua funcionando.

2. Os ajustes: o que você vai mexer de verdade

LIMITE_CM, MUITO_PERTO, as frequências e o ritmo. São as "perguntas" que o projeto faz: a partir de quantos centímetros avisar? quando entrar em pânico? quão agudo? quão rápido? Mexer nesses quatro números cria um projeto diferente — e é o melhor exercício pra turma.

3. medirDistancia(): como o Arduino "enxerga"

Essa função manda um estalo de ultrassom, cronometra a volta e converte o tempo em centímetros. O / 58 é a conta pronta: o som anda ~343 m/s e a viagem é de ida e volta. Se nada volta (mão longe demais), ela devolve 999 — o código lê isso como "nada por perto".

4. loop(): a decisão, 30 vezes por segundo

O loop() é o coração: mede → decide → age, sem parar. A lógica é uma escada de três degraus:

• Longe do limite → silêncio total.
• Dentro do limite → o map() traduz a distância em frequência e em ritmo. É aqui que mora a matemática: quanto menor a distância, maior o som e mais rápido o bipe.
• Muito perto → som contínuo, sem pausa.

Repare que os bipes usam millis() em vez de delay(). A diferença importa: com delay() o Arduino congela e para de medir; com millis() ele continua vigiando enquanto o bipe acontece. É o truque que faz o alarme parecer "vivo".

Outras sugestões de uso

O mesmo circuito, trocando pouca coisa no código, vira outros projetos:

• Contador de visitas: em vez de alarme, conte quantas pessoas passaram e mostre o total. Vira dado pra aula de Estatística.
• Alarme silencioso: troque o som por LED — turma agitada ou sala vizinha em prova.
• Vaga de estacionamento: verde, amarelo e vermelho conforme a aproximação (Física + Educação no Trânsito).
• Régua digital: mede objetos e compara com a régua de verdade — rende uma discussão ótima sobre erro de medição.
• Guardião da mesa: instale na gaveta do material e deixe a turma decidir a regra de uso.

Próximos passos

Montou o alarme? Então você acabou de aplicar o Método GAME inteiro: o Gancho (a sirene que ninguém esperava), a Ação (a turma montando), o Mapa (a amarração BNCC) e o Ensino (a proporcionalidade que ficou).

• Repita com outra turma mudando o LIMITE_CM — vira um projeto novo com o mesmo material.
• Evolua para a versão musical: o mesmo sensor vira um instrumento tocado no ar (membros ganham este bônus ao deixar um relato).
• Leve o método inteiro: na Sala dos Professores entra projeto GAME novo todo mês — cada um com código, vídeo-aula e mapa BNCC prontos.