Sensore di parcheggio Arduino: HC-SR04, buzzer, barra LED e OLED
Crea un sensore di parcheggio Arduino con HC-SR04: tabella distanza-bip, codice millis() non bloccante, barra LED, display OLED, versione ESP32 e montaggio.
Un sensore di parcheggio Arduino è un piccolo aiuto alla guida: un sensore a ultrasuoni HC-SR04 misura la distanza dall'ostacolo dietro di te, il bip accelera man mano che ti avvicini, una barra di LED si riempie dal verde al rosso e, se vuoi, un display OLED mostra la distanza in centimetri. I sensori di parcheggio delle auto vere funzionano con lo stesso principio: un sensore nel paraurti invia un'onda sonora, calcola la distanza dal tempo di ritorno dell'eco e avvisa il guidatore con un bip. Con un Arduino Uno, un HC-SR04, un buzzer e cinque LED puoi costruire la stessa cosa in una serata su una breadboard.
In questa guida definiremo prima in una tabella le zone di distanza e l'intervallo dei bip per ciascuna. Poi scriveremo un codice che funziona con millis() invece di delay(), così il bip non interrompe mai la misura. Dopo aggiungeremo un display OLED, ridurremo gli errori di misura con un filtro mediano e una correzione della temperatura, scriveremo una versione per ESP32 con buzzer passivo e isteresi e, infine, vedremo come montare il sensore sull'auto o sulla parete del garage.

