Sensor de estacionamento com Arduino: bipe HC-SR04, barra de LEDs e display OLED
Monte um sensor de estacionamento com Arduino e HC-SR04: tabela distância-bipe, código millis() sem bloqueio, barra de LEDs, display OLED, versão ESP32 e dicas de montagem.
Um sensor de estacionamento com Arduino é um pequeno auxílio ao motorista que mede a distância até um obstáculo atrás de você com um sensor ultrassônico HC-SR04, bipa mais rápido conforme você se aproxima, enche uma barra de LEDs do verde ao vermelho e, se quiser, mostra a distância em centímetros em um display OLED. Os sensores de estacionamento dos carros de verdade funcionam pelo mesmo princípio: um sensor no para-choque emite uma onda sonora, calcula a distância pelo tempo que o eco leva para voltar e avisa o motorista com um bipe. Com um Arduino Uno, um HC-SR04, um buzzer e cinco LEDs você monta a mesma coisa em uma noite.
Neste guia, primeiro vamos definir em uma tabela as zonas de distância e o intervalo de bipe de cada uma. Depois vamos escrever um código que roda com millis() em vez de delay(), para que o bipe nunca pare a medição. Em seguida vamos adicionar um display OLED, reduzir os erros de medição com um filtro de mediana e correção de temperatura, escrever uma versão para ESP32 com buzzer passivo e histerese e, por fim, ver como montar o sensor em um carro ou na parede da garagem.

