Arduino Befehle Übersicht: 36 Karten mit C++ und MicroPython

Am zuverlässigsten lernst du Arduino Befehle, wenn du sie nicht aus einer langen Liste auswendig lernst, sondern der Reihe nach durchgehst, jeden mit einem kleinen Beispiel und einem echten Projekt. Genau dafür gibt es in der BlueGrays App im Bereich Lektionen des Tabs Lernen den Code-Guide: 18 Karten im Lernpfad Arduino C++, von pinMode bis tone, und 18 Karten im Lernpfad MicroPython, von import bis I2C, zusammen 36 Karten. Jede Karte ist gleich aufgebaut: Wofür ist das gut?, Warum?, Syntax, Beispiel (mit den Reitern Blöcke, Arduino und MicroPython), Häufiger Fehler, Tipp, In Projekten ansehen und ein Minitest mit zwei Fragen. Auch die Reihenfolge steht fest: zuerst die Pins (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), dann die Zeit (delay, millis), danach Variablen, Bedingungen, Schleifen und Funktionen, zum Schluss Serial, map, random und tone. Wenn du einen Raspberry Pi Pico nutzt, lernst du dieselben Ideen im MicroPython-Lernpfad mit Pin, Pin.value, time.sleep, ADC.read_u16 und PWM.

Dieser Beitrag ist eine Landkarte des Guides. Zuerst siehst du, was in einer Karte steckt, dann die 18 Karten beider Lernpfade in ihrer echten Reihenfolge in der App, jeweils mit der Entsprechung in der anderen Sprache. Danach folgen drei kurze Beispiele, die die C++- und die MicroPython-Fassung desselben Programms nebeneinanderstellen, wie Minitest und Fortschritt funktionieren, eine Lernreihenfolge für 4 Wochen, eine tägliche Routine von 20 Minuten und die 8 häufigsten Fehler mit diesen Befehlen. Suchst du eine ausführliche Erklärung zu jedem einzelnen Befehl, gibt dir der Beitrag Arduino-Befehle mit Syntax und Beispielen für jeden Befehl einen eigenen Abschnitt; hier geht es darum, in welcher Reihenfolge du sie lernst und wie du übst.

Wo ist der Code-Guide und wie funktioniert er?

Du öffnest den Guide über den Tab Lernen unten: Tippe oben im Bereich Lektionen auf die Kachel Code-Guide. Im Guide siehst du oben zwei Reiter: Arduino C++ und MicroPython; die App merkt sich, welchen Lernpfad du zuletzt geöffnet hast. Darunter stehen der Zähler Was du gelernt hast und die Zeile Nächste Karte, damit du nie suchen musst, wo du aufgehört hast. Die Karten sind nach Themen gruppiert: Pins, Zeit, Variablen, Bedingungen, Schleifen, Funktionen, Serielle Schnittstelle, Mathematik und Ton; im MicroPython-Lernpfad kommen Grundstruktur und Fehlerbehandlung dazu. Der Code-Guide ist kostenlos: Für die Karten, die Beispiele und die Minitests brauchst du kein Premium. Die Karten gibt es in 10 Sprachen, du liest die Erklärungen also in der Sprache, in der du die App nutzt.

Was steckt in einer Karte?

Jede Karte hat dasselbe Gerüst, nach der dritten Karte weißt du also genau, wo du hinschauen musst. Die Tabelle zeigt die Abschnitte am Beispiel der 7. Karte des Arduino-Lernpfads, millis; die rechte Spalte fasst kurz zusammen, was auf der Karte steht. Die Reihenfolge der Abschnitte ist selbst schon eine Lernreihenfolge: Zuerst hörst du in einem Satz, was der Befehl tut, dann verstehst du über einen Vergleich aus dem Alltag, wozu du ihn brauchst, siehst, wie er geschrieben wird, liest ein funktionierendes Beispiel, lernst die häufigste Falle kennen und prüfst dich mit zwei Fragen.

