Guide · 10 min di lettura

Parcheggio intelligente Arduino: sbarra servo e contaposti LCD

Come fare un parcheggio intelligente con Arduino? Sensori HC-SR04 e a infrarossi, sbarra con servo SG90, posti liberi su LCD I2C, codice per Uno ed ESP32.

Il parcheggio intelligente con Arduino è un plastico che rileva con dei sensori se i posti auto sono occupati o liberi, alza e abbassa la sbarra d'ingresso con un servomotore e mostra su un display LCD quanti posti restano. È una piccola copia dei cartelli "Posti liberi: 12" che vedi nei parcheggi dei centri commerciali, da montare sulla scrivania. Unisce in un solo circuito misura di distanza, lettura di ingressi digitali, controllo di un servo e uso di un display: perfetto come primo grande progetto e per presentazioni scolastiche o fiere della scienza.

In questa guida costruirai da zero un plastico con quattro posti auto: un sensore a infrarossi per ogni posto, un sensore a ultrasuoni HC-SR04 all'ingresso che apre la sbarra quando arriva un'auto, un sensore separato all'uscita, una sbarra con servo SG90 e un LCD I2C 16x2. Prima analizzeremo il codice Arduino Uno riga per riga, poi porteremo lo stesso sistema su ESP32 con un pannello web da guardare dallo smartphone e infine scriveremo la versione MicroPython per Raspberry Pi Pico. In fondo trovi le misure del plastico e i consigli per la presentazione.

Sensore a ultrasuoni di distanza HC-SR04
L'HC-SR04 rileva l'auto in avvicinamento all'ingresso tra 2 e 400 cm; per il plastico basta una soglia di 8 cm.

Che cos'è un parcheggio intelligente con Arduino e come funziona?

Il sistema svolge tre compiti insieme. Il primo è il monitoraggio dell'occupazione: un sensore posto sul fondo o a lato di ogni posto segnala continuamente se c'è un'auto; Arduino conta i posti occupati e li sottrae al totale. Il secondo è il controllo della sbarra: quando il sensore d'ingresso vede un'auto e c'è un posto libero, la sbarra si alza di 90 gradi e si abbassa qualche secondo dopo il passaggio; se il parcheggio è pieno la sbarra resta chiusa e si accende il LED rosso. Per le auto in uscita la sbarra si apre sempre. Il terzo è l'informazione: sulla prima riga dell'LCD compare il numero di posti liberi, sulla seconda lo stato di ogni posto. Poiché calcoliamo i posti liberi direttamente dai sensori dei posti e non contando entrate e uscite, anche se un sensore perde un'auto il contatore non si sfasa in modo permanente: è un metodo molto più affidabile dei semplici progetti basati sul conteggio.

CompitoComponenteCosa fa
Occupazione dei posti4 sensori a infrarossi di ostacolo (modulo FC-51 o TCRT5000)Il pin OUT va a LOW se c'è un'auto
Rilevare l'auto all'ingressoSensore a ultrasuoni HC-SR04Misura la distanza dell'auto in cm
Rilevare l'auto all'uscita1 sensore a infrarossi di ostacoloVede l'auto che arriva dall'interno
SbarraServomotore SG90 + bastoncino di gelato0° chiusa, 90° aperta
Display informativoLCD I2C 16x2Posti liberi e stato dei posti
Luce di statoLED verde e rossoPosto disponibile / parcheggio pieno

Elenco dei materiali

MaterialeQuantitàNota
Arduino Uno (o Nano)1Le versioni ESP32 e Pico sono più sotto
Sensore di distanza HC-SR041Funziona a 5 V
Sensore a infrarossi di ostacolo (modulo FC-51 / TCRT5000)54 posti auto + 1 uscita
Servomotore SG901Per il braccio della sbarra
LCD 16x2 + modulo I2C1Indirizzo di solito 0x27 o 0x3F
LED verde e rosso2Ciascuno con resistenza da 220 Ω
Breadboard e jumper1 setPer i sensori sono comodi i cavi maschio-femmina
Alimentatore esterno 5 V (2 A)1Consigliato per servo e sensori
Materiale per il plastico-Pannello di polistirolo, cartoncino, macchinine, nastro colorato

HC-SR04 o sensore a infrarossi?

