Arduino kaputt? Symptome erkennen, Fehler finden, reparieren

„Ist mein Arduino kaputt?“ fragt sich fast jeder Elektronikbastler irgendwann: Ein Kabel berührt die falsche Stelle, ein Motor wird angeschlossen, und plötzlich ist das Board still. Die gute Nachricht: Meist ist nicht das ganze Board hinüber. Ein Arduino Uno besteht aus mehreren getrennten Teilen: dem USB-Anschluss mit Sicherung, dem Spannungsregler, dem USB-Seriell-Wandler und dem eigentlichen Mikrocontroller ATmega328P. Fällt einer davon aus, überleben die anderen oft, und mit der richtigen Diagnose ist die Rettung manchmal eine Sache von zwei Minuten.

In dieser Anleitung lernst du, Symptome richtig zu deuten und das Board Schritt für Schritt einzugrenzen, bis du den defekten Teil gefunden hast. Wir gehen der Reihe nach vor: Versorgung über Vin, Polyfuse und Regler mit dem Multimeter prüfen, heißen Chip finden, USB-Chip per Loopback-Test prüfen und mit zwei Arduino-Sketches alle Pins einzeln testen. Danach brennen wir einen beschädigten Bootloader mit einem zweiten Arduino neu, tauschen bei Bedarf den ATmega328P und fassen die Regeln zusammen, mit denen du nie wieder ein Board zerstörst. Die Software-Seite von Upload-Fehlern behandeln wir gesondert in Arduino-Sketch lässt sich nicht hochladen.

Arduino kaputt? Erste Symptome und ihre Bedeutung

Bevor du mit der Diagnose beginnst, hör dir an, was das Board dir sagt. Die grüne ON-LED zeigt, ob die 5-V-Schiene Spannung hat, die L-LED (D13), ob Mikrocontroller und Bootloader laufen, und die TX/RX-LEDs, ob der USB-Seriell-Chip Daten überträgt. Die Tabelle fasst die häufigsten Symptome zusammen und zeigt, wo du zuerst suchen solltest.

Schritt 1: Erste Prüfung mit Augen, Nase und Kabel

1. Untersuche das Board bei gutem Licht: Gesucht sind ein dunkler oder aufgeblähter Chip, ein gerissenes Gehäuse, geschmolzenes Lot oder eine verkohlte Leiterbahn. Achte besonders auf die Umgebung von Regler, Polyfuse und USB-Chip.
2. Riech am Board. Verbrannte Elektronik hinterlässt einen scharfen, bekannten Geruch, meist am stärksten rund um das defekte Teil.
3. Prüfe die Unterseite. Ein Metalltisch, ein Drahtrest oder leitfähiger Schaumstoff kann Lötstellen verbinden und einen Kurzschluss verursachen.
4. Teste ein anderes USB-Kabel und einen anderen USB-Port. Manche billigen Kabel haben nur Stromleitungen und übertragen keine Daten; das ist die häufigste Ursache für ein scheinbar totes Board.
5. Notiere, ob der Computer beim Einstecken den USB-Ton abspielt und ob die ON-LED leuchtet; die nächsten Schritte hängen von diesen beiden Beobachtungen ab.

Der Stromweg des Arduino Uno: Welches Bauteil versorgt was?

Am schnellsten findest du einen Fehler, wenn du den Weg des Stroms über das Board kennst. Die 5 V vom USB gehen zuerst durch eine 500-mA-Polyfuse (eine sich selbst zurücksetzende Sicherung), dann durch einen kleinen P-Kanal-MOSFET und erreichen die 5-V-Schiene. Die Spannung von der Hohlbuchse läuft erst durch eine Verpolschutzdiode, erreicht die VIN-Leitung und wird vom Regler NCP1117 auf 5 V gebracht. Steigt VIN über etwa 6,6 V, schaltet ein Komparator den MOSFET auf der USB-Seite ab, sodass sich die beiden Quellen nie in die Quere kommen. Die 3,3 V erzeugt ein kleiner LP2985 aus der 5-V-Schiene. ON-LED, USB-Seriell-Chip (beim Original ein ATmega16U2, bei Nachbauten meist ein CH340) und ATmega328P hängen alle an dieser 5-V-Schiene.

Schritt 2: ON-LED aus? Mit USB und mit Vin testen

