Parking intelligent Arduino : barrière servo et compteur LCD
Comment faire un parking intelligent Arduino ? Détection avec HC-SR04 ou capteur infrarouge, barrière servo SG90, places libres sur LCD I2C, code Uno/ESP32.
Le parking intelligent Arduino est une maquette qui détecte avec des capteurs si chaque place est occupée ou libre, ouvre et ferme la barrière d'entrée avec un servomoteur et affiche le nombre de places restantes sur un écran LCD. Tu construis sur ton bureau une petite copie des panneaux « Places libres : 12 » des parkings de centres commerciaux. Comme le projet réunit mesure de distance, lecture d'entrées numériques, commande de servo et affichage dans un seul montage, c'est à la fois un excellent premier gros projet et une idée parfaite pour un exposé ou un concours scientifique.
Dans ce guide, tu vas construire de A à Z une maquette de quatre places : un capteur infrarouge par place, un capteur à ultrasons HC-SR04 à l'entrée qui ouvre la barrière quand une voiture approche, un autre capteur à la sortie, une barrière avec servo SG90 et un LCD I2C 16x2. On commence par analyser le code Arduino Uno ligne par ligne, puis on transpose le système sur ESP32 avec un tableau de bord web consultable depuis ton téléphone, et enfin on écrit la version MicroPython pour Raspberry Pi Pico. À la fin, tu trouveras aussi les dimensions de la maquette et des conseils de présentation.

Qu'est-ce qu'un parking intelligent Arduino et comment fonctionne-t-il ?
Le système fait trois choses en même temps. D'abord le suivi de l'occupation : un capteur placé au sol ou à côté de chaque place indique en permanence si une voiture s'y trouve ; l'Arduino compte les places occupées et les soustrait du total. Ensuite le contrôle de la barrière : quand le capteur d'entrée voit une voiture et qu'il reste une place, la barrière se lève de 90 degrés puis redescend quelques secondes après le passage ; si le parking est complet, la barrière reste fermée et la LED rouge s'allume. Pour une voiture qui sort, la barrière s'ouvre toujours. Enfin l'information : la première ligne du LCD affiche « Bos yer: 3/4 » et la seconde l'état de chaque place. Comme on calcule le nombre de places libres directement à partir des capteurs de places, et non en comptant les entrées et les sorties, le compteur ne se décale jamais définitivement même si un capteur rate une voiture ; c'est une méthode bien plus fiable que les projets simples basés sur le comptage entrée-sortie.
| Fonction | Composant | Rôle |
|---|---|---|
| Occupation des places | 4 capteurs infrarouges d'obstacle (module FC-51 ou TCRT5000) | La broche OUT passe à LOW s'il y a une voiture |
| Détection à l'entrée | Capteur à ultrasons HC-SR04 | Mesure la distance de la voiture en cm |
| Détection à la sortie | 1 capteur infrarouge d'obstacle | Voit la voiture qui sort |
| Barrière | Servomoteur SG90 + bâtonnet de glace | 0° fermée, 90° ouverte |
| Affichage | LCD I2C 16x2 | Places libres et état des places |
| Voyant d'état | LED verte et rouge | Places disponibles / parking complet |
Liste du matériel
| Matériel | Quantité | Remarque |
|---|---|---|
| Arduino Uno (ou Nano) | 1 | Les versions ESP32 et Pico sont plus bas |
| Capteur de distance HC-SR04 | 1 | Fonctionne en 5 V |
| Capteur infrarouge d'obstacle (module FC-51 / TCRT5000) | 5 | 4 places + 1 sortie |
| Servomoteur SG90 | 1 | Pour le bras de la barrière |
| LCD 16x2 + module I2C | 1 | L'adresse est généralement 0x27 ou 0x3F |
| LED verte et rouge | 2 | Une résistance de 220 Ω pour chacune |
| Breadboard et fils de connexion | 1 lot | Des fils mâle-femelle sont pratiques pour les capteurs |
| Alimentation externe 5 V (2 A) | 1 | Recommandée pour le servo et les capteurs |
| Matériel de maquette | - | Plaque de mousse, carton, petites voitures, ruban coloré |
HC-SR04 ou capteur infrarouge ?
Tu peux détecter l'occupation d'une place de deux façons. Le HC-SR04 mesure la voiture avec des ondes sonores ; si tu en mets un par place, chacun consomme deux broches (TRIG et ECHO), soit huit broches pour quatre places. De plus, si les capteurs mesurent en même temps, ils peuvent entendre l'écho des autres : il faut donc les déclencher à tour de rôle. Les capteurs infrarouges d'obstacle, eux, n'ont qu'une sortie numérique, coûtent peu et leur distance de détection se règle avec le petit potentiomètre de la carte. La solution la plus équilibrée est donc un capteur infrarouge par place et un HC-SR04 à l'entrée, qui donne la distance sous forme de nombre. Tu trouveras plus de détails sur les différences entre les types de capteurs dans l'article comparatif des capteurs de distance.
| Caractéristique | HC-SR04 | Capteur d'obstacle FC-51 | Module TCRT5000 |
|---|---|---|---|
| Portée de détection | 2–400 cm | Environ 2–30 cm (réglable) | Environ 1–25 mm |
| Sortie | Durée d'impulsion (à mesurer) | Numérique (LOW = obstacle) | Numérique + analogique |
| Broches utilisées | 2 | 1 | 1 |
| Alimentation | 5 V | 3,3–5 V | 3,3–5 V |
| Point faible | Surfaces molles et inclinées | Lumière du soleil, surface noire | Portée très courte, surface noire |
| Meilleur emplacement | Barrière d'entrée | Bord arrière de la place | Sol de la place |