Puoi rilevare l'occupazione dei posti in due modi. L'HC-SR04 misura l'auto con le onde sonore; se ne metti uno per posto, ognuno usa due pin (TRIG ed ECHO) e per quattro posti ne servono otto. Inoltre, se i sensori misurano contemporaneamente possono sentire l'eco l'uno dell'altro, quindi vanno attivati a turno. I sensori a infrarossi di ostacolo hanno invece una sola uscita digitale, costano poco e la distanza di rilevamento si regola con il piccolo potenziometro sulla scheda. La soluzione più equilibrata è quindi usare sensori a infrarossi nei posti e l'HC-SR04 all'ingresso, che fornisce la distanza come numero. Trovi le differenze tra i tipi di sensore nel confronto tra sensori di distanza.

CaratteristicaHC-SR04Sensore di ostacolo FC-51Modulo TCRT5000
Raggio di rilevamento2–400 cmCirca 2–30 cm (regolabile)Circa 1–25 mm
UscitaDurata dell'impulso (da misurare)Digitale (LOW = ostacolo)Digitale + analogica
Pin usati211
Alimentazione5 V3,3–5 V3,3–5 V
Punto deboleSuperfici morbide e inclinateLuce solare, superfici nereRaggio cortissimo, superfici nere
Posizione ideale nel parcheggioSbarra d'ingressoBordo posteriore del postoFondo del posto
Servomotore SG90
Con un bastoncino di gelato incollato al braccio, il servo SG90 diventa la sbarra del parcheggio in miniatura.

Schema di collegamento e tabella dei pin

CollegamentoArduino UnoESP32Raspberry Pi Pico
Sensori posti 1–4 (OUT)D2, D3, D4, D5GPIO 32, 33, 25, 26GP2, GP3, GP4, GP5
Sensore di uscita (OUT)D6GPIO 27GP6
HC-SR04 TRIGD7GPIO 23GP16
HC-SR04 ECHOD8GPIO 18 (con partitore di tensione)GP17 (con partitore di tensione)
Segnale servo (filo arancione)D9GPIO 13GP15
LED verde / rosso (con 220 Ω)D10 / D11Non usatiNon usati
SDA / SCL dell'LCD I2CA4 / A5Non usatiNon usati
AlimentazioneSensori a 5V, servo con 5 V esternoHC-SR04 e servo a 5V/VIN, sensori IR a 3V3HC-SR04 e servo a VBUS, sensori IR a 3V3(OUT)
Alimentare servo, cinque sensori e LCD tutti dal pin 5V di Arduino è l'errore più comune. L'SG90 può assorbire per un istante quasi 500 mA mentre il braccio si muove; la tensione dell'USB cala, l'LCD si spegne e Arduino si riavvia. Alimenta il servo da un adattatore esterno da 5 V e collega sempre il GND dell'adattatore al GND di Arduino: senza una massa comune il segnale del servo non ha senso.

Regola il potenziometro blu sui sensori a infrarossi in modo che il LED del sensore si accenda quando la macchinina è nel posto e si spenga quando la togli. Su Arduino Uno per i LED basta una resistenza da 220 Ω; se usi LED di altro colore o un'altra tensione, trova il valore con il calcolatore di resistenza per LED. Per la disposizione dei pin delle schede dai un'occhiata veloce allo strumento pinout. I dettagli di collegamento dell'LCD I2C e lo sketch per scansionare gli indirizzi sono nell'articolo Display LCD I2C.

Costruire il plastico del parcheggio passo dopo passo

  1. Prendi un pannello di polistirolo o un cartone spesso di circa 40×30 cm: basta per quattro posti, la strada d'ingresso e il vano dell'elettronica.
  2. Misura la tua macchinina e disegna ogni posto largo circa 1,5 volte l'auto; per un'auto in scala 1:43 vanno bene aree da 6×11 cm. Evidenzia le linee con nastro bianco o giallo.
  3. Sul bordo posteriore di ogni posto fissa il sensore FC-51 rivolto verso l'auto, oppure pratica un piccolo foro nel fondo e incassa il TCRT5000 rivolto verso l'alto. Fai passare i cavi sotto il pannello.
  4. Accanto alla strada d'ingresso metti l'HC-SR04 rivolto verso il centro della strada, a 5–10 cm prima della sbarra. Sulla corsia d'uscita metti il quinto sensore a infrarossi.
  5. Fissa l'SG90 con colla a caldo dentro una piccola casetta ritagliata dal polistirolo e incolla al braccio del servo un bastoncino di gelato dipinto. Prima di montare il braccio porta il servo a 0 gradi, poi fissa il bastoncino in orizzontale.
  6. Sistema l'LCD e i LED su un pannello-cartello che il conducente veda all'ingresso; nascondi Arduino e la breadboard nel vano dietro o sotto il pannello.
  7. Confronta ogni collegamento con la tabella dei pin; prova prima solo i sensori nel Monitor seriale, poi aggiungi servo e LCD.
