Guide · 11 min di lettura

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.

Sensore di distanza a ultrasuoni HC-SR04
HC-SR04: un cilindro invia un'onda sonora a 40 kHz, l'altro ascolta l'eco. Questi due cilindri sono gli occhi del sensore di parcheggio.

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:

CaratteristicaValore
Alimentazione5 V, circa 15 mA
Frequenza del suono40 kHz
Campo di misura2–400 cm (affidabile per il parcheggio: 3–250 cm)
Angolo di rilevamentoUn cono di circa 15°
Impulso di triggerAlmeno 10 µs HIGH su TRIG
Frequenza di misuraAlmeno 60 ms tra due misure
RisoluzioneCirca 3 mm

Lista dei componenti

ComponenteQuantitàNota
Arduino Uno o Nano1Versione ESP32 più sotto
Sensore a ultrasuoni HC-SR041Fuori dall'auto meglio il JSN-SR04T impermeabile
Buzzer attivo1Nella versione ESP32 un buzzer passivo
LED (2 verdi, 2 gialli, 1 rosso)5In fila, come barra LED
Resistenza da 220 Ω5Una per LED
Display OLED I2C da 0,96 pollici1Indicatore opzionale
Breadboard e cavetti jumper1 setUsa fili corti
Resistenze da 1 kΩ e 2 kΩUna per tipoSolo 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:

ZonaDistanzaIntervallo bipLED accesiSignificato
SicuraOltre 150 cmSilenzioNessunoVia libera
1101–150 cm800 ms1 verdeOstacolo rilevato
271–100 cm500 ms2 verdiRallenta
346–70 cm300 ms2 verdi + 1 gialloAttenzione
426–45 cm150 ms2 verdi + 2 gialliMolto vicino
525 cm o menoSuono continuoTutti 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 pinArduino UnoESP32Nota
HC-SR04 VCC5VVIN (5V)Il sensore vuole 5 V
HC-SR04 GNDGNDGNDMassa comune
HC-SR04 TRIGD9GPIO 4Uscita di trigger
HC-SR04 ECHOD10GPIO 18Sull'ESP32 tramite partitore 1 kΩ + 2 kΩ
Buzzer (+)D8GPIO 19Attivo sull'Uno, passivo sull'ESP32
LED 1 e 2 (verdi)D2, D3GPIO 25, 26Resistenza in serie da 220 Ω per ogni LED
LED 3 e 4 (gialli)D4, D5GPIO 27, 32Resistenza in serie da 220 Ω per ogni LED
LED 5 (rosso)D6GPIO 33Si accende nella zona di stop
OLED SDA / SCLA4 / A5GPIO 21 / 22Opzionale
OLED VCC5V3V3Controlla l'ordine dei pin del modulo
Il pin ECHO dell'HC-SR04 dà in uscita 5 V. Per l'Arduino Uno non è un problema, ma i pin dell'ESP32 sopportano solo 3,3 V. Metti una resistenza da 1 kΩ tra ECHO e GPIO 18 e una da 2 kΩ tra GPIO 18 e GND: 5 V × 2 / 3 ≈ 3,3 V. Puoi verificare i valori con lo strumento Partitore di tensione. Non dimenticare nemmeno le resistenze in serie dei LED: 220 Ω danno circa 13 mA a 5 V; per i tuoi LED puoi usare lo strumento Resistenza per LED.

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

  1. Inserisci l'HC-SR04 a un'estremità della breadboard con i cilindri rivolti verso l'esterno; collega VCC a 5V e GND a GND.
  2. Collega TRIG a D9 ed ECHO a D10. Usa fili corti; un jumper allentato rovina le letture a caso.
  3. 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.
  4. 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.
  5. 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.
  6. 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():

