Arduino Projekt funktioniert nicht: Fehlersuche in 10 Minuten

Wenn dein Arduino Projekt nicht funktioniert, such den Fehler nicht, indem du wahllos Kabel ziehst und steckst. Geh von außen nach innen vor: zuerst die Stromversorgung (startet das Board?), dann der Upload (ist der Code wirklich auf dem Board?), dann die Verkabelung (ist GND gemeinsam, steckt jedes Kabel am richtigen Pin?), dann Richtung und Wert der Bauteile (ist die LED verpolt, stimmt der Widerstand?), dann der Code (Pinnummern und Logik) und zuletzt Sensor und Umgebung (Licht, Abstand, Versorgungsspannung). Mach pro Ebene einen Test und ändere jedes Mal nur eine Sache. Mit dieser Reihenfolge findest du die meisten Fehler in 10 Minuten, denn die häufigsten Fehler liegen in den äußeren Ebenen, und die lassen sich am schnellsten prüfen.

Dieser Beitrag listet keine einzelnen Fehlermeldungen auf, sondern gibt dir eine Methode zur Fehlersuche. Zuerst siehst du die zwei Regeln der Methode, dann eine Ablauftabelle mit Symptom, 1-Minuten-Test und wahrscheinlicher Ursache für jede Ebene. Danach folgen ein kurzer Testsketch, der die Schaltung mit Blink und dem seriellen Monitor in Teile zerlegt, 4 Messungen mit dem Multimeter (und die Alternativen mit LED und seriellem Monitor, falls du keins hast), eine Fehlersuche Schritt für Schritt in einem kostenlosen BlueGrays-Projekt, eine Schnellübersicht nach Symptom und eine Checkliste mit 8 Punkten für den Unterricht.

Die zwei Regeln der Fehlersuche: von außen nach innen, eine Variable

Die Logik dahinter ist einfach: Die inneren Ebenen hängen von den äußeren ab. Wenn das Board keinen Strom hat, ist es egal, ob der Code stimmt; wenn der Code nie auf dem Board angekommen ist, ändert eine korrigierte Verkabelung nichts. Die äußeren Ebenen sind außerdem am schnellsten geprüft: Ein Blick auf die Power-LED dauert 5 Sekunden, das Lesen der Upload-Meldung 10 Sekunden, aber einen Logikfehler im Code zu finden, kann Minuten dauern. Die zweite Regel ist die Ein-Variablen-Regel. Wenn du gleichzeitig das Kabel, den Widerstand und den Schwellwert im Code änderst, weißt du nicht, was den Fehler behoben hat, selbst wenn das Projekt danach läuft; und wenn nicht, hast du vielleicht einen neuen Fehler eingebaut. Eine Änderung, testen, Ergebnis notieren, dann die nächste.

• Beschreibe das Symptom in einem Satz: "Wenn ich die Hand über den LDR halte, soll die LED angehen, aber sie geht nie an." "Geht nicht" ist kein Symptom; sobald du getrennt aufschreibst, was du erwartest und was passiert, ist die zu prüfende Ebene oft schon klar.
• Beim Verkabeln USB abziehen: Bleibt das Board beim Umstecken versorgt, kann ein falscher Kontakt einen Kurzschluss verursachen. Ändern, mit dem Auge prüfen, dann wieder einstecken.
• Gegen ein sicher funktionierendes Teil tauschen: Die verdächtige LED, das Kabel oder den Sensor gegen ein Teil zu tauschen, von dem du weißt, dass es funktioniert, ist der stärkste Test ohne Messgerät.
• Notizen machen: Kurze Notizen wie "Kabel von 7 auf 8 gesteckt, keine Änderung" verhindern, dass du denselben Test zweimal machst, und sind eine fertige Zusammenfassung, wenn du im Forum oder deine Lehrkraft fragst.
• Vereinfachen: Ist das Projekt groß, nimm die Module einzeln heraus. Zuerst nur das Board, dann Board und Ausgabeteil, dann das Eingabeteil. Zu sehen, mit welchem Teil es kaputtgeht, zeigt dir den Ort des Fehlers.

Die Ablauftabelle für die 10-Minuten-Fehlersuche

