Arduino Parkplatz-System: Schranke und LCD für freie Plätze
Arduino Parkplatz-System bauen: Belegung per HC-SR04 oder Infrarot erkennen, SG90-Servo als Schranke, freie Plätze am I2C-LCD, Code für Uno und ESP32.
Ein Arduino Parkplatz-System ist ein Modellprojekt, das per Sensor erkennt, ob Parkplätze belegt oder frei sind, die Einfahrtsschranke mit einem Servo öffnet und schließt und die Zahl der freien Plätze auf einem LCD anzeigt. Du baust die kleine Version der „Frei: 12“-Anzeigen von Parkhäusern auf deinem Schreibtisch nach. Das Projekt vereint Abstandsmessung, digitale Eingänge, Servosteuerung und Display in einer Schaltung und eignet sich deshalb als erstes großes Projekt sowie für Schul- und Jugend-forscht-Präsentationen.
In dieser Anleitung baust du ein Modell mit vier Parkplätzen von Anfang bis Ende: ein Infrarotsensor pro Parkplatz, ein HC-SR04-Ultraschallsensor an der Einfahrt, der die Schranke öffnet, sobald sich ein Auto nähert, ein weiterer Sensor an der Ausfahrt, eine SG90-Servo-Schranke und ein 16x2-I2C-LCD. Zuerst gehen wir den Arduino-Uno-Code Zeile für Zeile durch, dann übertragen wir das System mit einem Webpanel fürs Handy auf den ESP32 und schreiben zum Schluss eine MicroPython-Version für den Raspberry Pi Pico. Am Ende findest du Modellmaße und Präsentationstipps.

Was ist ein Arduino Parkplatz-System und wie funktioniert es?
Das System erledigt drei Aufgaben gleichzeitig. Erstens die Belegungserfassung: Ein Sensor am Boden oder neben jedem Stellplatz meldet ständig, ob dort ein Auto steht; der Arduino zählt die belegten Plätze und zieht sie von der Gesamtzahl ab. Zweitens die Schrankensteuerung: Sieht der Sensor an der Einfahrt ein Auto und ist ein Platz frei, hebt sich die Schranke um 90 Grad und senkt sich einige Sekunden nach der Durchfahrt wieder; ist der Parkplatz voll, bleibt sie zu und eine rote LED leuchtet. Für Autos an der Ausfahrt öffnet sie immer. Drittens die Information: In der ersten LCD-Zeile steht „Bos yer: 3/4“, in der zweiten der Status jedes Stellplatzes. Weil wir die freien Plätze direkt aus den Parkplatzsensoren berechnen und nicht durch Zählen von Ein- und Ausfahrten, verschiebt sich der Zähler nicht dauerhaft, wenn ein Sensor mal ein Auto verpasst; das ist deutlich zuverlässiger als einfache Projekte mit Ein-/Ausfahrtszählung.
| Aufgabe | Bauteil | Was es tut |
|---|---|---|
| Belegung der Parkplätze | 4 Infrarot-Hindernissensoren (FC-51 oder TCRT5000-Modul) | OUT-Pin wird LOW, wenn ein Auto da ist |
| Auto an der Einfahrt erkennen | HC-SR04-Ultraschallsensor | Misst den Abstand des Autos in cm |
| Auto an der Ausfahrt erkennen | 1 Infrarot-Hindernissensor | Sieht das von innen kommende Auto |
| Schranke | SG90-Servo + Eisstiel | 0° geschlossen, 90° offen |
| Infoanzeige | 16x2-I2C-LCD | Anzahl freier Plätze und Platzstatus |
| Statusleuchte | Grüne und rote LED | Platz frei / Parkplatz voll |
Materialliste
| Material | Anzahl | Hinweis |
|---|---|---|
| Arduino Uno (oder Nano) | 1 | ESP32- und Pico-Versionen weiter unten |
| HC-SR04-Abstandssensor | 1 | Läuft mit 5 V |
| Infrarot-Hindernissensor (FC-51 / TCRT5000-Modul) | 5 | 4 Parkplätze + 1 Ausfahrt |
| SG90-Servomotor | 1 | Für den Schrankenarm |
| 16x2-LCD + I2C-Modul | 1 | Adresse meist 0x27 oder 0x3F |
| Grüne und rote LED | 2 | Je ein 220-Ω-Widerstand |
| Breadboard und Jumperkabel | 1 Set | Male-Female-Kabel sind für die Sensoren praktisch |
| Externes 5-V-Netzteil (2 A) | 1 | Empfohlen für Servo und Sensoren |
| Modellbaumaterial | - | Schaumstoffplatte, Pappe, Spielzeugautos, farbiges Klebeband |
HC-SR04 oder Infrarotsensor?
Die Belegung eines Parkplatzes kannst du auf zwei Arten erkennen. Der HC-SR04 misst das Auto per Schallwelle; setzt du an jeden Platz einen, brauchst du je zwei Pins (TRIG und ECHO), bei vier Plätzen also acht Pins. Außerdem können sich die Sensoren gegenseitig stören, wenn sie gleichzeitig messen, deshalb müssen sie nacheinander ausgelöst werden. Infrarot-Hindernissensoren liefern dagegen nur einen digitalen Ausgang, sind günstig und die Reichweite lässt sich mit dem kleinen Potentiometer auf der Platine einstellen. Die ausgewogenste Lösung ist deshalb: Infrarotsensoren an den Parkplätzen und der HC-SR04, der den Abstand als Zahl liefert, an der Einfahrt. Die Unterschiede zwischen den Sensortypen findest du ausführlicher im Beitrag Vergleich von Abstandssensoren.
| Eigenschaft | HC-SR04 | FC-51-Hindernissensor | TCRT5000-Modul |
|---|---|---|---|
| Erfassungsbereich | 2–400 cm | Etwa 2–30 cm (einstellbar) | Etwa 1–25 mm |
| Ausgang | Pulsdauer (wird gemessen) | Digital (LOW = Hindernis) | Digital + analog |
| Benötigte Pins | 2 | 1 | 1 |
| Versorgung | 5 V | 3,3–5 V | 3,3–5 V |
| Schwäche | Weiche und schräge Flächen | Sonnenlicht, schwarze Flächen | Sehr kurze Reichweite, schwarze Flächen |
| Bester Einsatz am Parkplatz | Einfahrtsschranke | Hinterer Rand des Stellplatzes | Boden des Stellplatzes |

