Arduino Code Schritt für Schritt erklärt: verstehen und ändern

Code verstehen ist der Reiter im Bereich Quellcode jeder BlueGrays-Projektseite, der den fertigen Arduino-Code Schritt für Schritt erklärt. Um herauszufinden, was der kopierte und hochgeladene Code eigentlich tut, gehst du so vor: Lies zuerst die Zusammenfassung Was macht dieser Code?, suche dann jeden Codeausschnitt aus dem Abschnitt Schritt für Schritt zusammen mit seiner Erklärung im vollständigen Code, schau bei Wenn du nicht weiterkommst nach, falls die Schaltung nicht wie erwartet arbeitet, und ändere zum Schluss mit der Aufgabe Probier es selbst eine einzige Sache im Code und beobachte das Ergebnis auf dem Board. Diese vier Abschnitte sind der kürzeste Weg von „es funktioniert, aber ich weiß nicht warum“ zu „ich weiß, was passiert, wenn ich diese Zeile ändere“.

In diesem Beitrag gehen wir Code verstehen von Anfang bis Ende anhand des echten Inhalts eines echten Projekts durch: Projekt Nummer 10, LED mit Taster ein- und ausschalten. Es ist kostenlos, als Anfänger eingestuft und hat auch eine Blockansicht, sodass jede und jeder die Erklärung für Code und Blöcke öffnen kann. Du findest hier die Abschnitte des Reiters, eine Methode, Code und Erklärung abzugleichen, eine 15-minütige Lernroutine, eine Strategie für Probier-es-selbst-Aufgaben, welche Änderung welches Konzept vermittelt, die Ansicht Blöcke verstehen, den Unterschied zwischen Wenn du nicht weiterkommst und Fehlerbehebung sowie Ideen für Lehrkräfte im Unterricht.

Wo ist Code verstehen und wer kann es nutzen?

Wenn du ein Projekt öffnest und zum Bereich Quellcode scrollst, siehst du oben eine Auswahl mit zwei Reitern: Code und Code verstehen. Der Reiter Code zeigt das ganze Programm, dort sind auch die Schaltflächen Kopieren und Link kopieren. Wechselst du zu Code verstehen, öffnet sich die kommentierte Fassung desselben Programms. Jedes der 200+ Projekte hat diesen Reiter, und er funktioniert bei Arduino-, ESP32- und Raspberry-Pi-Pico-Projekten gleich. Die Zugangsregel ist einfach: In den 60 kostenlosen Projekten (20 pro Plattform) ist Code verstehen für alle offen; auch mit einem kostenlosen Konto siehst du die Zusammenfassung, alle Schritte, Wenn du nicht weiterkommst und die Aufgabe Probier es selbst samt Lösung. In Premium-Projekten steht an der Stelle des Reiters eine Sperrkarte: „Mit Premium bekommst du den Code Schritt für Schritt erklärt.“ Die Methode aus diesem Beitrag kannst du also bei LED Blinken, Ampel, LED-Polizeilicht und den Tasterprojekten ohne Bezahlung anwenden.

Die Abschnitte: wofür ist welcher da?

Die Reihenfolge der Abschnitte ist bewusst gewählt: erst das große Ganze, dann die Teile, dann die Fehler und zum Schluss dein eigenes Experiment. Codeausschnitte sind nicht das ganze Programm, sondern nur die Zeilen, die der Schritt erklärt; die schließende geschweifte Klammer eines Blocks kann erst im nächsten Schritt auftauchen. Deshalb bringt es mehr, alle Schritte der Reihe nach zu lesen, statt nur einen anzuschauen. Der Tipp steht offen direkt unter dem Aufgabentext, die Lösung bleibt verborgen, bis du auf Lösung anzeigen tippst. So hast du Raum zum Nachdenken, bevor du die Antwort siehst.

Beispiel: Code verstehen im Projekt LED mit Taster ein- und ausschalten

Das Projekt besteht aus einem Taster und einer LED. Eine Seite des Tasters geht an 5V, die gegenüberliegende an Pin 13 des Boards; derselbe Pin wird über einen 10-kΩ-Widerstand auf GND gezogen. Das lange Bein der LED geht an Pin 7, das kurze über einen 330-Ω-Widerstand an GND. Die Zusammenfassung in Code verstehen beschreibt das Programm so: Bei jedem Tastendruck wechselt die LED einmal ihren Zustand, aus wird an und an wird aus; auch wenn du den Taster gedrückt hältst, wechselt die LED nur einmal, und eine Wartezeit von 50 ms ignoriert das Prellen des Tasters. Hier das vollständige Programm, mit zweisprachigen Kommentaren.