Como funciona um sensor de estacionamento?
Quando você dá ao pino TRIG do HC-SR04 um pulso de 10 microssegundos, o sensor emite oito rajadas de som a 40 kHz, uma frequência que o ouvido humano não escuta, e coloca o pino ECHO em HIGH. Quando o som bate em um obstáculo e volta, o pino ECHO vai para LOW. O tempo que o ECHO fica em HIGH é o tempo de ida e volta do som. A 20 °C o som viaja cerca de 343 metros por segundo no ar, então percorre um centímetro em cerca de 29 microssegundos. Contando a ida e a volta, a fórmula fica bem simples: distância (cm) = tempo (µs) / 58. Por exemplo, o eco de uma parede a 1 metro leva cerca de 5800 µs.
O sensor de estacionamento repete essa medição 15–20 vezes por segundo e transforma o resultado em uma zona. Quando a zona muda, mudam também o número de LEDs acesos e o ritmo do bipe. Estes são os valores do HC-SR04 que importam para um sensor de estacionamento:
| Característica | Valor |
|---|---|
| Alimentação | 5 V, cerca de 15 mA |
| Frequência do som | 40 kHz |
| Faixa de medição | 2–400 cm (faixa confiável para estacionar 3–250 cm) |
| Ângulo de detecção | Um cone de cerca de 15° |
| Pulso de disparo | No mínimo 10 µs em HIGH no TRIG |
| Taxa de medição | No mínimo 60 ms entre duas medições |
| Resolução | Cerca de 3 mm |
Lista de materiais
| Peça | Qtd. | Observação |
|---|---|---|
| Arduino Uno ou Nano | 1 | Versão ESP32 mais abaixo |
| Sensor ultrassônico HC-SR04 | 1 | Do lado de fora do carro, prefira um JSN-SR04T à prova d'água |
| Buzzer ativo | 1 | Buzzer passivo na versão ESP32 |
| LEDs (2 verdes, 2 amarelos, 1 vermelho) | 5 | Enfileirados lado a lado como barra de LEDs |
| Resistor de 220 Ω | 5 | Um por LED |
| Display OLED I2C de 0,96 polegada | 1 | Display opcional |
| Protoboard e jumpers | 1 conjunto | Mantenha os fios curtos |
| Resistores de 1 kΩ e 2 kΩ | Um de cada | Só no ESP32, divisor de tensão do ECHO |
Tabela de distância e intervalo de bipe
Os sensores de estacionamento dos carros de verdade costumam começar com um bipe lento a cerca de 1,5 metro, aceleram conforme o obstáculo se aproxima e viram um som contínuo nos últimos 25–30 centímetros. O motorista sabe quanto espaço resta só pelo ritmo, sem olhar para nenhuma tela. O nosso projeto tem cinco zonas de alerta e uma zona segura. Cada bipe dura 50 ms; o intervalo da tabela é o tempo entre o início de dois bipes:
| Zona | Distância | Intervalo do bipe | LEDs acesos | Significado |
|---|---|---|---|---|
| Segura | Mais de 150 cm | Silêncio | Nenhum | Caminho livre |
| 1 | 101–150 cm | 800 ms | 1 verde | Obstáculo detectado |
| 2 | 71–100 cm | 500 ms | 2 verdes | Diminua a velocidade |
| 3 | 46–70 cm | 300 ms | 2 verdes + 1 amarelo | Atenção |
| 4 | 26–45 cm | 150 ms | 2 verdes + 2 amarelos | Muito perto |
| 5 | 25 cm ou menos | Som contínuo | Os cinco (vermelho incluído) | Pare |
Você pode ajustar esses valores ao seu carro: em um carro com balanço traseiro longo, ou em uma garagem apertada, levar a zona de parada para 35–40 cm é mais seguro. Se preferir que o ritmo do bipe mude de forma contínua em vez de em degraus, você pode trocar a tabela de zonas por uma conversão como interval = map(distance, 25, 150, 100, 800) usando a função map(). Ainda assim, uma tabela em degraus é mais fácil de distinguir de ouvido: o motorista percebe na hora a mudança de som ao passar da zona três para a zona quatro.
Ligação: HC-SR04, buzzer e barra de LEDs
| Peça e pino | Arduino Uno | ESP32 | Observação |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5V) | O sensor precisa de 5 V |
| HC-SR04 GND | GND | GND | Terra comum |
| HC-SR04 TRIG | D9 | GPIO 4 | Saída de disparo |
| HC-SR04 ECHO | D10 | GPIO 18 | Pelo divisor de 1 kΩ + 2 kΩ no ESP32 |
| Buzzer (+) | D8 | GPIO 19 | Buzzer ativo no Uno, passivo no ESP32 |
| LED 1 e 2 (verdes) | D2, D3 | GPIO 25, 26 | Resistor de 220 Ω em série em cada LED |
| LED 3 e 4 (amarelos) | D4, D5 | GPIO 27, 32 | Resistor de 220 Ω em série em cada LED |
| LED 5 (vermelho) | D6 | GPIO 33 | Acende na zona de parada |
| OLED SDA / SCL | A4 / A5 | GPIO 21 / 22 | Opcional |
| OLED VCC | 5V | 3V3 | Confira a ordem dos pinos do módulo |
Por que millis() em vez de delay()?
A maioria dos sketches de sensor de estacionamento na internet faz o bipe assim: buzzer ligado, delay(50), desligado, delay(interval). Em uma zona de 800 ms, isso deixa o Arduino cego por quase um segundo a cada volta do loop. Um carro dando ré a 2 km/h (cerca de 1,2 mph) percorre uns 45 cm nesse tempo; os LEDs e o som ficam sempre atrasados em relação à distância real e, pior de tudo, a medição fica congelada justo quando você entra na zona de parada. O jeito certo é separar as duas tarefas: fazer uma medição a cada 60 ms e, a cada volta do loop, decidir com millis() se o buzzer deve estar ligado ou desligado. Explicamos a ideia em detalhes em millis() vs delay().
Montagem passo a passo
- Encaixe o HC-SR04 em uma ponta da protoboard com os cilindros voltados para fora; ligue o VCC ao 5V e o GND ao GND.
- Ligue o TRIG ao D9 e o ECHO ao D10. Mantenha os fios curtos; um jumper frouxo embaralha as leituras ao acaso.
- Enfileire os cinco LEDs: da esquerda para a direita, dois verdes, dois amarelos e um vermelho. Ligue o terminal longo (anodo) de cada LED aos pinos D2–D6 por um resistor de 220 Ω e o terminal curto à trilha do GND.
- Ligue o terminal + do buzzer ativo ao D8 e o outro terminal ao GND. Buzzers ativos costumam ter uma marca + em cima e bipam sozinhos quando recebem 5 V.
- Carregue o código, abra o Monitor Serial a 115200 baud e aproxime a mão do sensor devagar. A distância e o número da zona devem aparecer a cada 60 ms.
- Coloque uma caixa de papelão no chão, marque 150, 100, 70, 45 e 25 cm com uma trena e leve a caixa até esses pontos para conferir se as zonas mudam corretamente.
Código do sensor de estacionamento com Arduino (barra de LEDs + buzzer)
O código abaixo aplica exatamente as zonas da tabela. Ele mede a cada 60 ms, tira a mediana das três últimas leituras e gera o bipe com millis(), independente da medição. Não há nenhum delay() nele:
1// Arduino park sensörü: HC-SR04 + 5 LED bar + aktif buzzer / Arduino parking sensor: HC-SR04 + 5-LED bar + active buzzer
2const int TRIG_PIN = 9;
3const int ECHO_PIN = 10;
4const int BUZZER_PIN = 8;
5const int LED_PINS[5] = {2, 3, 4, 5, 6}; // yeşil, yeşil, sarı, sarı, kırmızı / green, green, yellow, yellow, red
6
7// Bölge sınırları (cm) ve bip aralıkları (ms), tablodaki değerler / zone limits (cm) and beep periods (ms) from the table
8const int ZONE_CM[5] = {150, 100, 70, 45, 25};
9const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0}; // 0 = sürekli ses / 0 = continuous tone
10const unsigned int BEEP_ON_MS = 50; // her bipin süresi / length of each beep
11const unsigned long MEASURE_MS = 60; // HC-SR04 için en az 60 ms / at least 60 ms for the HC-SR04
12
13unsigned long lastMeasure = 0;
14unsigned long lastBeep = 0;
15int samples[3] = {999, 999, 999}; // son 3 ölçüm / last 3 readings
16int sampleIndex = 0;
17int distanceCm = 999;
18int zone = 0; // 0 = güvenli, 5 = dur / 0 = safe, 5 = stop
19
20long readDistanceCm() {
21 digitalWrite(TRIG_PIN, LOW);
22 delayMicroseconds(2);
23 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
24 delayMicroseconds(10);
25 digitalWrite(TRIG_PIN, LOW);
26 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL); // 25 ms zaman aşımı, yaklaşık 4,3 m / 25 ms timeout, about 4.3 m
27 if (us == 0) return 999; // yankı yok: engel uzakta / no echo: obstacle far away
28 return us / 58; // µs / 58 = cm (gidiş-dönüş / round trip)
29}
30
31int median3(int a, int b, int c) { // üçün ortancası, ani sıçramaları atar / median of three, drops spikes
32 return max(min(a, b), min(max(a, b), c));
33}
34
35int zoneFor(int d) {
36 int z = 0;
37 for (int i = 0; i < 5; i++) {
38 if (d <= ZONE_CM[i]) z = i + 1;
39 }
40 return z;
41}
42
43void updateLeds() {
44 for (int i = 0; i < 5; i++) {
45 digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW); // bölge kadar LED yak / light as many LEDs as the zone
46 }
47}
48
49void updateBuzzer(unsigned long now) {
50 if (zone == 0) { // güvenli bölge: sessiz / safe zone: silent
51 digitalWrite(BUZZER_PIN, LOW);
52 return;
53 }
54 unsigned int period = BEEP_MS[zone - 1];
55 if (period == 0) { // dur bölgesi: sürekli ses / stop zone: continuous tone
56 digitalWrite(BUZZER_PIN, HIGH);
57 return;
58 }
59 if (now - lastBeep >= period) lastBeep = now; // yeni bip zamanı / time for a new beep
60 digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
61}
62
63void setup() {
64 pinMode(TRIG_PIN, OUTPUT);
65 pinMode(ECHO_PIN, INPUT);
66 pinMode(BUZZER_PIN, OUTPUT);
67 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
68 Serial.begin(115200);
69}
70
71void loop() {
72 unsigned long now = millis();
73 if (now - lastMeasure >= MEASURE_MS) { // 60 ms'de bir ölç / measure every 60 ms
74 lastMeasure = now;
75 samples[sampleIndex] = readDistanceCm();
76 sampleIndex = (sampleIndex + 1) % 3;
77 distanceCm = median3(samples[0], samples[1], samples[2]);
78 zone = zoneFor(distanceCm);
79 updateLeds();
80 Serial.print(F("Mesafe / Distance: "));
81 Serial.print(distanceCm);
82 Serial.print(F(" cm Bolge / Zone: "));
83 Serial.println(zone);
84 }
85 updateBuzzer(millis()); // bip, ölçümden bağımsız akar / beeping runs independently of measuring
86}| Parte do código | O que faz |
|---|---|
| ZONE_CM e BEEP_MS | Guardam os limites das zonas e os intervalos de bipe em um só lugar; para mudar a tabela, você só edita essas duas linhas. |
| pulseIn(..., 25000UL) | Espera o eco no máximo 25 ms (cerca de 4,3 m). Se nenhum eco chegar, retorna 0, e o código trata isso como 999, ou seja, sem obstáculo. |
| us / 58 | Converte o tempo de ida e volta em centímetros. |
| median3() | Tira a mediana das três últimas leituras; uma única leitura ruim não bagunça os LEDs nem o som. |
| now - lastBeep >= period | Verifica se chegou a hora de um novo bipe; o buzzer fica ligado nos primeiros 50 ms de cada bipe e desligado no resto. |
| MEASURE_MS = 60 | O ciclo de medição mais curto recomendado para o HC-SR04; medir mais rápido faz você confundir um eco atrasado da medição anterior com um novo. |
Precisão da medição: o efeito da temperatura e da superfície
O número 58 no código supõe que a velocidade do som é de cerca de 345 m/s, ou seja, que o ar está por volta de 22 °C. Mas a velocidade do som muda com a temperatura: v = 331,3 + 0,606 × T (m/s, T em °C). No inverno, a 0 °C, o som é mais lento, o eco volta mais tarde e o sensor acha que o obstáculo está um pouco mais longe do que está. Com uma distância real de 100 cm, as leituras ficam mais ou menos assim:
| Temperatura do ar | Velocidade do som | Leitura (tempo ÷ 58) |
|---|---|---|
| -10 °C | 325 m/s | Cerca de 106 cm |
| 0 °C | 331 m/s | Cerca de 104 cm |
| 10 °C | 337 m/s | Cerca de 102 cm |
| 20 °C | 343 m/s | Cerca de 100 cm |
| 30 °C | 350 m/s | Cerca de 99 cm |
| 40 °C | 356 m/s | Cerca de 97 cm |
Alguns centímetros não fazem diferença na hora de estacionar. Ainda assim, se você quer o mesmo ponto de parada em uma garagem a 40 °C no verão e abaixo de zero no inverno, pode medir a temperatura com um DHT11 ou DS18B20 e calcular a distância com time × (331.3 + 0.606 × T) / 20000. A superfície pesa muito mais que a temperatura: uma parede lisa, um portão de garagem ou o para-choque de outro carro refletem bem o som, enquanto um poste fino, uma cerca de arame, um arbusto ou superfícies macias como tecido enfraquecem o eco ou nem o devolvem. Uma superfície inclinada em relação ao sensor também desvia o som para longe. Por isso um sensor de estacionamento ultrassônico nunca deve ser a sua única medida de segurança.
Mostrando a distância em um display OLED
Um display OLED de 0,96 polegada é ideal para um indicador que o motorista consiga ver: ele mostra a distância em dígitos grandes e desenha embaixo uma barra que enche conforme o obstáculo se aproxima. Explicamos a ligação I2C do display e como instalar as bibliotecas Adafruit SSD1306 e Adafruit GFX em detalhes em display OLED SSD1306. A tela se atualiza cinco vezes por segundo; cada atualização leva cerca de 25–30 ms, então desenhar com mais frequência atrapalharia o tempo da medição e do bipe.
1// Park sensörü + 0,96" OLED: büyük rakamla mesafe ve doluluk çubuğu / parking sensor + 0.96" OLED: big distance digits and a fill bar
2#include <Wire.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1); // 128x64, reset pini yok / 128x64, no reset pin
7
8const int TRIG_PIN = 9;
9const int ECHO_PIN = 10;
10const int BUZZER_PIN = 8;
11const int LED_PINS[5] = {2, 3, 4, 5, 6};
12const int ZONE_CM[5] = {150, 100, 70, 45, 25};
13const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
14const unsigned int BEEP_ON_MS = 50;
15const int MAX_SHOW_CM = 200; // çubuğun boş olduğu mesafe / distance where the bar is empty
16
17unsigned long lastMeasure = 0, lastBeep = 0, lastDraw = 0;
18int samples[3] = {999, 999, 999};
19int sampleIndex = 0;
20int distanceCm = 999;
21int zone = 0;
22
23long readDistanceCm() {
24 digitalWrite(TRIG_PIN, LOW);
25 delayMicroseconds(2);
26 digitalWrite(TRIG_PIN, HIGH);
27 delayMicroseconds(10);
28 digitalWrite(TRIG_PIN, LOW);
29 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
30 return us == 0 ? 999 : us / 58;
31}
32
33int median3(int a, int b, int c) {
34 return max(min(a, b), min(max(a, b), c));
35}
36
37void drawScreen() {
38 display.clearDisplay();
39 display.setTextSize(1);
40 display.setCursor(0, 0);
41 if (zone == 5) display.print(F("DUR / STOP"));
42 else if (zone == 0) display.print(F("Yol acik / Clear"));
43 else display.print(F("Yaklasiyor / Closer"));
44
45 display.setTextSize(3); // büyük rakamlar / big digits
46 display.setCursor(0, 18);
47 if (distanceCm >= 999) display.print(F("---"));
48 else display.print(distanceCm);
49 display.setTextSize(2);
50 display.print(F(" cm"));
51
52 // Yaklaştıkça dolan çubuk / a bar that fills as you get closer
53 int d = constrain(distanceCm, 0, MAX_SHOW_CM);
54 int fill = map(d, MAX_SHOW_CM, 0, 0, 124);
55 display.drawRect(0, 50, 128, 12, SSD1306_WHITE);
56 display.fillRect(2, 52, fill, 8, SSD1306_WHITE);
57 display.display();
58}
59
60void setup() {
61 pinMode(TRIG_PIN, OUTPUT);
62 pinMode(ECHO_PIN, INPUT);
63 pinMode(BUZZER_PIN, OUTPUT);
64 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
65 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // OLED adresi genelde 0x3C / OLED address is usually 0x3C
66 for (;;); // ekran yoksa dur / stop if no display
67 }
68 display.setTextColor(SSD1306_WHITE);
69}
70
71void loop() {
72 unsigned long now = millis();
73 if (now - lastMeasure >= 60) {
74 lastMeasure = now;
75 samples[sampleIndex] = readDistanceCm();
76 sampleIndex = (sampleIndex + 1) % 3;
77 distanceCm = median3(samples[0], samples[1], samples[2]);
78 zone = 0;
79 for (int i = 0; i < 5; i++) if (distanceCm <= ZONE_CM[i]) zone = i + 1;
80 for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
81 }
82 if (now - lastDraw >= 200) { // ekranı saniyede 5 kez yenile / refresh the screen 5 times a second
83 lastDraw = now;
84 drawScreen();
85 }
86 now = millis();
87 if (zone == 0) {
88 digitalWrite(BUZZER_PIN, LOW);
89 } else if (BEEP_MS[zone - 1] == 0) {
90 digitalWrite(BUZZER_PIN, HIGH);
91 } else {
92 if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
93 digitalWrite(BUZZER_PIN, (now - lastBeep < BEEP_ON_MS) ? HIGH : LOW);
94 }
95}Dependendo da zona, a linha de cima mostra Yol acik / Clear, Yaklasiyor / Closer ou DUR / STOP. Os textos são bilíngues (turco / inglês) e escritos sem caracteres especiais, porque a fonte padrão da biblioteca do OLED só cobre ASCII simples. Cerca de 1 KB dos 2 KB de RAM do Uno vai para o buffer da tela; conforme você ampliar o código, mantenha os textos fixos dentro de F(), senão o display pode nem iniciar.
Sensor de estacionamento com ESP32
A versão ESP32 tem três diferenças. Primeiro, o sensor continua alimentado em 5 V, mas o pino ECHO passa pelo divisor de tensão. Segundo, usamos um buzzer passivo em vez de um ativo e geramos o som como um tom de 2,5 kHz com o hardware LEDC do ESP32; mudando a frequência, você escolhe o som. Terceiro, adicionamos 3 cm de histerese para os LEDs não piscarem no limite de uma zona: quando o carro se afasta, a distância precisa passar 3 cm do limite antes de cair para uma zona inferior. Como as funções LEDC mudaram na versão 3.x do core ESP32 Arduino, o código usa uma verificação ESP_ARDUINO_VERSION_MAJOR e compila tanto na 2.x quanto na 3.x.
1// ESP32 park sensörü: HC-SR04 + 5 LED + pasif buzzer (LEDC), çekirdek 2.x ve 3.x / ESP32 parking sensor: HC-SR04 + 5 LEDs + passive buzzer (LEDC), core 2.x and 3.x
2const int TRIG_PIN = 4;
3const int ECHO_PIN = 18; // 1 kΩ + 2 kΩ gerilim bölücüyle / through a 1 kΩ + 2 kΩ divider
4const int BUZZER_PIN = 19;
5const int LED_PINS[5] = {25, 26, 27, 32, 33};
6const int ZONE_CM[5] = {150, 100, 70, 45, 25};
7const unsigned int BEEP_MS[5] = {800, 500, 300, 150, 0};
8const unsigned int BEEP_ON_MS = 50;
9const unsigned int TONE_HZ = 2500; // pasif buzzerın en yüksek sesi genelde 2–4 kHz / passive buzzers are loudest around 2–4 kHz
10const int HYST_CM = 3; // bölge sınırında titremeyi önler / stops flicker at zone limits
11const int BUZZER_CH = 0; // yalnız 2.x için LEDC kanalı / LEDC channel, 2.x only
12
13unsigned long lastMeasure = 0, lastBeep = 0;
14int samples[3] = {999, 999, 999};
15int sampleIndex = 0;
16int distanceCm = 999;
17int zone = 0;
18bool buzzerOn = false;
19
20void buzzer(bool on) {
21 if (on == buzzerOn) return; // yalnız değişince yaz / write only on change
22 buzzerOn = on;
23#if ESP_ARDUINO_VERSION_MAJOR >= 3
24 ledcWriteTone(BUZZER_PIN, on ? TONE_HZ : 0); // 3.x: pin numarasıyla / 3.x: by pin number
25#else
26 ledcWriteTone(BUZZER_CH, on ? TONE_HZ : 0); // 2.x: kanal numarasıyla / 2.x: by channel number
27#endif
28}
29
30long readDistanceCm() {
31 digitalWrite(TRIG_PIN, LOW);
32 delayMicroseconds(2);
33 digitalWrite(TRIG_PIN, HIGH);
34 delayMicroseconds(10);
35 digitalWrite(TRIG_PIN, LOW);
36 unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);
37 return us == 0 ? 999 : us / 58;
38}
39
40int median3(int a, int b, int c) {
41 return max(min(a, b), min(max(a, b), c));
42}
43
44int zoneFor(int d, int current) {
45 int z = 0;
46 for (int i = 0; i < 5; i++) if (d <= ZONE_CM[i]) z = i + 1;
47 if (current > 0 && z < current && d <= ZONE_CM[current - 1] + HYST_CM) z = current; // uzaklaşırken 3 cm pay / 3 cm margin when moving away
48 return z;
49}
50
51void setup() {
52 Serial.begin(115200);
53 pinMode(TRIG_PIN, OUTPUT);
54 pinMode(ECHO_PIN, INPUT);
55 for (int i = 0; i < 5; i++) pinMode(LED_PINS[i], OUTPUT);
56#if ESP_ARDUINO_VERSION_MAJOR >= 3
57 ledcAttach(BUZZER_PIN, TONE_HZ, 8); // 3.x: pin, frekans, çözünürlük / 3.x: pin, frequency, resolution
58#else
59 ledcSetup(BUZZER_CH, TONE_HZ, 8); // 2.x: kanal kur, sonra pine bağla / 2.x: set up a channel, then attach the pin
60 ledcAttachPin(BUZZER_PIN, BUZZER_CH);
61#endif
62 buzzerOn = true;
63 buzzer(false); // sessiz başla / start silent
64}
65
66void loop() {
67 unsigned long now = millis();
68 if (now - lastMeasure >= 60) {
69 lastMeasure = now;
70 samples[sampleIndex] = readDistanceCm();
71 sampleIndex = (sampleIndex + 1) % 3;
72 distanceCm = median3(samples[0], samples[1], samples[2]);
73 zone = zoneFor(distanceCm, zone);
74 for (int i = 0; i < 5; i++) digitalWrite(LED_PINS[i], i < zone ? HIGH : LOW);
75 Serial.printf("Mesafe / Distance: %d cm Bolge / Zone: %d\n", distanceCm, zone);
76 }
77 now = millis();
78 if (zone == 0) {
79 buzzer(false);
80 } else if (BEEP_MS[zone - 1] == 0) {
81 buzzer(true);
82 } else {
83 if (now - lastBeep >= BEEP_MS[zone - 1]) lastBeep = now;
84 buzzer(now - lastBeep < BEEP_ON_MS);
85 }
86}Dicas de montagem no carro ou na garagem
- Altura e ângulo: monte o sensor a 50–70 cm do chão, paralelo a ele e inclinado 3–5 graus para cima. Um sensor apontado para baixo confunde ondulações da rua e o meio-fio com obstáculos.
- Água e poeira: o HC-SR04 não é à prova d'água; chuva, lama e lava-rápido acabam com ele logo. Para um sistema preso ao para-choque, use uma sonda ultrassônica à prova d'água como o JSN-SR04T. Essas sondas têm alcance mínimo de 20–25 cm, então você vai precisar levar a zona de parada para 30–35 cm.
- Alimentação: o sistema elétrico do carro sobe para 13,8–14,4 V com o motor ligado, com quedas bruscas na partida e picos quando uma carga é desligada. Não alimente o Arduino direto dos 12 V; baixe para 5 V com um conversor buck como o LM2596 e passe por um fusível de 1 A. Se você alimentar o circuito pela luz de ré, o sistema só funciona com a ré engatada.
- Fiação: você pode pôr o sensor no para-choque, o Arduino no porta-malas e o buzzer e a barra de LEDs onde o motorista consiga vê-los. Para cabos de TRIG e ECHO com mais de 3–4 metros, use fio de par trançado e coloque um capacitor de 100 nF entre o VCC e o GND do sensor.
- Vários sensores: carros de verdade costumam ter 3–4 sensores no para-choque traseiro. Se você disparar dois HC-SR04 ao mesmo tempo, um escuta o eco do outro; meça um depois do outro com no mínimo 30–60 ms de intervalo e informe ao motorista a menor distância.
- Versão na parede da garagem: se não quiser mexer no carro, monte o sensor na parede do fundo da garagem, na altura do para-choque. Conforme o carro entra, a barra de LEDs vai do verde ao vermelho como um semáforo; é o auxílio de estacionamento mais fácil e seguro de todos.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| A distância é sempre 999 ou nunca muda | TRIG e ECHO trocados, VCC não está em 5 V ou há um fio solto | Compare os pinos com a tabela de ligação e alimente o sensor pelo 5V |
| Os valores pulam ao acaso | Superfície macia ou inclinada, protoboard com mau contato, medições frequentes demais | Use o filtro de mediana e deixe no mínimo 60 ms entre medições |
| A distância congela enquanto bipa | Há um delay() no código | Gere o bipe com millis() e use o código deste artigo |
| O buzzer chia ou fica mudo | Código de buzzer ativo usado com buzzer passivo, ou o contrário | Use buzzer ativo com o código do Uno e passivo com o código do ESP32 |
| Os LEDs piscam no limite de uma zona | A distância está oscilando bem em cima do limite | Adicione ao código do Uno a histerese de 3 cm do código do ESP32 |
| O ESP32 não lê distância nenhuma | Sensor alimentado com 3,3 V ou divisor ligado ao contrário | Ligue o VCC ao VIN e confirme que o resistor de 2 kΩ está do lado do GND |
| Certo na bancada, alarmes falsos no carro | O sensor vê o chão, a placa ou o engate | Monte o sensor mais alto e incline-o 3–5 graus para cima |
| O buzzer está baixo demais | O pino não fornece corrente suficiente | Acione o buzzer com um transistor NPN como o BC547 |
Projetos para tentar depois do sensor de estacionamento
- Indicador colorido de garagem: use um anel WS2812B NeoPixel no lugar da barra de LEDs e deixe-o encher do verde ao vermelho conforme o carro se aproxima.
- Sistema de ocupação de estacionamento: monte um sistema de estacionamento com Arduino que põe um sensor em cada vaga e conta as vazias.
- Radar ultrassônico: faça um radar com Arduino que gira o sensor em um servo para varrer os arredores.
- Robô que desvia de obstáculos: combine a mesma medição de distância com controle de motores para fazer um robô que desvia de obstáculos.
- Medição precisa a curta distância: para acertar o ponto de parada no milímetro, experimente o sensor de distância a laser VL53L0X; as diferenças estão na nossa comparação de sensores de distância.
Como um sensor de estacionamento com Arduino junta som, luz e medição em um só projeto, ele é uma ótima escolha tanto como primeiro projeto sério quanto para uma feira de ciências. Ajuste a tabela de zonas ao seu carro, teste o sistema na garagem primeiro e depois vá além com as dicas de montagem. O esquema de ligação passo a passo e o código pronto do mesmo circuito estão nos projetos Sensor de Estacionamento HC-SR04 e Sensor de Estacionamento ESP32 do app BlueGrays.
Perguntas frequentes
Como fazer um sensor de estacionamento com Arduino?
Você precisa de um sensor ultrassônico HC-SR04, um buzzer e alguns LEDs. O Arduino mede o tempo do eco a cada 60 ms, converte em centímetros com tempo / 58 e associa a distância a zonas que definem o ritmo do bipe e o número de LEDs acesos. Usar millis() em vez de delay() mantém a medição rodando enquanto ele bipa.
Até que distância o HC-SR04 detecta?
No papel o HC-SR04 mede 2–400 cm, mas em uma superfície lisa e larga a faixa confiável é de cerca de 3–250 cm. Para estacionar, começar o alerta a 150 cm é mais que suficiente. Postes finos e superfícies macias podem não aparecer nem a distâncias menores.
Devo usar buzzer ativo ou passivo em um sensor de estacionamento?
O buzzer ativo tem oscilador próprio, então bipa assim que recebe 5 V e funciona com digitalWrite; o código do Uno deste artigo foi feito para ele. O buzzer passivo precisa de uma frequência vinda do tone() ou, no ESP32, do LEDC, mas permite escolher o tom. Para diferenciá-los, aplique 5 V: o que bipa sozinho é o ativo.
Posso montar um HC-SR04 no para-choque do carro?
Pode, mas o HC-SR04 não é à prova d'água nem de poeira e não aguenta muito tempo chuva e lava-rápido. Do lado de fora do carro, uma sonda à prova d'água como o JSN-SR04T é a melhor escolha. Se você só precisa de ajuda na garagem, montar o sensor na parede é a solução mais fácil.
Por que o meu HC-SR04 dá leituras aleatórias ou erradas?
As causas comuns são um fio solto, o sensor enxergando o chão, superfícies macias ou inclinadas e esperar menos de 60 ms entre medições. Tirar a mediana das três últimas leituras elimina o valor ruim ocasional. Inclinar o sensor 3–5 graus para cima também reduz os ecos do chão.
Posso usar vários sensores HC-SR04 ao mesmo tempo?
Sim, mas se dispararem no mesmo instante podem escutar os ecos uns dos outros. Meça os sensores um depois do outro com no mínimo 30–60 ms de intervalo e informe a menor distância. Cada sensor só precisa dos próprios pinos TRIG e ECHO.
Projetos para montar depois desta leitura
Ver todos os projetos
Medição de distância com HC-SR04 (Monitor Serial)
O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