I sensori a infrarossi non vedono bene le superfici nere, perché la vernice nera assorbe la luce infrarossa. Se hai una macchinina nera, incolla un pezzetto di nastro bianco sotto di essa o sul lato rivolto al sensore: il rilevamento migliora subito. Evita anche di far funzionare il plastico vicino a una finestra, perché la luce solare inganna i sensori a infrarossi.

Codice Arduino Uno per il parcheggio

Per il codice ti basta installare dal Gestore librerie la libreria LiquidCrystal I2C (Frank de Brabander); le librerie Servo e Wire sono incluse nell'IDE Arduino. Se l'LCD non mostra nulla, cambia l'indirizzo 0x27 nel codice in 0x3F. Il programma non usa un lungo delay per tenere la sbarra aperta ma conta il tempo con millis, così continua a leggere i sensori anche mentre la sbarra è alzata. Poiché la libreria Servo su Uno usa il Timer1, analogWrite non funziona su D9 e D10; dato che i LED vengono solo accesi e spenti, non è un problema.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Servo.h>
4
5const byte SPOT_COUNT = 4;
6const byte SPOT_PINS[SPOT_COUNT] = {2, 3, 4, 5};  // park yeri sensörleri / parking spot sensors
7const byte EXIT_PIN  = 6;    // çıkış sensörü / exit sensor
8const byte TRIG_PIN  = 7;    // HC-SR04 TRIG
9const byte ECHO_PIN  = 8;    // HC-SR04 ECHO
10const byte SERVO_PIN = 9;    // bariyer servosu / barrier servo
11const byte GREEN_LED = 10;   // yer var / space available
12const byte RED_LED   = 11;   // otopark dolu / car park full
13
14const int GATE_CLOSED = 0;                // kapalı açı / closed angle
15const int GATE_OPEN   = 90;               // açık açı / open angle
16const long CAR_DISTANCE_CM = 8;           // bu mesafeden yakınsa araç var / car present if closer
17const unsigned long GATE_HOLD_MS = 3000;  // son algılamadan sonra bekleme / wait after last detection
18
19LiquidCrystal_I2C lcd(0x27, 16, 2);       // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
20Servo gate;
21
22bool gateOpen = false;
23unsigned long lastSeen = 0;
24byte lastMask = 0xFF;                     // ilk çizimi zorlar / forces the first redraw
25
26byte readSpots() {
27  byte mask = 0;
28  for (byte i = 0; i < SPOT_COUNT; i++) {
29    if (digitalRead(SPOT_PINS[i]) == LOW) {   // LOW = araç var / LOW = car present
30      mask |= (1 << i);
31    }
32  }
33  return mask;
34}
35
36byte freeSpots(byte mask) {
37  byte count = 0;
38  for (byte i = 0; i < SPOT_COUNT; i++) {
39    if (!(mask & (1 << i))) count++;
40  }
41  return count;
42}
43
44long readDistanceCm() {
45  digitalWrite(TRIG_PIN, LOW);
46  delayMicroseconds(2);
47  digitalWrite(TRIG_PIN, HIGH);
48  delayMicroseconds(10);                  // 10 µs tetik darbesi / 10 µs trigger pulse
49  digitalWrite(TRIG_PIN, LOW);
50  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı / 25 ms timeout
51  if (us == 0) return 999;                // yankı yok / no echo
52  return us / 58;                         // µs -> cm
53}
54
55void showLcd(byte mask, byte freeCount) {
56  lcd.setCursor(0, 0);
57  lcd.print(F("Bos yer: "));
58  lcd.print(freeCount);
59  lcd.print('/');
60  lcd.print(SPOT_COUNT);
61  lcd.print(F("    "));
62  lcd.setCursor(0, 1);
63  for (byte i = 0; i < SPOT_COUNT; i++) {
64    lcd.print(i + 1);
65    lcd.print((mask & (1 << i)) ? 'X' : '-');   // X = dolu, - = boş / X = occupied, - = free
66    lcd.print(' ');
67  }
68  if (freeCount == 0) {
69    lcd.print(F("DOLU"));                 // otopark dolu / car park full
70  } else {
71    lcd.print(F("    "));
72  }
73}
74
75void setup() {
76  for (byte i = 0; i < SPOT_COUNT; i++) pinMode(SPOT_PINS[i], INPUT);
77  pinMode(EXIT_PIN, INPUT);
78  pinMode(TRIG_PIN, OUTPUT);
79  pinMode(ECHO_PIN, INPUT);
80  pinMode(GREEN_LED, OUTPUT);
81  pinMode(RED_LED, OUTPUT);
82
83  gate.attach(SERVO_PIN);
84  gate.write(GATE_CLOSED);                // bariyer kapalı başlar / barrier starts closed
85
86  lcd.init();
87  lcd.backlight();
88  lcd.setCursor(0, 0);
89  lcd.print(F("Akilli Otopark"));
90  lcd.setCursor(0, 1);
91  lcd.print(F("BlueGrays"));
92  delay(1500);
93  lcd.clear();
94}
95
96void loop() {
97  byte mask = readSpots();
98  byte freeCount = freeSpots(mask);
99
100  if (mask != lastMask) {                 // yalnız değişince yaz / redraw only on change
101    showLcd(mask, freeCount);
102    lastMask = mask;
103  }
104  digitalWrite(GREEN_LED, freeCount > 0 ? HIGH : LOW);
105  digitalWrite(RED_LED, freeCount == 0 ? HIGH : LOW);
106
107  bool carAtEntry = readDistanceCm() < CAR_DISTANCE_CM;
108  bool carAtExit  = digitalRead(EXIT_PIN) == LOW;
109  bool wantOpen   = (carAtEntry && freeCount > 0) || carAtExit;
110
111  if (wantOpen) {
112    lastSeen = millis();
113    if (!gateOpen) {
114      gate.write(GATE_OPEN);
115      gateOpen = true;
116    }
117  } else if (gateOpen && millis() - lastSeen > GATE_HOLD_MS) {
118    gate.write(GATE_CLOSED);
119    gateOpen = false;
120  }
121  delay(60);                              // HC-SR04 ölçüm aralığı / HC-SR04 measurement interval
122}