1int ledState = 0;     // LED durumu: 0 sönük, 1 yanık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Butonun önceki okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi, harici pull-down / Button input, external pull-down
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu tersine çevir / Flip the state
14      digitalWrite(7, ledState);  // Yeni durumu LED'e yaz / Write the new state to the LED
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}

Beim Lesen der Schritte lohnt es sich darauf zu achten, dass die Erklärung nicht nur sagt, was passiert, sondern auch, was ohne diese Zeile passieren würde. Schritt 1 erinnert daran, dass ledState mit 0 beginnt und die LED deshalb beim Einschalten aus ist. Daraus ergibt sich eine gute Frage: Wenn du den Wert auf 1 setzt, startet die LED dann eingeschaltet? Nein, denn diese Zeile ändert nur die Variable; setup() schreibt nichts an die LED, also startet sie aus, und beim ersten Druck springt ledState auf 0 zurück, sodass sie aus bleibt. Der Wert einer Variable und der tatsächliche Zustand eines Pins sind zwei verschiedene Dinge. Schritt 2 begründet INPUT am Taster mit dem 10-kΩ-Widerstand in der Schaltung: Ist der Taster nicht gedrückt, zieht der Widerstand den Pin auf GND und es wird 0 gelesen. Ohne Widerstand hängt der Pin in der Luft und liefert Zufallswerte; das Symptom „LED geht von selbst an und aus“ in Wenn du nicht weiterkommst entspricht genau diesem Fall.

Die Schritte 3 und 5 gehören zusammen. Der Vergleich in Schritt 3 funktioniert nur, wenn lastButton nach jeder Änderung aktualisiert wird, und das passiert in der Zeile lastButton = button in Schritt 5. Wenn du beide Schritte abgleichst, wird die Kernidee des Programms sichtbar: Der Code prüft nicht, ob der Taster gedrückt ist, sondern ob sich sein Zustand geändert hat. Hältst du ihn gedrückt, wird bei jedem Durchlauf 1 gelesen, aber lastButton ist ebenfalls 1, der Vergleich ist falsch und die LED ändert sich nicht. Der Operator ! in Schritt 4 ist ein Ein-Aus-Schalter in zwei Zeilen. Schritt 5 endet mit einer Warnung: Ist die Wartezeit zu kurz, kann die LED bei einem Druck manchmal mehrmals wechseln. Daraus ergibt sich dein erstes Experiment vor der Aufgabe: Setz 50 auf 5, drück ein paar Mal und beobachte, ob die LED gelegentlich doppelt wechselt; das Ergebnis hängt von der Qualität des Tasters ab. Mehr zum Entprellen findest du im Beitrag Taster am Arduino anschließen.

Der Abschnitt Wenn du nicht weiterkommst nennt in diesem Projekt fünf Symptome: Die LED leuchtet nie; die LED wechselt von selbst, ohne dass du den Taster berührst; beim Drücken passiert nichts; der Taster verhält sich, als wäre er dauernd gedrückt; der Code lässt sich nicht hochladen. Zu jedem Symptom gibt es eine konkrete Prüfung. Beim Symptom „dauernd gedrückt“ wird zum Beispiel erklärt, dass D13 ständig mit 5V verbunden bleibt, wenn die Tasterbeine falsch herum stecken, und dass du den Taster um 90 Grad drehen musst. Die Aufgabe Probier es selbst lautet: Die LED soll nicht beim Drücken, sondern beim Loslassen des Tasters wechseln. Der Tipp erinnert daran, dass die Variable button beim Drücken 1 und beim Loslassen 0 wird. Die Lösung ist eine Änderung um ein Zeichen: Aus der Zeile if (button == 1) wird if (button == 0). Diese kleine Aufgabe prüft, ob du die Flankenerkennung aus Schritt 3 wirklich verstanden hast.

Lesemethode: Zusammenfassung, Abgleich, Test