Lies die Tabelle von oben nach unten und geh erst zur nächsten Ebene, wenn der Test der aktuellen bestanden ist. Jeder Test dauert etwa eine Minute, also sind alle sechs Ebenen in 6–10 Minuten erledigt. Für die meisten Tests reichen deine Augen, die LEDs auf dem Board und der serielle Monitor der Arduino IDE; ein Multimeter beschleunigt die Sache, ist aber nicht nötig. Die Spalte "Wahrscheinliche Ursache" nennt die ersten Stellen, an denen du bei einem fehlgeschlagenen Test suchen solltest, ungefähr nach Häufigkeit sortiert.

Ebene 1 und 2: Stromversorgung und Upload

Beim Arduino Uno geben zwei LEDs den ersten Hinweis für diese beiden Ebenen. Die ON-LED zeigt, dass das Board versorgt wird; leuchtet sie nicht, tausche zuerst das USB-Kabel, denn manche Kabel laden nur und übertragen keine Daten. Leuchtet ON, aber der USB-Ton deines Computers bricht beim Einstecken ab oder die LED flackert, gibt es vielleicht einen Kurzschluss in der Schaltung: USB abziehen, die 5V- und GND-Leitungen verfolgen und nach einem verkehrt gesteckten Modul oder einem Kabel suchen, das beide Schienen verbindet. Ein Bauteil, das heiß wird, ist immer ein ernstes Zeichen; versorge das Board erst wieder, wenn du es entfernt hast. Wenn du Motor, Servo oder Relais nutzt, reicht der Strom über USB eventuell nicht; dann ist das Symptom meist nicht "gar nichts geht", sondern zufällige Resets oder Zittern. Möglichkeiten mit Batterie und Netzteil findest du unter Arduino mit Batterie betreiben.

Auf der Upload-Ebene suchst du die Antwort auf eine einzige Frage: Ist der Code auf dem Board der Code, den du auf dem Bildschirm siehst? Nach dem Hochladen meldet die Arduino IDE im Ausgabebereich unten, dass der Upload abgeschlossen ist; stehen dort rote Zeilen, ist der Code nie auf dem Board angekommen und es führt sein altes Programm weiter aus. Das ist tückisch, weil du denkst, deine Korrektur habe nicht funktioniert. Fehler mit avrdude, Port und Treiber erklärt Arduino Code lässt sich nicht hochladen Meldung für Meldung, und beim Kompilieren hilft Kompilierfehler. Es gibt auch einen einfachen Beweistest: Ändere eine Wartezeit im Code von 100 auf 1000 und lade hoch. Ändert sich der Rhythmus der LED nicht, liegt das Problem beim Upload. Manche ESP32-Boards brauchen beim Hochladen die gedrückte BOOT-Taste; beim Raspberry Pi Pico prüfst du, ob in Thonny unten rechts der MicroPython-Interpreter ausgewählt ist.

Ebene 3: Verkabelung, GND und Pins

Board versorgt, Code hochgeladen: Jetzt sind die Kabel dran. Die zwei häufigsten Fehler sind eine vergessene gemeinsame Masse und ein falsch gelesenes Steckbrett. Auch wenn ein Sensor oder Modul eine eigene Versorgung hat, muss sein GND mit dem GND des Arduino verbunden sein, sonst hat die Signalspannung keinen Bezug. Auf dem Steckbrett trennt die Mittelrinne die beiden Hälften, und bei langen Steckbrettern können die Stromschienen am Rand in der Mitte geteilt sein; 5V in eine Hälfte einzuspeisen und anzunehmen, dass damit ein Bauteil auf der anderen Hälfte versorgt wird, ist ein sehr häufiger Fehler. Die beste Methode auf dieser Ebene ist der direkte Abgleich mit dem Schaltplan: Zähl jedes Kabel mit beiden Enden und zeig mit dem Finger auf sein Gegenstück im Plan. Digital 2 mit Analog A2 verwechselt, 5V mit VIN vertauscht oder ein Kabel eine Reihe daneben fallen dabei sofort auf. Wenn dir die Schaltsymbole fremd sind, erklärt Schaltplan lesen den Weg aufs Steckbrett Schritt für Schritt.

Ebene 4: Richtung und Wert der Bauteile