Versorge das Board einmal per USB und einmal mit einem 9-V-Netzteil an der Hohlbuchse (oder 7–12 V an Vin) und beobachte jeweils die ON-LED. Weil beide Wege nur die 5-V-Schiene gemeinsam haben, grenzt dieser einfache Vergleich den Fehler stark ein. Hat die Polyfuse wegen Überstrom ausgelöst, lass das Board ein paar Minuten stromlos, damit sie sich erholt; besteht der Kurzschluss weiter, löst sie beim erneuten Einstecken wieder aus. Akku- und Netzteiloptionen erklären wir ausführlich unter Arduino mit Batterie betreiben.

Schritt 3: Kurzschluss, Polyfuse und Regler mit dem Multimeter prüfen

1. Kurzschlusstest (Board stromlos): Stell das Multimeter auf Widerstand oder Durchgang und halte die Spitzen an 5V und GND. Dass der Wert niedrig beginnt und mit dem Laden der Kondensatoren steigt, ist normal; ein Dauerpiepton oder ein Wert, der unter wenigen Ohm bleibt, bedeutet Kurzschluss.
2. Polyfuse-Test (USB eingesteckt): Im DC-Spannungsbereich legst du die schwarze Spitze an GND und misst nacheinander beide Seiten der Polyfuse. Auf beiden Seiten sollten etwa 5 V anliegen; 5 V auf einer und fast null auf der anderen Seite heißt, die Polyfuse ist offen.
3. Reglertest (9 V an der Hohlbuchse): Am Eingang des NCP1117 solltest du etwa 8,3 V messen (an der Diode fallen 0,7 V ab), am Ausgang 5,0 V.
4. 3,3-V-Test: Zwischen 3V3 und GND solltest du 3,2–3,4 V messen.
5. Miss in genau dieser Reihenfolge; jeder Schritt verändert die Bedeutung des nächsten. Messbereiche und sicheres Messen erklären wir ausführlich unter Multimeter richtig benutzen.

Schritt 4: Den heißen Chip finden

Gibt es einen Kurzschluss auf der 5-V-Schiene, zieht das kurzgeschlossene Bauteil den Großteil des Stroms und wird binnen Sekunden heiß. Steck das Board an USB, warte 3–5 Sekunden, zieh den Stecker und berühre kurz nacheinander mit der Fingerspitze ATmega328P, USB-Chip und Regler. Ist ein Teil zu heiß zum Anfassen, sitzt dort der Kurzschluss. Ist der ATmega328P heiß, hat meist ein Pin über 5 V abbekommen; ist der USB-Chip heiß, liegt das Problem auf der USB-Seite; ist der Regler heiß, ist er selbst defekt oder eine Last an der 5-V-Schiene zieht zu viel Strom. Lass das Board bei diesem Test nicht lange unter Spannung, sonst nehmen auch gesunde Teile Schaden.

Schritt 5: USB-Chip testen, wenn kein Port erscheint

Leuchtet die ON-LED, aber der Computer erkennt das Board nicht, schließe zuerst die Software-Seite aus: Installiere bei Nachbauten den Treiber für den CH340, sieh unter Windows im Geräte-Manager bei „Anschlüsse (COM & LPT)“ nach, unter macOS und Linux bei den Geräten /dev/cu.* oder /dev/ttyUSB*. Erscheint gar kein Gerät oder nur ein unbekanntes, prüfst du den USB-Seriell-Chip selbst. Der Loopback-Test nimmt den ATmega328P aus dem Spiel und lässt den USB-Chip seine gesendeten Daten direkt wieder empfangen; so trennst du, ob der Fehler im USB-Chip oder im Mikrocontroller steckt.

1. Trenne das Board von der Versorgung und verbinde RESET per Jumperkabel mit GND. So bleibt der ATmega328P im Reset und gibt die TX/RX-Leitungen frei.
2. Verbinde D0 (RX) und D1 (TX) mit einem zweiten Jumperkabel.
3. Steck das Board an USB, wähle in der Arduino IDE den Port und öffne den seriellen Monitor (die Baudrate ist egal).
4. Tippe etwas ein und drücke Senden. Kommt der Text unverändert zurück und blinken die TX/RX-LEDs, ist der USB-Chip in Ordnung; der Fehler liegt beim ATmega328P oder beim Bootloader.
5. Kommt nichts zurück und erscheint auch kein Port, sind USB-Chip oder USB-Buchse beschädigt. Dann kannst du Code noch über einen externen USB-TTL-Wandler oder einen ISP-Programmer aufspielen.