1. Zusammenfassung lesen, in einem Satz notieren: Lies Was macht dieser Code? und schreib das Programm dann in einem Satz ins Heft, ohne aufs Handy zu schauen. Für das Tasterprojekt: „Jeder Druck schaltet die LED einmal ein oder aus.“
2. Code von oben nach unten mit den Schritten abgleichen: Öffne den Code in der Arduino IDE (Link kopieren im Quellcode macht das einfach), finde den Ausschnitt jedes Schritts im vollständigen Code und schreib die Schrittnummer als Kommentar neben die Zeile. Die Schritte folgen der Reihenfolge des Codes: globale Variablen, setup(), loop().
3. Nicht zugeordnete Zeilen markieren: Bleibt eine Zeile übrig, die in keinem Schritt vorkommt (meist sind es nur schließende Klammern), überleg, warum sie nicht erklärt wird; ist es keine Klammer, such sie noch einmal in den Erklärungen.
4. An der Schaltung testen: Lade den Code hoch und teste das Verhalten aus der Zusammenfassung Punkt für Punkt. Beim Tasterprojekt reichen drei Tests: einmal drücken, gedrückt halten, schnell hintereinander drücken. Sag vor jedem Test laut, was passieren wird.

Der Abgleich ist der Schritt, der am häufigsten übersprungen wird und am meisten bringt. Wenn du Schrittnummern neben die Zeilen schreibst, wird das Gerüst des Codes sichtbar: welche Zeile einmal und welche ständig läuft, wo eine Variable gelesen und wo sie geschrieben wird. Im Tasterprojekt kommt lastButton an zwei Stellen vor: In Schritt 1 wird sie deklariert, in Schritt 5 aktualisiert. Das mit eigenen Augen zu sehen, bleibt viel besser hängen als der Satz „eine Variable ist eine Kiste“. Wenn du Variablen, Schleifen und Funktionen gesondert üben willst, lies Arduino-Programmierung: die Grundlagen.

Eine 15-Minuten-Routine mit Code verstehen

Diese Routine ist für ein Projekt gedacht, dessen Schaltung schon steht. Baust du die Schaltung zum ersten Mal auf, plane dafür zusätzlich 10–15 Minuten ein oder verschiebe die Routine auf den nächsten Tag. Die letzten zwei Minuten sind der wertvollste Teil: Eine eigene kleine Änderung nach der Lösung prüft die verstandene Idee, nicht die auswendig gelernte Antwort. Im Tasterprojekt könntest du zum Beispiel die LED an einen anderen Pin legen oder die 50 ms auf 300 ms erhöhen und schauen, was mit schnellen Tastendrücken passiert. Ein Projekt pro Tag in diesem Tempo heißt: fünf kostenlose Projekte in einer Woche, die du wirklich verstanden hast. Für einen längeren Plan lies den 30-Tage-Fahrplan für Arduino.

Strategie für Probier-es-selbst-Aufgaben

Die Aufgaben in Probier es selbst sind kurz, aber bewusst gewählt: Jede verlangt eine einzige Änderung, und das Ergebnis kannst du sehen oder hören. Wenn du beim Lösen diese Reihenfolge einhältst, lernst du doppelt so viel:

1. Vorhersagen: Lies die Aufgabe und sag zuerst selbst, welche Zeile du anfasst und was du nach der Änderung sehen wirst. Die Vorhersage aufzuschreiben verhindert später die Täuschung „das hab ich doch gleich gedacht“.
2. Ändern: Ändere nur eine Sache. Änderst du zwei Zeilen gleichzeitig, kannst du nicht unterscheiden, welche Änderung was bewirkt hat.
3. Hochladen: Lade den Code aufs Board und warte auf die Meldung, dass das Hochladen fertig ist. Bei einem Kompilierfehler prüf Semikolons und Klammern in der geänderten Zeile.
4. Beobachten: Vergleich das Ergebnis mit deiner Vorhersage. Bei Zeitaufgaben zählst du die Sekunden, bei Tonaufgaben hörst du alten und neuen Ton direkt nacheinander.
5. Tipp ansehen: Lag deine Vorhersage daneben oder findest du die Zeile nicht, lies den Tipp. Weil der Tipp offen direkt unter der Aufgabe steht, hilft es, ihn beim ersten Lesen mit der Hand abzudecken.
6. Lösung zuletzt öffnen: Tipp erst auf Lösung anzeigen, wenn du selbst einen Versuch gemacht hast. Stimmt die Lösung mit deiner überein, überleg, warum sie richtig ist; weicht sie ab, überleg, warum beide Wege zu unterschiedlichen Ergebnissen führen.