Stimmt die Verkabelung, aber ein Bauteil reagiert immer noch nicht, schau dir das Bauteil selbst an. Das lange Bein der LED (Anode) geht über den Widerstand zum Pin, das kurze (Kathode) zu GND; eine verpolte LED geht meist nicht kaputt, sie bleibt nur dunkel. Widerstände werden am häufigsten verwechselt: 220 Ω hat die Ringe Rot-Rot-Braun, 10 kΩ Braun-Schwarz-Orange. Steckt neben der LED ein 10-kΩ-Widerstand, leuchtet sie so schwach, dass du es nicht bemerkst; steckt neben einem LDR oder Taster ein 220-Ω-Widerstand, ergeben die Messwerte keinen Sinn mehr. Die Ringe liest du mit dem Farbcode-Rechner, den passenden Wert für eine LED findest du mit dem LED-Vorwiderstand-Rechner. Ein vierbeiniger Taster, der um 90 Grad gedreht steckt, wirkt immer gedrückt oder nie gedrückt. Bei Modulen hängt die Reihenfolge von VCC, GND und Signal vom Hersteller ab; lies die Pinbeschriftung auf der Platine selbst, nicht auf einem Bild aus dem Internet. Auch bei dreibeinigen Bauteilen wie Transistoren und Spannungsreglern ist die Pinbelegung je nach Modell anders.

Ebene 5: Code (Pinnummern und Logik)

Ist die Hardware in Ordnung, prüfe, ob der Code dasselbe sagt wie die Schaltung. Die erste Prüfung sind die Pinnummern: Steckt die LED physisch an 8, im Code steht aber digitalWrite(9, HIGH), sieht alles perfekt aus und nichts passiert. Die zweite Prüfung ist pinMode: Fehlt pinMode(pin, OUTPUT) in setup(), macht digitalWrite(pin, HIGH) den Pin nicht zum Ausgang, sondern schaltet nur den internen Pull-up-Widerstand ein, und die LED glimmt sehr schwach. Neben dem Widerstand ist das die häufigste Ursache für eine "schwache LED". Die dritte Prüfung ist die Logik: if (wert = 100) vergleicht nichts, sondern weist der Variable 100 zu, und die Bedingung ist immer wahr; richtig ist ==. Auch Schwellwerte und Wartezeiten gehören zu dieser Ebene: Ein Schwellwert, der nicht zu deiner Umgebung passt, löst nie aus, selbst wenn der Sensor einwandfrei arbeitet. Bei Projekten mit Bibliotheken prüfst du außerdem, ob die richtige Bibliothek installiert ist; Details stehen in Arduino Bibliothek installieren.

Ebene 6: Sensor und Umgebung

Die letzte Ebene sind äußere Bedingungen, die das Ergebnis verfälschen, obwohl Schaltung und Code stimmen. Der Wert eines LDR hängt vom Raumlicht ab; ein Schwellwert, der tagsüber am Fenster funktioniert, passt abends unter der Lampe vielleicht nicht. Ein HC-SR04 bekommt von weichen Flächen wie Stoff kein Echo und misst nicht näher als 2 cm. Gassensoren der MQ-Reihe brauchen vor dem Messen einige Minuten zum Aufwärmen. Ein DHT11 liefert Fehler, wenn du ihn öfter als einmal pro Sekunde ausliest. Die Pins von ESP32 und Raspberry Pi Pico arbeiten mit 3,3 V; einen Sensor mit 5-V-Ausgang direkt anzuschließen, kann zu falschen Werten führen und den Pin beschädigen. Lange Kabel, Störungen durch Motoren und offene Eingänge lassen Werte ebenfalls springen. Das beste Werkzeug auf dieser Ebene ist der serielle Monitor: Beobachte den Rohwert des Sensors und verändere die Umgebung gezielt. Antwortet ein I2C-Display oder -Sensor gar nicht, zeigt der Scanner-Sketch in Was ist I2C seine Adresse.

Teile und herrsche: das Board mit Blink, die Schritte mit dem seriellen Monitor prüfen