Der Abschnitt Beispiel öffnet im Lernpfad der Karte: Auf einer Arduino-Karte steht der Reiter Arduino vorn, auf einer MicroPython-Karte der Reiter MicroPython. Der andere Reiter ist aber immer auch da, und dadurch wird der Guide zum Wörterbuch. Auf der Karte Pin-Ausgang: Pin(15, Pin.OUT) im MicroPython-Lernpfad steht im Reiter Arduino zum Beispiel Code, der dieselbe Aufgabe mit pinMode und digitalWrite erledigt, und die Kommentare sagen, welche Zeile wofür steht (etwa die Zeile, die led.toggle() entspricht). Fast jede Karte hat außerdem einen dritten Reiter, Blöcke, der das Beispielprogramm als Blöcke zeigt. Wenn du von Arduino zum Pico wechselst, ist das der schnellste Weg: Öffne eine Karte, die du kennst, wechsle den Reiter und ordne beide Programme Zeile für Zeile einander zu.

Lernpfad Arduino C++: 18 Karten und ihre MicroPython-Entsprechungen

Die Tabelle zeigt die echte Reihenfolge des Arduino-Lernpfads in der App; die letzte Spalte zeigt, wie dieselbe Aufgabe mit MicroPython auf einem Raspberry Pi Pico gelöst wird. Die Pinnummern entsprechen den Beispielen auf den Karten: für eine LED 13 oder 9 am Uno und GP15 am Pico, für einen Taster 2 am Uno und GP14 am Pico, für analoges Lesen A0 am Uno und GP26 am Pico. Die ersten fünf Karten behandeln Pins, 6 und 7 die Zeit, 8 bis 14 die Grundlagen der Programmierung, die letzten vier die serielle Schnittstelle, das Umrechnen von Bereichen, Zufallszahlen und Ton. Die Reihenfolge ist Absicht: Zuerst lernst du, wie das Board die Außenwelt berührt, dann steuerst du diese Berührungen mit Variablen, Bedingungen und Schleifen.

Lernpfad MicroPython: 18 Karten und ihre Arduino-Entsprechungen

Der MicroPython-Lernpfad ist auf den Raspberry Pi Pico zugeschnitten; die Beispiele auf den Karten sind kurze Programme, die du auf einem Pico ausführen kannst, zum Beispiel mit Thonny. Die Reihenfolge weicht etwas vom Arduino-Lernpfad ab, denn in Python musst du dich zuerst an die Regeln der Sprache gewöhnen: Module mit import einbinden, mit print ausgeben, Einrückung und Doppelpunkt. Im Reiter Arduino jeder MicroPython-Karte steht auch die C++-Fassung desselben Programms; wenn du Arduino schon kannst, liest du die Tabelle also von rechts nach links. Nutzt du einen Pico zum ersten Mal, ist der Beitrag Was ist ein Raspberry Pi Pico eine gute Vorbereitung für Einrichtung und Pins.

Dasselbe Programm in zwei Sprachen: 3 Beispiele nebeneinander

Das erste Beispiel ist das „Hallo Welt“ jeder Sprache: die LED auf dem Board jede halbe Sekunde blinken lassen. Am Uno hängt die eingebaute LED an Pin 13, du musst also keine Schaltung bauen. Beim Pico ist es etwas anders: Beim normalen Pico hängt die Onboard-LED an GP25, beim Pico W ist sie aber mit dem Funkchip verbunden, und Pin(25) bringt sie nicht zum Leuchten. Deshalb ist Pin("LED", Pin.OUT) in MicroPython die sicherere Wahl; in aktuellen MicroPython-Versionen findet dieser Name die Onboard-LED auf Pico und Pico W. Erkennt die Firmware auf deinem Board den Namen "LED" nicht, spiel ein aktuelles MicroPython auf den Pico. Das kostenlose Projekt Raspberry Pi Pico Onboard-LED Blinken (Pico und Pico W) erklärt genau diesen Unterschied.

1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3  pinMode(13, OUTPUT);     // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7  digitalWrite(13, HIGH);  // LED yanar / LED on
8  delay(500);              // 500 ms bekle / wait 500 ms
9  digitalWrite(13, LOW);   // LED söner / LED off
10  delay(500);              // 500 ms bekle / wait 500 ms
11}