Schéma de câblage et tableau des broches
| Connexion | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Capteurs des places 1–4 (OUT) | D2, D3, D4, D5 | GPIO 32, 33, 25, 26 | GP2, GP3, GP4, GP5 |
| Capteur de sortie (OUT) | D6 | GPIO 27 | GP6 |
| HC-SR04 TRIG | D7 | GPIO 23 | GP16 |
| HC-SR04 ECHO | D8 | GPIO 18 (avec pont diviseur de tension) | GP17 (avec pont diviseur de tension) |
| Signal du servo (fil orange) | D9 | GPIO 13 | GP15 |
| LED verte / rouge (avec 220 Ω) | D10 / D11 | Non utilisées | Non utilisées |
| LCD I2C SDA / SCL | A4 / A5 | Non utilisé | Non utilisé |
| Alimentation | Capteurs en 5V, servo sur 5 V externe | HC-SR04 et servo en 5V/VIN, capteurs IR en 3V3 | HC-SR04 et servo en VBUS, capteurs IR en 3V3(OUT) |
Règle le potentiomètre bleu des capteurs infrarouges de façon que la LED du capteur s'allume quand la petite voiture est sur la place et s'éteigne quand elle part. Sur l'Arduino Uno, une résistance de 220 Ω suffit pour les LED ; si tu utilises une LED d'une autre couleur ou une autre tension, trouve la valeur avec le calculateur de résistance de LED. Tu peux consulter rapidement le brochage des cartes avec l'outil pinout. Les détails de câblage du LCD I2C et le code du scanner d'adresses sont expliqués dans l'article écran LCD I2C.
Construire la maquette du parking pas à pas
- Prends une plaque de mousse ou un carton épais d'environ 40×30 cm ; cette taille suffit pour quatre places, une voie d'entrée et un compartiment pour l'électronique.
- Mesure ta petite voiture et trace chaque place avec une largeur d'environ 1,5 fois celle de la voiture ; pour une voiture à l'échelle 1:43, des zones de 6×11 cm conviennent. Renforce les lignes avec du ruban blanc ou jaune.
- Place le capteur FC-51 au bord arrière de chaque place, face à la voiture, ou perce un petit trou dans le sol et encastre le TCRT5000 tourné vers le haut. Fais passer les fils sous la plaque.
- Place le HC-SR04 à côté de la voie d'entrée, dirigé vers le milieu de la route, 5 à 10 cm avant la barrière. Mets aussi le cinquième capteur infrarouge sur la voie de sortie.
- Fixe le SG90 à la colle chaude dans une petite cabine découpée dans la mousse et colle un bâtonnet de glace peint sur le bras du servo. Avant de monter le bras, mets le servo à 0 degré, puis fixe le bâtonnet à l'horizontale.
- Place le LCD et les LED sur un panneau visible par le conducteur à l'entrée ; cache l'Arduino et la breadboard dans le compartiment derrière ou sous la plaque.
- Compare chaque connexion avec le tableau des broches ; teste d'abord uniquement les capteurs dans le moniteur série, puis ajoute le servo et le LCD.
Code du parking pour Arduino Uno
Pour ce code, il suffit d'installer la bibliothèque LiquidCrystal I2C (Frank de Brabander) depuis le gestionnaire de bibliothèques ; les bibliothèques Servo et Wire sont fournies avec l'IDE Arduino. Si le LCD n'affiche rien, remplace l'adresse 0x27 du code par 0x3F. Le programme n'utilise pas de long delay pour garder la barrière ouverte, il chronomètre avec millis ; ainsi, il continue de lire les capteurs même quand la barrière est levée. Comme la bibliothèque Servo utilise le Timer1 sur l'Uno, analogWrite ne fonctionne pas sur D9 et D10 ; ce n'est pas un problème, puisque nous ne faisons qu'allumer et éteindre les LED.
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}Comment fonctionne le code ?
| Partie | Rôle |
|---|---|
| readSpots() | Lit les quatre capteurs de places et renvoie un masque où les bits des places occupées valent 1 ; par exemple, 0b0101 signifie que les places 1 et 3 sont occupées. |
| freeSpots() | Compte les bits à 0 du masque pour obtenir le nombre de places libres. |
| readDistanceCm() | Envoie une impulsion de déclenchement de 10 µs au HC-SR04, mesure la durée de l'écho avec pulseIn et la divise par 58 pour obtenir des cm. Si aucun écho n'arrive en 25 ms, renvoie 999. |
| showLcd() | Ne met à jour le LCD que lorsque l'état des places change ; l'écran ne scintille donc pas. |
| wantOpen | Indique que la barrière doit s'ouvrir s'il y a une voiture à l'entrée et une place libre, ou une voiture à la sortie. |
| GATE_HOLD_MS | La barrière redescend 3 secondes après la dernière détection ; tu peux augmenter ce délai selon ta maquette pour que le bras ne descende pas quand la voiture est dessous. |
| delay(60) | Laisse au moins 60 ms entre deux mesures du HC-SR04 pour que l'écho de la mesure précédente ne perturbe pas la nouvelle. |
Cette logique simple a une limite : une voiture qui passe l'entrée n'a pas encore atteint sa place, donc le nombre de places libres ne change pas pendant quelques secondes. Pour la dernière place libre, si deux voitures arrivent l'une derrière l'autre, les deux peuvent être admises. Pour régler ce problème, tu peux garder les voitures entrées dans un compteur « en route » à soustraire des places libres, puis le décrémenter quand la voiture se gare. La façon d'écrire proprement ce genre de comportements par étapes, c'est l'approche de la machine à états ; tu peux aussi lire pourquoi le timing se fait avec millis dans l'article différence entre millis et delay.
Parking avec tableau de bord web sur ESP32
Si tu réalises le même système avec un ESP32, tu peux suivre l'état du parking depuis un téléphone ou un ordinateur sur le même réseau Wi-Fi. Le code ci-dessous lance un petit serveur web dans l'ESP32 : la page d'accueil affiche le nombre de places libres, chaque place apparaît sous forme d'une case verte ou rouge, la page s'actualise toutes les deux secondes et le lien « Bariyeri ac » permet de lever la barrière à distance. De plus, l'adresse /api renvoie l'état en JSON ; tu pourras l'utiliser plus tard dans une application mobile ou sur une autre carte. Pour le servo, installe la bibliothèque ESP32Servo depuis le gestionnaire de bibliothèques ; les bibliothèques WiFi et WebServer sont fournies avec le core Arduino ESP32 et fonctionnent de la même façon en versions 2.x et 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}Avant de téléverser le code, remplace WIFI_ADIN et WIFI_SIFREN par les informations de ton propre réseau. Après le téléversement, ouvre le moniteur série à 115200 bauds ; une fois connecté au réseau, l'ESP32 affiche son adresse IP, et tu n'as plus qu'à la saisir dans le navigateur de ton téléphone. Les broches de l'ESP32 fonctionnent en 3,3 V et ne tolèrent pas le 5 V ; comme la broche ECHO du HC-SR04 envoie des impulsions de 5 V, place entre les deux un pont diviseur de tension de 1 kΩ et 2 kΩ : 5 V × 2 / (1 + 2) = 3,33 V. Tu peux vérifier le résultat avec d'autres valeurs de résistances grâce au calculateur de pont diviseur. Alimente les capteurs infrarouges par la broche 3V3 pour que leurs sorties soient aussi en 3,3 V. Si tu veux une mise à jour instantanée plutôt qu'un rechargement complet de la page, utilise la méthode de l'article ESP32 WebSocket.
Version MicroPython avec Raspberry Pi Pico
Si tu utilises un Raspberry Pi Pico, aucune bibliothèque supplémentaire n'est nécessaire pour le servo ; le PWM matériel du Pico génère directement le signal de servo à 50 Hz. L'angle du servo est converti en largeur d'impulsion : 0,5 ms pour 0°, 2,4 ms pour 180° ; sur une période de 20 ms, cette valeur est mise à l'échelle de 0 à 65535 avec duty_u16. La durée de l'écho du HC-SR04 est mesurée par machine.time_pulse_us. Le code ci-dessous écrit le nombre de places libres dans la console Thonny ; comme sur l'ESP32, n'oublie pas de mettre un pont diviseur de tension sur la ligne 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 intervalIdées pour améliorer le projet de parking
- Accès par carte pour abonnés : ajoute un lecteur RFID RC522 à l'entrée ; la barrière ne s'ouvre que pour les abonnés qui présentent une carte enregistrée.
- Grand afficheur numérique : montre le nombre de places libres avec un afficheur 7 segments lisible aussi depuis la route.
- Notification de parking complet : ajoute un bot Telegram à la version ESP32 pour envoyer un message sur ton téléphone quand le parking est plein.
- Durée et tarif de stationnement : enregistre avec millis le moment où chaque place se remplit, puis calcule le tarif selon la durée écoulée à la sortie de la voiture et affiche-le sur le LCD.
- Éclairage nocturne : allume automatiquement les LED de la voie quand la nuit tombe grâce à une LDR.
- Alerte place handicapé : fais retentir un court avertissement avec un buzzer quand une voiture entre dans la place réservée.
Conseils pour présenter le projet à l'école ou à un concours scientifique
- Commence par le problème : ouvre ta présentation avec une question comme « Combien de minutes les conducteurs perdent-ils à chercher une place ? » et explique en une phrase quel problème réel ton projet résout.
- Prépare un organigramme : un schéma montrant les étapes « La voiture est-elle arrivée ? Y a-t-il une place libre ? Ouvrir la barrière » permet au jury de comprendre la logique sans lire le code.
- Prévois une démonstration en direct : apporte autant de petites voitures que de places pour pouvoir remplir complètement le parking et montrer le message « DOLU » et la LED rouge.
- Prévois des secours : aie sous la main des fils de rechange, un deuxième câble USB, une batterie externe et un ordinateur portable avec le code déjà chargé ; dans une salle de concours, les connexions qui se desserrent arrivent très souvent.
- Parle honnêtement des limites : préciser que les capteurs infrarouges peuvent se tromper en plein soleil et que les vrais parkings utilisent des systèmes magnétiques ou par caméra est un point positif aux yeux du jury.
- Présente un plan d'évolution : évoquer les étapes suivantes, comme le tableau de bord web ESP32, l'abonnement par RFID ou le calcul du tarif, montre que le projet peut grandir. Pour plus de conseils, consulte l'article présenter un projet à un concours scientifique.
Erreurs fréquentes et solutions
| Problème | Cause probable | Solution |
|---|---|---|
| Le servo tremble, l'Arduino se réinitialise | Le servo est alimenté par l'USB, le courant ne suffit pas | Alimente le servo avec un 5 V externe, relie les GND et ajoute un condensateur de 470 µF sur l'alimentation |
| Le LCD s'allume mais n'affiche rien | Mauvaise adresse I2C ou réglage du contraste | Essaie l'adresse 0x3F, tourne le potentiomètre au dos du module I2C |
| Une place apparaît toujours occupée | Sensibilité du capteur trop élevée ou il voit le sol | Réduis la portée avec le potentiomètre, incline légèrement le capteur vers le haut |
| La voiture noire n'est pas détectée | La surface noire absorbe la lumière infrarouge | Colle du ruban blanc sur la face de la voiture tournée vers le capteur |
| Le HC-SR04 donne toujours 999 ou des valeurs aléatoires | TRIG et ECHO inversés, mesures trop rapprochées ou voiture trop inclinée | Vérifie les broches, attends au moins 60 ms entre les mesures, place le capteur perpendiculaire à la voiture |
| La barrière descend alors qu'une voiture est dessous | Durée GATE_HOLD_MS trop courte | Passe la durée à 4–5 secondes ou ajoute un second capteur sous la barrière |
| La page ESP32 ne s'ouvre pas | Le téléphone est sur un autre réseau ou l'IP est fausse | Connecte le téléphone au même réseau Wi-Fi, utilise l'IP du moniteur série |
Le parking intelligent Arduino réunit lecture de capteurs, prise de décision, commande de moteur et affichage dans une seule maquette amusante : c'est l'un des meilleurs moyens de combiner ce que tu as appris. Si tu veux découvrir les composants un par un, jette aussi un œil aux articles servomoteur et capteur infrarouge TCRT5000. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets de mesure de distance avec HC-SR04, de capteur de recul, d'afficheur de distance sur LCD, de commande de servo et de serveur web ESP32, pour tester séparément chaque partie de ce parking.
Questions fréquentes
Quel capteur utiliser pour un projet de parking Arduino ?
Pour l'occupation des places, l'option la plus pratique est un capteur infrarouge d'obstacle comme le FC-51 ou le TCRT5000 : il n'utilise qu'une broche numérique et coûte peu. Pour détecter la voiture qui approche à l'entrée, le capteur à ultrasons HC-SR04, qui donne la distance sous forme de nombre, convient mieux. Tu peux aussi mettre un HC-SR04 sur chaque place, mais chaque capteur consomme deux broches et doit être déclenché à tour de rôle.
Comment calculer le nombre de places libres d'un parking avec Arduino ?
La méthode la plus fiable consiste à placer un capteur sur chaque place, à compter les places occupées et à les soustraire du nombre total. La méthode qui compte les voitures à l'entrée et à la sortie utilise moins de capteurs, mais une seule voiture ratée décale le compteur définitivement. Le code de cet article lit les quatre capteurs à chaque boucle et recalcule le nombre de places libres.
Pourquoi l'Arduino se réinitialise-t-il quand la barrière à servo s'ouvre ?
Au démarrage de son mouvement, le servo SG90 peut appeler brièvement près de 500 mA et fait chuter la tension de l'alimentation USB. Quand la tension baisse, l'Arduino redémarre et le LCD pâlit. Alimente le servo avec une source 5 V externe, relie les GND et ajoute un condensateur de 470 µF, par exemple, sur l'alimentation du servo.
Comment faire une maquette de parking, avec quels matériaux ?
La plaque de mousse ou le carton épais se découpent facilement et se percent pour cacher capteurs et câbles. Une base d'environ 40×30 cm suffit pour quatre places et une voie d'entrée. Tu peux utiliser du ruban coloré pour les lignes de stationnement, un bâtonnet de glace pour le bras de la barrière et des petites voitures à l'échelle 1:43 comme véhicules.
Combien de capteurs de places peut-on brancher sur un Arduino Uno ?
L'Uno possède 20 broches, D0–D13 et A0–A5 ; une fois réservées celles du port série, de l'I2C, du servo, du HC-SR04, du capteur de sortie et des LED, il reste environ 10 broches pour les places. Les broches A0–A3 peuvent aussi servir d'entrées numériques. Pour plus de places, tu peux utiliser un registre à décalage d'entrée comme le 74HC165 ou une carte Arduino Mega.
Peut-on suivre le parking depuis un téléphone ?
Oui. Dans la version réalisée avec l'ESP32, la carte exécute son propre serveur web ; en saisissant l'adresse IP de l'ESP32 dans le navigateur de ton téléphone sur le même réseau Wi-Fi, tu vois le nombre de places libres et l'état de chaque place. Pour un accès depuis l'extérieur de la maison, on peut ajouter un bot Telegram, MQTT ou une solution cloud comme Blynk.
Projets à réaliser après cet article
Voir tous les projets
HC-SR04 Mesure de la distance (affichage en série)
Le capteur HC-SR04 fonctionne comme une chauve-souris qui trouve son chemin dans le noir : il envoie un son que tu ne peux pas entendre, écoute l'écho et mesure à quelle distance se trouve l'objet…