Come funziona il codice?

ParteCompito
readSpots()Legge i quattro sensori dei posti e restituisce una maschera con il bit a 1 per i posti occupati; per esempio 0b0101 significa che il 1° e il 3° posto sono occupati.
freeSpots()Conta i bit a 0 nella maschera per trovare il numero di posti liberi.
readDistanceCm()Invia all'HC-SR04 un impulso di trigger da 10 µs, misura la durata dell'eco con pulseIn e divide per 58 per ottenere i cm. Se l'eco non arriva entro 25 ms restituisce 999.
showLcd()Aggiorna l'LCD solo quando cambia lo stato dei posti, così lo schermo non sfarfalla.
wantOpenIndica che la sbarra deve aprirsi se c'è un'auto all'ingresso e un posto libero, oppure se c'è un'auto all'uscita.
GATE_HOLD_MSLa sbarra si abbassa 3 secondi dopo l'ultimo rilevamento; puoi aumentare questo tempo in base al plastico, perché il braccio non scenda mentre l'auto è sotto la sbarra.
delay(60)Lascia almeno 60 ms tra le misure dell'HC-SR04, così l'eco della misura precedente non disturba la nuova.

Questa logica semplice ha un limite: l'auto che passa dall'ingresso non ha ancora raggiunto il posto, quindi per qualche secondo il numero di posti liberi non cambia. Per l'ultimo posto libero, se arrivano due auto di fila possono entrare entrambe. Per risolvere puoi tenere le auto passate dall'ingresso in un contatore "in transito" da sottrarre ai posti liberi e diminuirlo quando l'auto si ferma nel posto. Il modo di scrivere in modo ordinato questi comportamenti a passi è l'approccio a macchina a stati; perché la temporizzazione si fa con millis lo leggi in differenza tra millis e delay.

Parcheggio con pannello web su ESP32