Schaltplan und Pin-Tabelle
| Anschluss | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Sensor Parkplatz 1–4 (OUT) | D2, D3, D4, D5 | GPIO 32, 33, 25, 26 | GP2, GP3, GP4, GP5 |
| Ausfahrtssensor (OUT) | D6 | GPIO 27 | GP6 |
| HC-SR04 TRIG | D7 | GPIO 23 | GP16 |
| HC-SR04 ECHO | D8 | GPIO 18 (mit Spannungsteiler) | GP17 (mit Spannungsteiler) |
| Servo-Signal (oranges Kabel) | D9 | GPIO 13 | GP15 |
| Grüne / rote LED (mit 220 Ω) | D10 / D11 | Nicht genutzt | Nicht genutzt |
| I2C-LCD SDA / SCL | A4 / A5 | Nicht genutzt | Nicht genutzt |
| Versorgung | Sensoren 5V, Servo extern 5 V | HC-SR04 und Servo 5V/VIN, IR-Sensoren 3V3 | HC-SR04 und Servo VBUS, IR-Sensoren 3V3(OUT) |
Stelle das blaue Potentiometer auf den Infrarotsensoren so ein, dass die LED des Sensors leuchtet, wenn das Spielzeugauto auf dem Platz steht, und erlischt, wenn es weg ist. Am Arduino Uno reicht für die LEDs ein 220-Ω-Widerstand; bei anderer Farbe oder anderer Spannung bestimmst du den Wert mit dem LED-Widerstandsrechner. Die Pinbelegungen der Boards kannst du schnell im Pinout-Tool nachschlagen. Anschluss und I2C-Scanner-Code für das LCD stehen im Beitrag I2C-LCD-Display.
Parkplatzmodell Schritt für Schritt bauen
- Nimm eine Schaumstoffplatte oder dicke Pappe von etwa 40×30 cm; das reicht für vier Stellplätze, die Zufahrt und ein Fach für die Elektronik.
- Miss dein Spielzeugauto und zeichne jeden Stellplatz etwa 1,5-mal so breit wie das Auto; für ein Auto im Maßstab 1:43 passen Felder von 6×11 cm. Hebe die Linien mit weißem oder gelbem Klebeband hervor.
- Setze den FC-51 an den hinteren Rand jedes Stellplatzes, zum Auto gerichtet, oder versenke den TCRT5000 nach oben gerichtet in einem kleinen Loch im Boden. Führe die Kabel unter der Platte durch.
- Platziere den HC-SR04 neben der Zufahrt, zur Wegmitte gerichtet, 5–10 cm vor der Schranke. Setze den fünften Infrarotsensor an die Ausfahrtsspur.
- Befestige den SG90 mit Heißkleber in einem kleinen Häuschen aus Schaumstoff und klebe einen bemalten Eisstiel an den Servoarm. Bringe den Servo vor dem Aufstecken des Arms auf 0 Grad und stecke den Stiel dann waagerecht auf.
- Setze LCD und LEDs auf ein Schild an der Einfahrt, das der Fahrer sieht; verstecke Arduino und Breadboard im Fach hinter oder unter der Platte.
- Vergleiche jede Verbindung mit der Pin-Tabelle; teste zuerst nur die Sensoren im Seriellen Monitor und füge dann Servo und LCD hinzu.
Arduino-Uno-Code für das Parkplatz-System
Für den Code reicht es, die Bibliothek LiquidCrystal I2C (Frank de Brabander) über den Bibliotheksverwalter zu installieren; Servo und Wire sind in der Arduino IDE enthalten. Zeigt das LCD nichts an, ändere die Adresse 0x27 im Code auf 0x3F. Das Programm wartet bei der Schranke nicht mit einem langen delay, sondern misst die Zeit mit millis; so liest es auch bei geöffneter Schranke weiter die Sensoren. Da die Servo-Bibliothek auf dem Uno Timer1 nutzt, funktioniert analogWrite an D9 und D10 nicht; weil wir die LEDs nur ein- und ausschalten, ist das kein Problem.
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}Wie funktioniert der Code?
| Abschnitt | Aufgabe |
|---|---|
| readSpots() | Liest die vier Parkplatzsensoren und gibt eine Maske zurück, in der belegte Plätze als Bit 1 stehen; 0b0101 bedeutet zum Beispiel, dass Platz 1 und 3 belegt sind. |
| freeSpots() | Zählt die Bits mit Wert 0 in der Maske und ermittelt so die Zahl freier Plätze. |
| readDistanceCm() | Sendet einen 10-µs-Triggerimpuls an den HC-SR04, misst die Echodauer mit pulseIn und rechnet durch Teilen durch 58 in cm um. Kommt innerhalb von 25 ms kein Echo, gibt sie 999 zurück. |
| showLcd() | Aktualisiert das LCD nur, wenn sich der Status der Parkplätze ändert; so flackert die Anzeige nicht. |
| wantOpen | Zeigt an, dass die Schranke öffnen soll, wenn an der Einfahrt ein Auto steht und ein Platz frei ist oder wenn an der Ausfahrt ein Auto steht. |
| GATE_HOLD_MS | Die Schranke senkt sich 3 Sekunden nach der letzten Erkennung; damit sie nicht auf ein Auto fällt, kannst du die Zeit für dein Modell erhöhen. |
| delay(60) | Lässt zwischen den HC-SR04-Messungen mindestens 60 ms; so stört das Echo der vorigen Messung die neue nicht. |
Diese einfache Logik hat eine Grenze: Ein Auto, das durch die Einfahrt fährt, hat den Stellplatz noch nicht erreicht, deshalb ändert sich die Zahl freier Plätze einige Sekunden lang nicht. Kommen für den letzten freien Platz zwei Autos kurz hintereinander, können beide hineinfahren. Das löst du, indem du durchgefahrene Autos in einem „unterwegs“-Zähler führst und von den freien Plätzen abziehst, bis das Auto geparkt hat. Solche schrittweisen Abläufe schreibst du am saubersten mit einer Zustandsmaschine; warum die Zeitsteuerung mit millis erfolgt, kannst du im Beitrag Unterschied zwischen millis und delay nachlesen.
Parkplatz-System mit ESP32 und Webpanel
Baust du dasselbe System mit dem ESP32, kannst du den Parkplatzstatus mit dem Handy oder Computer im selben WLAN verfolgen. Der folgende Code startet auf dem ESP32 einen kleinen Webserver: Auf der Startseite steht die Zahl freier Plätze, jeder Stellplatz erscheint als grünes oder rotes Kästchen, die Seite lädt alle zwei Sekunden neu und über den Link „Bariyeri ac“ kannst du die Schranke aus der Ferne öffnen. Außerdem liefert die Adresse /api den Status als JSON, den du später in einer Mobil-App oder auf einem anderen Board nutzen kannst. Installiere für den Servo die Bibliothek ESP32Servo über den Bibliotheksverwalter; WiFi und WebServer sind im ESP32-Arduino-Core enthalten und funktionieren in Version 2.x und 3.x gleich.
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}Trage vor dem Hochladen anstelle von WIFI_ADIN und WIFI_SIFREN deine eigenen WLAN-Daten ein. Öffne danach den Seriellen Monitor mit 115200 Baud; sobald sich der ESP32 mit dem Netz verbunden hat, gibt er die IP-Adresse aus, die du nur noch im Browser deines Handys eingeben musst. Die ESP32-Pins arbeiten mit 3,3 V und sind nicht 5-V-tolerant; da der ECHO-Pin des HC-SR04 5-V-Impulse liefert, setze einen Spannungsteiler aus 1 kΩ und 2 kΩ dazwischen: 5 V × 2 / (1 + 2) = 3,33 V. Mit anderen Widerstandswerten prüfst du das Ergebnis im Spannungsteiler-Rechner. Versorge die Infrarotsensoren über den 3V3-Pin, damit auch ihre Ausgänge 3,3 V haben. Willst du statt eines Seiten-Neuladens Live-Updates, nutze die Methode aus dem Beitrag ESP32 WebSocket.
MicroPython-Version mit dem Raspberry Pi Pico
Nutzt du den Raspberry Pi Pico, brauchst du für den Servo keine zusätzliche Bibliothek; die Hardware-PWM des Pico erzeugt das 50-Hz-Servosignal direkt. Der Servowinkel wird in eine Pulsbreite umgerechnet: 0,5 ms für 0° und 2,4 ms für 180°; bei 20 ms Periode wird dieser Wert mit duty_u16 auf den Bereich 0–65535 skaliert. Die Echodauer des HC-SR04 misst machine.time_pulse_us. Der folgende Code schreibt die Zahl freier Plätze in die Thonny-Konsole; denke wie beim ESP32 an den Spannungsteiler an der ECHO-Leitung.
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 intervalIdeen zum Ausbau des Parkplatz-Projekts
- Abo-Zufahrt per Karte: Ergänze an der Einfahrt einen RFID-RC522-Leser; die Schranke öffnet nur für Abonnenten mit registrierter Karte.
- Große Zahlenanzeige: Zeige die Zahl freier Plätze mit einem 7-Segment-Display an, damit man sie auch von der Straße aus lesen kann.
- Belegtmeldung: Füge der ESP32-Version einen Telegram-Bot hinzu und schicke eine Nachricht aufs Handy, wenn der Parkplatz voll ist.
- Parkdauer und Gebühr: Speichere mit millis den Zeitpunkt, an dem ein Platz belegt wird, berechne beim Wegfahren die Gebühr nach der Parkdauer und zeige sie auf dem LCD an.
- Nachtbeleuchtung: Schalte mit einem LDR die Wegbeleuchtung per LED automatisch ein, wenn es dunkel wird.
- Warnung für Behindertenparkplatz: Spiele mit einem Buzzer einen kurzen Warnton, wenn ein Auto auf den reservierten Platz fährt.
Tipps für Schulprojekt und Wettbewerbspräsentation
- Beginne mit dem Problem: Starte die Präsentation mit einer Frage wie „Wie viele Minuten verlieren Fahrer bei der Parkplatzsuche?“ und erkläre in einem Satz, welches echte Problem dein Projekt löst.
- Erstelle ein Flussdiagramm: Ein Diagramm mit den Schritten „Auto da? Platz frei? Schranke öffnen“ hilft der Jury, die Logik zu verstehen, ohne den Code zu lesen.
- Plane eine Live-Vorführung: Bringe so viele Spielzeugautos mit, wie es Stellplätze gibt, damit du den Parkplatz komplett füllen und die Anzeige „DOLU“ sowie die rote LED zeigen kannst.
- Halte Ersatz bereit: Nimm Ersatz-Jumperkabel, ein zweites USB-Kabel, eine Powerbank und einen Laptop mit dem geladenen Code mit; auf Messen lösen sich Verbindungen sehr oft.
- Nenne die Grenzen ehrlich: Wenn du erwähnst, dass Infrarotsensoren bei Sonnenlicht Fehler machen und echte Parkplätze magnetische oder kamerabasierte Systeme nutzen, gibt das Pluspunkte bei der Jury.
- Zeige einen Ausbauplan: Nächste Schritte wie ESP32-Webpanel, RFID-Abo oder Gebührenberechnung zeigen, dass das Projekt wachsen kann. Weitere Tipps findest du im Beitrag Projektpräsentation für den Wissenschaftswettbewerb.
Häufige Fehler und ihre Lösungen
| Problem | Mögliche Ursache | Lösung |
|---|---|---|
| Servo zittert, Arduino startet neu | Servo hängt am USB, der Strom reicht nicht | Servo extern mit 5 V versorgen, GNDs verbinden, einen 470-µF-Kondensator an die Versorgung setzen |
| LCD leuchtet, aber kein Text | Falsche I2C-Adresse oder Kontrasteinstellung | Adresse 0x3F probieren, Potentiometer auf der Rückseite des I2C-Moduls drehen |
| Parkplatz erscheint immer belegt | Sensor zu empfindlich oder sieht den Boden | Reichweite mit dem Potentiometer verringern, Sensor leicht nach oben neigen |
| Schwarzes Auto wird nicht erkannt | Schwarze Fläche schluckt Infrarotlicht | Weißes Klebeband auf die dem Sensor zugewandte Seite des Autos kleben |
| HC-SR04 liefert immer 999 oder Zufallswerte | TRIG und ECHO vertauscht, Messungen zu schnell oder Auto zu schräg | Pins prüfen, zwischen Messungen mindestens 60 ms warten, Sensor senkrecht zum Auto ausrichten |
| Schranke senkt sich über dem Auto | GATE_HOLD_MS ist zu kurz | Zeit auf 4–5 Sekunden erhöhen oder einen zweiten Sensor unter die Schranke setzen |
| ESP32-Seite lässt sich nicht öffnen | Handy in einem anderen Netz oder falsche IP | Handy mit demselben WLAN verbinden, die IP aus dem Seriellen Monitor verwenden |
Ein Arduino Parkplatz-System vereint Sensorauswertung, Entscheidungslogik, Motorsteuerung und Display in einem unterhaltsamen Modellprojekt und ist deshalb eine der besten Möglichkeiten, Gelerntes zu kombinieren. Möchtest du die Bauteile einzeln kennenlernen, schau dir die Beiträge Servomotor und TCRT5000-Infrarotsensor an. In der BlueGrays-App findest du Projekte zu Abstandsmessung mit dem HC-SR04, Einparkhilfe, LCD-Abstandsanzeige, Servosteuerung und ESP32-Webserver mit Schaltplänen und Code, sodass du jeden Teil dieses Parkplatzes einzeln ausprobieren kannst.
Häufige Fragen
Welcher Sensor eignet sich für ein Arduino-Parkplatzprojekt?
Zur Belegungserkennung der Stellplätze sind Infrarot-Hindernissensoren wie FC-51 oder TCRT5000 am praktischsten; sie brauchen nur einen digitalen Pin und sind günstig. Für das Erkennen eines näherkommenden Autos an der Einfahrt passt der HC-SR04-Ultraschallsensor besser, der den Abstand als Zahl liefert. Du kannst auch an jeden Stellplatz einen HC-SR04 setzen, aber jeder braucht zwei Pins und muss nacheinander ausgelöst werden.
Wie berechnet man mit Arduino die freien Parkplätze?
Am zuverlässigsten setzt du an jeden Stellplatz einen Sensor, zählst die belegten Plätze und ziehst sie von der Gesamtzahl ab. Die Methode mit Zählen von Ein- und Ausfahrten braucht weniger Sensoren, aber ein einziges verpasstes Auto verschiebt den Zähler dauerhaft. Der Code in diesem Beitrag liest in jedem Durchlauf alle vier Sensoren und berechnet die freien Plätze neu.
Warum startet der Arduino neu, wenn sich die Servo-Schranke öffnet?
Der SG90-Servo kann beim Anfahren kurzzeitig fast 500 mA ziehen und lässt die USB-Spannung einbrechen. Fällt die Spannung ab, startet der Arduino neu und das LCD wird blass. Versorge den Servo aus einer externen 5-V-Quelle, verbinde die GNDs und setze einen Kondensator wie 470 µF an die Servoversorgung.
Wie baut man ein Parkplatzmodell und welches Material eignet sich?
Schaumstoffplatte oder dicke Pappe lässt sich leicht schneiden und zum Verstecken von Sensoren und Kabeln durchbohren. Eine Grundplatte von etwa 40×30 cm reicht für vier Stellplätze und die Zufahrt. Für die Parklinien kannst du farbiges Klebeband, für den Schrankenarm einen Eisstiel und als Autos Spielzeugautos im Maßstab 1:43 verwenden.
Wie viele Parkplatzsensoren kann man an einen Arduino Uno anschließen?
Der Uno hat 20 Pins (D0–D13 und A0–A5); nach Abzug von serieller Schnittstelle, I2C, Servo, HC-SR04, Ausfahrtssensor und LEDs bleiben für die Parkplätze etwa 10 Pins. Auch A0–A3 lassen sich als digitale Eingänge nutzen. Für mehr Stellplätze kannst du ein Eingangs-Schieberegister wie den 74HC165 oder einen Arduino Mega verwenden.
Kann man das Parkplatz-System per Handy überwachen?
Ja. In der ESP32-Version läuft auf dem Board ein eigener Webserver; gibst du die IP-Adresse des ESP32 im Browser eines Handys im selben WLAN ein, siehst du die Zahl freier Plätze und den Status jedes Stellplatzes. Für den Zugriff von außerhalb des Hauses kannst du einen Telegram-Bot, MQTT oder Cloud-Lösungen wie Blynk ergänzen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
HC-SR04 Abstandsmessung (serielle Anzeige)
Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

