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.

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.
| Compito | Componente | Cosa fa |
|---|---|---|
| Occupazione dei posti | 4 sensori a infrarossi di ostacolo (modulo FC-51 o TCRT5000) | Il pin OUT va a LOW se c'è un'auto |
| Rilevare l'auto all'ingresso | Sensore a ultrasuoni HC-SR04 | Misura la distanza dell'auto in cm |
| Rilevare l'auto all'uscita | 1 sensore a infrarossi di ostacolo | Vede l'auto che arriva dall'interno |
| Sbarra | Servomotore SG90 + bastoncino di gelato | 0° chiusa, 90° aperta |
| Display informativo | LCD I2C 16x2 | Posti liberi e stato dei posti |
| Luce di stato | LED verde e rosso | Posto disponibile / parcheggio pieno |
Elenco dei materiali
| Materiale | Quantità | Nota |
|---|---|---|
| Arduino Uno (o Nano) | 1 | Le versioni ESP32 e Pico sono più sotto |
| Sensore di distanza HC-SR04 | 1 | Funziona a 5 V |
| Sensore a infrarossi di ostacolo (modulo FC-51 / TCRT5000) | 5 | 4 posti auto + 1 uscita |
| Servomotore SG90 | 1 | Per il braccio della sbarra |
| LCD 16x2 + modulo I2C | 1 | Indirizzo di solito 0x27 o 0x3F |
| LED verde e rosso | 2 | Ciascuno con resistenza da 220 Ω |
| Breadboard e jumper | 1 set | Per i sensori sono comodi i cavi maschio-femmina |
| Alimentatore esterno 5 V (2 A) | 1 | Consigliato 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.
| Caratteristica | HC-SR04 | Sensore di ostacolo FC-51 | Modulo TCRT5000 |
|---|---|---|---|
| Raggio di rilevamento | 2–400 cm | Circa 2–30 cm (regolabile) | Circa 1–25 mm |
| Uscita | Durata dell'impulso (da misurare) | Digitale (LOW = ostacolo) | Digitale + analogica |
| Pin usati | 2 | 1 | 1 |
| Alimentazione | 5 V | 3,3–5 V | 3,3–5 V |
| Punto debole | Superfici morbide e inclinate | Luce solare, superfici nere | Raggio cortissimo, superfici nere |
| Posizione ideale nel parcheggio | Sbarra d'ingresso | Bordo posteriore del posto | Fondo del posto |

Schema di collegamento e tabella dei pin
| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Sensori posti 1–4 (OUT) | D2, D3, D4, D5 | GPIO 32, 33, 25, 26 | GP2, GP3, GP4, GP5 |
| Sensore di uscita (OUT) | D6 | GPIO 27 | GP6 |
| HC-SR04 TRIG | D7 | GPIO 23 | GP16 |
| HC-SR04 ECHO | D8 | GPIO 18 (con partitore di tensione) | GP17 (con partitore di tensione) |
| Segnale servo (filo arancione) | D9 | GPIO 13 | GP15 |
| LED verde / rosso (con 220 Ω) | D10 / D11 | Non usati | Non usati |
| SDA / SCL dell'LCD I2C | A4 / A5 | Non usati | Non usati |
| Alimentazione | Sensori a 5V, servo con 5 V esterno | HC-SR04 e servo a 5V/VIN, sensori IR a 3V3 | HC-SR04 e servo a VBUS, sensori IR a 3V3(OUT) |
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
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Confronta ogni collegamento con la tabella dei pin; prova prima solo i sensori nel Monitor seriale, poi aggiungi servo e LCD.
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.
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?
| Parte | Compito |
|---|---|
| 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. |
| wantOpen | Indica che la sbarra deve aprirsi se c'è un'auto all'ingresso e un posto libero, oppure se c'è un'auto all'uscita. |
| GATE_HOLD_MS | La 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.
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.
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 intervalIdee 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
| Problema | Causa probabile | Soluzione |
|---|---|---|
| Il servo vibra e Arduino si riavvia | Il servo è alimentato dall'USB e la corrente non basta | Alimenta il servo con un 5 V esterno, unisci i GND e aggiungi un condensatore da 470 µF all'alimentazione |
| L'LCD è acceso ma senza testo | Indirizzo I2C sbagliato o contrasto da regolare | Prova l'indirizzo 0x3F e ruota il potenziometro sul retro del modulo I2C |
| Un posto risulta sempre occupato | Sensibilità del sensore troppo alta o vede il fondo | Riduci il raggio con il potenziometro e inclina leggermente il sensore verso l'alto |
| L'auto nera non viene rilevata | La superficie nera assorbe la luce infrarossa | Incolla del nastro bianco sul lato dell'auto rivolto al sensore |
| L'HC-SR04 dà sempre 999 o valori casuali | TRIG ed ECHO invertiti, misure troppo ravvicinate o auto troppo inclinata | Controlla i pin, aspetta almeno 60 ms tra le misure e disponi il sensore perpendicolare all'auto |
| La sbarra scende con l'auto sotto | Il tempo GATE_HOLD_MS è troppo corto | Portalo a 4–5 secondi oppure metti un secondo sensore sotto la sbarra |
| La pagina dell'ESP32 non si apre | Lo smartphone è su un'altra rete o l'IP è sbagliato | Collega lo smartphone alla stessa rete Wi-Fi e usa l'IP mostrato nel Monitor seriale |
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.
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é.

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

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.

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.

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.

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.

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

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