Am schnellsten kommst du durch die Ebenen, wenn du Schaltung und Code in Teile zerlegst. Der erste Teil ist das Board selbst: Lade ohne angeschlossene Bauteile einen Code hoch, der die L-LED auf dem Board blinken lässt. Blinkt L, sind Stromversorgung, Upload und Board in Ordnung, und du suchst das Problem ab jetzt außerhalb des Boards. Der zweite Teil ist der Ausgang: Lass im selben Code die externe LED mitblinken. Der dritte Teil ist der Eingang: Gib den Sensorwert im seriellen Monitor aus. Der Sketch unten erledigt alle drei Teile und schreibt bei jedem Schritt einen nummerierten Kontrollpunkt in den seriellen Monitor. Schließ die externe LED über einen 220-Ω-Widerstand an Pin 9 und das Signal des analogen Sensors, den du testen willst, an A0 an; stell den seriellen Monitor auf 9600 Baud.

1const int LED_PIN = 9;       // Harici LED pini / External LED pin
2const int SENSOR_PIN = A0;   // Analog sensör pini / Analog sensor pin
3
4void setup() {
5  Serial.begin(9600);                  // Seri monitör de 9600 olmalı / Serial Monitor must be 9600 too
6  pinMode(LED_BUILTIN, OUTPUT);        // Karttaki L ışığı / On-board L LED
7  pinMode(LED_PIN, OUTPUT);            // Harici LED çıkış / External LED as output
8  Serial.println("1) setup bitti");    // Kontrol noktası 1 / Checkpoint 1
9}
10
11void loop() {
12  digitalWrite(LED_BUILTIN, HIGH);     // Kart canlı mı? / Is the board alive?
13  digitalWrite(LED_PIN, HIGH);         // Harici LED açık / External LED on
14  Serial.println("2) LED acik");       // Kontrol noktası 2 / Checkpoint 2
15  delay(500);
16
17  digitalWrite(LED_BUILTIN, LOW);
18  digitalWrite(LED_PIN, LOW);          // Harici LED kapalı / External LED off
19  Serial.println("3) LED kapali");     // Kontrol noktası 3 / Checkpoint 3
20  delay(500);
21
22  int value = analogRead(SENSOR_PIN);  // 0-1023 arası okuma / Reading from 0 to 1023
23  Serial.print("4) A0 = ");
24  Serial.println(value);               // Sensör değeri / Sensor value
25}

Die eigentliche Stärke dieses Sketches sind die Kontrollpunkte. Nutz dieselbe Methode in deinem eigenen Projekt: Setz ans Ende von setup() und hinter jeden wichtigen Schritt in loop() ein kurzes Serial.println(), zum Beispiel "Taster gedrueckt" oder "Schwelle ueberschritten". Welche Meldung zuletzt im seriellen Monitor erscheint, zeigt dir, wo das Programm hängt. Um herauszufinden, warum eine Bedingung nie greift, gib den verglichenen Wert direkt vor der Bedingung aus; ist "wert < 50" nie wahr, siehst du genau dort, dass der Wert nie unter 50 fällt. In größeren Projekten gilt dieselbe Logik: Kommentiere einen Teil des Codes vorübergehend aus und teste die Teile einzeln. Einstellungen wie Baudrate, Zeilenende und Plotter erklärt Arduino Serial Monitor benutzen.

4 Messungen mit dem Multimeter (ohne: mit LED und seriellem Monitor)

Ein Multimeter macht aus Raten Messen, und schon vier Messungen decken die meisten Arduino-Fehler ab. Stell das Gerät vorher auf den richtigen Bereich: DC V für Spannung, Piepser (Durchgang) für Kabel und Reihen, Ω für Widerstände. Durchgangs- und Widerstandsmessungen machst du immer mit abgezogenem USB-Kabel. Wenn du kein Multimeter hast, geben die Methoden in der letzten Spalte eine gröbere, aber ausreichende Antwort auf dieselbe Frage. Die Bereiche des Messgeräts und welche Buchsen die Messspitzen bekommen, zeigt Multimeter benutzen mit Bildern.

Beispiel: Die LED im Projekt Nachtlicht mit LDR geht nicht an

Probieren wir die Methode an einem kostenlosen BlueGrays-Projekt aus: Nachtlicht mit LDR. In der Schaltung geht ein Ende des LDR an 5V, das andere an A0; zwischen A0 und GND sitzt ein 10-kΩ-Widerstand, und beide bilden einen Spannungsteiler. Die LED hängt über einen 330-Ω-Widerstand an Pin 13. Der Code liest A0 und schaltet die LED ein, wenn der Wert unter 50 liegt, weil er den Raum dann als dunkel wertet. Das Symptom: "Ich halte die Hand über den LDR, aber die LED geht nie an." Statt wahllos Kabel zu tauschen, gehen wir die Ebenen der Reihe nach durch.