Se costruisci lo stesso sistema con l'ESP32, puoi controllare lo stato del parcheggio dallo smartphone o dal computer collegati alla stessa rete Wi-Fi. Il codice qui sotto avvia un piccolo server web nell'ESP32: nella pagina principale compaiono i posti liberi, ogni posto è un riquadro verde o rosso, la pagina si aggiorna ogni due secondi e con il link "Bariyeri ac" puoi alzare la sbarra da remoto. L'indirizzo /api restituisce inoltre lo stato in JSON, da usare in futuro in un'app mobile o su un'altra scheda. Per il servo installa dal Gestore librerie la libreria ESP32Servo; WiFi e WebServer sono inclusi nell'ESP32 Arduino core e funzionano allo stesso modo sia nella versione 2.x sia nella 3.x.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* WIFI_SSID = "WIFI_ADIN";      // kendi ağ adın / your network name
6const char* WIFI_PASS = "WIFI_SIFREN";    // kendi şifren / your password
7
8const int SPOT_COUNT = 4;
9const int SPOT_PINS[SPOT_COUNT] = {32, 33, 25, 26};  // park yeri sensörleri / parking spot sensors
10const int EXIT_PIN  = 27;    // çıkış sensörü / exit sensor
11const int TRIG_PIN  = 23;    // HC-SR04 TRIG
12const int ECHO_PIN  = 18;    // HC-SR04 ECHO (gerilim bölücüyle / via voltage divider)
13const int SERVO_PIN = 13;    // bariyer servosu / barrier servo
14
15const int GATE_CLOSED = 0;
16const int GATE_OPEN   = 90;
17const long CAR_DISTANCE_CM = 8;
18const unsigned long GATE_HOLD_MS = 3000;
19
20WebServer server(80);
21Servo gate;
22bool gateOpen = false;
23unsigned long lastSeen = 0;
24
25bool spotFull(int i) {
26  return digitalRead(SPOT_PINS[i]) == LOW;   // LOW = araç var / LOW = car present
27}
28
29int freeSpots() {
30  int count = 0;
31  for (int i = 0; i < SPOT_COUNT; i++) {
32    if (!spotFull(i)) count++;
33  }
34  return count;
35}
36
37long readDistanceCm() {
38  digitalWrite(TRIG_PIN, LOW);
39  delayMicroseconds(2);
40  digitalWrite(TRIG_PIN, HIGH);
41  delayMicroseconds(10);                  // 10 µs tetik darbesi / 10 µs trigger pulse
42  digitalWrite(TRIG_PIN, LOW);
43  unsigned long us = pulseIn(ECHO_PIN, HIGH, 25000UL);  // 25 ms zaman aşımı / 25 ms timeout
44  if (us == 0) return 999;                // yankı yok / no echo
45  return us / 58;
46}
47
48void openGate() {
49  lastSeen = millis();
50  if (!gateOpen) {
51    gate.write(GATE_OPEN);
52    gateOpen = true;
53  }
54}
55
56void handleRoot() {
57  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>";
58  html += "<meta name='viewport' content='width=device-width,initial-scale=1'>";
59  html += "<meta http-equiv='refresh' content='2'><title>Otopark</title></head>";
60  html += "<body style='font-family:sans-serif;text-align:center'>";
61  html += "<h1>Akilli Otopark</h1>";
62  html += "<h2>Bos yer: " + String(freeSpots()) + " / " + String(SPOT_COUNT) + "</h2>";
63  for (int i = 0; i < SPOT_COUNT; i++) {
64    html += "<div style='display:inline-block;width:70px;height:90px;line-height:90px;margin:6px;";
65    html += "border-radius:8px;color:#fff;font-size:24px;background:";
66    html += spotFull(i) ? "#c62828'>" : "#2e7d32'>";   // kırmızı = dolu, yeşil = boş / red = full, green = free
67    html += "P" + String(i + 1) + "</div>";
68  }
69  html += "<p>Bariyer: ";
70  html += gateOpen ? "ACIK" : "KAPALI";
71  html += "</p><p><a href='/open'>Bariyeri ac</a></p></body></html>";
72  server.send(200, "text/html", html);
73}
74
75void handleApi() {
76  String json = "{\"free\":" + String(freeSpots()) + ",\"spots\":[";
77  for (int i = 0; i < SPOT_COUNT; i++) {
78    json += spotFull(i) ? "1" : "0";
79    if (i < SPOT_COUNT - 1) json += ",";
80  }
81  json += "],\"gate\":";
82  json += gateOpen ? "true" : "false";
83  json += "}";
84  server.send(200, "application/json", json);
85}
86
87void handleOpen() {
88  openGate();                              // görevli bariyeri elle açar / operator opens the gate manually
89  server.sendHeader("Location", "/");
90  server.send(303, "text/plain", "");
91}
92
93void setup() {
94  Serial.begin(115200);
95  for (int i = 0; i < SPOT_COUNT; i++) pinMode(SPOT_PINS[i], INPUT);
96  pinMode(EXIT_PIN, INPUT);
97  pinMode(TRIG_PIN, OUTPUT);
98  pinMode(ECHO_PIN, INPUT);
99
100  gate.setPeriodHertz(50);                 // standart servo frekansı / standard servo frequency
101  gate.attach(SERVO_PIN, 500, 2400);       // darbe aralığı µs / pulse range in µs
102  gate.write(GATE_CLOSED);
103
104  WiFi.mode(WIFI_STA);
105  WiFi.begin(WIFI_SSID, WIFI_PASS);
106  Serial.print("Wi-Fi baglaniyor");
107  while (WiFi.status() != WL_CONNECTED) {
108    delay(500);
109    Serial.print('.');
110  }
111  Serial.println();
112  Serial.print("Panel IP: ");
113  Serial.println(WiFi.localIP());          // bu adresi tarayıcıya yaz / type this address in the browser
114
115  server.on("/", handleRoot);
116  server.on("/open", handleOpen);
117  server.on("/api", handleApi);
118  server.begin();
119}
120
121void loop() {
122  server.handleClient();
123
124  static unsigned long lastCheck = 0;
125  if (millis() - lastCheck < 60) return;   // 60 ms'de bir ölç / measure every 60 ms
126  lastCheck = millis();
127
128  bool carAtEntry = readDistanceCm() < CAR_DISTANCE_CM;
129  bool carAtExit  = digitalRead(EXIT_PIN) == LOW;
130
131  if ((carAtEntry && freeSpots() > 0) || carAtExit) {
132    openGate();
133  } else if (gateOpen && millis() - lastSeen > GATE_HOLD_MS) {
134    gate.write(GATE_CLOSED);
135    gateOpen = false;
136  }
137}

