Arduino lernen App: In 30 Tagen von null zum eigenen Projekt

Wenn du eine Arduino lernen App suchst, solltest du zuerst eines wissen: Keine Handy-App programmiert ein Arduino-Board allein. Der Code wird am Computer mit der Arduino IDE (beim Raspberry Pi Pico mit Thonny) über ein USB-Kabel auf das Board geladen. Der ganze Rest des Lernens funktioniert aber gut auf dem Handy: das richtige Startprojekt auswählen, den Schaltplan lesen, verstehen, was der Code Zeile für Zeile macht, Widerstände berechnen und das Gelernte jeden Tag wiederholen. Kurz gesagt: Ja, du kannst Arduino mit einer App lernen. Das Handy ist dein Lehrer und dein Heft, der Computer der Ort, an dem du mit dem Board sprichst.

In diesem Beitrag findest du einen 30-Tage-Fahrplan für alle, die mit der BlueGrays-App bei null anfangen: was du kaufen musst, wofür jeder Bereich der App gedacht ist, welche kostenlosen Projekte du in vier Wochen in welcher Reihenfolge baust, welche Befehle du jede Woche lernst, wie du 30 Minuten am Tag aufteilst und wo man am häufigsten hängen bleibt. Der ganze Plan besteht aus kostenlosen Projekten; wann Premium wirklich sinnvoll sein kann, erklären wir ohne Übertreibung in einem eigenen Abschnitt.

Was macht die App, was macht der Computer?

Wenn du die Arbeit von Anfang an aufteilst, stimmen die Erwartungen. Damit ein Programm auf den ATmega328P-Mikrocontroller des Arduino Uno kommt, muss der Code kompiliert und per USB auf das Board übertragen werden; das erledigt die Arduino IDE, und dafür brauchst du einen Computer mit Windows, macOS oder Linux. In BlueGrays holst du dir den Code im Bereich Quellcode eines Projekts mit Kopieren, oder du nutzt Link kopieren, um einen Link zu bekommen, mit dem du den Code am Computer öffnest. So vermeidest du fehlende Semikolons und falsche Groß- und Kleinschreibung, die beim Abtippen passieren. Der Schalter Als Blöcke zeigen zeigt dasselbe Programm als Blöcke, aber diese Blöcke sind nur zum Lesen da: In der App werden keine Blöcke bearbeitet und keine Blöcke auf das Board geladen.

Was brauchst du, bevor du anfängst?

Für den 30-Tage-Plan brauchst du kein großes Set. Die Liste unten deckt alle kostenlosen Projekte des Fahrplans ab, und die meisten Teile sind in fertigen Starter-Kits ohnehin enthalten. Als Board empfehlen wir den Arduino Uno: Er arbeitet mit 5 V, die Arduino IDE erkennt ihn ohne zusätzliches Paket, und die meisten Anleitungen für Einsteiger beziehen sich auf ihn. Ein Nano geht auch, aber seine Pinbelegung ist anders, daher musst du die Verbindungen aus dem Schaltplan auf die Pins deines Boards übertragen. Die letzte Spalte zeigt, an welchem Tag ein Teil im Plan zum ersten Mal gebraucht wird; du musst nicht alles auf einmal kaufen.

Die Bereiche der App: Wofür ist welcher da?

BlueGrays läuft auf iOS und Android in 10 Sprachen. Die unteren Tabs heißen Entdecken, Lernen, Werkzeuge, Werkstatt und Profil; zu Projekten und Bauteilen kommst du über die Bereiche Projekte und Bauteile oben im Tab Entdecken, zu den Fragen des Tages und zum Code-Guide über Lernen › Lektionen und zum Forum über Lernen › Forum. Die Tabelle fasst zusammen, welchen Bereich du in den 30 Tagen wofür nutzt und ob er kostenlos ist.

