Arduino Code verstehen: einen Sketch Zeile für Zeile lesen
Arduino Code verstehen: Bibliotheken, Pin-Definitionen, setup und loop, Funktionen und if-Bedingungen, Beispiel Zeile für Zeile erklärt, dazu ESP32 und Pico.
Arduino Code verstehen zu können ist der Unterschied zwischen einem kopierten Projekt, bei dem du hoffst, dass es läuft, und einem Projekt, das wirklich deines ist. Fast jeder Sketch aus dem Internet, aus Büchern oder von Freunden folgt demselben Gerüst: oben Bibliotheken und Pin-Definitionen, in der Mitte ein setup(), das einmal läuft, darunter ein loop(), das endlos wiederholt wird, und bei Bedarf ein paar eigene Funktionen. Kennst du dieses Gerüst, kannst du auch bei unbekanntem Code sagen: „Diese Zeile liest jenen Pin, und in diesem Fall startet sie jenen Motor.“
In diesem Artikel lernst du eine Schritt-für-Schritt-Methode, um Arduino-Code zu lesen. Zuerst schauen wir uns die Teile eines Sketches und ihre Aufgaben an, dann nehmen wir Zeile für Zeile den Code eines kleinen Mülleimers auseinander, dessen Deckel sich öffnet, wenn eine Hand näherkommt. Danach geht es um Variablen, Bedingungen und Funktionen, um das Anpassen fremden Codes an deine Schaltung und um den Umzug auf einen ESP32 und einen Raspberry Pi Pico. Zum Schluss siehst du, wie du mit dem Reiter „Code verstehen“ in BlueGrays üben kannst.

