Guides · 11 min de lecture

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.

Capteur de distance à ultrasons HC-SR04
Le HC-SR04 détecte une voiture qui approche à l'entrée du parking entre 2 et 400 cm ; pour la maquette, un seuil de 8 cm suffit.

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.

FonctionComposantRôle
Occupation des places4 capteurs infrarouges d'obstacle (module FC-51 ou TCRT5000)La broche OUT passe à LOW s'il y a une voiture
Détection à l'entréeCapteur à ultrasons HC-SR04Mesure la distance de la voiture en cm
Détection à la sortie1 capteur infrarouge d'obstacleVoit la voiture qui sort
BarrièreServomoteur SG90 + bâtonnet de glace0° fermée, 90° ouverte
AffichageLCD I2C 16x2Places libres et état des places
Voyant d'étatLED verte et rougePlaces disponibles / parking complet

Liste du matériel

MatérielQuantitéRemarque
Arduino Uno (ou Nano)1Les versions ESP32 et Pico sont plus bas
Capteur de distance HC-SR041Fonctionne en 5 V
Capteur infrarouge d'obstacle (module FC-51 / TCRT5000)54 places + 1 sortie
Servomoteur SG901Pour le bras de la barrière
LCD 16x2 + module I2C1L'adresse est généralement 0x27 ou 0x3F
LED verte et rouge2Une résistance de 220 Ω pour chacune
Breadboard et fils de connexion1 lotDes fils mâle-femelle sont pratiques pour les capteurs
Alimentation externe 5 V (2 A)1Recommandé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éristiqueHC-SR04Capteur d'obstacle FC-51Module TCRT5000
Portée de détection2–400 cmEnviron 2–30 cm (réglable)Environ 1–25 mm
SortieDurée d'impulsion (à mesurer)Numérique (LOW = obstacle)Numérique + analogique
Broches utilisées211
Alimentation5 V3,3–5 V3,3–5 V
Point faibleSurfaces molles et inclinéesLumière du soleil, surface noirePortée très courte, surface noire
Meilleur emplacementBarrière d'entréeBord arrière de la placeSol de la place
Servomoteur SG90
Avec un bâtonnet de glace collé sur son bras, le servo SG90 devient la barrière du parking miniature.

Schéma de câblage et tableau des broches

ConnexionArduino UnoESP32Raspberry Pi Pico
Capteurs des places 1–4 (OUT)D2, D3, D4, D5GPIO 32, 33, 25, 26GP2, GP3, GP4, GP5
Capteur de sortie (OUT)D6GPIO 27GP6
HC-SR04 TRIGD7GPIO 23GP16
HC-SR04 ECHOD8GPIO 18 (avec pont diviseur de tension)GP17 (avec pont diviseur de tension)
Signal du servo (fil orange)D9GPIO 13GP15
LED verte / rouge (avec 220 Ω)D10 / D11Non utiliséesNon utilisées
LCD I2C SDA / SCLA4 / A5Non utiliséNon utilisé
AlimentationCapteurs en 5V, servo sur 5 V externeHC-SR04 et servo en 5V/VIN, capteurs IR en 3V3HC-SR04 et servo en VBUS, capteurs IR en 3V3(OUT)
L'erreur la plus fréquente est d'alimenter en même temps le servo, les cinq capteurs et le LCD depuis la broche 5V de l'Arduino. Quand le bras bouge, le SG90 peut appeler brièvement près de 500 mA ; la tension de l'USB chute, le LCD devient pâle et l'Arduino se réinitialise. Alimente le servo avec un adaptateur 5 V externe et relie obligatoirement la masse (GND) de l'adaptateur à celle de l'Arduino ; sans masse commune, le signal du servo n'a plus aucun sens.

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.
Les capteurs infrarouges voient mal les surfaces noires, car la peinture noire absorbe la lumière infrarouge. Si tu as une voiture noire, colle un petit morceau de ruban blanc dessous ou sur la face tournée vers le capteur ; la détection s'améliore aussitôt. Évite aussi de faire fonctionner la maquette près d'une fenêtre : la lumière du soleil trompe les capteurs infrarouges.

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.

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}

Comment fonctionne le code ?

PartieRô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.
wantOpenIndique 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_MSLa 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.

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}

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.

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

Idé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èmeCause probableSolution
Le servo tremble, l'Arduino se réinitialiseLe servo est alimenté par l'USB, le courant ne suffit pasAlimente 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 rienMauvaise adresse I2C ou réglage du contrasteEssaie l'adresse 0x3F, tourne le potentiomètre au dos du module I2C
Une place apparaît toujours occupéeSensibilité du capteur trop élevée ou il voit le solRé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éeLa surface noire absorbe la lumière infrarougeColle du ruban blanc sur la face de la voiture tournée vers le capteur
Le HC-SR04 donne toujours 999 ou des valeurs aléatoiresTRIG et ECHO inversés, mesures trop rapprochées ou voiture trop inclinéeVé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 dessousDurée GATE_HOLD_MS trop courtePasse la durée à 4–5 secondes ou ajoute un second capteur sous la barrière
La page ESP32 ne s'ouvre pasLe téléphone est sur un autre réseau ou l'IP est fausseConnecte le téléphone au même réseau Wi-Fi, utilise l'IP du moniteur série
Monte le projet morceau par morceau : teste d'abord uniquement les capteurs de places dans le moniteur série, puis le HC-SR04, puis le servo et enfin le LCD. Chercher une panne quand tout a été branché d'un coup prend bien plus de temps que d'avancer étape par étape. Pour les problèmes de servo, consulte l'article servo qui tremble et, pour les redémarrages inattendus, Arduino qui se réinitialise.

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.

Voir tous les projets
HC-SR04 Mesure de la distance (affichage en série)
AR-27Débutant

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…

4.6(50)
82
Capteur de stationnement avec HC-SR04
AR-28Intermédiaire
Premium

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.

4.8(64)
86
Mesure de la distance à l'aide d'un écran LCD
AR-31Avancé
Premium

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.

4.6(45)
59
Utilisation du servomoteur
AR-35Débutant
Premium

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.

4.7(48)
67
Lecture de réflexion (proximité) avec TCRT5000
AR-77Intermédiaire
Premium

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.

4.6(33)
43
ESP32 HC-SR04 Télémètre à ultrasons
ES-14Intermédiaire

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

4.9(29)
48
Serveur Web asynchrone ESP32 (avec affichage de l'adresse IP sur l'écran LCD)
ES-27Avancé

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

4.8(16)
26
Capteur de stationnement ESP32 (HC-SR04 + barre à 5 LED + buzzer + écran OLED)
ES-38Avancé
Premium

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.

14