Wenn du am ersten Tag nicht weißt, wo du anfangen sollst, öffne den Projektfinder: Antworte auf die Board-Frage mit Arduino Uno / Nano und auf die Erfahrungsfrage mit "Das wird mein erstes Projekt". Die Karte ZUERST AUFWÄRMEN · KOSTENLOS im Ergebnis zeigt ein kostenloses Aufwärmprojekt, das du mit denselben Teilen beginnen kannst. Hast du noch kein Board, gibt es auch die Option "Ich habe noch kein Board". Der Projektfinder ist keine Alternative zu diesem Plan, sondern eine Ergänzung: In der 4. Woche hilft er dir wieder, wenn du dein eigenes Projekt auswählst.

Der 30-Tage-Fahrplan für Arduino

Der Plan fügt jede Woche genau eine neue Idee hinzu: Zuerst tut das Board etwas (Ausgang), dann hört es auf die Welt (Eingang), danach misst es Zwischenwerte und wiederholt Dinge (analog, serielle Schnittstelle, Schleifen), und am Ende kombinierst du das Gelernte. Gib jedem Projekt zwei Tage: Am ersten baust du die Schaltung auf und bringst sie zum Laufen, am zweiten arbeitest du Code verstehen durch und löst die Aufgabe Probier es selbst. Tag 7, 14 und 21 sind Wiederholungstage ohne neues Projekt. Alle Projekte in der Tabelle sind in BlueGrays mit Schaltplan, Code und Blöcken kostenlos, und die meisten Namen in der Befehlsspalte haben im Code-Guide auch eine eigene Karte.

Woche 1 (Tag 1–7): LEDs, Timing und das Programmgerüst

Der erste Tag ist der schwerste, weil die meiste Arbeit Einrichtung ist: Installiere die Arduino IDE, verbinde das Board per USB, wähle im Menü Werkzeuge Board und Port und lade den Code des Projekts LED Blinken hoch. Blinkt die LED, ist dein erstes Ziel erreicht. Am zweiten Tag öffnest du im selben Projekt Code verstehen: setup() läuft einmal, loop() immer wieder; pinMode macht einen Pin zum Ausgang, digitalWrite schreibt HIGH oder LOW darauf, und delay wartet in Millisekunden. Löse die Aufgabe Probier es selbst, senke dann den delay-Wert von 1000 auf 200 und beobachte den Unterschied. An Tag 3–4 folgt Zwei LEDs abwechselnd blinken: dieselben Befehle auf zwei Pins; sieh dir an, wie sich das Verhalten ändert, wenn du die Reihenfolge der Zeilen tauschst. An Tag 5–6 kommt die Ampel: drei LEDs nacheinander mit Zeiten wie Rot 2000 ms, Gelb 300 ms und Grün 2000 ms. An Tag 7 öffnest du kein neues Projekt; gib der Ampel eigene Zeiten und löse im Code-Guide die Minitests der Karten pinMode, digitalWrite und delay.

Woche 2 (Tag 8–14): Taster, Entscheidungen und Töne

In dieser Woche fängt das Board an, auf die Welt zu hören. LED mit Taster schalten (Push) lässt die LED leuchten, solange du den Taster gedrückt hältst: digitalRead liest, ob der Pin HIGH oder LOW ist, und if / else entscheidet danach. Siehst du im Schaltplan einen Widerstand neben dem Taster, hat das einen Grund: Ist der Taster nicht gedrückt, hängt der Pin in der Luft und liest zufällige Werte, und der Widerstand zieht ihn auf einen festen Pegel. Im Beitrag Taster am Arduino anschließen erklären wir das mit dem Unterschied zwischen Pull-up und Pull-down. LED mit Taster ein- und ausschalten geht einen Schritt weiter: Ein Druck schaltet ein, der nächste aus. Dafür muss sich das Programm den Zustand der LED in einer Variablen merken (ledState = !ledState) und das Prellen des Tasters mit einer kurzen Wartezeit wie 50 ms herausfiltern. An Tag 12–13 folgt Verwendung des Summers: tone() spielt einen Ton mit einer bestimmten Frequenz, noTone() schaltet ihn ab. Tag 14 ist Wiederholungstag: Probier eine kleine Änderung, bei der ein Tastendruck einen Piepton erzeugt.