Prima di caricare il codice, sostituisci WIFI_ADIN e WIFI_SIFREN con i dati della tua rete. Dopo il caricamento apri il Monitor seriale a 115200 baud; quando l'ESP32 si collega alla rete stampa il suo indirizzo IP, che ti basta digitare nel browser dello smartphone. I pin dell'ESP32 lavorano a 3,3 V e non tollerano i 5 V; poiché il pin ECHO dell'HC-SR04 dà impulsi a 5 V, inserisci un partitore di tensione con resistenze da 1 kΩ e 2 kΩ: 5 V × 2 / (1 + 2) = 3,33 V. Con altri valori di resistenza puoi verificare il risultato con il calcolatore del partitore di tensione. Alimenta i sensori a infrarossi dal pin 3V3, così anche le loro uscite sono a 3,3 V. Se vuoi un aggiornamento istantaneo invece di ricaricare la pagina a ogni refresh, usa il metodo dell'articolo ESP32 WebSocket.

Versione MicroPython con Raspberry Pi Pico

Se usi il Raspberry Pi Pico per il servo non servono librerie aggiuntive: il PWM hardware del Pico genera direttamente il segnale a 50 Hz. L'angolo del servo si converte in larghezza d'impulso: 0,5 ms per 0° e 2,4 ms per 180°; su un periodo di 20 ms questo valore viene scalato con duty_u16 nell'intervallo 0–65535. La durata dell'eco dell'HC-SR04 la misura machine.time_pulse_us. Il codice qui sotto scrive i posti liberi nella console di Thonny; come per l'ESP32, non dimenticare il partitore di tensione sulla linea ECHO.