1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)  # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True:                # Arduino'daki loop() gibi / like loop() in Arduino
9    led.on()               # LED yanar / LED on
10    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms
11    led.off()              # LED söner / LED off
12    time.sleep_ms(500)     # 500 ms bekle / wait 500 ms

Das zweite Beispiel fügt einen Eingang hinzu: Solange der Taster gedrückt ist, leuchtet die LED. Der Taster kommt am Uno zwischen Pin 2 und GND, am Pico zwischen GP14 und GND. Am Uno nutzen wir wieder die eingebaute LED an Pin 13; am Pico schließt du eine externe LED über einen 220-Ω-Widerstand an GP15 an (das Werkzeug LED-Vorwiderstand berechnet den Wert für deine eigene LED). In beiden Sprachen wird der interne Pull-up-Widerstand eingeschaltet: INPUT_PULLUP bei Arduino, Pin.PULL_UP bei MicroPython. Bei dieser Verdrahtung ist die Logik umgekehrt: Ein Druck auf den Taster zieht den Pin auf GND, der Arduino liest LOW, der Pico 0. Die Pause von 20 ms am Ende löst das mechanische Prellen des Tasters nicht ganz, verringert aber sehr kurzes Flackern. Details zur Verdrahtung stehen im Beitrag Taster am Arduino anschließen.

1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2;  // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13;    // dahili LED / built-in LED
4
5void setup() {
6  pinMode(BUTTON_PIN, INPUT_PULLUP);  // iç pull-up direnci açık / internal pull-up on
7  pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11  if (digitalRead(BUTTON_PIN) == LOW) {  // basılıyken LOW okunur / reads LOW while pressed
12    digitalWrite(LED_PIN, HIGH);
13  } else {
14    digitalWrite(LED_PIN, LOW);
15  }
16  delay(20);  // kısa bekleme / short pause
17}

1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP)  # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT)                 # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9    if button.value() == 0:            # basılıyken 0 okunur / reads 0 while pressed
10        led.value(1)
11    else:
12        led.value(0)
13    time.sleep_ms(20)                  # kısa bekleme / short pause

Das dritte Beispiel zeigt den wichtigsten Unterschied zwischen den beiden Sprachen: die Zahlenbereiche. Der mittlere Anschluss des Potentiometers geht am Uno an A0, am Pico an GP26; die äußeren Anschlüsse kommen am Uno an 5V und GND, am Pico an 3V3 (OUT) und GND. Die LED sitzt am Uno an Pin 9 (mit ~ markiert), am Pico an GP15, jeweils mit 220-Ω-Widerstand. Bei Arduino liefert analogRead 0–1023, analogWrite erwartet aber 0–255, deshalb steht map(raw, 0, 1023, 0, 255) dazwischen. Am Pico nutzen read_u16 und duty_u16 beide 0–65535, du kannst den Messwert also direkt an die PWM geben. Wie PWM funktioniert, steht im Beitrag Was ist PWM, wie du Werte live beobachtest, in der Anleitung zum seriellen Monitor.

1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0;  // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6  pinMode(LED_PIN, OUTPUT);
7  Serial.begin(9600);
8}
9
10void loop() {
11  int raw = analogRead(POT_PIN);               // 0-1023
12  int brightness = map(raw, 0, 1023, 0, 255);  // 0-255 aralığına ölçekle / scale to 0-255
13  analogWrite(LED_PIN, brightness);
14  Serial.println(raw);                         // Seri Monitör'de izle / watch in the Serial Monitor
15  delay(50);
16}

1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26)            # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15))       # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000)           # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10    raw = pot.read_u16()     # 0-65535
11    led.duty_u16(raw)        # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12    print(raw)               # Thonny kabuğunda izle / watch in the Thonny shell
13    time.sleep_ms(50)

Minitest, „Verstanden“ und dein Fortschritt unter Mein Level