Uso do buzzer
Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

Sensor de estacionamento com HC-SR04
Uma versão em miniatura do sensor de estacionamento de um carro: quanto mais perto um objeto chega, mais rápidos ficam os bipes.

Sensor de estacionamento com ESP32 (HC-SR04 + barra de 5 LEDs + buzzer + OLED)
A versão com ESP32 do sensor de estacionamento de carro! Usamos o sensor ultrassônico HC-SR04 para medir a distância até o objeto à sua frente. Conforme a distância diminui, a barra de 5 LEDs vai se preenchendo (verde → amarelo → vermelho) e o intervalo entre os bipes do buzzer diminui. Quando o objeto chega muito perto (menos de 10 cm), o alarme soa continuamente e todos os LEDs acendem.

Medidor ultrassônico de distância HC-SR04 com ESP32
O sensor ultrassônico HC-SR04 calcula a distância medindo o tempo que a onda sonora emitida leva para atingir um objeto e retornar (tempo de voo). Neste projeto, enviaremos um pulso de 10 microssegundos do ESP32 ao pino TRIG do sensor e leremos a duração do eco no pino ECHO com pulseIn(). Exibiremos a distância calculada em centímetros em um LCD I2C 16x2. Como o HC-SR04 opera a 5V, é preciso usar um divisor de tensão no pino ECHO; caso contrário, o GPIO de 3,3V do ESP32 será danificado.

Medição de distância com display LCD
Uma ferramenta que mede distâncias sem régua: aproxime e afaste a mão na frente do sensor e veja o número mudar.

Robô que desvia de obstáculos
Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

Projeto de medição de altura
Um medidor de altura preso ao batente da porta que informa, em centímetros, a altura de quem está embaixo dele.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