1. Strom: Die ON-LED leuchtet, nichts ist warm. Weiter.
2. Upload: Der Upload lief fehlerfrei. Zur Sicherheit änderst du die 50 im Code vorübergehend auf 2000 und lädst hoch; da analogRead höchstens 1023 liefert, ist die Bedingung immer wahr und die LED sollte dauerhaft leuchten.
3. Verkabelung und L-LED: Pin 13 ist auch mit der L-LED auf dem Board verbunden. Leuchtet L mit der Schwelle 2000, die externe LED aber nicht, läuft der Code; das Problem liegt im Weg der LED. Geht das lange Bein der LED über 330 Ω an 13 und das kurze an GND?
4. Richtung und Wert: Die LED ist nicht verpolt, aber steckt neben ihr 10 kΩ statt 330 Ω, leuchtet sie zu schwach, um es zu bemerken. Unterscheide die beiden Widerstände an ihren Farben.
5. Code und Sensor: Leuchtet die externe LED mit der Schwelle 2000, stell sie wieder auf 50. Um jetzt die echten Werte zu sehen, lade den Code des Projekts Lichtstärke messen mit LDR auf dieselbe Schaltung; er nutzt dieselbe LDR-Verkabelung und schreibt A0 jede halbe Sekunde in den seriellen Monitor.
6. Werte lesen: Angenommen, du siehst offen etwa 600 und mit der Hand darüber etwa 120. Der Wert fällt nie unter 50, also geht die LED nie an. Geh zurück zum Nachtlicht-Code und erhöhe die Schwelle auf einen Wert zwischen 200 und 300.
7. Umgekehrtes Verhalten erkennen: Steigt der Wert beim Abdecken, statt zu fallen, sind LDR und 10 kΩ vertauscht. Springt der Wert zufällig, obwohl die Hand ruhig ist, sitzt das A0-Kabel nicht in der Reihe, in der sich LDR und Widerstand treffen.

In diesem Beispiel hat nicht neues Wissen den Fehler gefunden, sondern die Reihenfolge: Zuerst haben wir bewiesen, dass die LED selbst leuchten kann, dann haben wir nachgesehen, was der Sensor wirklich misst. In der App stehen im Bereich Wenn du nicht weiterkommst des Tabs Code verstehen genau dieses Projekts fünf dieser Symptome bereits als Paare aus Symptom und Lösung: die externe LED geht im Dunkeln nie an, die LED leuchtet im Hellen und geht im Dunkeln aus, sie geht selbst mit der Hand darüber nicht an, sie bleibt dauernd an oder flackert, und ein Upload-Fehler. Der Bereich Fehlerbehebung des Projekts liefert eine allgemeine Checkliste mit 10 Schritten, die bei der Stromversorgung beginnt und über Upload, Pinnummern, Steckbrett, Jumperkabel, GND, LED bis zum Widerstand reicht. Vielleicht ist es dir aufgefallen: Diese Reihenfolge entspricht fast genau den Ebenen vom Anfang dieses Beitrags.

Hilfe in der App: Wo schaust du nach, wenn ein Projekt nicht läuft?