Schritt 6: Defekte Pins finden

Lädt das Board Code, aber dein Projekt verhält sich seltsam, ist vielleicht ein einzelner Pin defekt. Ein Motor, eine Relaisspule oder eine LED ohne Vorwiderstand am Pin, zwei kurzgeschlossene Ausgänge oder mehr als 5 V an einem Pin können genau diesen Pin zerstören, während der Rest des ATmega328P weiterarbeitet. Der erste Sketch macht jeden Pin zum Eingang mit internem Pull-up: Ein gesunder Pin liest offen HIGH. Dann verbindest du ein Ende eines Jumperkabels mit GND und berührst mit dem anderen nacheinander die Pins; bei jeder Berührung sollte der serielle Monitor zeigen, dass der Pin auf LOW geht.

1// Arduino Uno giriş testi / input test (D0 ve D1 seri port için hariç / D0 and D1 skipped for serial)
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4bool lastState[COUNT];
5
6void printPin(byte p) {
7  if (p >= A0) {
8    Serial.print('A');
9    Serial.print(p - A0);
10  } else {
11    Serial.print('D');
12    Serial.print(p);
13  }
14}
15
16void setup() {
17  Serial.begin(9600);
18  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], INPUT_PULLUP);   // dahili pull-up açık / internal pull-up on
19  delay(10);
20  Serial.println(F("1) Bos pin testi / free pin test:"));
21  for (byte i = 0; i < COUNT; i++) {
22    lastState[i] = digitalRead(PINS[i]);
23    printPin(PINS[i]);
24    Serial.println(lastState[i] ? F("  HIGH  tamam / ok") : F("  LOW   SUPHELI / suspect"));
25  }
26  Serial.println(F("2) GND'ye bagli kabloyla pinlere sirayla dokun / touch each pin with a GND wire"));
27}
28
29void loop() {
30  for (byte i = 0; i < COUNT; i++) {
31    bool v = digitalRead(PINS[i]);
32    if (v != lastState[i]) {                 // durum değişti / state changed
33      lastState[i] = v;
34      printPin(PINS[i]);
35      Serial.println(v ? F("  birakildi / released") : F("  GND algilandi / GND detected"));
36    }
37  }
38  delay(20);
39}

Ein Pin, der offen LOW liest oder sich beim Berühren mit GND gar nicht ändert, ist verdächtig; seine Eingangsstufe hat einen inneren Kurzschluss oder eine Unterbrechung. Bei manchen Nachbauten hängt die L-LED direkt an D13, sodass D13 offen LOW lesen kann; das ist kein Defekt. Der zweite Sketch prüft die Ausgangsstufe: Alle Pins wechseln einmal pro Sekunde zwischen HIGH und LOW. Verbinde die Kathode einer LED mit GND und die Anode mit einem 220-Ω-Widerstand und berühre mit dessen anderem Ende nacheinander die Pins: An jedem gesunden Pin blinkt die LED. Den passenden Widerstand findest du mit dem LED-Vorwiderstandsrechner. Mit dem Multimeter solltest du im HIGH-Zustand etwa 5 V messen; ein Pin, der nie leuchtet, nur schwach glimmt oder deutlich unter 4 V bleibt, ist beschädigt.

1// Arduino Uno çıkış testi / output test: bütün pinler 1 sn HIGH, 1 sn LOW / all pins 1 s HIGH, 1 s LOW
2const byte PINS[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, A0, A1, A2, A3, A4, A5};
3const byte COUNT = sizeof(PINS);
4
5void setAll(bool level) {
6  for (byte i = 0; i < COUNT; i++) digitalWrite(PINS[i], level);
7}
8
9void setup() {
10  Serial.begin(9600);
11  for (byte i = 0; i < COUNT; i++) pinMode(PINS[i], OUTPUT);
12  Serial.println(F("LED + 220 ohm probuyla pinlere dokun / touch the pins with an LED + 220 ohm probe"));
13}
14
15void loop() {
16  setAll(HIGH);
17  Serial.println(F("HIGH (~5 V)"));
18  delay(1000);
19  setAll(LOW);
20  Serial.println(F("LOW (0 V)"));
21  delay(1000);
22}