Come funziona un sensore di parcheggio?
Quando dai al pin TRIG dell'HC-SR04 un impulso di 10 microsecondi, il sensore emette otto impulsi sonori a 40 kHz, una frequenza che l'orecchio umano non sente, e porta il pin ECHO a HIGH. Quando il suono colpisce un ostacolo e torna indietro, ECHO torna a LOW. Il tempo in cui ECHO resta HIGH è il tempo di andata e ritorno del suono. A 20 °C il suono percorre nell'aria circa 343 metri al secondo, cioè un centimetro in circa 29 microsecondi. Considerando andata e ritorno, la formula diventa semplicissima: distanza (cm) = tempo (µs) / 58. Per esempio, l'eco di un muro a 1 metro impiega circa 5800 µs.
Il sensore di parcheggio ripete questa misura 15–20 volte al secondo e trasforma il risultato in una zona. Al cambiare della zona cambiano anche il numero di LED accesi e il ritmo dei bip. Questi sono i dati dell'HC-SR04 che contano per questo progetto:
| Caratteristica | Valore |
|---|---|
| Alimentazione | 5 V, circa 15 mA |
| Frequenza del suono | 40 kHz |
| Campo di misura | 2–400 cm (affidabile per il parcheggio: 3–250 cm) |
| Angolo di rilevamento | Un cono di circa 15° |
| Impulso di trigger | Almeno 10 µs HIGH su TRIG |
| Frequenza di misura | Almeno 60 ms tra due misure |
| Risoluzione | Circa 3 mm |
Lista dei componenti
| Componente | Quantità | Nota |
|---|---|---|
| Arduino Uno o Nano | 1 | Versione ESP32 più sotto |
| Sensore a ultrasuoni HC-SR04 | 1 | Fuori dall'auto meglio il JSN-SR04T impermeabile |
| Buzzer attivo | 1 | Nella versione ESP32 un buzzer passivo |
| LED (2 verdi, 2 gialli, 1 rosso) | 5 | In fila, come barra LED |
| Resistenza da 220 Ω | 5 | Una per LED |
| Display OLED I2C da 0,96 pollici | 1 | Indicatore opzionale |
| Breadboard e cavetti jumper | 1 set | Usa fili corti |
| Resistenze da 1 kΩ e 2 kΩ | Una per tipo | Solo per ESP32, partitore di tensione su ECHO |
Tabella distanza e intervallo dei bip
I sensori di parcheggio delle auto di solito iniziano con un bip lento da circa 1,5 metri, accelerano man mano che l'ostacolo si avvicina e diventano un suono continuo negli ultimi 25–30 centimetri. Il guidatore capisce quanto spazio resta solo dal ritmo, senza guardare uno schermo. Il nostro progetto ha cinque zone di avviso e una zona sicura. Ogni bip dura 50 ms; l'intervallo in tabella è il tempo tra l'inizio di due bip:
| Zona | Distanza | Intervallo bip | LED accesi | Significato |
|---|---|---|---|---|
| Sicura | Oltre 150 cm | Silenzio | Nessuno | Via libera |
| 1 | 101–150 cm | 800 ms | 1 verde | Ostacolo rilevato |
| 2 | 71–100 cm | 500 ms | 2 verdi | Rallenta |
| 3 | 46–70 cm | 300 ms | 2 verdi + 1 giallo | Attenzione |
| 4 | 26–45 cm | 150 ms | 2 verdi + 2 gialli | Molto vicino |
| 5 | 25 cm o meno | Suono continuo | Tutti e cinque (rosso compreso) | Stop |
Puoi adattare questi valori alla tua auto: su un'auto con lo sbalzo posteriore lungo, o in un garage stretto, è più sicuro spostare la zona di stop a 35–40 cm. Se preferisci che il ritmo dei bip cambi in modo continuo e non a gradini, puoi sostituire la tabella delle zone con una conversione come intervallo = map(distanza, 25, 150, 100, 800) usando la funzione map(). Una tabella a gradini però si distingue meglio a orecchio: il guidatore nota subito il cambio di suono quando passa dalla zona tre alla quattro.
Schema di collegamento: HC-SR04, buzzer e barra LED
| Componente e pin | Arduino Uno | ESP32 | Nota |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN (5V) | Il sensore vuole 5 V |
| HC-SR04 GND | GND | GND | Massa comune |
| HC-SR04 TRIG | D9 | GPIO 4 | Uscita di trigger |
| HC-SR04 ECHO | D10 | GPIO 18 | Sull'ESP32 tramite partitore 1 kΩ + 2 kΩ |
| Buzzer (+) | D8 | GPIO 19 | Attivo sull'Uno, passivo sull'ESP32 |
| LED 1 e 2 (verdi) | D2, D3 | GPIO 25, 26 | Resistenza in serie da 220 Ω per ogni LED |
| LED 3 e 4 (gialli) | D4, D5 | GPIO 27, 32 | Resistenza in serie da 220 Ω per ogni LED |
| LED 5 (rosso) | D6 | GPIO 33 | Si accende nella zona di stop |
| OLED SDA / SCL | A4 / A5 | GPIO 21 / 22 | Opzionale |
| OLED VCC | 5V | 3V3 | Controlla l'ordine dei pin del modulo |
Perché millis() e non delay()?
Quasi tutti gli sketch di sensore di parcheggio che si trovano online generano il bip così: buzzer acceso, delay(50), spento, delay(intervallo). In una zona da 800 ms questo rende Arduino cieco per quasi un secondo a ogni giro del loop. Un'auto che va in retromarcia a 2 km/h percorre circa 45 cm in quel tempo; LED e suono restano sempre indietro rispetto alla distanza reale e, peggio ancora, la misura è bloccata proprio mentre entri nella zona di stop. La cosa giusta è separare i due compiti: misurare ogni 60 ms e decidere a ogni giro del loop, con millis(), se il buzzer deve essere acceso o spento. Spieghiamo l'idea in dettaglio in millis() o delay().
Montaggio passo passo
- Inserisci l'HC-SR04 a un'estremità della breadboard con i cilindri rivolti verso l'esterno; collega VCC a 5V e GND a GND.
- Collega TRIG a D9 ed ECHO a D10. Usa fili corti; un jumper allentato rovina le letture a caso.
- Metti in fila i cinque LED: da sinistra a destra due verdi, due gialli e uno rosso. Collega la gamba lunga (anodo) di ogni LED ai pin D2–D6 tramite una resistenza da 220 Ω e la gamba corta alla linea GND.
- Collega la gamba + del buzzer attivo a D8 e l'altra a GND. I buzzer attivi di solito hanno un segno + sopra e suonano da soli quando ricevono 5 V.
- Carica il codice, apri il Monitor seriale a 115200 baud e avvicina lentamente la mano al sensore. Ogni 60 ms dovrebbero comparire la distanza e il numero della zona.
- Metti una scatola di cartone sul pavimento, segna 150, 100, 70, 45 e 25 cm con un metro a nastro e sposta la scatola in questi punti per verificare che le zone cambino correttamente.
Codice del sensore di parcheggio Arduino (barra LED + buzzer)
Il codice qui sotto applica esattamente le zone della tabella. Misura ogni 60 ms, prende la mediana delle ultime tre letture e genera il bip con millis(), indipendentemente dalla misura. Non contiene nemmeno un delay():
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 del codice | Cosa fa |
|---|---|
| ZONE_CM e BEEP_MS | Tengono in un solo punto i limiti delle zone e gli intervalli dei bip; per cambiare la tabella modifichi solo queste due righe. |
| pulseIn(..., 25000UL) | Aspetta l'eco al massimo 25 ms (circa 4,3 m). Se non arriva restituisce 0 e il codice lo interpreta come 999, cioè nessun ostacolo. |
| us / 58 | Converte il tempo di andata e ritorno in centimetri. |
| median3() | Prende la mediana delle ultime tre letture; una sola lettura sbagliata non disturba né i LED né il suono. |
| now - lastBeep >= period | Controlla se è ora di un nuovo bip; il buzzer resta acceso per i primi 50 ms di ogni bip e spento per il resto. |
| MEASURE_MS = 60 | Il ciclo di misura più breve consigliato per l'HC-SR04; misurando più spesso rischi di scambiare un eco in ritardo della misura precedente per uno nuovo. |
Precisione della misura: effetto di temperatura e superficie
Il numero 58 nel codice presuppone una velocità del suono di circa 345 m/s, cioè aria a circa 22 °C. Ma la velocità del suono cambia con la temperatura: v = 331,3 + 0,606 × T (m/s, T in °C). D'inverno, a 0 °C, il suono è più lento, l'eco torna più tardi e il sensore crede che l'ostacolo sia un po' più lontano di quanto è. Con una distanza reale di 100 cm, le letture sono circa:
| Temperatura dell'aria | Velocità del suono | Lettura (tempo ÷ 58) |
|---|---|---|
| -10 °C | 325 m/s | Circa 106 cm |
| 0 °C | 331 m/s | Circa 104 cm |
| 10 °C | 337 m/s | Circa 102 cm |
| 20 °C | 343 m/s | Circa 100 cm |
| 30 °C | 350 m/s | Circa 99 cm |
| 40 °C | 356 m/s | Circa 97 cm |
Quando parcheggi, qualche centimetro non conta. Se però vuoi lo stesso punto di stop in un garage a 40 °C d'estate e sotto zero d'inverno, puoi misurare la temperatura con un DHT11 o un DS18B20 e calcolare la distanza con tempo × (331,3 + 0,606 × T) / 20000. La superficie pesa molto più della temperatura: un muro liscio, una basculante del garage o il paraurti di un'altra auto riflettono bene il suono, mentre un palo sottile, una rete metallica, un cespuglio o superfici morbide come il tessuto indeboliscono l'eco o non lo rimandano affatto. Anche una superficie inclinata rispetto al sensore devia il suono altrove. Per questo un sensore di parcheggio a ultrasuoni non deve mai essere la tua unica misura di sicurezza.
Mostrare la distanza su un display OLED
Per un indicatore visibile dal guidatore, il display OLED da 0,96 pollici è l'ideale: mostra la distanza con cifre grandi e sotto disegna una barra che si riempie man mano che l'ostacolo si avvicina. Il collegamento I2C del display e l'installazione delle librerie Adafruit SSD1306 e Adafruit GFX sono spiegati in dettaglio in display OLED SSD1306. Lo schermo si aggiorna cinque volte al secondo; ogni aggiornamento richiede circa 25–30 ms, quindi disegnare più spesso disturberebbe la misura e il ritmo dei bip.
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}A seconda della zona, la riga in alto mostra Yol acik / Clear, Yaklasiyor / Closer o DUR / STOP. I testi sono bilingui (turco / inglese) e scritti senza accenti, perché il font predefinito della libreria OLED contiene solo i caratteri ASCII di base. Circa 1 KB dei 2 KB di RAM dell'Uno va al buffer dello schermo; quando ampli il codice, continua a tenere i testi fissi dentro F(), altrimenti il display potrebbe non avviarsi.
Sensore di parcheggio con ESP32
La versione per ESP32 ha tre differenze. Primo, il sensore è sempre alimentato a 5 V, ma il pin ECHO passa dal partitore di tensione. Secondo, usiamo un buzzer passivo al posto di quello attivo e generiamo il suono come tono a 2,5 kHz con l'hardware LEDC dell'ESP32; cambiando la frequenza scegli tu il suono. Terzo, abbiamo aggiunto 3 cm di isteresi perché i LED non sfarfallino al limite di una zona: quando l'auto si allontana, la distanza deve superare il limite di 3 cm prima di scendere di zona. Poiché le funzioni LEDC sono cambiate nella versione 3.x del core Arduino per ESP32, il codice controlla ESP_ARDUINO_VERSION_MAJOR e si compila sia con la 2.x sia con la 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}Consigli di montaggio su auto o garage
- Altezza e angolo: Monta il sensore a 50–70 cm da terra, parallelo al suolo e inclinato di 3–5 gradi verso l'alto. Un sensore rivolto verso il basso scambia le irregolarità dell'asfalto e il bordo del marciapiede per ostacoli.
- Acqua e polvere: L'HC-SR04 non è impermeabile; pioggia, fango e autolavaggio lo rovinano in poco tempo. Per un sistema montato nel paraurti usa una sonda a ultrasuoni impermeabile come il JSN-SR04T. Queste sonde misurano solo da 20–25 cm in su, quindi dovrai spostare la zona di stop a 30–35 cm.
- Alimentazione: L'impianto elettrico dell'auto sale a 13,8–14,4 V a motore acceso, con cali improvvisi all'avviamento e picchi quando si stacca un carico. Non alimentare Arduino direttamente a 12 V: abbassa la tensione a 5 V con un convertitore step-down come l'LM2596 e proteggilo con un fusibile da 1 A. Se prendi l'alimentazione dal circuito della luce di retromarcia, il sistema funziona solo in retromarcia.
- Cavi: Puoi mettere il sensore nel paraurti, Arduino nel bagagliaio e buzzer e barra LED dove il guidatore li vede. Per cavi TRIG ed ECHO più lunghi di 3–4 metri usa cavo intrecciato e aggiungi un condensatore da 100 nF tra VCC e GND del sensore.
- Più sensori: Le auto vere hanno di solito 3–4 sensori nel paraurti posteriore. Se attivi due HC-SR04 nello stesso momento, uno sente l'eco dell'altro; misurali uno dopo l'altro con almeno 30–60 ms di pausa e comunica al guidatore la distanza più piccola.
- Versione da parete per il garage: Se non vuoi toccare l'auto, monta il sensore sulla parete di fondo del garage, all'altezza del paraurti. Quando l'auto entra, la barra LED passa dal verde al rosso come un semaforo; è l'aiuto al parcheggio più semplice e sicuro di tutti.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| La distanza è sempre 999 o non cambia | TRIG ed ECHO invertiti, VCC diverso da 5 V o filo allentato | Confronta i pin con la tabella dei collegamenti e alimenta il sensore dai 5V |
| I valori saltano a caso | Superficie morbida o inclinata, breadboard allentata, misure troppo ravvicinate | Usa il filtro mediano e lascia almeno 60 ms tra una misura e l'altra |
| La distanza si blocca durante il bip | Nel codice c'è un delay() | Genera il bip con millis() e usa il codice di questo articolo |
| Il buzzer gracchia o resta muto | Codice per buzzer attivo usato con un buzzer passivo, o viceversa | Usa un buzzer attivo con il codice Uno e uno passivo con il codice ESP32 |
| I LED sfarfallano al limite di una zona | La distanza oscilla proprio sul limite | Aggiungi anche al codice Uno l'isteresi di 3 cm del codice ESP32 |
| L'ESP32 non legge nessuna distanza | Sensore alimentato a 3,3 V o partitore collegato al contrario | Collega VCC a VIN e verifica che la resistenza da 2 kΩ sia dal lato GND |
| Sul tavolo va bene, sull'auto falsi allarmi | Il sensore vede il suolo, la targa o il gancio di traino | Monta il sensore più in alto e inclinalo di 3–5 gradi verso l'alto |
| Il buzzer è troppo debole | Il pin non fornisce abbastanza corrente | Pilota il buzzer con un transistor NPN come il BC547 |
Progetti da provare dopo il sensore di parcheggio
- Indicatore a colori per il garage: Usa un anello WS2812B NeoPixel al posto della barra LED, che si riempie dal verde al rosso man mano che l'auto si avvicina.
- Sistema di occupazione del parcheggio: Costruisci un parcheggio intelligente con Arduino che mette un sensore in ogni posto e conta quelli liberi.
- Radar a ultrasuoni: Realizza un radar con Arduino che fa ruotare il sensore su un servo per scansionare l'ambiente.
- Robot che evita gli ostacoli: Unisci la stessa misura di distanza al controllo dei motori per creare un robot che evita gli ostacoli.
- Misura precisa a corta distanza: Per regolare il punto di stop al millimetro, prova il sensore di distanza laser VL53L0X; le differenze sono nel nostro confronto tra sensori di distanza.
Poiché un sensore di parcheggio Arduino unisce suono, luce e misura in un unico progetto, è un'ottima scelta sia come primo progetto serio sia per una tesina o una fiera della scienza. Adatta la tabella delle zone alla tua auto, prova il sistema prima in garage e poi fai un passo in più con i consigli di montaggio. Nell'app BlueGrays trovi lo schema di collegamento passo passo e il codice pronto dello stesso circuito nei progetti di sensore di parcheggio con HC-SR04 e con ESP32.
Domande frequenti
Come funziona un sensore di parcheggio con Arduino?
Un HC-SR04 invia ultrasuoni e misura il tempo di ritorno dell'eco, che Arduino converte in centimetri con tempo / 58. In base alla distanza sceglie una zona che decide il ritmo dei bip e quanti LED accendere. Usando millis() al posto di delay(), la misura continua anche mentre il buzzer suona.
Fino a che distanza misura l'HC-SR04?
Secondo il datasheet misura da 2 a 400 cm, ma su una superficie piana e ampia il campo affidabile è di circa 3–250 cm. Per parcheggiare basta iniziare l'avviso a 150 cm. Pali sottili e superfici morbide possono sfuggire anche a distanza minore.
L'HC-SR04 è impermeabile? Si può montare sul paraurti?
No, l'HC-SR04 non resiste ad acqua e polvere e dura poco sotto la pioggia e all'autolavaggio. Per il montaggio all'esterno dell'auto è meglio una sonda impermeabile come il JSN-SR04T. Se ti serve solo in garage, la soluzione più semplice è fissare il sensore alla parete.
Buzzer attivo o passivo per il sensore di parcheggio?
Il buzzer attivo ha un oscillatore interno: suona appena riceve 5 V e si comanda con digitalWrite, per questo il codice Uno è scritto per lui. Il passivo ha bisogno di una frequenza da tone() o, sull'ESP32, da LEDC, ma ti lascia scegliere il tono. Per riconoscerli collegali a 5 V: quello che suona da solo è attivo.
Come alimento Arduino in auto a 12 V?
L'impianto dell'auto arriva fino a 14,4 V a motore acceso e ha picchi di tensione, quindi la soluzione più sicura è un convertitore step-down come l'LM2596 regolato a 5 V. Aggiungi un fusibile da 1 A. Se lo colleghi alla luce di retromarcia, il sensore si accende solo in retromarcia.
Si possono usare più sensori a ultrasuoni insieme?
Sì, ma se trasmettono nello stesso istante possono sentire l'eco degli altri. Misura i sensori uno dopo l'altro con almeno 30–60 ms di pausa e mostra la distanza più piccola. Ogni sensore ha bisogno solo dei suoi pin TRIG ed ECHO.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
HC-SR04 Misura della distanza (display seriale)
Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Sensore di parcheggio con HC-SR04
Una versione in miniatura del sensore di parcheggio delle auto: più qualcosa si avvicina, più i bip accelerano.

Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
La versione ESP32 di un sensore di parcheggio! Il sensore a ultrasuoni HC-SR04 misura la distanza dall'oggetto davanti. Più si avvicina, più si riempie una barra di 5 LED (verde → giallo → rosso) e più il buzzer suona rapido. Molto vicino (sotto i 10 cm) parte un allarme continuo e si accendono tutti i LED. Il display OLED SSD1306 mostra i cm in tempo reale a caratteri grandi, insieme a un messaggio di stato.

ESP32 HC-SR04 Misuratore di distanza a ultrasuoni
Il sensore a ultrasuoni HC-SR04 misura la distanza in base al tempo che il suo impulso sonoro impiega a rimbalzare su un oggetto e tornare (tempo di volo). L'ESP32 invia un impulso di 10 microsecondi al pin TRIG e legge la durata dell'eco su ECHO con pulseIn(). La distanza appare in cm su un LCD I2C 16x2. L'HC-SR04 funziona a 5 V, quindi ECHO richiede un partitore di tensione, altrimenti il GPIO a 3,3 V dell'ESP32 si danneggia.

Misurazione della distanza tramite display LCD
Uno strumento che misura le distanze senza righello: muovi la mano avanti e indietro davanti al sensore e guarda il numero cambiare.

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.

Progetto di misurazione dell'altezza
Un misuratore d'altezza da appendere allo stipite della porta che ti dice in centimetri quanto è alto chi ci sta sotto.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