MicroPython
1from machine import Pin, PWM, time_pulse_us
2import time
3
4spots = [Pin(p, Pin.IN) for p in (2, 3, 4, 5)]   # park yeri sensörleri / parking spot sensors
5exit_ir = Pin(6, Pin.IN)                         # çıkış sensörü / exit sensor
6trig = Pin(16, Pin.OUT)                          # HC-SR04 TRIG
7echo = Pin(17, Pin.IN)                           # gerilim bölücüyle / via voltage divider
8servo = PWM(Pin(15))
9servo.freq(50)                                   # 20 ms periyot / 20 ms period
10
11GATE_CLOSED = 0
12GATE_OPEN = 90
13CAR_DISTANCE_CM = 8
14GATE_HOLD_MS = 3000
15
16def set_angle(angle):
17    us = 500 + angle * 1900 // 180               # 0,5-2,4 ms darbe / 0.5-2.4 ms pulse
18    servo.duty_u16(us * 65535 // 20000)
19
20def distance_cm():
21    trig.low()
22    time.sleep_us(2)
23    trig.high()
24    time.sleep_us(10)                            # 10 µs tetik / 10 µs trigger
25    trig.low()
26    t = time_pulse_us(echo, 1, 25000)            # 25 ms zaman aşımı / 25 ms timeout
27    if t < 0:
28        return 999                               # yankı yok / no echo
29    return t / 58
30
31def free_spots():
32    return sum(1 for s in spots if s.value() == 1)   # 1 = boş / 1 = free
33
34gate_open = False
35last_seen = 0
36last_free = -1
37set_angle(GATE_CLOSED)
38
39while True:
40    free = free_spots()
41    if free != last_free:                        # yalnız değişince yaz / print only on change
42        print("Bos yer:", free, "/", len(spots))
43        last_free = free
44    car_in = distance_cm() < CAR_DISTANCE_CM
45    car_out = exit_ir.value() == 0
46    now = time.ticks_ms()
47    if (car_in and free > 0) or car_out:
48        last_seen = now
49        if not gate_open:
50            set_angle(GATE_OPEN)
51            gate_open = True
52    elif gate_open and time.ticks_diff(now, last_seen) > GATE_HOLD_MS:
53        set_angle(GATE_CLOSED)
54        gate_open = False
55    time.sleep_ms(60)                            # ölçüm aralığı / measurement interval

Idee per far crescere il progetto del parcheggio

  • Ingresso con tessera per abbonati: aggiungi all'ingresso un lettore RFID RC522; la sbarra si apre solo per gli abbonati che passano la tessera registrata.
  • Grande cartello numerico: mostra i posti liberi con un display a 7 segmenti, leggibile anche dalla strada.
  • Avviso di parcheggio pieno: aggiungi alla versione ESP32 un bot Telegram che ti manda un messaggio quando il parcheggio si riempie.
  • Tempo di sosta e tariffa: registra con millis il momento in cui ogni posto si occupa, calcola la tariffa in base al tempo trascorso quando l'auto esce e mostrala sull'LCD.
  • Illuminazione notturna: con una fotoresistenza LDR accendi automaticamente i LED della strada quando fa buio.
  • Avviso per il posto disabili: fai suonare un breve avviso con un buzzer quando un'auto entra nel posto riservato.

Progetto scolastico e fiera della scienza: consigli per la presentazione

  • Parti dal problema: apri la presentazione con una domanda come "Quanti minuti perdono i conducenti cercando un posto libero?" e spiega in una frase quale problema reale risolve il progetto.
  • Prepara un diagramma di flusso: uno schema con i passi "È arrivata un'auto? C'è un posto libero? Apri la sbarra" permette alla giuria di capire la logica senza leggere il codice.
  • Pianifica una dimostrazione dal vivo: porta tante macchinine quanti sono i posti, per riempire del tutto il parcheggio e mostrare la scritta "DOLU" e il LED rosso.
  • Porta i ricambi: tieni a portata di mano jumper di scorta, un secondo cavo USB, un powerbank e un portatile con il codice già caricato; in fiera i collegamenti che si allentano sono frequentissimi.
  • Dichiara onestamente i limiti: dire che i sensori a infrarossi possono sbagliare alla luce del sole e che nei parcheggi reali si usano sistemi magnetici o a telecamera è un punto in più agli occhi della giuria.
  • Presenta un piano di sviluppo: raccontare i passi successivi, come il pannello web ESP32, l'abbonamento RFID o il calcolo della tariffa, mostra che il progetto può crescere. Per altri consigli leggi l'articolo sulla presentazione di un progetto per la fiera della scienza.

Errori comuni e soluzioni

ProblemaCausa probabileSoluzione
Il servo vibra e Arduino si riavviaIl servo è alimentato dall'USB e la corrente non bastaAlimenta il servo con un 5 V esterno, unisci i GND e aggiungi un condensatore da 470 µF all'alimentazione
L'LCD è acceso ma senza testoIndirizzo I2C sbagliato o contrasto da regolareProva l'indirizzo 0x3F e ruota il potenziometro sul retro del modulo I2C
Un posto risulta sempre occupatoSensibilità del sensore troppo alta o vede il fondoRiduci il raggio con il potenziometro e inclina leggermente il sensore verso l'alto
L'auto nera non viene rilevataLa superficie nera assorbe la luce infrarossaIncolla del nastro bianco sul lato dell'auto rivolto al sensore
L'HC-SR04 dà sempre 999 o valori casualiTRIG ed ECHO invertiti, misure troppo ravvicinate o auto troppo inclinataControlla i pin, aspetta almeno 60 ms tra le misure e disponi il sensore perpendicolare all'auto
La sbarra scende con l'auto sottoIl tempo GATE_HOLD_MS è troppo cortoPortalo a 4–5 secondi oppure metti un secondo sensore sotto la sbarra
La pagina dell'ESP32 non si apreLo smartphone è su un'altra rete o l'IP è sbagliatoCollega lo smartphone alla stessa rete Wi-Fi e usa l'IP mostrato nel Monitor seriale
Costruisci il progetto un pezzo alla volta: prova prima solo i sensori dei posti nel Monitor seriale, poi l'HC-SR04, poi il servo e per ultimo l'LCD. Collegare tutto insieme e cercare l'errore quando non funziona richiede molto più tempo che procedere a passi. Per i problemi con il servo leggi il problema delle vibrazioni del servo, per i riavvii imprevisti Arduino si riavvia.

Il parcheggio intelligente con Arduino è uno dei modi migliori per mettere insieme ciò che hai imparato, perché riunisce in un solo divertente plastico lettura di sensori, decisioni, controllo di un motore e uso di un display. Se vuoi conoscere i componenti uno per uno, dai un'occhiata anche agli articoli sul servomotore e sul sensore a infrarossi TCRT5000. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, i progetti di misura della distanza con HC-SR04, sensore di parcheggio, indicatore di distanza con LCD, controllo di servo e server web ESP32, così puoi provare ogni parte di questo parcheggio separatamente.

Domande frequenti

Quale sensore si usa per un progetto di parcheggio con Arduino?

Per l'occupazione dei posti la scelta più pratica sono i sensori a infrarossi di ostacolo come FC-51 o TCRT5000: usano un solo pin digitale e costano poco. Per rilevare l'auto in arrivo all'ingresso è più adatto il sensore a ultrasuoni HC-SR04, che dà la distanza come numero. Puoi mettere un HC-SR04 anche in ogni posto, ma ogni sensore usa due pin e va attivato a turno.

Come si calcolano i posti liberi di un parcheggio con Arduino?

Il metodo più affidabile è mettere un sensore per ogni posto, contare quelli occupati e sottrarli al totale. Il metodo che conta le auto in entrata e in uscita usa meno sensori, ma un solo passaggio mancato sfasa il contatore in modo permanente. Il codice di questo articolo legge i quattro sensori a ogni ciclo e ricalcola i posti liberi.

Perché Arduino si riavvia quando la sbarra del servo si apre?

L'SG90 all'avvio del movimento può assorbire per un istante quasi 500 mA e fa calare la tensione dell'alimentazione USB. Quando la tensione scende, Arduino si riavvia e l'LCD si spegne. Alimenta il servo da una fonte esterna a 5 V, unisci i GND e aggiungi un condensatore, per esempio da 470 µF, all'alimentazione del servo.

Come si costruisce un plastico di parcheggio e quali materiali si usano?

Il pannello di polistirolo o il cartone spesso si taglia facilmente e si può forare per nascondere sensori e cavi. Una base di circa 40×30 cm basta per quattro posti e la strada d'ingresso. Puoi usare nastro colorato per le linee dei posti, un bastoncino di gelato per il braccio della sbarra e macchinine in scala 1:43 come auto.

Quanti sensori di posto si possono collegare ad Arduino Uno?

L'Uno ha 20 pin, D0–D13 e A0–A5; dopo aver riservato seriale, I2C, servo, HC-SR04, sensore d'uscita e LED, per i posti ne restano circa 10. Anche i pin A0–A3 si possono usare come ingressi digitali. Per più posti puoi usare un registro a scorrimento in ingresso come il 74HC165 oppure un Arduino Mega.

Si può controllare il parcheggio dallo smartphone?

Sì. Nella versione con ESP32 la scheda esegue un proprio server web; scrivendo l'indirizzo IP dell'ESP32 nel browser dello smartphone collegato alla stessa rete Wi-Fi vedi i posti liberi e lo stato di ogni posto. Per l'accesso da fuori casa si possono aggiungere un bot Telegram, MQTT o soluzioni cloud come Blynk.

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
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
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
Utilizzo del servomotore
AR-35Principiante
Premium

Utilizzo del servomotore

Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

4.7(48)
67
Lettura della riflessione (prossimità) con TCRT5000
AR-77Intermedio
Premium

Lettura della riflessione (prossimità) con TCRT5000

Con un piccolo sensore che manda luce invisibile e misura quanta ne torna indietro, rilevi la superficie che ha davanti.

4.6(33)
43
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
Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)
ES-27Avanzato

Server web asincrono ESP32 (con indicazione dell'IP sul display LCD)

In questo progetto trasformiamo l'ESP32 in un server web asincrono che potrete controllare dal vostro telefono o computer collegato alla stessa rete Wi-Fi. Grazie alla libreria ESPAsyncWebServer, il server è in grado di elaborare più richieste contemporaneamente (a differenza del classico WebServer.h, che si blocca su una singola richiesta).

4.8(16)
26
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