Woche 3 (Tag 15–21): analoger Sensor, serielle Schnittstelle und Schleifen

Bisher war alles entweder HIGH oder LOW. Mit Lichtstärke messen mit LDR siehst du zum ersten Mal Zwischenwerte: analogRead(A0) liefert eine Zahl zwischen 0 und 1023, und dank der seriellen Schnittstelle, die du mit Serial.begin(9600) öffnest, verfolgst du diese Zahl im seriellen Monitor am Computer. Halte die Hand über den LDR und sieh zu, wie die Zahl sinkt. Nachtlicht mit LDR vergleicht denselben Wert mit einer Schwelle: Wird es im Raum dunkel, geht die LED an. Die Schwelle an das Licht in deinem eigenen Zimmer anzupassen, ist die lehrreichste Aufgabe dieser Woche. An Tag 18–19 folgt LED-Polizeilicht: die Wartezeit in einer int-Variablen speichern und dasselbe Blinken mit einer for-Schleife mehrmals wiederholen. An Tag 20–21 folgt LED-Lauflicht: die Pinnummern von sechs LEDs in einem Array speichern und sie mit einer for-Schleife nacheinander einschalten. Siehst du im seriellen Monitor wirre Zeichen, prüfe die Baudrate; der Beitrag zum seriellen Monitor hilft dir in dieser Woche.

Woche 4 (Tag 22–30): zwei Projekte zu deinem eigenen kombinieren

Die letzte Woche beginnt mit einem neuen Sensor: HC-SR04 Abstandsmessung (serielle Anzeige) misst mit pulseIn, wie lange der Schallimpuls des Sensors für den Rückweg braucht, rechnet das in Zentimeter um und schreibt es in den seriellen Monitor. An Tag 22–23 baust und verstehst du dieses Projekt. Wenn du mit Sensormodulen noch etwas üben willst, nimm optional das Projekt Temperatur und Luftfeuchtigkeit mit DHT11 dazu; solche Sensoren werden meist mit einer Bibliothek ausgelesen, schau bei Bedarf in den Beitrag Arduino-Bibliothek hinzufügen. Tag 24–29 sind die eigentliche Arbeit: zwei Projekte, die du schon gebaut hast, zu einem kleinen eigenen Projekt kombinieren. Die naheliegendste Kombination ist der HC-SR04 mit dem Summer: ein Mini-Parksensor, dessen Pieptöne schneller werden, je näher ein Hindernis kommt. An Tag 30 teilst du dein Projekt im Forum. So gehst du vor:

1. Wähle zwei kostenlose Projekte und bring zuerst jedes einzeln zum Laufen (hier HC-SR04 Abstandsmessung (serielle Anzeige) und Verwendung des Summers).
2. Notiere aus den Schritten von Code verstehen beider Projekte, welche Zeile was macht: Eins misst den Abstand, das andere erzeugt den Ton.
3. Prüfe auf Pin-Konflikte: Nutzen beide Projekte denselben Pin, verlege einen davon auf einen freien Pin und schreib eine kleine Pintabelle wie unten.
4. Baue die kombinierte Schaltung bei abgezogenem USB-Kabel auf; führe dann die pinMode-Zeilen in setup() in einem Sketch zusammen, miss in loop() und mach aus dem Ergebnis mit if / else if / else einen Ton.
5. Gib den Abstand im seriellen Monitor aus und passe die Schwellen von 10 cm und 30 cm an deine eigenen Versuche an.
6. Funktioniert alles, fotografiere die Schaltung und teile sie im Forum unter Anleitung oder Idee; häng deinen Code mit Code hinzufügen an.