Parksensor mit HC-SR04
Eine Mini-Ausgabe der Einparkhilfe im Auto: Je näher etwas kommt, desto schneller piept es.

Abstandsmessung mit LCD-Display
Ein Gerät, das ohne Lineal Abstände misst: Beweg deine Hand vor dem Sensor vor und zurück und sieh zu, wie sich die Zahl ändert.

Verwendung von Servomotoren
Der Arm eines kleinen Servomotors dreht sich nacheinander in drei Stellungen: ganz an den Anfang, genau in die Mitte und ganz ans Ende, mit jeweils zwei Sekunden Pause.

Reflexion (Nähe) mit TCRT5000 messen
Mit einem kleinen Sensor, der unsichtbares Licht aussendet und misst, wie viel davon zurückkommt, erkennst du die Fläche vor ihm.

ESP32 HC-SR04 Ultraschall-Entfernungsmesser
Der Ultraschallsensor HC-SR04 misst Entfernungen über die Laufzeit seines Schallimpulses zum Objekt und zurück (Time of Flight). Der ESP32 sendet einen 10-Mikrosekunden-Impuls an TRIG und liest die Echozeit an ECHO mit pulseIn(). Die Entfernung erscheint in cm auf einem 16x2-I2C-LCD. Der HC-SR04 läuft mit 5 V, daher braucht ECHO einen Spannungsteiler, sonst nimmt der 3,3-V-GPIO des ESP32 Schaden.

ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-Parksensor (HC-SR04 + 5-LED-Leiste + Summer + OLED)
Die ESP32-Version einer Einparkhilfe! Der Ultraschallsensor HC-SR04 misst den Abstand zum Objekt davor. Je näher es kommt, desto weiter füllt sich eine Leiste aus 5 LEDs (grün → gelb → rot) und desto schneller piept der Summer. Ganz nah (unter 10 cm) ertönt ein Daueralarm und alle LEDs leuchten. Das SSD1306-OLED zeigt den aktuellen Abstand in cm groß an, dazu einen Statustext.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