C++ (Arduino IDE)
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 codiceCosa fa
ZONE_CM e BEEP_MSTengono 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 / 58Converte 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 >= periodControlla 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 = 60Il 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.
Perché un filtro mediano è meglio di una media? Se tre letture danno 82, 83 e 3 cm, la media è 56 cm e il sistema salta per errore alla zona tre. La mediana è 82 cm; un singolo valore assurdo viene semplicemente ignorato. Puoi confrontare diversi tipi di filtro in filtrare i dati dei sensori.

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'ariaVelocità del suonoLettura (tempo ÷ 58)
-10 °C325 m/sCirca 106 cm
0 °C331 m/sCirca 104 cm
10 °C337 m/sCirca 102 cm
20 °C343 m/sCirca 100 cm
30 °C350 m/sCirca 99 cm
40 °C356 m/sCirca 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
I pin GPIO 34–39 dell'ESP32 funzionano solo come ingressi; se ci colleghi TRIG o i LED non succede nulla, ma per ECHO vanno bene. Se il suono non è abbastanza forte, prova valori di TONE_HZ tra 2000 e 4000; ogni buzzer passivo ha una frequenza a cui suona più forte. Se sei alle prime armi con l'ESP32, Cos'è l'ESP32? è un buon punto di partenza.

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.
Questo progetto è pensato per imparare e sperimentare e non sostituisce i sistemi di sicurezza dell'auto. Prima di lavorare sull'impianto elettrico del veicolo, stacca il morsetto negativo della batteria e tieni i cavi lontani da parti in movimento e dallo scarico. Continua a usare gli specchietti e a guardare dietro di te per gli ostacoli che il sensore non vede, come pali sottili, bambini o animali.

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
La distanza è sempre 999 o non cambiaTRIG ed ECHO invertiti, VCC diverso da 5 V o filo allentatoConfronta i pin con la tabella dei collegamenti e alimenta il sensore dai 5V
I valori saltano a casoSuperficie morbida o inclinata, breadboard allentata, misure troppo ravvicinateUsa il filtro mediano e lascia almeno 60 ms tra una misura e l'altra
La distanza si blocca durante il bipNel codice c'è un delay()Genera il bip con millis() e usa il codice di questo articolo
Il buzzer gracchia o resta mutoCodice per buzzer attivo usato con un buzzer passivo, o viceversaUsa un buzzer attivo con il codice Uno e uno passivo con il codice ESP32
I LED sfarfallano al limite di una zonaLa distanza oscilla proprio sul limiteAggiungi anche al codice Uno l'isteresi di 3 cm del codice ESP32
L'ESP32 non legge nessuna distanzaSensore alimentato a 3,3 V o partitore collegato al contrarioCollega VCC a VIN e verifica che la resistenza da 2 kΩ sia dal lato GND
Sul tavolo va bene, sull'auto falsi allarmiIl sensore vede il suolo, la targa o il gancio di trainoMonta il sensore più in alto e inclinalo di 3–5 gradi verso l'alto
Il buzzer è troppo deboleIl pin non fornisce abbastanza correntePilota il buzzer con un transistor NPN come il BC547
Dopo ogni modifica ripeti lo stesso test: sposta la scatola sui segni di 150, 100, 70, 45 e 25 cm e confronta il numero di zona nel Monitor seriale con la tabella. Se coincide in tutti i punti, il sistema è pronto. Trovi i dettagli del sensore e un primo sketch di misura in sensore di distanza HC-SR04, e i tipi di buzzer in Cos'è un buzzer?.

Progetti da provare dopo il sensore di parcheggio

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.

Vedi tutti i progetti
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

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é.

4.6(50)
82
Uso del cicalino
AR-13Principiante

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.

4.7(92)
171
Sensore di parcheggio con HC-SR04
AR-28Intermedio
Premium

Sensore di parcheggio con HC-SR04

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

4.8(64)
86
Sensore di parcheggio ESP32 (HC-SR04 + barra a 5 LED + cicalino + OLED)
ES-38Avanzato
Premium

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.

14
ESP32 HC-SR04 Misuratore di distanza a ultrasuoni
ES-14Intermedio

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.

4.9(29)
48
Misurazione della distanza tramite display LCD
AR-31Avanzato
Premium

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.

4.6(45)
59
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49
Progetto di misurazione dell'altezza
AR-33Intermedio
Premium

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.

4.5(25)
34