• Minitest: Jede Karte endet mit zwei Fragen, in der Überschrift steht Minitest · 1 / 2. Tippst du auf eine Antwort, kommt sofort Richtig. oder Nicht ganz. mit einer kurzen Erklärung; mit Nächste Frage geht es weiter.
• Ergebnis: Nach beiden Fragen siehst du ein Ergebnis wie 2 / 2 richtig. Ohne Test lässt sich die Karte nicht abschließen; statt des Knopfs steht dort Löse den Minitest, um die Karte abzuschließen.
• Verstanden: Ist der Test erledigt, erscheint der Knopf Verstanden, nächste Karte (auf der letzten Karte eines Lernpfads nur Verstanden). Ein Tipp darauf speichert die Karte in deinem Konto als gelernt, eine kurze Feier zeigt deinen Stand, etwa Super! 5 / 18 Karten, und die nächste Karte öffnet sich.
• Abzeichen und Zähler: Gelernte Karten tragen in der Liste die Markierung Gelernt, und der Zähler Was du gelernt hast oben im Guide steigt. Hast du alle Karten eines Lernpfads geschafft, erscheint Du hast alle Karten in diesem Lernpfad gelernt.
• Mein Level: Auf dem Bildschirm Mein Level im Bereich Lernen stehen unter der Überschrift Code-Guide und dem Hinweis Gelernte Karten zwei getrennte Balken: Arduino C++ x/18 und MicroPython x/18. Diese Balken zählen nur die Karten im Code-Guide.
• Eine ehrliche Regel für dich: Die App hält dich nach einer falschen Antwort nicht auf; der Knopf Verstanden erscheint, sobald der Test erledigt ist. Prüfe deshalb vor dem Tippen, ob du laut erklären kannst, warum beide Antworten richtig sind; wenn nicht, geh zurück zum Abschnitt Beispiel und lies den Code noch einmal Zeile für Zeile.

In Projekten ansehen: den Befehl in echtem Code finden

Der letzte Schritt beim Lernen eines Befehls ist, ihn in einem funktionierenden Projekt wiederzuerkennen, das jemand anderes geschrieben hat. Im Abschnitt In Projekten ansehen zeigt die Karte einige ausgewählte Projekte und darunter einen Satz, in wie vielen Projekten der Befehl im Code vorkommt; der Link Alle öffnet die ganze Liste. Sie ist von leicht bis schwer sortiert und lässt sich mit den Filtern Alle, Kostenlos und Premium eingrenzen. millis kommt zum Beispiel im Code von über 50 Projekten vor: Die Liste beginnt mit dem kostenlosen Projekt ESP32 LED Steuerung mit Taster (Toggle), geht mit Pico-Einsteigerprojekten wie Raspberry Pi Pico Tasten-Klavier (5 Taster + Summer + Melodie-Rekorder) und Raspberry Pi Pico Einparkhilfe (HC-SR04 + 3 LEDs + Summer) weiter und steigt zu mittelschweren Projekten wie Raspberry Pi Pico-Ampel mit 4-Modus-Tastenwahlschalter (Zustandsmaschine, GP11-13 + GP4) auf, die Taster und Zeitsteuerung verbinden. Unser Vorschlag: Öffne ein kostenloses Projekt aus der Liste, such den Befehl im Code, ändere einen Wert und sag das Ergebnis vorher voraus. Um zu sehen, was jede Codezeile tut, ist der Reiter Code verstehen im Projekt der natürliche nächste Schritt.

Empfohlene Lernreihenfolge: ein Plan für 4 Wochen

Nehmen wir an, du hast an 5 Tagen pro Woche etwa 20 Minuten Zeit. Um einen Lernpfad in 4 Wochen abzuschließen, reicht an den meisten Tagen eine Karte; an den übrigen Tagen wiederholst du und arbeitest an einem Projekt statt an einer neuen Karte. Hast du einen Arduino, folgst du nur der Arduino-Spalte, hast du einen Pico, der MicroPython-Spalte. Hast du beides, schließ zuerst den Arduino-Lernpfad ab und wechsle im zweiten Monat zu MicroPython; die Konzepte sind dieselben, deshalb geht der zweite Lernpfad viel schneller. Alle Projekte in der Tabelle sind bei BlueGrays kostenlos. Für einen breiteren Plan passt der 30-Tage-Fahrplan aus dem Beitrag Arduino lernen mit einer App gut zu dieser Tabelle; unterrichtest du mit dem Pico, verteilt der Unterrichtsplan für den Raspberry Pi Pico die MicroPython-Karten auf 6 Wochen Unterricht.