• Fehlerbehebung: Eine geordnete Checkliste auf der Projektseite, die mit "Wenn Ihr Projekt nicht funktioniert, überprüfen Sie die folgenden Schritte." beginnt. Es gibt sie bei mehr als 170 Projekten, sie öffnet sich mit Premium; auch bei kostenlosen Projekten ist dieser Bereich mit Premium sichtbar. Wenn du keine Ahnung hast, was kaputt ist, gehst du sie hier von Anfang bis Ende durch.
• Code verstehen > Wenn du nicht weiterkommst: Paare aus Symptom und Lösung, die zum Code und zur Schaltung genau dieses Projekts gehören. Bei kostenlosen Projekten für alle offen, bei Premium-Projekten mit Premium. Kannst du dein Symptom in einem Satz beschreiben, schau zuerst hier. Den ganzen Bereich erklärt der Beitrag Code verstehen.
• Zu den Schritten von Lass es uns zusammen bauen zurückgehen: Geh im geführten Modus zurück zu 2. Schaltung aufbauen und bau die Schaltung neu auf, während das USB-Kabel des Boards abgezogen ist; bei 3. Code hochladen prüfst du noch einmal Board und Port im Menü Werkzeuge der Arduino IDE. Der Modus merkt sich, bei welchem Schritt du warst. Wie er funktioniert, steht in dein erstes Arduino-Projekt.
• Schaltplan vergrößern: Zieh den Schaltplan mit zwei Fingern groß und vergleiche deine Verkabelung Verbindung für Verbindung; wenn du magst, speicherst du ihn mit In Galerie speichern und markierst die geprüften Kabel. So findest du die meisten Fehler der Ebene 3.
• Die richtige Frage im Forum: Hast du all das versucht und es läuft immer noch nicht, eröffne unter Lernen › Forum ein Thema in der Kategorie Frage. Nenne Board, den vollständigen Code, die Verbindungen, das erwartete und das tatsächliche Verhalten und welche Ebenen du geprüft hast, und häng ein deutliches Foto der Schaltung an. Wie du das schreibst, steht in im Forum fragen.

Schnellübersicht nach Symptom

Für Lehrkräfte: eine Checkliste mit 8 Punkten zur Fehlersuche

Angenommen, in einer Klasse mit 24 Schülerinnen und Schülern bauen 8 Gruppen gleichzeitig Schaltungen, und in den ersten 15 Minuten melden sich sechs Gruppen mit "Es geht nicht". Leg die Checkliste unten auf jeden Gruppentisch und mach die Regel gleich zu Beginn klar: Bevor ihr euch meldet, geht ihr die Karte von oben nach unten durch und schreibt auf die Rückseite, bei welchem Punkt ihr hängt und was ihr geändert habt. Das verschafft dir Zeit und baut bei den Lernenden Problemlösegewohnheiten auf; die Notizen zur Fehlersuche sind außerdem ein Prozessnachweis, den du für die Bewertung nutzen kannst. Zur Gruppenorganisation in großen Klassen lies Arduino-Unterricht in großen Klassen, zur Bewertung des Prozesses das Bewertungsraster.

1. Symptom: Was haben wir erwartet, was passiert? In einem Satz aufschreiben.
2. Strom: Leuchtet die ON-LED? USB abziehen: Ist ein Bauteil warm?
3. Upload: Lief der Upload fehlerfrei? Stimmen Board und Port im Menü Werkzeuge?
4. Board: Blinkt nach dem Hochladen von Blink die L-LED auf dem Board?
5. Verkabelung: Schaltplan vergrößern und jedes Kabel an beiden Enden zählen. Ist GND gemeinsam, stecken die Kabel am richtigen Pin und in der richtigen Reihe?
6. Bauteil: Geht das lange Bein der LED zum Pin? Passen die Farbringe zum Wert in der Bauteilliste? Stimmen VCC und GND am Modul?
7. Code: Stimmen die Pinnummern im Code mit der Schaltung überein? Welcher Kontrollpunkt erscheint im seriellen Monitor zuletzt?
8. Sensor und nächster Schritt: Ist der Sensorwert im seriellen Monitor plausibel und ändert er sich, wenn sich die Umgebung ändert? Ist es immer noch nicht gelöst, schaut in Wenn du nicht weiterkommst und Fehlerbehebung nach und ruft dann die Lehrkraft. Immer nur eine Sache ändern und Notizen machen.

Fehlersuche ist eine Fähigkeit, und mit jedem Fehler wirst du schneller: Was beim ersten Projekt 20 Minuten dauert, schaffst du beim fünften in 3 Minuten, weil du anfängst, die Ebene schon am Symptom zu erkennen. Wenn das nächste Projekt nicht läuft, öffne diese Reihenfolge, bevor du Kabel ziehst, und arbeite dich von oben nach unten durch. Zum Üben eignen sich kleine Projekte wie das Nachtlicht aus diesem Beitrag; in der BlueGrays-App bringt jedes der 60 kostenlosen Projekte Schaltplan, Code und den Bereich Code verstehen mit, sodass du beim nächsten Fehler schon weißt, wo du nachschauen musst.