Der Aufbau eines Arduino-Sketches
Arduino-Sketches sind von oben nach unten immer gleich aufgebaut. Der Compiler liest die Datei von vorn bis hinten, das Board führt sie aber in anderer Reihenfolge aus: Zuerst werden die globalen Deklarationen vorbereitet, dann läuft setup() einmal, und danach wiederholt sich loop(), solange das Board Strom hat. Die Tabelle zeigt die Teile, die du beim Öffnen eines Sketches siehst, und woran du sie erkennst:
| Codeteil | Aufgabe | Typische Zeile | Woran erkennst du ihn? |
|---|---|---|---|
| Kommentare | Erklären den Code, der Compiler ignoriert sie | // Hinweis oder /* ... */ | Beginnen mit //, in der IDE grau |
| Bibliotheken | Binden fertigen Code ein (Servo, Display, Sensor) | #include <Servo.h> | Beginnen mit #, ganz oben |
| Pin-Definitionen und Konstanten | Geben Pin-Nummern und Schwellwerten einen Namen | const int LED_PIN = 13; | Meist Namen in GROSSBUCHSTABEN |
| Globale Variablen und Objekte | Daten, die überall im Code erreichbar sind | int count = 0; Servo lidServo; | Außerhalb jeder Funktion |
| setup() | Läuft einmal beim Einschalten | pinMode(LED_PIN, OUTPUT); | void setup() { ... } |
| loop() | Wiederholt sich endlos, hier passiert die eigentliche Arbeit | if (distance < 20) { ... } | void loop() { ... } |
| Eigene Funktionen | Bündeln eine Aufgabe, die öfter vorkommt | long readDistanceCm() { ... } | Eigene Blöcke über oder unter loop |
Wo fängst du an? Eine Methode in fünf Schritten
- Lies Kommentare und Bibliotheken. Die #include-Zeilen verraten die Hardware: Servo.h bedeutet einen Servo, LiquidCrystal_I2C.h ein I2C-LCD, DHT.h einen Temperatursensor.
- Schreib die Pin-Definitionen auf Papier. Mach aus jeder const-int- oder #define-Zeile eine Verdrahtungsliste wie „TRIG = D9, ECHO = D10“ und vergleiche sie mit deiner Schaltung.
- Lies setup(). Hier siehst du, welche Pins Ein- und welche Ausgänge sind, die serielle Geschwindigkeit und den Startzustand des Boards (Servo zu, LED aus usw.).
- Spiel loop() einmal von Hand durch. Nimm dir einen Sensorwert, etwa 45 cm, und verfolge den Code Zeile für Zeile damit; notiere, in welchen if-Block du gelangst und welche Variable sich ändert.
- Steig bei Bedarf in die Funktionen ein. Siehst du in loop() einen Aufruf wie readDistanceCm(), rate zuerst anhand des Namens, was er macht, und prüf es dann in der Funktion selbst.
Beispiel-Sketch: Zeile für Zeile erklärt
Zum Üben haben wir den Code eines echten Projekts gewählt: Ein Ultraschallsensor HC-SR04 erkennt eine Hand, ein Servo öffnet den Deckel und schließt ihn drei Sekunden später wieder, währenddessen leuchtet eine LED, und die Zahl der Öffnungen erscheint im seriellen Monitor. Im Sketch steckt alles: Bibliothek, Konstanten, globale Variable, Objekt, setup, loop, Bedingung und eine eigene Funktion. Schau dir zuerst das Ganze an, danach gehen wir es mit der Tabelle Zeile für Zeile durch.
1// Akıllı çöp kutusu: el yaklaşınca kapak açılır / Smart bin: the lid opens when a hand comes close
2#include <Servo.h> // servo kütüphanesi / servo library
3
4const int TRIG_PIN = 9; // HC-SR04 TRIG
5const int ECHO_PIN = 10; // HC-SR04 ECHO
6const int SERVO_PIN = 6; // servo sinyal kablosu / servo signal wire
7const int LED_PIN = 13; // durum LED'i / status LED
8const int OPEN_DISTANCE = 20; // bundan yakınsa aç (cm) / open if closer than this (cm)
9const int OPEN_ANGLE = 90; // açık kapak açısı / open lid angle
10const int CLOSED_ANGLE = 0; // kapalı kapak açısı / closed lid angle
11
12Servo lidServo; // servo nesnesi / servo object
13int openCount = 0; // kaç kez açıldı / how many times it opened
14
15void setup() {
16 Serial.begin(9600);
17 pinMode(TRIG_PIN, OUTPUT);
18 pinMode(ECHO_PIN, INPUT);
19 pinMode(LED_PIN, OUTPUT);
20 lidServo.attach(SERVO_PIN);
21 lidServo.write(CLOSED_ANGLE); // açılışta kapalı / closed at power-up
22}
23
24void loop() {
25 long distance = readDistanceCm(); // mesafeyi ölç / measure the distance
26 Serial.print("Mesafe / Distance: ");
27 Serial.println(distance);
28
29 if (distance > 0 && distance < OPEN_DISTANCE) {
30 openCount++; // sayacı bir artır / add one to the counter
31 digitalWrite(LED_PIN, HIGH);
32 lidServo.write(OPEN_ANGLE); // kapağı aç / open the lid
33 delay(3000); // 3 sn açık kal / stay open for 3 s
34 lidServo.write(CLOSED_ANGLE); // kapağı kapat / close the lid
35 digitalWrite(LED_PIN, LOW);
36 Serial.print("Acilma sayisi / Times opened: ");
37 Serial.println(openCount);
38 }
39 delay(100); // saniyede yaklaşık 10 ölçüm / about 10 readings per second
40}
41
42// Mesafeyi santimetre olarak döndürür / returns the distance in centimetres
43long readDistanceCm() {
44 digitalWrite(TRIG_PIN, LOW);
45 delayMicroseconds(2);
46 digitalWrite(TRIG_PIN, HIGH); // 10 µs tetik darbesi / 10 µs trigger pulse
47 delayMicroseconds(10);
48 digitalWrite(TRIG_PIN, LOW);
49 long duration = pulseIn(ECHO_PIN, HIGH, 30000); // en fazla 30 ms bekle / wait at most 30 ms
50 return duration / 58; // µs'yi cm'ye çevir / convert µs to cm
51}| Zeile | Was sie macht | Was passiert, wenn du sie änderst? |
|---|---|---|
| #include <Servo.h> | Bindet die Servo-Bibliothek ein | Ohne sie meldet der Compiler „'Servo' does not name a type“ |
| const int TRIG_PIN = 9; | Gibt Pin 9 den Namen TRIG_PIN | Steckst du das Kabel um, änderst du nur diese Zahl |
| const int OPEN_DISTANCE = 20; | Schwellwert, ab dem der Deckel aufgeht | Mit 30 öffnet der Deckel schon aus größerer Entfernung |
| Servo lidServo; | Legt ein Servo-Objekt namens lidServo an | Alle folgenden Zeilen müssen denselben Namen verwenden |
| int openCount = 0; | Globaler Zähler, beim Start null | In loop() verschoben, startet er jede Runde bei null und zeigt immer 1 |
| lidServo.attach(SERVO_PIN); | Verbindet den Servo mit Pin 6 | Fehlt die Zeile, bewegt sich der Servo gar nicht |
| long distance = readDistanceCm(); | Ruft die Funktion auf und speichert das Ergebnis | distance existiert nur innerhalb von loop() |
| if (distance > 0 && distance < OPEN_DISTANCE) | Betritt den Block, wenn beide Bedingungen wahr sind | distance > 0 filtert die 0 heraus, die ohne Echo zurückkommt |
| delay(3000); | Lässt das Board 3 Sekunden warten | In dieser Zeit prüft der Arduino nichts anderes |
| return duration / 58; | Rechnet die Echozeit in Zentimeter um | Der Schall läuft hin und zurück, also etwa 58 µs pro Zentimeter |
Spielen wir loop() jetzt mit zwei Situationen von Hand durch. Steht niemand davor, misst der Sensor 45 cm: distance wird 45, der serielle Monitor zeigt „Mesafe / Distance: 45“, die Bedingung 45 < 20 ist falsch, also wird der Block übersprungen, das Board wartet 100 ms, und loop() beginnt von vorn. Das passiert etwa zehnmal pro Sekunde. Hältst du die Hand auf 12 cm, sind beide Bedingungen wahr: openCount steigt von 0 auf 1, die LED geht an, der Servo dreht auf 90 Grad, das Board wartet drei Sekunden, der Deckel schließt, die LED geht aus, und im Monitor steht „Acilma sayisi / Times opened: 1“. Code mit echten Zahlen zu verfolgen ist der zuverlässigste Weg, ihn zu verstehen.
Achte noch auf ein Detail: Bekommt pulseIn() innerhalb von 30 ms kein Echo, liefert es 0. Ohne die Prüfung distance > 0 würde diese 0, gemessen ins Leere, als „kleiner als 20“ gelten, und der Deckel ginge grundlos auf. Gut geschriebener Code steckt voller kleiner Prüfungen wie dieser; verstehst du nicht, warum eine Zeile da ist, lösch sie vorübergehend und schau, was passiert. Wie der Sensor funktioniert, steht im Artikel zum Ultraschallsensor HC-SR04, die vollständige Version mit zwei Sensoren im Artikel zum smarten Mülleimer.
Variablen und Datentypen: Etiketten auf Kisten
Eine Variable ist eine beschriftete Kiste, in die du eine Zahl oder einen Text legst. Das Wort am Zeilenanfang gibt den Typ der Kiste an, also was hineinpasst. Auf dem Arduino Uno führt der falsche Typ zu stillen Fehlern: Speicherst du millis() zum Beispiel in einem int, wird die Zahl nach etwa 32 Sekunden negativ.
| Typ | Wertebereich (Arduino Uno) | Typische Verwendung |
|---|---|---|
| int | -32.768 bis 32.767 | Pin-Nummern, analogRead-Werte, Zähler |
| long | etwa ±2,1 Milliarden | pulseIn-Dauer, große Zahlen |
| unsigned long | 0 bis etwa 4,29 Milliarden | Zeiten von millis() und micros() |
| float | Kommazahlen, 6–7 Stellen Genauigkeit | Rechnungen mit Temperatur, Spannung, Entfernung |
| bool | true oder false | Ist etwas an oder aus? |
| byte | 0 bis 255 | PWM-Werte, kleine Zahlen |
| char / String | Ein Zeichen / Text | Befehle über die serielle Schnittstelle, Displaytexte |
Wichtig ist auch, wo eine Variable deklariert wird; das nennt man ihren Gültigkeitsbereich. Im Beispiel steht openCount außerhalb jeder Funktion und ist damit global: Ihr Wert bleibt bei jedem Durchlauf von loop() erhalten. distance wird dagegen in loop() deklariert und ist lokal: Sie entsteht in jeder Runde neu und verschwindet am Rundenende. Steht const davor, ist die Variable eine Konstante, die das Programm nicht ändern kann. Mehr dazu findest du in den Grundlagen der Arduino-Programmierung und, für mehrere Werte in einer Variablen, im Artikel über Arrays in Arduino.
Bedingungen, Schleifen und Funktionen lesen
- if / else if / else: Lies es als „wenn ..., dann mach das, sonst mach jenes“. Die geschweiften Klammern { } zeigen, welche Zeilen von der Bedingung abhängen.
- Vergleiche: == bedeutet „gleich“, != „ungleich“, < „kleiner als“, >= „größer oder gleich“. && heißt „und“, || „oder“, ! „nicht“.
- for-Schleife: for (int i = 0; i < 5; i++) liest du als „i beginnt bei 0, wiederhole, solange i kleiner als 5 ist, und zähle jedes Mal eins hoch“; der Block läuft 5-mal.
- while-Schleife: while (digitalRead(BUTTON_PIN) == HIGH) heißt „warte, solange der Taster nicht gedrückt ist“; ändert sich die Bedingung nie, bleibt der Code dort hängen.
- switch / case: Das Programm nimmt je nach Wert einer Variablen einen anderen Weg; fehlt das break am Ende eines case, läuft der nächste case gleich mit.
- Funktionsdefinition: In long readDistanceCm() ist long der Typ des Rückgabewerts, readDistanceCm der Name, und die leeren Klammern bedeuten: keine Parameter. Funktionen mit void geben nichts zurück, sie erledigen nur eine Aufgabe.
Bibliotheksfunktionen erkennen
In einer Zeile wie lidServo.write(90) zeigt der Punkt, dass die Funktion write zum Objekt lidServo gehört: „lidServo, fahr auf 90 Grad“. Es gibt drei einfache Wege, herauszufinden, was eine Bibliotheksfunktion tut: In der Arduino IDE 2 mit der Maus darüberfahren und die Beschreibung lesen oder per Rechtsklick Go to Definition wählen; über Datei > Beispiele die Beispiele der Bibliothek öffnen; oder in der .h-Datei der Bibliothek die Liste der Funktionen ansehen. Wie man Bibliotheken installiert, erklären wir im Artikel Arduino-Bibliothek hinzufügen. Diese Grundfunktionen begegnen dir in fast jedem Sketch:
| Funktion | Was sie macht | Beispiel |
|---|---|---|
| pinMode(pin, modus) | Macht einen Pin zum Ein- oder Ausgang | pinMode(13, OUTPUT); |
| digitalWrite(pin, wert) | Setzt einen Ausgang auf 5 V (HIGH) oder 0 V (LOW) | digitalWrite(13, HIGH); |
| digitalRead(pin) | Liest, ob ein Eingang HIGH oder LOW ist | digitalRead(2) |
| analogRead(pin) | Wandelt 0–5 V in eine Zahl von 0 bis 1023 | analogRead(A0) |
| analogWrite(pin, 0–255) | Stellt per PWM LED-Helligkeit oder Motordrehzahl ein | analogWrite(9, 128); |
| delay(ms) | Hält das Board für die angegebene Zeit an | delay(1000); |
| millis() | Millisekunden seit dem Einschalten | if (millis() - last > 500) |
| Serial.begin / print / println | Schickt Text an den seriellen Monitor | Serial.println(distance); |
| map(x, a, b, c, d) | Rechnet einen Wertebereich in einen anderen um | map(value, 0, 1023, 0, 180) |
| pulseIn(pin, HIGH) | Misst die Länge eines Impulses in µs | pulseIn(10, HIGH, 30000) |
Die vollständige Liste mit ausführlichen Beispielen findest du im Artikel über Arduino-Befehle. Den Unterschied zwischen delay() und millis() zu verstehen, hilft dir beim Lesen von Sketchen enorm; der Artikel millis und delay erklärt ihn an Beispielen.
Fremden Code an die eigene Schaltung anpassen
- Zieh eine Verdrahtungstabelle aus dem Code. Schreib alle Pin-Konstanten untereinander; das ist die Schaltung der Person, die den Code geschrieben hat.
- Vergleiche mit deiner Schaltung. Hast du andere Pins benutzt, steck keine Kabel um, sondern ändere nur die Zahlen in den const-Zeilen und lass den restlichen Code in Ruhe.
- Prüf Unterschiede bei den Bibliotheken. Zwei Bibliotheken mit gleichem Namen können verschiedene Funktionen haben; bei I2C-LCDs ist die Adresse 0x27 oder 0x3F außerdem die häufigste Fehlerquelle.
- Achte auf active LOW und active HIGH. Die meisten Relaismodule ziehen bei LOW an; schaltet der Code mit HIGH ein, macht dein Relais genau das Gegenteil.
- Gleiche die serielle Geschwindigkeit an. Steht im Code Serial.begin(115200), stell auch im seriellen Monitor 115200 ein, sonst siehst du nur Zeichensalat.
- Teste Stück für Stück. Lass zuerst nur den Teil laufen, der den Sensor liest, und füge Motor und Display erst hinzu, wenn die Werte stimmen.
Den gleichen Code auf den ESP32 übertragen
Auch der ESP32 wird mit der Arduino IDE programmiert, daher läuft der Großteil des Codes unverändert; anders sind die Pin-Nummern, der Spannungspegel und einige Bibliotheken. Die Tabelle zeigt, was du beim Umzug von Arduino-Uno-Code auf den ESP32 prüfen solltest:
| Thema | Arduino Uno | ESP32 | Was ist zu tun? |
|---|---|---|---|
| Pin-Namen | D2–D13, A0–A5 | GPIO-Nummern | Konstanten durch GPIO-Nummern ersetzen, Vorsicht bei 6–11 und 34–39 |
| Betriebsspannung | 5 V | 3,3 V | Spannungsteiler an Sensoren mit 5-V-Ausgang (ECHO des HC-SR04) |
| analogRead | 10 Bit, 0–1023 | 12 Bit, 0–4095 | Schwellwerte und map()-Bereiche für den vierfachen Bereich neu berechnen |
| Servo-Bibliothek | Servo.h | ESP32Servo.h | Bibliothek tauschen und bei attach den Impulsbereich angeben |
| Serielle Geschwindigkeit | meist 9600 | meist 115200 | Serial.begin und seriellen Monitor angleichen |
| Speicher | 2 KB RAM | etwa 320 KB RAM | Große Arrays und Strings sind kein Problem mehr |
1// ESP32 sürümü: değişen satırlar işaretli / ESP32 version: changed lines are marked
2#include <ESP32Servo.h> // DEĞİŞTİ: Servo.h yerine / CHANGED: instead of Servo.h
3
4const int TRIG_PIN = 26; // DEĞİŞTİ / CHANGED
5const int ECHO_PIN = 27; // DEĞİŞTİ: 1k/2k bölücüyle / CHANGED: through a 1k/2k divider
6const int SERVO_PIN = 18; // DEĞİŞTİ / CHANGED
7const int LED_PIN = 2; // DEĞİŞTİ: çoğu DevKit'te dahili LED / CHANGED: onboard LED on most DevKits
8const int OPEN_DISTANCE = 20;
9const int OPEN_ANGLE = 90;
10const int CLOSED_ANGLE = 0;
11
12Servo lidServo;
13int openCount = 0;
14
15void setup() {
16 Serial.begin(115200); // DEĞİŞTİ: ESP32'de yaygın hız / CHANGED: common ESP32 speed
17 pinMode(TRIG_PIN, OUTPUT);
18 pinMode(ECHO_PIN, INPUT);
19 pinMode(LED_PIN, OUTPUT);
20 lidServo.setPeriodHertz(50); // EKLENDİ: standart servo 50 Hz / ADDED: standard servo 50 Hz
21 lidServo.attach(SERVO_PIN, 500, 2400); // DEĞİŞTİ: darbe aralığı µs / CHANGED: pulse range in µs
22 lidServo.write(CLOSED_ANGLE);
23}
24
25void loop() {
26 long distance = readDistanceCm();
27 Serial.print("Mesafe / Distance: ");
28 Serial.println(distance);
29
30 if (distance > 0 && distance < OPEN_DISTANCE) {
31 openCount++;
32 digitalWrite(LED_PIN, HIGH);
33 lidServo.write(OPEN_ANGLE);
34 delay(3000);
35 lidServo.write(CLOSED_ANGLE);
36 digitalWrite(LED_PIN, LOW);
37 Serial.print("Acilma sayisi / Times opened: ");
38 Serial.println(openCount);
39 }
40 delay(100);
41}
42
43long readDistanceCm() {
44 digitalWrite(TRIG_PIN, LOW);
45 delayMicroseconds(2);
46 digitalWrite(TRIG_PIN, HIGH);
47 delayMicroseconds(10);
48 digitalWrite(TRIG_PIN, LOW);
49 long duration = pulseIn(ECHO_PIN, HIGH, 30000);
50 return duration / 58;
51}Wie du siehst, sind loop() und readDistanceCm() ohne einen geänderten Buchstaben umgezogen; alles, was sich geändert hat, steht oben in der Datei und in setup(). Das ist ein Zeichen für gut geschriebenen Code: Hardwaredetails stehen gesammelt oben, die Logik darunter bleibt sauber. Weil der ECHO-Pin des HC-SR04 5 V ausgibt, muss er über einen Spannungsteiler aus 1 kΩ und 2 kΩ zum ESP32; den Servo versorgst du aus den 5 V am VIN-Pin, nicht aus 3,3 V. Die übrigen Unterschiede zwischen den Boards vergleichen wir im Artikel Arduino oder ESP32.
Dieselbe Logik auf dem Raspberry Pi Pico: MicroPython
Programmierst du den Pico in MicroPython, sieht der Code anders aus, die Logik bleibt aber gleich. Statt #include schreibst du import, statt geschweifter Klammern zählt die Einrückung. setup() und loop() gibt es nicht: Die Zeilen oben in der Datei laufen einmal (das Gegenstück zu setup), der Block while True: läuft endlos (das Gegenstück zu loop). Funktionen beginnen mit def statt mit void oder long. Leg diesen Code neben den Arduino-Sketch oben, und du findest für jede Zeile die Entsprechung:
1from machine import Pin, PWM, time_pulse_us # #include karşılığı / the #include part
2import time
3
4TRIG = Pin(14, Pin.OUT) # HC-SR04 TRIG
5ECHO = Pin(15, Pin.IN) # HC-SR04 ECHO, bölücüyle / through a divider
6LED = Pin(25, Pin.OUT) # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7servo = PWM(Pin(16))
8servo.freq(50) # servo 50 Hz ister / servos need 50 Hz
9
10OPEN_DISTANCE = 20 # cm
11
12
13def set_angle(angle):
14 pulse_us = 500 + angle * 2000 // 180 # 0 derece 0,5 ms, 180 derece 2,5 ms / 0 deg 0.5 ms, 180 deg 2.5 ms
15 servo.duty_u16(pulse_us * 65535 // 20000) # 20 ms periyodun oranı / share of the 20 ms period
16
17
18def read_distance_cm():
19 TRIG.low()
20 time.sleep_us(2)
21 TRIG.high() # 10 µs tetik darbesi / 10 µs trigger pulse
22 time.sleep_us(10)
23 TRIG.low()
24 duration = time_pulse_us(ECHO, 1, 30000) # zaman aşımında negatif / negative on timeout
25 if duration < 0:
26 return 0
27 return duration // 58
28
29
30set_angle(0) # setup() karşılığı / the setup() part
31open_count = 0
32
33while True: # loop() karşılığı / the loop() part
34 distance = read_distance_cm()
35 print("Mesafe / Distance:", distance)
36 if 0 < distance < OPEN_DISTANCE:
37 open_count += 1
38 LED.on()
39 set_angle(90)
40 time.sleep(3)
41 set_angle(0)
42 LED.off()
43 print("Acilma sayisi / Times opened:", open_count)
44 time.sleep_ms(100)Weil es hier in Python keine Servo-Bibliothek gibt, rechnet die Funktion set_angle() den Winkel selbst in eine Impulsdauer um: Ein Servo richtet sich nach einem Impuls von 0,5 bis 2,5 ms, der alle 20 ms kommt. Die Schreibweise 0 < distance < OPEN_DISTANCE ist in Python die Kurzform der C++-Bedingung distance > 0 && distance < OPEN_DISTANCE. Bist du neu bei MicroPython, erklärt der Artikel zu den MicroPython-Grundlagen die Regeln für Einrückung, Variablen und Funktionen.
Üben mit „Code verstehen“ in BlueGrays
In der BlueGrays-App hat der Code-Bildschirm jedes Projekts zusätzlich den Reiter „Code verstehen“. Der Abschnitt „Was macht dieser Code?“ fasst zuerst in wenigen Sätzen zusammen, was das Programm tut. „Schritt für Schritt“ zerlegt den Code dann in kleine Stücke und erklärt unter jedem, wofür diese Zeilen da sind und was passiert, wenn du sie änderst. „Wenn du nicht weiterkommst“ listet die häufigsten Probleme als Symptom und Lösung auf, und „Probier es selbst“ stellt dir eine kleine Aufgabe mit Tipp und Lösung, zum Beispiel den Schwellwert eines Nachtlichts so zu ändern, dass die LED früher angeht. Dort kannst du die Fünf-Schritte-Methode aus diesem Artikel direkt anwenden: Zusammenfassung lesen, jedes Stück deiner Schaltung zuordnen und zum Schluss die Aufgabe lösen, indem du den Code selbst änderst.
Übungen zum Code-Lesen
- Vorhersagen, dann testen: Bevor du eine Konstante änderst, schreib auf, was passieren wird, lade den Code hoch und prüf deine Vorhersage.
- Eine Zeile auskommentieren: Setz // vor eine Zeile und lade erneut hoch; was dann nicht mehr funktioniert, zeigt dir die Aufgabe dieser Zeile.
- In eigenen Worten erzählen: Übersetze jede Zeile von loop() in einen deutschen Satz; eine Zeile, die du nicht übersetzen kannst, hast du noch nicht verstanden.
- Ein Ablaufdiagramm zeichnen: Stell setup, loop, die if-Abfragen und Funktionsaufrufe als Kästchen und Pfeile dar; das hilft besonders bei Code mit Zustandsautomaten.
- Absichtlich einen Fehler machen: Lösch ein Semikolon und lies die Meldung des Compilers; der Artikel zu Arduino-Kompilierfehlern erklärt die häufigsten Meldungen.
Typische Fehler beim Code-Lesen
| Fehler | Warum das ein Problem ist | So geht es richtig |
|---|---|---|
| Den Code für eine Liste halten, die einmal von oben nach unten läuft | loop() wiederholt sich endlos, Variablen ändern sich zwischen den Runden | loop() über mehrere Runden mit verschiedenen Werten verfolgen |
| = und == verwechseln | if (x = 5) ist immer wahr | Zum Vergleichen immer == verwenden |
| Ganzzahldivision übersehen | 5 / 2 ergibt 2, die Nachkommastellen fallen weg | Brauchst du Kommazahlen, schreib 5.0 / 2 oder nimm float |
| Vergessen, dass delay() alles anhält | Während der Wartezeit werden Taster und Sensoren nicht gelesen | Bei mehreren Aufgaben die Zeit mit millis() steuern |
| Versionsunterschiede bei Bibliotheken ignorieren | Dieselbe Funktion kann in einer neuen Version anders heißen | In den Kommentaren nachsehen, mit welcher Bibliothek der Code geschrieben wurde |
| Pin-Konstante ändern, aber das Kabel vergessen | Der Code liest den richtigen Pin, das Kabel steckt woanders | Nach jeder Änderung die Verdrahtungstabelle aktualisieren |
Code lesen wird, genau wie Schaltpläne lesen, mit jedem Beispiel schneller. Für den Einstieg empfehlen wir dir, in der BlueGrays-App kurze Projekte wie LED einschalten, die Ampel, die LED mit Taster oder das Nachtlicht mit LDR zu öffnen und dem Reiter „Code verstehen“ Zeile für Zeile zu folgen; jedes Projekt bringt Schaltplan, eine stückweise Erklärung des Codes und eine kleine Aufgabe mit.
Häufige Fragen
In welcher Sprache wird Arduino programmiert?
Arduino-Code basiert auf C und C++. Arduino ergänzt fertige Funktionen wie pinMode oder digitalWrite, die vieles vereinfachen, aber die Regeln für if, for-Schleifen, Variablen und Funktionen sind reines C++. Etwas C++-Wissen macht Arduino-Code deshalb deutlich leichter lesbar.
Was ist der Unterschied zwischen setup und loop?
setup() läuft nur einmal, wenn das Board startet oder zurückgesetzt wird, und dient zur Vorbereitung, etwa für Pin-Einstellungen und die serielle Verbindung. loop() wiederholt sich danach ohne Pause, solange Strom anliegt; dort passiert die eigentliche Arbeit wie Sensoren lesen, Entscheidungen treffen und Motoren ansteuern.
Was bedeutet void bei Arduino?
void bedeutet, dass eine Funktion keinen Wert zurückgibt. void setup() und void loop() erledigen Aufgaben, liefern aber kein Ergebnis. Eine Funktion wie long readDistanceCm() gibt dagegen mit return einen Wert des Typs zurück, der vor ihrem Namen steht.
Der Code kompiliert, aber die Schaltung funktioniert nicht. Warum?
Der Compiler prüft nur die Schreibweise; eine falsche Pin-Nummer, ein verkehrt angeschlossenes Modul oder ein unpassender Schwellwert erzeugen keinen Kompilierfehler. Vergleich die Pin-Konstanten im Code mit deiner Schaltung und beobachte die Werte mit Serial.println im seriellen Monitor; meist liegt es an der Verdrahtung oder an einem Schwellwert.
Kann ich Arduino-Code auf dem ESP32 verwenden?
Meistens ja, denn auch der ESP32 wird mit der Arduino IDE programmiert, und die Grundfunktionen sind gleich. Du musst die Pin-Nummern durch GPIO-Nummern ersetzen, 5-V-Signale auf 3,3 V herunterteilen und manche Bibliotheken wie Servo gegen ESP32-Versionen tauschen. Denk außerdem daran, dass analogRead Werte von 0 bis 4095 liefert.
Wo finde ich Arduino-Beispielcode?
Das Menü Datei > Beispiele in der Arduino IDE ist ein guter Startpunkt, zusammen mit den Beispielen jeder installierten Bibliothek. Auch die Projekte in der BlueGrays-App kommen mit Schaltplan und Zeile für Zeile erklärtem Code. Egal woher der Code stammt: Lies ihn vor dem Hochladen einmal mit der Methode aus diesem Artikel, dann findest du Fehler von Anfang an.
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…

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

Servomotorbetrieb mit Potentiometer
Während du am Knopf des Potentiometers drehst, dreht sich der Arm des Servomotors einfach mit: Das eine Ende des Knopfes bedeutet null Grad, das andere eine halbe Umdrehung.
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