Ein weiterer Vorteil dieser Reihenfolge: Fehler werden lehrreich. Angenommen, du willst in der Aufgabe zum Projekt Ampel das Gelb nach Grün auf 1,5 Sekunden verlängern, änderst aber aus Versehen die erste Zeile delay(300). Statt des erwarteten Ergebnisses wird das Gelb nach Rot länger. Dieser Fehler zeigt dir viel besser als die Lösung, dass der Code zwei getrennte Gelbphasen hat und loop() Zeile für Zeile abläuft. Die Lösung der Aufgabe sagt genau das: Die Zeile delay(300) ganz am Ende von loop() wird zu delay(1500), das Gelb nach Rot bleibt bei 0,3 Sekunden.

Arten von Änderungen: was lehrt welches Konzept?

Schaust du dir die Aufgaben der kostenlosen Projekte an, siehst du, dass jede zu einer von wenigen Arten gehört. Wer die Art erkennt, kann sich in einem neuen Projekt leichter eine eigene Aufgabe stellen. Die Beispiele in der Tabelle stammen aus echten Probier-es-selbst-Aufgaben kostenloser Projekte; die Zeile zum Pinwechsel ist ein Experiment, das du im selben Projekt selbst machen kannst.

Blöcke verstehen: dieselbe Erklärung mit Blöcken

Projekte mit Blockansicht haben im Bereich Quellcode den Schalter Als Blöcke zeigen. Schaltest du ihn ein, erscheint dasselbe Programm statt als Code als Blöcke in der Sprache der App, und der Reiter daneben heißt nicht mehr Code verstehen, sondern Blöcke verstehen. Zusammenfassung, Wenn du nicht weiterkommst und Aufgabe bleiben gleich; anders ist der Abschnitt Schritt für Schritt: Jeder Schritt zeigt statt des Codeausschnitts seine eigenen Blöcke, und ein Tippen auf das Bild öffnet es im Vollbild. Über 100 Projekte haben eine Blockansicht, darunter mehr als 30 der kostenlosen. Die Blöcke dienen nur zum Lesen; in der App werden sie nicht bearbeitet und nicht aufs Board geladen, aufs Board kommt immer der echte Code.

Am besten nutzt du Blöcke verstehen, indem du zwischen beiden Ansichten hin und her wechselst. Im Tasterprojekt bestehen die Blöcke von Schritt 3 aus einem Block „setze button auf Pin 13 lesen“ und zwei verschachtelten „falls“-Blöcken; im Code sind das die Zeile int button = digitalRead(13); und zwei verschachtelte if. Der Block „setze ledState auf nicht ledState“ in Schritt 4 ist genau die Zeile ledState = !ledState;. Lies zuerst den Block und sag, was er tut, dann schalte den Schalter aus und schau dir den Codeausschnitt desselben Schritts an. Dieser Abgleich zwischen Block und Code ist der solideste Weg von der Blockprogrammierung zum textbasierten Code; von vorn beginnst du mit Was ist Blockprogrammierung? und dem Beitrag zum falls-Block.

Wenn du nicht weiterkommst oder Fehlerbehebung: der Unterschied

In der Praxis gehst du so vor: Funktioniert die Schaltung nicht, beschreib das Symptom in einem Satz und such es in Wenn du nicht weiterkommst. Steht dein Symptom dort, ist die Lösung meist ein einzelnes Kabel, ein Widerstand oder eine Zeile. Steht es nicht dort oder hilft die vorgeschlagene Lösung nicht, geh die Schritte der Fehlerbehebung der Reihe nach durch; dabei fällt dir oft eine übersprungene Grundprüfung auf (Stromversorgung des Boards, richtiger Port, gemeinsames GND). Hängst du beim Hochladen, hilft Arduino-Sketch lässt sich nicht hochladen, bei Kompilierfehlern der Beitrag zu Arduino-Kompilierfehlern.

Für Lehrkräfte: Code verstehen im Unterricht nutzen