Während dieser Sketch läuft, darf nichts anderes an den Pins hängen, denn alle Pins werden als Ausgang getrieben. Willst du auch die Analogeingänge prüfen, verbinde A0 nacheinander mit GND, 3V3 und 5V und lies ihn mit analogRead(): Du solltest etwa 0, 675 und 1023 sehen. Die vollständige Pinliste und welcher Pin welche Funktion hat, steht unter Arduino-Uno-Pinbelegung, Platinenbilder findest du im Pinout-Werkzeug.

Bootloader neu brennen: Arduino as ISP

Ist die Stromversorgung in Ordnung und der Loopback-Test erfolgreich, blinkt die L-LED beim Reset aber nicht und jeder Upload endet mit „avrdude: stk500_getsync(): not in sync“, ist der Bootloader vielleicht gelöscht oder beschädigt. Der Bootloader ist das kleine Programm, das den Upload per USB ermöglicht, und lässt sich per ISP (In-System-Programmierung) neu schreiben. Einen eigenen Programmer brauchst du dafür nicht: Ein zweiter, intakter Arduino Uno wird mit dem Beispielsketch ArduinoISP zum Programmer. ISP nutzt die SPI-Pins; alternativ kannst du den 6-poligen ICSP-Header des Zielboards verwenden.

1. Schließe den intakten Uno an den Computer an, öffne Datei > Beispiele > 11.ArduinoISP > ArduinoISP und lade den Sketch auf dieses Board.
2. Trenne die Verbindung zum Computer, verdrahte beide Boards nach der Tabelle oben und setze den 10-µF-Kondensator zwischen RESET und GND des Programmer-Uno.
3. Steck den Programmer wieder an USB. Wähle im Menü Werkzeuge als Board Arduino Uno und als Port den des Programmers.
4. Wähle unter Werkzeuge > Programmer die Option Arduino as ISP. Die ähnlich benannte Option „ArduinoISP“ ist für einen separaten USB-Programmer; nimm sie nicht.
5. Führe Werkzeuge > Bootloader brennen aus. Das dauert ein paar Sekunden und endet mit „Done burning bootloader“.
6. Entferne die Kabel, schließe das Zielboard über seinen eigenen USB an und lade das Blink-Beispiel hoch. Blinkt die L-LED beim Reset wieder kurz, ist das Board gerettet.

Scheitert der Vorgang, verrät die Signatur-Meldung von avrdude viel. „Device signature = 0x000000“ oder „0xffffff“ heißt, dass der Programmer gar nicht mit dem Zielchip sprechen kann: Prüfe Verdrahtung, 10-µF-Kondensator und ob das Ziel 5 V bekommt; stimmt alles, ist der ATmega328P sehr wahrscheinlich tot. Die Signatur 1E 95 0F bedeutet, dass es ein ATmega328P ist und die Verbindung steht. Siehst du 1E 95 14, hast du einen ATmega328 ohne „P“ und brauchst die passende Board-Definition für diesen Chip.

Den ATmega328P tauschen

Beim originalen Arduino Uno R3 und vielen Nachbauten sitzt der ATmega328P im 28-poligen DIP-Gehäuse in einem Sockel und lässt sich ohne Löten tauschen. Wird der Mikrocontroller heiß, lässt sich seine Signatur nicht lesen oder sind die meisten Pins tot, ist das die günstigste Lösung. Verschwindet der Kurzschluss, sobald der Chip draußen ist (ON-LED leuchtet wieder, Board bleibt kühl), steht fest, dass der Chip defekt ist. Beim Kauf erleichtert ein ATmega328P-PU mit vorinstalliertem Uno-Bootloader die Sache; einen leeren Chip versiehst du selbst per Arduino as ISP mit dem Bootloader. Bei Boards wie dem Nano und dem SMD-Uno ist der Chip aufgelötet; dort brauchst du für den Tausch eine Heißluftstation und Erfahrung.