Eine tägliche Routine von 20 Minuten

1. 3 Minuten, Aufwärmen: Löse die Fragen des Tages im Bereich Lernen oder mach den Minitest von gestern noch einmal. Ziel ist zu prüfen, ob du den Befehl von gestern heute noch weißt.
2. 5 Minuten, neue Karte: Lies die Abschnitte Wofür ist das gut?, Warum? und Syntax. Schreib die Syntax von Hand auf Papier; beim Abschreiben übersiehst du Klammern und Semikolons viel seltener.
3. 3 Minuten, Beispiel: Erklär dir das Beispiel Zeile für Zeile und wechsle dann den Reiter. Auf einer Arduino-Karte schaust du in den Reiter MicroPython, auf einer MicroPython-Karte in den Reiter Arduino, und ordnest die Zeilen einander zu, die in beiden Programmen dasselbe tun.
4. 2 Minuten, Minitest: Beantworte beide Fragen und lies die Erklärung zu jeder falschen Antwort. Wirf an dieser Stelle noch einmal einen Blick auf die Kästen Häufiger Fehler und Tipp.
5. 6 Minuten, Projekt: Öffne aus der Liste In Projekten ansehen ein kostenloses, leichtes Projekt, such den Befehl im Code und ändere einen einzigen Wert: eine Wartezeit, eine Pinnummer oder einen Schwellenwert. Steht deine Schaltung, lad den Code aufs Board; sonst sag das Ergebnis voraus und prüf es mit Code verstehen.
6. 1 Minute, Notiz: Schreib eine Zeile in dein Heft: den Namen des Befehls, seine Bedeutung in einem Satz und die Entsprechung in der anderen Sprache. Nach vier Wochen ist diese Seite dein eigenes Befehlswörterbuch.

8 häufige Fehler mit diesen Befehlen

Der Reiter Blöcke: einen Befehl durch Sehen verstehen

Der Reiter Blöcke zeigt dir, vor allem auf den ersten Karten eines Lernpfads, was ein Befehl tut, ohne dass du Code schreibst. Im Bild oben wird pinMode zum Block „Pin 9 als AUSGANG setzen“, digitalWrite zu „HOCH an Pin 9 schreiben“ und delay zu „100 ms warten“; auf der Karte pinMode nennt ein Hinweis unter der Blockansicht auch die Optionen im Aufklappmenü: AUSGANG, EINGANG und EINGANG (PULLUP). Die Blöcke erscheinen in der Sprache der App und sind zum Lesen da: In der App ziehst du keine Blöcke zu einem Programm zusammen, und aufs Board kommt immer der echte Code. So nutzt du sie am besten: Sag zuerst im Reiter Blöcke voraus, was das Programm tun wird, wechsle dann in den Reiter Arduino und such, welche Zeile zu welchem Block gehört. In Projekten mit Blockansicht macht der Schalter Als Blöcke zeigen auf der Projektseite dieselbe Zuordnung für ein ganzes Projekt möglich; die Grundlagen stehen im Beitrag Was ist Blockprogrammierung.

Kurz gesagt: Um Arduino Befehle zu lernen, brauchst du keine lange Liste. Es reichen die richtige Reihenfolge, ein kleines funktionierendes Beispiel pro Befehl, eine Kontrolle mit zwei Fragen und ein echtes Projekt, in dem der Befehl vorkommt. Fängst du heute mit der Karte pinMode an, hast du in vier Wochen alle 18 Karten geschafft und jeden Befehl in mindestens einem Projekt mit eigenen Augen gesehen; wenn du zum Pico wechselst, gehst du dieselben Konzepte im MicroPython-Lernpfad viel schneller durch. Wenn du die Karten und die Projekte darin ausprobieren möchtest, installiere BlueGrays auf deinem Handy und öffne im Bereich Lernen die erste Karte.