• Gemeinsames Lesen am Beamer: Spiegel zu Beginn der Stunde deinen Handybildschirm, lest gemeinsam die Zusammenfassung Was macht dieser Code? und lass die Klasse das Programm in einem Satz zusammenfassen. Zeig dann dieselben Schritte mit eingeschaltetem Als Blöcke zeigen; für Schülerinnen und Schüler, die mit Blöcken angefangen haben, ist das eine Brücke.
• Eine Gruppe pro Schritt: Teil die Klasse bei einem Projekt mit 5 Schritten in 5 Gruppen; jede Gruppe liest einen Schritt, findet den Ausschnitt im vollständigen Code und erklärt ihn der Klasse in zwei Minuten. Während eine Gruppe erklärt, fragen die anderen: „Was wäre ohne diese Zeile?“
• Vorhersagezettel: Schreib die Aufgabe Probier es selbst an die Tafel; jede Gruppe notiert ihre Vorhersage auf einem Zettel, bevor sie etwas ändert, und lädt dann hoch. Über den Unterschied zwischen Vorhersage und Ergebnis zu sprechen, bringt mehr als die Aufgabe selbst.
• Abschlussfrage: In den letzten zwei Minuten beantworten alle eine Frage. Beispiele zum Tasterprojekt: Was würde ohne lastButton passieren, wenn man den Taster gedrückt hält? Was ändert sich, wenn du delay(50) löschst? Warum kann die LED von selbst wechseln, wenn du den 10-kΩ-Widerstand entfernst?

Für die Planung des Zugangs gilt: Da Code verstehen in kostenlosen Projekten für alle offen ist, können deine Schülerinnen und Schüler diese Methode mit LED Blinken, Ampel, LED-Polizeilicht und den beiden Tasterprojekten ohne Bezahlung anwenden. In Premium-Projekten wird Code verstehen mit Premium freigeschaltet; willst du mit der Klasse zu Premium-Projekten wechseln, kannst du statt einzelner Abos Codes aus den Paketen für Lehrkräfte verteilen, Details im Beitrag Arduino-App für die Klasse. Willst du eine selbst entworfene Schaltung teilen, kannst du im Forum ein Thema der Kategorie Anleitung eröffnen; es kommt ohne Schritte in Code verstehen und ohne Blockansicht, die Erklärung schreibst du also selbst in den Thementext und fügst den Code über Code hinzufügen ein (Unterricht mit deinem eigenen Projekt). Ein Panel, das dir zeigt, welche Aufgaben die einzelnen Lernenden gelöst haben, gibt es in der App nicht; du prüfst die Aufgabe im Unterricht, an der funktionierenden Schaltung oder per Foto.

Häufige Fehler und einfache Lösungen

• Die Lösung sofort öffnen: Tippst du direkt nach dem Lesen auf Lösung anzeigen, kennst du die Antwort, aber nicht die Idee. Die Regel: erst Vorhersage, dann Versuch, dann Tipp, zuletzt die Lösung.
• Kopieren, ohne die Schritte zu lesen: Den Code mit Kopieren holen und hochladen funktioniert, aber wenn du ohne Schritt für Schritt zum nächsten Projekt springst, fängst du jedes Mal bei null an. Lies nach dem Hochladen wenigstens Zusammenfassung und Schritte.
• Einen Codeausschnitt für das ganze Programm halten: Ausschnitte enthalten nur die Zeilen eines Schritts; allein in die IDE eingefügt, kompilieren sie nicht. Ändere immer im vollständigen Code.
• Mehrere Dinge gleichzeitig ändern: Änderst du zwei Zeilen auf einmal und das Ergebnis überrascht dich, weißt du nicht, welche schuld ist. Eine Änderung pro Hochladen.
• Die Pinnummer nur an einer Stelle ändern: pinMode ändern und digitalWrite oder das Kabel vergessen gehört zu den häufigsten Fehlern. Markier vorher jede Stelle im Code, an der die Nummer vorkommt.
• Wenn du nicht weiterkommst überspringen und sofort im Forum fragen: Die Antwort steht oft schon in der Liste dieses Projekts. Schau zuerst dort, dann in der Fehlerbehebung nach; ist es dann noch ungelöst, frag im Forum mit einem Foto der Schaltung und deinem Code.
• Die Aufgabe lösen und dort aufhören: Machst du nach dem Vergleich mit der Lösung keine eigene kleine Änderung, bleibt das Gelernte an diese eine Aufgabe gebunden. Wähl selbst eine Zahl, einen Pin oder eine Bedingung.

Wenn du Code verstehen bei ein paar Projekten in dieser Reihenfolge genutzt hast, ist fertiger Code keine verschlossene Kiste mehr: Du kannst vorher sagen, welche Zeile was bestimmt und was passiert, wenn du sie änderst. LED mit Taster ein- und ausschalten ist dafür ein guter Einstieg, weil ein kurzer Code globale Variable, Flankenerkennung, Toggle und Entprellen auf einmal zeigt. Wenn du es ausprobieren möchtest, öffne das Projekt in der BlueGrays-App und beginne mit der Aufgabe im Reiter Code verstehen; dieselben Abschnitte findest du in allen 60 kostenlosen Projekten.