1// Gün 24-29 örneği: HC-SR04 + buzzer = mini park sensörü / Day 24-29 example: HC-SR04 + buzzer = mini parking sensor
2const int TRIG_PIN = 9;     // HC-SR04 TRIG / HC-SR04 TRIG
3const int ECHO_PIN = 10;    // HC-SR04 ECHO / HC-SR04 ECHO
4const int BUZZER_PIN = 8;   // buzzer (+) bacağı / buzzer (+) leg
5const int LED_PIN = 7;      // kırmızı LED, 220 ohm ile / red LED, with 220 ohm
6
7// Mesafeyi cm olarak ölçer, yankı yoksa -1 döner / Measures distance in cm, returns -1 if there is no echo
8long readDistanceCm() {
9  digitalWrite(TRIG_PIN, LOW);
10  delayMicroseconds(2);
11  digitalWrite(TRIG_PIN, HIGH);                       // 10 µs tetik darbesi / 10 µs trigger pulse
12  delayMicroseconds(10);
13  digitalWrite(TRIG_PIN, LOW);
14  long duration = pulseIn(ECHO_PIN, HIGH, 30000UL);   // en fazla 30 ms bekle / wait at most 30 ms
15  if (duration == 0) return -1;                       // yankı yok / no echo
16  return duration / 58;                               // µs -> cm / µs -> cm
17}
18
19void setup() {
20  pinMode(TRIG_PIN, OUTPUT);
21  pinMode(ECHO_PIN, INPUT);
22  pinMode(BUZZER_PIN, OUTPUT);
23  pinMode(LED_PIN, OUTPUT);
24  Serial.begin(9600);                                 // Seri Monitör'de 9600 seç / select 9600 in the Serial Monitor
25}
26
27void loop() {
28  long cm = readDistanceCm();
29  Serial.print("cm: ");
30  Serial.println(cm);
31
32  if (cm > 0 && cm < 10) {                            // çok yakın: sürekli ses / very close: continuous tone
33    digitalWrite(LED_PIN, HIGH);
34    tone(BUZZER_PIN, 1000);
35    delay(100);
36  } else if (cm > 0 && cm < 30) {                     // yakın: kesik bip / close: short beeps
37    digitalWrite(LED_PIN, HIGH);
38    tone(BUZZER_PIN, 1000, 80);                       // 80 ms bip / 80 ms beep
39    delay(80 + cm * 10);                              // yaklaştıkça bipler sıklaşır / beeps get faster as you get closer
40    digitalWrite(LED_PIN, LOW);
41  } else {                                            // uzak ya da ölçüm yok: sessiz / far or no reading: silent
42    noTone(BUZZER_PIN);
43    digitalWrite(LED_PIN, LOW);
44    delay(100);
45  }
46}
47

Neu an diesem Code ist, dass die Abstandsmessung in eine eigene Funktion namens readDistanceCm() wandert; so bleibt loop() kurz und lesbar. Unter 10 cm gibt es einen Dauerton, zwischen 10 und 30 cm Pieptöne, die mit dem Abstand schneller werden, und weiter weg bleibt es still. Die Zeile delay(80 + cm * 10) verkürzt die Pause, je näher das Hindernis kommt: 330 ms bei 25 cm, 200 ms bei 12 cm. Fürs Teilen im Forum reichen ein Foto der Schaltung (bis zu 5 Bilder pro Beitrag), der Code und ein Satz dazu, was es macht; schreibst du auch, was du verbessern willst, werden die Kommentare hilfreicher. Hast du eine Frage gestellt und die Antwort gefunden, schließ das Thema mit Als gelöst markieren.

Tägliche Lernroutine in 30 Minuten

Arduino, ESP32 oder Raspberry Pi Pico?

