Grundlagen · 10 Min. Lesezeit

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.

Arduino Uno mit seinen Pins
Jede Pin-Nummer im Code entspricht einer Beschriftung auf der Platine: Die Zeile const int TRIG_PIN = 9 sagt dir, dass das Kabel in der Buchse mit der Aufschrift D9 steckt.

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:

CodeteilAufgabeTypische ZeileWoran erkennst du ihn?
KommentareErklären den Code, der Compiler ignoriert sie// Hinweis oder /* ... */Beginnen mit //, in der IDE grau
BibliothekenBinden fertigen Code ein (Servo, Display, Sensor)#include <Servo.h>Beginnen mit #, ganz oben
Pin-Definitionen und KonstantenGeben Pin-Nummern und Schwellwerten einen Namenconst int LED_PIN = 13;Meist Namen in GROSSBUCHSTABEN
Globale Variablen und ObjekteDaten, die überall im Code erreichbar sindint count = 0; Servo lidServo;Außerhalb jeder Funktion
setup()Läuft einmal beim EinschaltenpinMode(LED_PIN, OUTPUT);void setup() { ... }
loop()Wiederholt sich endlos, hier passiert die eigentliche Arbeitif (distance < 20) { ... }void loop() { ... }
Eigene FunktionenBündeln eine Aufgabe, die öfter vorkommtlong readDistanceCm() { ... }Eigene Blöcke über oder unter loop

Wo fängst du an? Eine Methode in fünf Schritten

  1. 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.
  2. 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.
  3. 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.).
  4. 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.
  5. 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.

C++ (Arduino IDE)
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}
ZeileWas sie machtWas passiert, wenn du sie änderst?
#include <Servo.h>Bindet die Servo-Bibliothek einOhne sie meldet der Compiler „'Servo' does not name a type“
const int TRIG_PIN = 9;Gibt Pin 9 den Namen TRIG_PINSteckst du das Kabel um, änderst du nur diese Zahl
const int OPEN_DISTANCE = 20;Schwellwert, ab dem der Deckel aufgehtMit 30 öffnet der Deckel schon aus größerer Entfernung
Servo lidServo;Legt ein Servo-Objekt namens lidServo anAlle folgenden Zeilen müssen denselben Namen verwenden
int openCount = 0;Globaler Zähler, beim Start nullIn loop() verschoben, startet er jede Runde bei null und zeigt immer 1
lidServo.attach(SERVO_PIN);Verbindet den Servo mit Pin 6Fehlt die Zeile, bewegt sich der Servo gar nicht
long distance = readDistanceCm();Ruft die Funktion auf und speichert das Ergebnisdistance existiert nur innerhalb von loop()
if (distance > 0 && distance < OPEN_DISTANCE)Betritt den Block, wenn beide Bedingungen wahr sinddistance > 0 filtert die 0 heraus, die ohne Echo zurückkommt
delay(3000);Lässt das Board 3 Sekunden wartenIn dieser Zeit prüft der Arduino nichts anderes
return duration / 58;Rechnet die Echozeit in Zentimeter umDer 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.

TypWertebereich (Arduino Uno)Typische Verwendung
int-32.768 bis 32.767Pin-Nummern, analogRead-Werte, Zähler
longetwa ±2,1 MilliardenpulseIn-Dauer, große Zahlen
unsigned long0 bis etwa 4,29 MilliardenZeiten von millis() und micros()
floatKommazahlen, 6–7 Stellen GenauigkeitRechnungen mit Temperatur, Spannung, Entfernung
booltrue oder falseIst etwas an oder aus?
byte0 bis 255PWM-Werte, kleine Zahlen
char / StringEin Zeichen / TextBefehle ü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.
Zwei Fallen übersieht man beim Lesen leicht. if (x = 5) ist kein Vergleich, sondern weist x den Wert 5 zu, und die Bedingung ist immer wahr; richtig ist if (x == 5). Außerdem macht das Semikolon am Ende von if (distance < 20); die Bedingung wirkungslos, und der Block darunter läuft in jeder Runde. Der Compiler meldet in beiden Fällen keinen Fehler, lies solche Zeilen also besonders genau.

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:

FunktionWas sie machtBeispiel
pinMode(pin, modus)Macht einen Pin zum Ein- oder AusgangpinMode(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 istdigitalRead(2)
analogRead(pin)Wandelt 0–5 V in eine Zahl von 0 bis 1023analogRead(A0)
analogWrite(pin, 0–255)Stellt per PWM LED-Helligkeit oder Motordrehzahl einanalogWrite(9, 128);
delay(ms)Hält das Board für die angegebene Zeit andelay(1000);
millis()Millisekunden seit dem Einschaltenif (millis() - last > 500)
Serial.begin / print / printlnSchickt Text an den seriellen MonitorSerial.println(distance);
map(x, a, b, c, d)Rechnet einen Wertebereich in einen anderen ummap(value, 0, 1023, 0, 180)
pulseIn(pin, HIGH)Misst die Länge eines Impulses in µspulseIn(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

  1. Zieh eine Verdrahtungstabelle aus dem Code. Schreib alle Pin-Konstanten untereinander; das ist die Schaltung der Person, die den Code geschrieben hat.
  2. 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.
  3. 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.
  4. 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.
  5. Gleiche die serielle Geschwindigkeit an. Steht im Code Serial.begin(115200), stell auch im seriellen Monitor 115200 ein, sonst siehst du nur Zeichensalat.
  6. 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.
Der serielle Monitor ist eine Taschenlampe, mit der du in deinen Code leuchtest. Verstehst du nicht, warum eine Bedingung nicht greift, setz direkt vor das if eine Zeile wie Serial.println(distance) und sieh nach, mit welchem Wert wirklich verglichen wird. Mehr dazu im Artikel zum seriellen Monitor in Arduino.

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:

ThemaArduino UnoESP32Was ist zu tun?
Pin-NamenD2–D13, A0–A5GPIO-NummernKonstanten durch GPIO-Nummern ersetzen, Vorsicht bei 6–11 und 34–39
Betriebsspannung5 V3,3 VSpannungsteiler an Sensoren mit 5-V-Ausgang (ECHO des HC-SR04)
analogRead10 Bit, 0–102312 Bit, 0–4095Schwellwerte und map()-Bereiche für den vierfachen Bereich neu berechnen
Servo-BibliothekServo.hESP32Servo.hBibliothek tauschen und bei attach den Impulsbereich angeben
Serielle Geschwindigkeitmeist 9600meist 115200Serial.begin und seriellen Monitor angleichen
Speicher2 KB RAMetwa 320 KB RAMGroße Arrays und Strings sind kein Problem mehr
C++ (Arduino IDE)
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:

MicroPython
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

FehlerWarum das ein Problem istSo geht es richtig
Den Code für eine Liste halten, die einmal von oben nach unten läuftloop() wiederholt sich endlos, Variablen ändern sich zwischen den Rundenloop() über mehrere Runden mit verschiedenen Werten verfolgen
= und == verwechselnif (x = 5) ist immer wahrZum Vergleichen immer == verwenden
Ganzzahldivision übersehen5 / 2 ergibt 2, die Nachkommastellen fallen wegBrauchst du Kommazahlen, schreib 5.0 / 2 oder nimm float
Vergessen, dass delay() alles anhältWährend der Wartezeit werden Taster und Sensoren nicht gelesenBei mehreren Aufgaben die Zeit mit millis() steuern
Versionsunterschiede bei Bibliotheken ignorierenDieselbe Funktion kann in einer neuen Version anders heißenIn den Kommentaren nachsehen, mit welcher Bibliothek der Code geschrieben wurde
Pin-Konstante ändern, aber das Kabel vergessenDer Code liest den richtigen Pin, das Kabel steckt woandersNach jeder Änderung die Verdrahtungstabelle aktualisieren
Wirkt ein Sketch schwierig, schreib ihn zuerst in Alltagssprache um: „Miss die Entfernung. Ist sie größer als 0 und kleiner als 20, zähl den Zähler hoch, schalte die LED ein, öffne den Deckel, warte 3 Sekunden, schließ den Deckel, schalte die LED aus. Warte 100 ms und fang von vorn an.“ Das nennt man Pseudocode, und so erfasst du am schnellsten, was sich die Person beim Schreiben gedacht hat.

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.

Alle Projekte ansehen
LED Blinken
AR-1Anfänger

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.

4.6(200)
1246
Ampel
AR-3Anfänger

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…

4.8(137)
440
LED mit Taster schalten (Push)
AR-9Anfänger

LED mit Taster schalten (Push)

Wie bei einer Türklingel: Das Licht leuchtet, solange du drückst, und geht aus, wenn du loslässt.

4.8(114)
253
Nachtlicht mit LDR
AR-12Anfänger

Nachtlicht mit LDR

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

4.7(105)
224
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

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…

4.6(50)
82
Temperatur und Luftfeuchtigkeit mit DHT11
AR-55Mittel

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…

4.7(47)
83
Parksensor mit HC-SR04
AR-28Mittel
Premium

Parksensor mit HC-SR04

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

4.8(64)
86
Servomotorbetrieb mit Potentiometer
AR-36Anfänger
Premium

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.

4.6(37)
53