Arduino Projekte Winterferien: 14-Tage-Plan Schritt für Schritt
Arduino Projekte für die Winterferien: 14-Tage-Plan mit Starterset, je ein Projekt pro Tag, drei Wege (Uno, ESP32, Pico), Materialliste und Abschlussprojekt.
Die beste Methode für Arduino Projekte in den Winterferien: Verbring die zwei Wochen nicht mit zufälligen Versuchen, sondern mit kleinen Projekten, die jeden Tag auf dem vorherigen aufbauen. In dieser Anleitung findest du einen fertigen Plan, mit dem du mit einem Starterset und 1–2 Stunden pro Tag in 14 Tagen vom LED-Blinken über das Auslesen von Sensoren und Text auf dem Display bis zur Motorsteuerung kommst. Zu jedem Tag gibt es das Projekt, das nötige Material und den Link zum Artikel, der das Thema vertieft. Am Ende der Ferien steht ein Abschlussprojekt, das alles Gelernte verbindet.
Der Plan lässt sich auf drei Wege anpassen: den Arduino Uno für alle ohne Vorkenntnisse, den ESP32 für alle mit Grundwissen, die ihr Projekt ins Internet bringen wollen, und den Raspberry Pi Pico für alle, die Python lernen möchten. Die Themen der Tage sind auf allen drei Wegen gleich; nur Board, Pinnummern und Programmiersprache ändern sich. Hast du noch kein Board, kannst du die ersten Tage in der Simulation mit Wokwi oder Tinkercad machen und danach auf die echte Schaltung wechseln.
Bevor es losgeht: Welches Material brauchst du?
Fast alles in der folgenden Liste steckt in den üblichen Standard-Startersets. Fehlt in deinem Set ein Teil, tausch einfach die Reihenfolge der Tage; ohne Servo kannst du Tag 13 zum Beispiel durch ein Buzzer-Melodie-Projekt ersetzen. Wenn du dir bei der Wahl des Sets unsicher bist, vergleicht der Artikel Arduino Starterset die Inhalte im Detail.
| Material | Anzahl | Verwendet an Tag |
|---|---|---|
| Arduino Uno, ESP32 oder Raspberry Pi Pico + USB-Kabel | 1 | Jeden Tag |
| Breadboard und Jumperkabel (male-male) | 1 + 30 | Jeden Tag |
| LED (rot, gelb, grün) | 6–8 | 1, 2, 3, 6, 7, 9, 11 |
| 220-Ω-Widerstand | 8 | 1, 2, 3, 6, 7, 11 |
| 10-kΩ-Widerstand | 2 | 7 |
| 1-kΩ-Widerstand (Spannungsteiler für ESP32 und Pico) | 3 | 10, 11 |
| Taster | 2 | 4, 7, 9 |
| 10-kΩ-Potentiometer | 1 | 5, 13 |
| RGB-LED | 1 | 6 |
| LDR (Fotowiderstand) | 1 | 7 |
| Passiver Buzzer | 1 | 8, 11 |
| Abstandssensor HC-SR04 | 1 | 10, 11 |
| Temperatur- und Feuchtesensor DHT11 | 1 | 12 |
| I2C-LCD 16x2 | 1 | 12, 14 |
| Servomotor SG90 | 1 | 13, 14 |
Welchen Weg sollst du wählen: Uno, ESP32 oder Pico?
Alle drei Boards schaffen den ganzen Plan, bieten aber ein unterschiedliches Lernerlebnis. Der Uno arbeitet mit 5 V und passt deshalb direkt zu allen Modulen im Set; die meisten Beispiele im Netz sind für ihn geschrieben. Wenn du zum ersten Mal mit Elektronik zu tun hast, ist das der Weg mit der einfachsten Fehlersuche. Der ESP32 wird in derselben Arduino-Sprache programmiert, macht dein Abschlussprojekt aber dank Dual-Core-Prozessor mit 240 MHz, WLAN und Bluetooth per Handy abrufbar; dafür musst du daran denken, dass seine Pins mit 3,3 V arbeiten. Beim Pico schreibst du Code in MicroPython und siehst ihn sofort laufen, sobald du speicherst; wenn ihr in der Schule Python habt, bringst du dein Wissen direkt auf die Hardware. Bist du unsicher, wirf einen Blick auf den Vergleich Arduino oder ESP32.
| Weg | Für wen? | Sprache und Editor | Stärke | Darauf musst du achten |
|---|---|---|---|---|
| Arduino Uno | Alle, die zum ersten Mal mit Elektronik starten | Arduino C++, Arduino IDE | 5-V-Pins, passt direkt zu allen Modulen im Set, die meisten Beispielcodes | Kein WLAN, nur 2 KB RAM |
| ESP32 | Alle mit Grundwissen, die ins Internet wollen | Arduino C++, Arduino IDE (ESP32-Boardpaket) | WLAN und Bluetooth, Dual-Core mit 240 MHz, 12-Bit-ADC | 3,3-V-Pins, bei Sensoren mit 5-V-Signal ist ein Spannungsteiler nötig |
| Raspberry Pi Pico | Alle, die Python lernen wollen | MicroPython, Thonny | Läuft sofort ohne Kompilieren, Dual-Core mit 133 MHz, günstig | 3,3-V-Pins, der klassische Pico hat kein WLAN (der Pico W schon) |
Tagesablauf: die Regel von 1–2 Stunden
- Die ersten 15 Minuten lesen: Lies den Artikel zum Tag und zeichne Schaltplan und Pin-Tabelle auf Papier.
- 30–45 Minuten Aufbau und Code: Baue die Schaltung bei abgezogenem USB-Kabel auf, kontrolliere die Verbindungen noch einmal und lade dann den Code hoch.
- 20 Minuten verändern: Wenn der Code läuft, ändere mindestens eine Sache selbst: die Zeit, den Pin, den Schwellenwert oder die Anzahl der LEDs. Hier passiert das eigentliche Lernen.
- 10 Minuten Notizen: Schreib in ein Heft, was du gemacht hast, wo du hängengeblieben bist und wie du es gelöst hast; diese Notizen sparen dir beim Abschlussprojekt viel Zeit.
- Flexible Tage: Wirst du krank oder dauert ein Projekt länger, kannst du Tag 7 und Tag 14 auch als Puffertage nutzen.
Woche 1: die Grundlagen (Tag 1–7)
Das Ziel der ersten Woche ist es, vier Grundkonzepte praktisch zu lernen: digitaler Ausgang, digitaler Eingang, analoges Lesen und PWM. Jeden Tag kommen im Schnitt ein neuer Befehl und ein neues Bauteil dazu; am Ende von Tag 7 gehen dir pinMode, digitalWrite, digitalRead, analogRead, analogWrite und Serial.println leicht von der Hand.
- Tag 1 – LED zum Leuchten bringen: Lass Blink mit der eingebauten LED laufen, schließe dann auf dem Breadboard eine externe LED mit 220-Ω-Widerstand an D13 an und ändere die Blinkzeit. Material: Board, Breadboard, 1 LED, 1 × 220-Ω-Widerstand. Lesen: Breadboard verwenden, LED-Vorwiderstand berechnen.
- Tag 2 – Ampel: Schließe die rote, gelbe und grüne LED an D10, D9 und D8 an und ahme mit delay die Lichtfolge einer echten Kreuzung nach. Material: 3 LEDs, 3 × 220-Ω-Widerstand. Lesen: Arduino Ampel.
- Tag 3 – Lauflicht und Knight Rider: Lerne, 6 LEDs nacheinander mit einer for-Schleife und einem Pin-Array anzusteuern. Material: 6 LEDs, 6 × 220-Ω-Widerstand. Lesen: Knight Rider und Lauflicht, Arrays in Arduino.
- Tag 4 – LED mit Taster: Baue zuerst eine LED, die leuchtet, solange du drückst, und dann eine, die bei jedem Druck umschaltet (Toggle); dabei lernst du INPUT_PULLUP und Entprellen. Material: 1 Taster, 1 LED, 1 × 220-Ω-Widerstand. Lesen: Taster an den Arduino anschließen, Pull-up- und Pull-down-Widerstand.
- Tag 5 – Potentiometer und Serieller Monitor: Lies mit analogRead Werte von 0–1023, beobachte sie im Seriellen Monitor und wandle sie mit map in die Blinkgeschwindigkeit der LED um. Material: 10-kΩ-Potentiometer, 1 LED. Lesen: Was ist ein Potentiometer, Seriellen Monitor verwenden, Die map-Funktion.
- Tag 6 – PWM und RGB-LED: Lass die LED mit analogWrite langsam auf- und abglimmen (Atmungseffekt) und mische dann die drei Kanäle der RGB-LED zu deiner eigenen Farbe. Material: 1 RGB-LED, 3 × 220-Ω-Widerstand. Lesen: Was ist PWM, RGB-LED verwenden.
- Tag 7 – LDR-Nachtlicht und Wochenwiederholung: Schließe den LDR mit einem 10-kΩ-Widerstand als Spannungsteiler an und lass die LED leuchten, wenn es dunkel wird. In der zweiten Tageshälfte baust du die Ampel mit Fußgängertaster unten auf. Material: LDR, 10-kΩ-Widerstand, 3 LEDs, Taster. Lesen: LDR-Lichtsensor, Spannungsteiler.
Das Abschlussprojekt der ersten Woche verbindet das, was du an Tag 2, 4 und 5 gelernt hast, in einer Schaltung: Eine Ampel zeigt für Autos dauerhaft Grün; drückt ein Fußgänger den Taster, schaltet sie auf Gelb, dann auf Rot und nach fünf Sekunden wieder auf Grün. Der Taster hängt zwischen D2 und GND; dank des internen Pull-up-Widerstands brauchst du keinen externen, und beim Drücken liest der Pin LOW.
1// Yaya butonlu trafik lambası / Pedestrian button traffic light
2const int RED_PIN = 10; // kırmızı LED / red LED
3const int YELLOW_PIN = 9; // sarı LED / yellow LED
4const int GREEN_PIN = 8; // yeşil LED / green LED
5const int BUTTON_PIN = 2; // buton, diğer ucu GND / button, other leg to GND
6
7void setup() {
8 pinMode(RED_PIN, OUTPUT);
9 pinMode(YELLOW_PIN, OUTPUT);
10 pinMode(GREEN_PIN, OUTPUT);
11 pinMode(BUTTON_PIN, INPUT_PULLUP); // basılınca LOW okunur / reads LOW when pressed
12 digitalWrite(GREEN_PIN, HIGH); // araçlara yeşil / green for cars
13 Serial.begin(9600);
14}
15
16void loop() {
17 if (digitalRead(BUTTON_PIN) == LOW) {
18 Serial.println("Yaya istegi / Pedestrian request");
19 delay(1000);
20 digitalWrite(GREEN_PIN, LOW);
21 digitalWrite(YELLOW_PIN, HIGH); // sarı: yavaşla / yellow: slow down
22 delay(2000);
23 digitalWrite(YELLOW_PIN, LOW);
24 digitalWrite(RED_PIN, HIGH); // araçlar durur, yaya geçer / cars stop, pedestrians cross
25 delay(5000);
26 digitalWrite(YELLOW_PIN, HIGH); // kırmızı + sarı: hazırlan / red + yellow: get ready
27 delay(1500);
28 digitalWrite(RED_PIN, LOW);
29 digitalWrite(YELLOW_PIN, LOW);
30 digitalWrite(GREEN_PIN, HIGH);
31 delay(3000); // art arda basmayı engelle / ignore repeated presses
32 }
33}Das letzte delay(3000) im Code verhindert, dass die Ampel sofort wieder auf Rot springt, wenn ein Fußgänger mehrfach hintereinander drückt; echte Ampeln nutzen eine ähnliche Sperrzeit. Als eigene Änderung kannst du die Rotzeit per Potentiometer einstellbar machen oder den Buzzer kurze Pieptöne ausgeben lassen, solange Rot leuchtet. Die Schwäche dieses Codes ist, dass das Board während eines delay nichts anderes tun kann; dieses Problem löst du an Tag 9 mit millis.
Woche 2: Ton, Timing, Sensoren und Display (Tag 8–14)
In der zweiten Woche beginnt das Board, die Außenwelt zu messen und die Ergebnisse anzuzeigen. An diesen Tagen installierst du zum ersten Mal eine Bibliothek, misst Zeit auf die Mikrosekunde genau und schreibst Text auf ein Display. Weil die Projekte etwas länger sind, teile einen Tag ruhig auf zwei Tage auf; der Plan ist kein Wettrennen, sondern eine Methode, eine Gewohnheit aufzubauen.
- Tag 8 – Buzzer und Melodie: Spiele mit tone(pin, frequenz, dauer) Töne ab; 262 Hz ist C, 294 Hz D, 330 Hz E. Ein aktiver Buzzer gibt nur einen festen Ton aus, für Melodien brauchst du einen passiven Buzzer. Material: passiver Buzzer. Lesen: Was ist ein Buzzer.
- Tag 9 – millis statt delay: Schaffe es, dass eine LED im Sekundentakt blinkt und gleichzeitig der Taster abgefragt wird. Das ist die Grundlage des Abschlussprojekts; jedes Projekt, das mehrere Dinge gleichzeitig tut, nutzt millis oder eine Zustandsmaschine. Material: 2 LEDs, Taster. Lesen: Unterschied zwischen millis und delay, Arduino Zustandsmaschine.
- Tag 10 – Entfernung mit dem HC-SR04 messen: Miss die Laufzeit der Schallwelle hin und zurück; da sich Schall in Luft mit etwa 343 m/s ausbreitet, ergibt die Zeit in Mikrosekunden geteilt durch 58 die Entfernung in Zentimetern. Material: HC-SR04. Lesen: Abstandssensor HC-SR04.
- Tag 11 – Einparkhilfe: Kombiniere Tag 8 und 10: Je näher ein Hindernis kommt, desto kürzer wird der Abstand zwischen den Pieptönen, und die LED blinkt bei jedem Piepton. Material: HC-SR04, passiver Buzzer, LED, 220-Ω-Widerstand. Lesen: Arduino Parksystem.
- Tag 12 – DHT11 und I2C-LCD: Installiere deine erste Bibliothek und zeige Temperatur und Luftfeuchtigkeit auf dem 16x2-LCD an. Dank I2C wird das Display nur mit 4 Kabeln angeschlossen; die Adresse der meisten Module ist 0x27 oder 0x3F. Material: DHT11, I2C-16x2-LCD. Lesen: Arduino Bibliothek hinzufügen, DHT11-Sensor, I2C-LCD-Display.
- Tag 13 – Servomotor und Finalplanung: Drehe den SG90 mit der Servo-Bibliothek zwischen 0 und 180 Grad und steuere den Winkel per Potentiometer. In der zweiten Tageshälfte wählst du dein Abschlussprojekt und planst es anhand der Schritte unten auf Papier. Material: SG90-Servo, Potentiometer. Lesen: Was ist ein Servomotor, Servo zittert.
- Tag 14 – Abschlussprojekt und Präsentation: Verbinde die Codes der vorherigen Tage, setze die Schaltung in eine Box oder ein Kartonmodell, dreh ein kurzes Video und präsentiere dein Projekt deiner Familie oder Klasse. Material: Teileliste deines Abschlussprojekts. Lesen: Projektpräsentation bei Jugend forscht und Science Fairs.
Der folgende Code ist die Einparkhilfe von Tag 11 und nutzt die Entfernungsmessung von Tag 10 in einer Funktion wieder. Das Timeout von 30 000 Mikrosekunden bei pulseIn entspricht etwa 5 Metern; bekommt der Sensor kein Echo, gibt der Code -1 zurück, statt ewig zu warten. Die map-Funktion wandelt den Bereich 0–50 cm in 50–500 ms Pause um, sodass die Pieptöne schneller werden, je näher das Hindernis kommt.
1// Park sensörü: HC-SR04 + buzzer + LED / Parking sensor: HC-SR04 + buzzer + LED
2const int TRIG_PIN = 7;
3const int ECHO_PIN = 6;
4const int BUZZER_PIN = 5; // pasif buzzer / passive buzzer
5const int LED_PIN = 4; // 220 ohm dirençle / with a 220 ohm resistor
6
7long readDistanceCm() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(2);
10 digitalWrite(TRIG_PIN, HIGH); // 10 mikrosaniye tetik darbesi / 10 microsecond trigger pulse
11 delayMicroseconds(10);
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
14 if (duration == 0) return -1; // yankı yok / no echo
15 return duration / 58; // mikrosaniye -> cm / microseconds -> cm
16}
17
18void setup() {
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 pinMode(BUZZER_PIN, OUTPUT);
22 pinMode(LED_PIN, OUTPUT);
23 Serial.begin(9600);
24}
25
26void loop() {
27 long cm = readDistanceCm();
28 Serial.print("Mesafe / Distance: ");
29 Serial.print(cm);
30 Serial.println(" cm");
31
32 if (cm > 0 && cm < 50) {
33 int pause = map(cm, 0, 50, 50, 500); // yaklaştıkça kısalır / shorter when closer
34 tone(BUZZER_PIN, 2000, 50); // 2 kHz, 50 ms bip / 2 kHz, 50 ms beep
35 digitalWrite(LED_PIN, HIGH);
36 delay(50);
37 digitalWrite(LED_PIN, LOW);
38 delay(pause);
39 } else {
40 noTone(BUZZER_PIN);
41 digitalWrite(LED_PIN, LOW);
42 delay(200);
43 }
44}| Verbindung | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN / 5V | VBUS (5 V) |
| HC-SR04 GND | GND | GND | GND |
| HC-SR04 TRIG | D7 | GPIO 5 | GP14 |
| HC-SR04 ECHO | D6 | GPIO 18 (mit Spannungsteiler) | GP15 (mit Spannungsteiler) |
| Buzzer (+) | D5 | GPIO 19 | GP13 |
| LED (mit 220 Ω) | D4 | GPIO 23 | GP12 |
ESP32-Weg: derselbe Plan, jetzt mit WLAN
Mit dem ESP32 machst du die Tage 1–13 mit fast demselben Code und änderst nur die Pinnummern. Zwei Unterschiede musst du beachten: analogRead liefert beim ESP32 Werte von 0–4095 (12 Bit), und fürs analoge Lesen solltest du ADC1-Pins (GPIO 32–39) bevorzugen, weil ADC2-Pins bei aktivem WLAN nicht nutzbar sind. Außerdem solltest du dir nach Tag 9 einen Abend für WLAN reservieren: Der folgende Code zeigt die von der Einparkhilfe gemessene Entfernung auf einer Webseite im lokalen Netzwerk an, die Seite aktualisiert sich jede Sekunde, und die LED leuchtet, sobald die Entfernung unter 30 cm fällt. Lässt du den Buzzer wie in der Tabelle an GPIO 19 angeschlossen, ist ein akustischer Alarm im Finale leicht nachzurüsten. Zur Einrichtung des Boards siehst du dir den Artikel Was ist der ESP32 an.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // kendi ağ adın / your network name
5const char* WIFI_PASS = "Sifre123"; // kendi şifren / your password
6
7const int TRIG_PIN = 5;
8const int ECHO_PIN = 18; // gerilim bölücüyle / through a voltage divider
9const int LED_PIN = 23;
10
11WebServer server(80);
12
13long readDistanceCm() {
14 digitalWrite(TRIG_PIN, LOW);
15 delayMicroseconds(2);
16 digitalWrite(TRIG_PIN, HIGH);
17 delayMicroseconds(10);
18 digitalWrite(TRIG_PIN, LOW);
19 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
20 if (duration == 0) return -1;
21 return duration / 58;
22}
23
24void handleRoot() {
25 long cm = readDistanceCm();
26 digitalWrite(LED_PIN, (cm > 0 && cm < 30) ? HIGH : LOW); // 30 cm altında uyarı / warn below 30 cm
27 String html = "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='1'></head><body>";
28 html += "<h1>Mesafe: " + String(cm) + " cm</h1></body></html>";
29 server.send(200, "text/html", html);
30}
31
32void setup() {
33 Serial.begin(115200);
34 pinMode(TRIG_PIN, OUTPUT);
35 pinMode(ECHO_PIN, INPUT);
36 pinMode(LED_PIN, OUTPUT);
37 WiFi.mode(WIFI_STA);
38 WiFi.begin(WIFI_SSID, WIFI_PASS);
39 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
40 delay(500);
41 Serial.print(".");
42 }
43 Serial.println();
44 Serial.print("IP: ");
45 Serial.println(WiFi.localIP()); // bu adresi tarayıcıya yaz / type this address in a browser
46 server.on("/", handleRoot);
47 server.begin();
48}
49
50void loop() {
51 server.handleClient();
52}Öffne nach dem Hochladen den Seriellen Monitor mit 115200 Baud und gib die IP-Adresse, die nach dem Verbinden angezeigt wird, im Browser deines Handys ein. Dein Handy und der ESP32 müssen im selben WLAN sein. Der ESP32 verbindet sich nur mit 2,4-GHz-Netzen; klappt es nicht, geh die Checkliste im Artikel ESP32 verbindet sich nicht mit WLAN durch. Ein gutes Ziel für den nächsten Schritt ist, DHT11-Daten und einen LED-Schalter auf dieser Seite im Abschlussprojekt einzubauen.
Raspberry-Pi-Pico-Weg: dieselben Tage mit MicroPython
Beim Pico nutzt du statt der Arduino IDE den Editor Thonny; nachdem du die MicroPython-Firmware einmal aufgespielt hast, landet dein Code auf dem Board, sobald du ihn speicherst und ausführst. Die eingebaute LED hängt beim klassischen Pico an GP25 (beim Pico W erreichst du sie mit Pin("LED")), für PWM nutzt du machine.PWM, fürs analoge Lesen machine.ADC, und read_u16 liefert Werte im Bereich 0–65535. Bist du mit der Python-Syntax nicht vertraut, wirf vor Tag 1 einen Blick auf MicroPython-Grundlagen; zur Vorstellung des Boards gibt es die Anleitung Was ist der Raspberry Pi Pico. Der folgende Code ist die MicroPython-Version der Einparkhilfe von Tag 11 und nutzt die Pico-Spalte der Pin-Tabelle.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN) # gerilim bölücüyle / through a voltage divider
6buzzer = PWM(Pin(13)) # pasif buzzer / passive buzzer
7led = Pin(12, Pin.OUT)
8
9def mesafe_cm():
10 trig.value(0)
11 time.sleep_us(2)
12 trig.value(1)
13 time.sleep_us(10) # 10 mikrosaniye tetik / 10 microsecond trigger
14 trig.value(0)
15 sure = time_pulse_us(echo, 1, 30000) # 30 ms zaman aşımı / 30 ms timeout
16 if sure < 0:
17 return -1 # yankı yok / no echo
18 return sure / 58
19
20while True:
21 cm = mesafe_cm()
22 print("Mesafe / Distance:", cm, "cm")
23 if 0 < cm < 50:
24 bekle = int(50 + cm * 9) # yaklaştıkça kısalır / shorter when closer
25 buzzer.freq(2000)
26 buzzer.duty_u16(32768) # yüzde 50 doluluk / 50 percent duty
27 led.value(1)
28 time.sleep_ms(50)
29 buzzer.duty_u16(0)
30 led.value(0)
31 time.sleep_ms(bekle)
32 else:
33 buzzer.duty_u16(0)
34 led.value(0)
35 time.sleep_ms(200)Abschlussprojekt: Was fertigst du am Ende der Ferien?
Das Abschlussprojekt bündelt die Teile, die du in zwei Wochen gelernt hast, in einem Gerät, das etwas Nützliches tut. Ein gutes Abschlussprojekt hat mindestens einen Eingang (Sensor oder Taster), eine Verarbeitung (Code, der entscheidet) und einen Ausgang (LED, Ton, Display oder Motor). Keine der folgenden Optionen braucht ein teures Teil außerhalb des Sets; wähle die passende für dein Level und arbeite ab Tag 13 daran. Weitere Ideen findest du in der Liste Arduino Projektideen.
| Level / Weg | Abschlussprojekt | Kombinierte Tage | Zusätzliches Material |
|---|---|---|---|
| Uno – Einsteiger | Smarter Parkassistent: Piepen wird mit der Entfernung schneller, Zentimeter auf dem LCD, Servo-Schranke senkt sich bei 10 cm | 4, 9, 10, 11, 12, 13 | Keins, das Set reicht |
| Uno – Alternative | Mini-Wetterstation: DHT11-Daten auf dem LCD, per Taster Seite wechseln, bei Dunkelheit geht die Displaybeleuchtung aus | 4, 7, 9, 12 | Keins, das Set reicht |
| ESP32 | Raumstation per Handy: Temperatur, Luftfeuchtigkeit und Entfernung auf einer Webseite, LED per Browser ein- und ausschalten | 6, 9, 10, 12 + WLAN | Keins, das ESP32-Board reicht |
| Pico | Reaktionsspiel: Wer als Schnellster die zu einem zufälligen Zeitpunkt aufleuchtende LED drückt, gewinnt; die Zeit erscheint in der Thonny-Konsole, der Sieger wird mit einer Buzzer-Melodie gefeiert | 4, 8, 9 | Zweiter Taster |
- In einem Satz beschreiben: Schreib in einem klaren Satz auf, was das Gerät tut, etwa: "Je näher das Auto der Garage kommt, desto schneller piept es, und bei 10 cm senkt sich die Schranke."
- Ein-/Verarbeitung-/Ausgabe-Schema zeichnen: Zeichne mit Kästchen auf Papier, welcher Sensor Daten liefert, worüber der Code entscheidet und welches Teil reagiert.
- Pinplan erstellen: Schreib in eine Tabelle, an welchen Pin jedes Teil kommt. Ausgänge, die PWM brauchen, etwa für die LED-Helligkeit, legst du auf Pins mit ~; denk daran, dass die Servo-Bibliothek beim Uno PWM an D9 und D10 deaktiviert. Das Tool Pinout-Diagramm hilft dir bei der Pinbelegung deines Boards.
- Teil für Teil testen: Lass jedes Modul zuerst mit seinem eigenen kleinen Code allein laufen; geh erst ans Zusammenfügen, wenn alle einzeln funktionieren.
- Zusammenführen und delays entfernen: Fasse die Codes in einer Datei zusammen und ersetze lange delays durch die millis-Struktur von Tag 9, damit Sensorabfrage, Ton und Display nicht aufeinander warten.
- Einbauen und präsentieren: Setze die Schaltung in eine Karton- oder Plastikbox, fixiere die Kabel mit Klebeband und dreh ein 30–60 Sekunden langes Vorstellungsvideo. Willst du die Schaltung dauerhaft machen, ist das Löten auf Lochrasterplatine dein nächster Schritt.
Typische Stolperstellen und ihre Lösungen
| Problem | Mögliche Ursache | Lösung |
|---|---|---|
| Code lässt sich nicht hochladen, Port fehlt | Falsches Board oder falscher Port gewählt, CH340-Treiber fehlt oder ein reines Ladekabel wird benutzt | Wähle Board und Port im Menü Werkzeuge, nimm ein USB-Datenkabel, installiere den Treiber |
| LED leuchtet gar nicht | LED falsch herum eingesetzt oder die Beinchen sitzen im Breadboard nicht in derselben Reihe | Das lange Bein (Anode) kommt zur Pin-Seite, das kurze (Kathode) zur GND-Seite; versuche, die Verbindung um eine Reihe zu verschieben |
| Taster löst auch ohne Drücken aus | Pin ist offen (floating), kein Pull-up-Widerstand | Nutze pinMode(pin, INPUT_PULLUP) und verbinde das andere Ende des Tasters mit GND |
| HC-SR04 zeigt ständig 0 oder -1 | TRIG und ECHO vertauscht oder der Sensor bekommt keine 5 V | Prüfe die Pin-Tabelle, schließe VCC an 5 V an und halte den Sensor vor eine glatte Fläche in mindestens 2 cm Abstand |
| LCD-Hintergrundbeleuchtung an, aber kein Text | Kontrast oder I2C-Adresse falsch | Dreh am blauen Trimmer auf der Rückseite des Moduls und probiere die Adressen 0x27 und 0x3F |
| Board startet neu, wenn der Servo sich bewegt | Der Servo zieht mehr Strom, als USB liefern kann | Versorge den Servo aus einer externen 5-V-Quelle und verbinde deren GND mit dem GND des Boards |
| Beim Hochladen auf den ESP32 erscheint "Failed to connect" | Das Board wechselt nicht in den Download-Modus | Halte beim Start des Uploads die BOOT-Taste gedrückt und lass sie los, sobald "Connecting..." erscheint |
Nach den zwei Wochen hast du nicht nur ein funktionierendes Abschlussprojekt, sondern auch eine Methode, mit der du einen neuen Sensor oder ein neues Modul selbst lernen kannst: lesen, zeichnen, aufbauen, testen, verändern. Behältst du diese Gewohnheit nach den Ferien mit einem Projekt pro Woche bei, bist du bis zum Sommer bereit für eine Arbeit auf dem Niveau von Jugend forscht oder einer Science Fair; für die Ideenphase ist der Artikel Arduino Projektideen für Wettbewerbe ein guter Start. Schaltpläne und Codes für die Projekte LED, Ampel, Taster, LDR-Nachtlicht, Entfernungsmessung und DHT11 findest du Schritt für Schritt in der BlueGrays-App für Uno, ESP32 und Pico, und jeden Tag kannst du direkt in der App verfolgen.
Häufige Fragen
Kann man in den Winterferien Arduino lernen?
Ja, mit regelmäßigen 1–2 Stunden pro Tag kannst du in zwei Wochen digitale und analoge Ein- und Ausgänge, Sensorauslesen, Displays und Motorsteuerung lernen. Wichtig ist, jeden Tag ein kleines, aber abgeschlossenes Projekt zu beenden und den Code selbst zu verändern. Am Ende der Ferien kannst du ein Projekt bauen, das mehrere Module verbindet.
Welches Starterset sollte ich für Arduino kaufen?
Ein Starterset mit Arduino Uno, Breadboard, Jumperkabeln, LEDs, Widerständen, Taster, Potentiometer, LDR, Buzzer, HC-SR04, DHT11, Servo und I2C-LCD reicht für den ganzen Plan. Uno-Klone führen denselben Code aus wie das Original; eventuell musst du nur den CH340-Treiber installieren.
Soll ich mit Arduino, ESP32 oder Raspberry Pi Pico starten?
Ohne Vorerfahrung ist der Arduino Uno der einfachste Einstieg; er arbeitet mit 5 V, und die meisten Beispiele sind für ihn geschrieben. Willst du deine Projekte ins Internet bringen, ist der ESP32 besser, willst du Python lernen, der Raspberry Pi Pico mit MicroPython. Die Grundkonzepte, die du lernst, sind auf allen drei Boards gleich.
Kann ich Arduino ohne Board lernen?
Ja. Simulatoren im Browser wie Wokwi und Tinkercad erlauben es dir, Teile wie LED, Taster, Potentiometer, HC-SR04, Servo und LCD virtuell zu verbinden und den Code laufen zu lassen. Die erste Woche dieses Plans kannst du komplett in der Simulation machen und denselben Code ausprobieren, sobald dein Board da ist, in der echten Schaltung.
Was ist das einfachste Projekt mit Arduino?
Das einfachste Projekt ist, eine LED mit 220-Ω-Widerstand anzuschließen und blinken zu lassen (Blink). Danach folgen Ampel, LED-Steuerung per Taster und das Nachtlicht mit LDR. Diese vier Projekte vermitteln die Grundlagen von digitalem Ausgang, digitalem Eingang und analogem Lesen.
Muss ich programmieren können, um Arduino zu lernen?
Du musst nicht vorher programmieren können; die Arduino-Sprache basiert auf C++, aber in den Einsteigerprojekten kommst du mit ein paar Befehlen und einfachen if- und for-Strukturen aus. Am schnellsten lernst du, indem du fertige Beispielcodes laufen lässt und Zeile für Zeile veränderst. Kannst du Python, kannst du dieselben Projekte mit dem Raspberry Pi Pico und MicroPython bauen.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
LED Blinken
Das allererste Hallo der Elektronik: eine einzelne LED an- und ausschalten. Der Arduino schaltet die LED in kurzen Abständen ein und aus, das Licht blinkt also schnell.