Dieser Plan setzt auf den Arduino Uno, weil er für Einsteiger das Board mit den wenigsten Überraschungen ist. Das spiegelt sich in der App wider: Von den 200+ Projekten sind mehr als 110 für Arduino, etwa 50 für ESP32 und mehr als 30 für den Raspberry Pi Pico. Die kostenlosen Projekte sind dagegen gleichmäßig verteilt: Von den 60 kostenlosen Projekten sind 20 für Arduino, 20 für ESP32 und 20 für den Raspberry Pi Pico. Unser praktischer Rat: Bring die ersten 30 Tage mit einem Arduino Uno zu Ende und steig dann auf den ESP32 um, wenn du WLAN oder Bluetooth willst. Willst du einen ESP32 vom Handy aus steuern, ist dein erstes Gerät mit BlueGrays IoT in der App kostenlos; die Schritte erklärt die Anleitung, einen ESP32 vom Handy aus zu steuern. Die meisten Befehle bleiben gleich, und du startest mit einem bekannten Projekt wie ESP32 Ampel. Wählst du den Python-Weg, helfen dir die 18 MicroPython-Karten im Code-Guide und die MicroPython-Auswahl bei den Fragen des Tages. Pins, Eingänge, Ausgänge, Bedingungen und Schleifen funktionieren auf allen drei Boards gleich; die Unterschiede bei Spannung, Speicher und Funk findest du in Arduino oder ESP32, die MicroPython-Einrichtung des Pico in Was ist der Raspberry Pi Pico.

Was geht kostenlos, und wann lohnt sich Premium?

Der ganze 30-Tage-Plan in diesem Beitrag ist kostenlos: Schaltplan, Teileliste, Code, Blöcke und der Bereich Code verstehen sind bei jedem Projekt des Fahrplans offen. Dazu kommen 7 Elektronik-Werkzeuge (Farbcode, LED-Vorwiderstand, Ohmsches Gesetz und weitere), der Kern der Fragen des Tages, der Code-Guide mit 36 Karten, das Forum und der Projektfinder, und du kannst die Liste und die Vorschau aller anderen Projekte ansehen. Du kannst also einen Monat lang regelmäßig lernen und ein kleines eigenes Projekt bauen, ohne Premium. Der Punkt, an dem Premium sinnvoll wird, kommt meist nach Tag 30, wenn du dich einem bestimmten Thema zuwendest und die kostenlosen Projekte nicht mehr reichen. Premium für Einzelpersonen gibt es als Monats- oder Jahresabo; den aktuellen Preis für dein Land siehst du auf dem Abo-Bildschirm der App. Überlegenswert ist es, wenn einer dieser Punkte auf dich zutrifft:

• Du hast ein konkretes Ziel (Roboterauto, Uhr mit Display, Steuerung per Handy über WLAN) und brauchst die Schritte, den Code und die Schaltpläne dieser Projekte.
• Wenn du feststeckst, willst du die Liste Fehlerbehebung auf der Projektseite und den Bereich Code verstehen in Premium-Projekten nutzen.
• Du willst die 11 Premium-Werkzeuge wie Reihen-/Parallelschaltung, Spannungsteiler oder 555-Timer nutzen und deine Ergebnisse mit Gespeicherte Berechnungen auf allen Geräten behalten.
• Du willst deine Teile unter Werkstatt › Teile speichern und sehen, welche Projekte du mit dem Vorhandenen bauen kannst.
• Trifft nichts davon zu, gibt es keinen Grund zur Eile: Verbring den ersten Monat mit den kostenlosen Projekten und entscheide, wenn du weißt, was du wirklich brauchst.

Typische Stolpersteine und wo dir die App hilft

Das Geheimnis beim Arduino-Lernen ist nicht, viel auf einmal zu machen, sondern jeden Tag einen kleinen Schritt wirklich zu verstehen: LED einschalten, nachlesen, warum sie leuchtet, einen Wert ändern und am nächsten Tag mit drei Minuten Fragen wiederholen. Am Ende dieser 30 Tage hast du die Grundbefehle von pinMode bis zu deiner eigenen Funktion benutzt, Daten aus einem Sensor gelesen und ein eigenes Projekt aus zwei anderen geteilt. Wenn du den Plan auf dem Handy dabeihaben willst, lade BlueGrays herunter und öffne am ersten Tag das Projekt LED Blinken; jedes Projekt dieses Fahrplans wartet dort kostenlos auf dich.