Capteur de stationnement avec HC-SR04
Une version miniature du radar de recul des voitures : plus un objet s'approche, plus les bips s'accélèrent.

Mesure de la distance à l'aide d'un écran LCD
Un appareil qui mesure les distances sans règle : avance et recule ta main devant le capteur et regarde le nombre changer.

Utilisation du servomoteur
Le bras d'un petit servomoteur tourne tour à tour vers trois positions : tout au début, pile au milieu et tout au bout, en attendant deux secondes à chaque arrêt.

Lecture de réflexion (proximité) avec TCRT5000
Avec un petit capteur qui envoie une lumière invisible et mesure ce qui revient, tu détectes la surface placée devant lui.

ESP32 HC-SR04 Télémètre à ultrasons
Le capteur à ultrasons HC-SR04 mesure une distance d'après le temps que met son impulsion sonore à rebondir sur un objet et revenir (temps de vol). L'ESP32 envoie une impulsion de 10 microsecondes sur TRIG et lit la durée de l'écho sur ECHO avec pulseIn(). La distance s'affiche en cm sur un LCD I2C 16x2. Le HC-SR04 fonctionne en 5 V : ECHO a besoin d'un pont diviseur, sinon le GPIO 3,3 V de l'ESP32 est endommagé.

Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
On transforme l'ESP32 en serveur web asynchrone que tu pilotes depuis ton téléphone ou ton ordinateur sur le même réseau Wi-Fi. Grâce à la bibliothèque ESPAsyncWebServer, le serveur traite plusieurs requêtes à la fois (il ne bloque pas sur une seule requête comme le WebServer.h classique). Ouvre l'adresse IP de l'ESP32 dans le navigateur et allume ou éteins la LED sur GPIO 5 avec les boutons ON/OFF (adresses /on et /off).

Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
La version ESP32 d'un radar de recul ! Le capteur à ultrasons HC-SR04 mesure la distance jusqu'à l'objet devant lui. Plus il se rapproche, plus une barre de 5 LED se remplit (vert → jaune → rouge) et plus le buzzer bipe vite. Tout près (moins de 10 cm), une alarme continue retentit et toutes les LED s'allument. L'écran OLED SSD1306 affiche la distance en cm en grands caractères, avec un message d'état.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