Ampel
Eine winzige Nachbildung der Ampel, die du jeden Tag auf der Straße siehst. Rot leuchtet zwei Sekunden, Gelb blitzt kurz auf, Grün leuchtet zwei Sekunden, dann geht es über Gelb wieder zurück zu Rot…

LED mit Taster schalten (Push)
Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

Nachtlicht mit LDR
Ein kleines Nachtlicht, das von selbst angeht, wenn es dunkel wird, und am Morgen wieder ausgeht.

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…

Temperatur und Luftfeuchtigkeit mit DHT11
Wie warm ist dein Zimmer, und ist die Luft feucht oder trocken? Der DHT11-Sensor misst Temperatur und Luftfeuchtigkeit, und der Arduino schreibt die Werte auf ein zweizeiliges LCD und aktualisiert…

LED Blinken mit ESP32
Lehrt die grundlegende Verwendung von GPIO-Ausgängen mit ESP32. Wir erreichen einen Blinkeffekt, indem wir eine LED über einen digitalen Pin ein- und ausschalten. ESP32-Version des klassischen Blink-Projekts auf Arduino UNO; die grundlegenden Blink-Befehle in der Arduino-Umgebung bleiben gleich, aber die Pinbelegung und die GPIO-Pegel von 3,3 V des ESP32 unterscheiden sich von denen des Arduino UNO.

Raspberry Pi Pico Ampel-Simulator (3 LEDs sequenziell)
Wir simulieren eine echte Ampel mit roten, gelben und grünen LEDs. Grün 4 Sek "gehen", gelb 1,5 Sek "bereit", rot 3 Sek "stopp" und rot+gelb 1 Sek "starten" (europäisches Ampelmuster). Lerne Funktionsdefinition, Zustandsmaschinen-Logik und Multi-GPIO-Synchronisation. Sehr einfache Schaltung: 3 LEDs an GP11/GP12/GP13, jeweils mit 220Ω Widerstand.
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