1. Trenne das Board von der Versorgung und fotografiere, in welche Richtung die Kerbe des Chips (Seite von Pin 1) zeigt.
2. Schiebe einen kleinen Schlitzschraubendreher zwischen Chip und Sockel und hebe den Chip abwechselnd an beiden Enden Stück für Stück an; hebelst du nur auf einer Seite, verbiegen sich die Beinchen.
3. Die Beinchen eines neuen Chips stehen meist leicht nach außen. Leg den Chip auf die Seite und drück ihn gegen eine ebene Tischplatte, um beide Reihen etwas nach innen zu biegen.
4. Richte den Chip so am Sockel aus, dass die Kerbe wie beim alten Chip zeigt, prüfe, dass alle Beinchen in den Löchern sitzen, und drück ihn dann gleichmäßig hinein.
5. Steck das Board an USB, prüfe, ob die L-LED beim Reset blinkt, und schließe den Test mit dem Blink-Beispiel ab.

Kurze Hinweise zu ESP32 und Raspberry Pi Pico

Dieselbe Logik gilt für andere Boards, nur die Bauteile sind andere. ESP32-Entwicklungsboards haben einen AMS1117-artigen Regler, der 5 V auf 3,3 V senkt, und einen USB-Chip CP2102 oder CH340; wird der Regler heiß, suchst du einen Kurzschluss auf der 3,3-V-Schiene. Die ESP32-Pins sind nicht 5-V-tolerant, darum ist der häufigste Defekt eine 5-V-Spannung an einem Pin. „Failed to connect“ beim Upload ist oft kein Defekt, sondern ein Fall für die gedrückte BOOT-Taste; Details stehen unter Arduino-Sketch lässt sich nicht hochladen. Beim Raspberry Pi Pico ist der schnellste Test, ihn mit gedrückter BOOTSEL-Taste an USB zu stecken: Erscheint ein Laufwerk namens RPI-RP2, sind RP2040 und USB-Verbindung in Ordnung. Auch die Pico-Pins sind nicht 5-V-tolerant, und an 3V3(OUT) solltest du etwa 3,3 V messen.

10 Regeln, damit dein Arduino nicht kaputtgeht

• 20 mA pro Pin: Zieh höchstens 20 mA aus einem Pin; die absolute Grenze liegt bei 40 mA, und alle Pins zusammen sollten 200 mA nicht überschreiten.
• LED immer mit Vorwiderstand: Eine LED ohne Widerstand belastet Pin und LED; bei 5 V reichen 220–330 Ω.
• Nie mehr als 5 V an einen Pin: Die Spannung an einem Eingang darf höchstens 0,5 V über der Versorgung liegen; ein 12-V-Signal tötet den Pin sofort.
• Motoren, Relais und Pumpen nie direkt an einen Pin: Nimm einen Transistor oder MOSFET und eine Freilaufdiode; eine Beispielschaltung zeigt der Beitrag zur Mini-Wasserpumpe.
• 7–12 V an Vin: Das ist der empfohlene Bereich; über 12 V wird der Regler heiß, über 20 V ist die Grenze überschritten.
• Vin nie verpolen: Die Schutzdiode der Hohlbuchse schützt nicht, wenn du über den Vin-Pin einspeist; Plus und Minus vertauschen zerstört das Board.
• Nicht mehr als 50 mA aus dem 3V3-Pin: Für WLAN-Module oder große Displays nimmst du einen eigenen 3,3-V-Regler.
• Beim Umstecken Strom aus: Kabel an einer Schaltung unter Spannung umzustecken ist die häufigste Ursache kurzer Kurzschlüsse.
• Board nicht auf Metall legen: Die Lötstellen auf der Unterseite schließen kurz, wenn sie einen Metalltisch, ein Werkzeug oder einen Drahtrest berühren; nutze Kunststofffüße oder ein Gehäuse.
• Gemeinsame Masse, getrennte Versorgung: Verbinde bei extern versorgten Lasten die Massen, aber leite große Ströme nicht über das Board.

Bevor du deinen Arduino abschreibst, rettet es oft das Board, herauszufinden, welcher Teil verstummt ist: Die ON-LED prüft den Stromweg, der Loopback-Test den USB-Chip, die L-LED beim Reset den Bootloader, und die Pin-Test-Sketches jedes einzelne Beinchen des ATmega328P. Der Bootloader lässt sich neu brennen, ein gesockelter Chip in wenigen Minuten tauschen, und mit den Regeln oben lebt dein nächstes Board lange. Um zu sehen, dass dein Board wieder gesund läuft, probiere in der BlueGrays-App die Projekte LED blinken, Ampel, LED per Taster und Digitalvoltmeter mit LCD, mit Schritt-für-Schritt-Schaltplänen und Code.