Arduino startet ständig neu: Servo, Relais und Hänger beheben

Wenn dein Arduino ständig neu startet oder nach einer Weile hängen bleibt, ist das Board fast nie defekt. In den meisten Fällen liegt es an der Stromversorgung: Sobald ein Servo losfährt, ein Motor anläuft oder ein Relais anzieht, lässt der plötzliche Strom die 5-V-Leitung kurz einbrechen, und der Unterspannungsschutz des Prozessors (Brown-out) startet das Board neu. In den übrigen Fällen sind Störungen von Relais und Motoren, lange Kabel, ein voller Arbeitsspeicher, ein vergessener Watchdog oder ein USB-Port, der nicht genug Strom liefert, schuld.

In dieser Anleitung lernst du zuerst, ob das Board wirklich neu startet oder nur hängt. Danach erklären wir jede Ursache mit echten Strom- und Spannungswerten und zeigen die Lösungen mit Code: getrennte Versorgung und gemeinsame Masse, Kondensatoren mit 100–470 µF, Freilaufdioden, feste Puffer statt String und den Watchdog. Außerdem findest du einen Diagnose-Sketch, der die eigene Versorgungsspannung und den freien RAM des Arduino misst, eine Schritt-für-Schritt-Tabelle vom Symptom zur Lösung und Beispiele, die den Reset-Grund auf dem ESP32 und dem Raspberry Pi Pico auslesen.

Reset oder Hänger? Erkenne zuerst das Symptom

Ein Arduino, der neu startet, führt das Programm von vorne aus, als hättest du das USB-Kabel ab- und wieder angesteckt: setup() läuft erneut, der Servo fährt in seine Startposition, das LCD zeigt wieder den Begrüßungstext und im seriellen Monitor erscheint die Startmeldung noch einmal. Ein hängender Arduino reagiert dagegen auf nichts mehr; die LEDs bleiben im letzten Zustand, die serielle Ausgabe bricht ab und das Board verharrt so, bis du den Reset-Taster drückst. Da Ursachen und Lösungen verschieden sind, finde zuerst heraus, welcher Fall bei dir vorliegt. Am einfachsten fügst du in setup() eine Zeile Serial.println("GESTARTET") ein und lässt den seriellen Monitor offen.

Warum startet der Arduino von selbst neu? Die Reset-Quellen

Nur wenige Quellen können den ATmega328P auf dem Arduino Uno und Nano neu starten, und jede hat ihren eigenen Auslöser. Fällt die Versorgungsspannung unter eine bestimmte Schwelle, greift der Brown-out-Detektor (BOD) ein; beim Uno und Nano liegt diese Schwelle durch die Fuse-Einstellungen bei 2,7 V. Alles, was den RESET-Pin auf LOW zieht, startet das Board ebenfalls neu: der Reset-Taster, das DTR-Signal des Computers oder Störungen, die ein langes Kabel an diesem Pin einfängt. Dazu kommt ein Fall, der wie ein Reset aussieht, aber keiner ist: Durch beschädigten Speicher springt das Programm an Adresse 0 und beginnt von vorne, doch weil die Hardware-Einheiten nicht zurückgesetzt werden, verhält sich das Board seltsam.

Servo-, Motor- und Relaisstrom: wie ein Spannungseinbruch den Reset auslöst

Ein SG90-Servo zieht in Bewegung 100–250 mA, beim Anlaufen und unter Last am Arm springt der Strom aber über 0,5 A. Ein USB-2.0-Port liefert höchstens 500 mA, und die Sicherung in der USB-Leitung des Uno arbeitet an derselben Grenze. Überschreiten Servo, die 50 mA des Boards und ein paar Module diese Grenze, begrenzt der Port oder die Sicherung den Strom, die 5-V-Leitung bricht kurz ein, und sinkt die Spannung unter 2,7 V, setzt der BOD das Board zurück. Tückischer ist der Fall, dass die Spannung zwischen 2,7 V und etwa 3,8 V bleibt: Laut Datenblatt braucht der ATmega328P rund 3,8 V, um bei 16 MHz sicher zu laufen. In dieser Grauzone greift der BOD nicht, aber der Prozessor arbeitet außerhalb seiner Taktgrenze; das Board kann sich deshalb aufhängen statt neu zu starten, unsinnige Werte liefern, oder I2C-Displays und Sensoren verriegeln sich intern.

Auch die Kabel zählen. Die dünnen Jumperkabel in Steckbrett-Projekten haben meist 26–28 AWG, und Kupferdraht mit 28 AWG hat etwa 0,21 Ω pro Meter. Versorgst du den Servo über zwei 20-cm-Kabel (hin und zurück 0,4 m) und ein Steckbrett, kommen durch die Kabel etwa 0,085 Ω und durch vier Steckkontakte zusammen rund 0,2 Ω hinzu. Nach dem ohmschen Gesetz (U = I × R) gehen bei einem Servo-Stromstoß von 1 A an diesen 0,29 Ω etwa 0,3 V verloren. Ein dünnes, langes USB-Kabel, die Sicherung und die Schutzbauteile auf dem Board bringen zusammen noch einmal rund ein halbes Ohm; beim selben Stromstoß sinkt die 5-V-Leitung des Arduino unter 4,5 V, und wenn der USB-Port den Strom begrenzt, wird der Einbruch noch viel tiefer. Den Spannungsabfall in deiner eigenen Schaltung berechnest du mit dem Rechner für das ohmsche Gesetz.

Lösung 1: Getrennte Stromversorgung und gemeinsame Masse

1. Wähle für Servos und Motoren eine eigene Quelle: für Servos ein 5–6-V-Netzteil mit mindestens 1 A pro Servo (2–3 A für einen MG996R), einen 4×AA-NiMH-Akkupack oder ein auf 5–6 V eingestelltes LM2596-Step-down-Modul.
2. Verbinde den Pluspol der Quelle nur mit den roten Servoleitungen oder dem Leistungseingang des Motortreibers; diese Leitung kommt nicht an den 5V-Pin des Arduino.
3. Verbinde den Minuspol (GND) der Quelle sowohl mit der Last als auch mit dem GND-Pin des Arduino. Ohne diese gemeinsame Masse hat die Spannung am Signalpin keinen Bezug; der Servo zittert oder bewegt sich gar nicht.
4. Führe die GND-Leitungen an einem einzigen Punkt neben der Quelle zusammen (sternförmige Masse). Der Motorstrom darf nicht über den Arduino und seine Masseleiterbahnen zurückfließen, sonst springt die Masse des Arduino bei jedem Motorstoß.
5. Versorge den Arduino über seinen eigenen Eingang: USB, die DC-Buchse (7–12 V) oder geregelte 5 V. So bleibt der Prozessor stabil, selbst wenn die Servoversorgung einbricht.
6. Miss zum Schluss, während sich der Servo bewegt, zwischen 5V und GND des Arduino oder lass den Diagnose-Sketch unten laufen; die Spannung sollte nicht unter 4,75 V fallen.

Lösung 2: Kondensator (100–470 µF) und Diode

Ein Elektrolytkondensator wirkt wie ein kleiner Energiespeicher direkt an der Last: Verlangt der Servo plötzlich Strom, liefert ihn der Kondensator, bis Kabel und Netzteil nachkommen. Wie viel er hilft, zeigt die Formel ΔU = I × Δt / C. Ein 470-µF-Kondensator lässt die Spannung bei einem Stromstoß von 1 A und 100 µs Dauer nur um 0,21 V sinken; dauert derselbe Stoß 1 ms, sind es 2,1 V. Ein Kondensator schluckt also kurze Spitzen und das Bürstenfeuer von Motoren, ersetzt aber kein zu schwaches Netzteil. Setze 470–1000 µF an die Servoleitung und 100 µF zwischen 5V und GND des Arduino, und ergänze jeweils einen 100-nF-Keramikkondensator mit dem Aufdruck 104 gegen hochfrequente Störungen. Den Aufdruck entschlüsselst du mit dem Werkzeug Kondensator-Code, die Summe parallel geschalteter Kondensatoren mit dem Rechner Kondensatornetzwerk; die Unterschiede der Bauarten erklärt Was ist ein Kondensator?.

Relaisspulen, Motoren und Hubmagnete sind Induktivitäten. Wird der Strom durch sie plötzlich unterbrochen, wehrt sich die Spule gegen die Änderung und erzeugt an ihren Anschlüssen eine kurze Spannungsspitze von Dutzenden oder sogar Hunderten Volt, weit über der Versorgungsspannung. Diese Spitze breitet sich auf der Leitung aus, setzt den Arduino zurück und kann auch den Treibertransistor oder den Pin zerstören. Die Lösung ist eine Freilaufdiode, die in Sperrrichtung parallel zur Spule geschaltet wird: Das Ende mit dem Kathodenring einer 1N4007 kommt an Plus, das andere Ende an die Seite, die zum Transistor führt. Fertige Relaismodule haben diese Diode bereits; bei einem nackten Relais, einem Hubmagneten oder einem Motor, den du mit Transistor oder MOSFET schaltest, musst du sie selbst einbauen. Bei Motoren mit PWM-Drehzahlregelung arbeitet die schnellere Schottky-Diode 1N5819 besser. Mehr dazu in Was ist eine Diode? und MOSFET mit Arduino verwenden.

Störungen, Relaiskontakte und lange Kabel

Startet das Board genau in dem Moment neu, in dem ein Relais abfällt, liegt kein Versorgungs-, sondern ein Störproblem vor. Schaltet ein Relais eine Wasserpumpe, einen Lüfter, eine Leuchtstofflampe oder ein Schütz ab, entsteht zwischen den Kontakten ein kleiner Lichtbogen, der breitbandige elektromagnetische Störungen abstrahlt. Diese koppeln in nahe Sensorkabel, die RESET-Leitung und die I2C-Leitungen ein, setzen den Prozessor zurück oder blockieren ein Modul. Verwende dagegen ein Relaismodul mit Optokoppler, ziehe den JD-VCC-Jumper ab und versorge die Relaisspulen aus einer eigenen 5-V-Quelle; so bleiben Spulenstrom und Störungen von der Versorgung des Arduino fern. Bei induktiven Lasten am Stromnetz unterdrückt ein RC-Snubber (100 Ω + 100 nF, Klasse X2) oder ein Varistor über den Kontakten oder der Last den Lichtbogen stark. Die Verdrahtung findest du in Was ist ein Relaismodul?, das Prinzip der galvanischen Trennung in Was ist ein Optokoppler?.

• I2C kurz halten: I2C wurde für kurze Strecken auf einer Platine entwickelt. Halte SDA und SCL unter 50 cm; bei längeren Leitungen senke die Pull-up-Widerstände von 4,7 kΩ auf 2,2 kΩ und bleib bei 100 kHz.
• Verdrillte Leitungen: Verdrille jede Signalleitung mit einer GND-Leitung; die verdrillten Adernpaare eines Netzwerkkabels sind dafür ideal.
• Leistung und Signal trennen: Verlege Sensorkabel nicht parallel zu Motor-, Relais- oder Netzleitungen; wenn sie sich kreuzen müssen, dann im rechten Winkel.
• RESET-Pin frei lassen: Ein langes Kabel am RESET-Pin wirkt wie eine Antenne und setzt das Board zurück, wenn du es berührst oder ein Motor in der Nähe läuft. Brauchst du einen externen Reset-Taster, halte das Kabel kurz.
• Ferrit und Gehäuse: Ferritringe an Motorleitungen und ein Metallgehäuse verringern hochfrequente Störungen.
• Timeout setzen: Blockieren Störungen den I2C-Bus, wartet die Wire-Bibliothek standardmäßig endlos und das Board hängt. Der folgende Code verhindert das mit einem Timeout.

1#include <Wire.h>
2
3const uint8_t ADDR = 0x27;   // örnek: I2C LCD adresi / example: I2C LCD address
4
5void setup() {
6  Serial.begin(9600);
7  Wire.begin();
8  Wire.setWireTimeout(25000, true);   // 25 ms; takılırsa I2C birimini sıfırla / reset the I2C unit on timeout
9}
10
11void loop() {
12  Wire.beginTransmission(ADDR);
13  byte err = Wire.endTransmission();  // 0 = cihaz cevap verdi / 0 = device answered
14
15  if (Wire.getWireTimeoutFlag()) {    // hat kilitlendi ama program donmadı / bus hung, sketch did not freeze
16    Serial.println(F("I2C zaman asimi / I2C timeout"));
17    Wire.clearWireTimeoutFlag();
18  } else if (err != 0) {
19    Serial.print(F("I2C hatasi / I2C error: "));
20    Serial.println(err);              // 2 = cihaz yok, 5 = zaman aşımı / 2 = no device, 5 = timeout
21  }
22  delay(1000);
23}

RAM-Überlauf und die Verwendung von String

Der Arduino Uno hat nur 2 KB SRAM, und diesen kleinen Platz teilen sich globale Variablen, der dynamische Speicher (Heap) und der Stack, den Funktionsaufrufe nutzen. Siehst du am Ende des Kompilierens die Warnung Low memory available, stability problems may occur., stürzt das Board sehr wahrscheinlich nach einer Weile ab. Die heimtückischste Ursache ist die Klasse String: Jede Verkettung belegt ein neues Stück auf dem Heap, das alte wird freigegeben, und mit der Zeit ist der Speicher voller Lücken. Irgendwann stößt der Stack an den Heap, und das Programm startet in einem zufälligen Moment neu oder hängt. Da das meist erst nach Minuten oder Stunden auftritt, lässt es sich leicht von Versorgungsproblemen unterscheiden. Lass konstante Texte mit dem Makro F() im Flash, nutze char-Arrays fester Größe und snprintf() statt String und lege in Funktionen keine großen lokalen Arrays an. Der folgende Code gibt jede Sekunde den freien RAM aus; sinkt der Wert stetig, gibt es ein Speicherleck. Alles Weitere steht in Arduino-Speicher voll.

1extern int __heap_start, *__brkval;
2
3// Heap ile stack arasındaki boş RAM / free RAM between heap and stack
4int freeRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9char line[32];             // sabit tampon, bir kez ayrılır / fixed buffer, allocated once
10unsigned long counter = 0;
11
12void setup() {
13  Serial.begin(9600);
14}
15
16void loop() {
17  counter++;
18  // Kaçın / avoid: String s = "Sayac: " + String(counter) + " sn";
19  snprintf(line, sizeof(line), "Sayac: %lu sn", counter);  // heap kullanmaz / no heap use
20  Serial.println(line);
21
22  Serial.print(F("Bos RAM / free RAM: "));  // F(): metin flaşta kalır / text stays in flash
23  Serial.println(freeRam());                // sürekli azalıyorsa sızıntı var / steady drop = leak
24  delay(1000);
25}

Watchdog: der Sicherheitsgurt gegen Hänger

Der Watchdog ist ein Zähler im Prozessor, der mit seinem eigenen 128-kHz-Oszillator unabhängig läuft. Dein Programm muss ihn regelmäßig mit wdt_reset() zurücksetzen; geschieht das nicht innerhalb der eingestellten Zeit (zwischen 15 ms und 8 Sekunden), setzt der Watchdog das Board zurück. So kann ein blockierter I2C-Bus, eine Funktion in einer Endlosschleife oder ein durch Störungen verfälschter Sensorwert das Board nicht für immer einfrieren; es fängt sich nach wenigen Sekunden. Denk daran, dass der Watchdog ein Sicherheitsgurt und keine Reparatur ist: Er behebt keine Versorgungs- oder Speicherprobleme, sondern lässt ein Projekt im Feld nur von selbst wieder anlaufen. Wähle die Zeit deutlich länger als die längste Operation in deinem Code; mit delay(3000) im Code setzt ein 2-Sekunden-Watchdog das Board immer wieder zurück.

1#include <avr/wdt.h>
2
3const int LED_PIN = 13;
4
5void setup() {
6  MCUSR = 0;          // reset bayraklarını temizle / clear reset flags
7  wdt_disable();      // açılışta watchdog kapalı / watchdog off during startup
8  Serial.begin(9600);
9  pinMode(LED_PIN, OUTPUT);
10  Serial.println(F("Basladi / started"));
11  delay(500);
12  wdt_enable(WDTO_2S);  // 2 sn içinde beslenmezse reset / reset if not fed within 2 s
13}
14
15void loop() {
16  digitalWrite(LED_PIN, !digitalRead(LED_PIN));
17  delay(250);
18
19  // Seri Monitör'den 'x' gönder: takılmayı taklit eder / send 'x' to simulate a hang
20  if (Serial.available() && Serial.read() == 'x') {
21    Serial.println(F("Sonsuz donguye girildi / stuck in a loop"));
22    while (true) {}     // wdt_reset() yok: 2 sn sonra reset / no wdt_reset(): reset after 2 s
23  }
24
25  wdt_reset();          // her turda besle / feed it every loop
26}

Diagnose-Sketch: Der Arduino misst seine eigene Spannung und seinen RAM

Ein Multimeter ist zu träge, um Spannungseinbrüche im Millisekundenbereich zu sehen. Stattdessen kannst du den Arduino selbst als einfaches Messgerät nutzen: Der folgende Code misst mit dem ADC die interne 1,1-V-Referenz des Chips, berechnet daraus etwa 9000-mal pro Sekunde die Versorgungsspannung und gibt den niedrigsten Wert jeder Sekunde aus. Außerdem erhöht er bei jedem Start einen Zähler im EEPROM, sodass du auch beim späteren Öffnen des seriellen Monitors siehst, wie oft das Board neu gestartet ist. Als Testlast bewegt er den Servo an D9 alle 2 Sekunden zwischen 0 und 180 Grad; hast du ein eigenes Projekt, kannst du den Messteil in dessen Code übernehmen. Öffne den seriellen Monitor mit 115200 Baud.

1// Reset teşhis kodu (Uno, Nano) / reset diagnostic sketch (Uno, Nano)
2#include <EEPROM.h>
3#include <Servo.h>
4
5Servo servo;
6extern int __heap_start, *__brkval;
7
8int freeRam() {
9  int v;
10  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
11}
12
13// Besleme gerilimini dahili 1,1 V referansla ölç / measure supply voltage against the internal 1.1 V reference
14long readVcc() {
15  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
16  ADCSRA |= _BV(ADSC);                  // ölçümü başlat / start a conversion
17  while (bit_is_set(ADCSRA, ADSC)) {}   // bitmesini bekle / wait until it is done
18  return 1125300L / ADC;                // 1100 mV × 1023 / okuma → mV / reading → mV
19}
20
21long minVcc = 9999;
22unsigned long lastPrint = 0, lastMove = 0;
23bool sideA = false;
24
25void setup() {
26  Serial.begin(115200);
27  uint16_t boots;
28  EEPROM.get(0, boots);                 // açılış sayacı / boot counter
29  if (boots == 0xFFFF) boots = 0;       // boş EEPROM / blank EEPROM
30  EEPROM.put(0, ++boots);
31  Serial.print(F("BASLADI / STARTED  acilis no / boot #"));
32  Serial.println(boots);
33
34  servo.attach(9);                      // test yükü: servo D9'da / test load: servo on D9
35  readVcc();                            // ilk ölçümü at / discard the first reading
36  delay(5);
37}
38
39void loop() {
40  long v = readVcc();                   // saniyede ~9000 ölçüm / ~9000 samples per second
41  if (v < minVcc) minVcc = v;
42
43  if (millis() - lastMove >= 2000) {    // 2 sn'de bir servoyu oynat / move the servo every 2 s
44    lastMove = millis();
45    sideA = !sideA;
46    servo.write(sideA ? 180 : 0);
47  }
48
49  if (millis() - lastPrint >= 1000) {
50    lastPrint = millis();
51    Serial.print(F("sn/s: "));
52    Serial.print(millis() / 1000);
53    Serial.print(F("  min Vcc (mV): "));
54    Serial.print(minVcc);
55    Serial.print(F("  bos RAM / free RAM: "));
56    Serial.println(freeRam());
57    minVcc = 9999;                      // her saniye sıfırla / reset every second
58  }
59}

So liest du die Ergebnisse: Bei einem gesunden Uno an USB bleibt der niedrigste Wert zwischen 4,6 und 5,1 V. Fällt er bei jeder Servobewegung unter 4,5 V und fallen die Resets mit diesen Momenten zusammen, liegt das Problem bei der Versorgung. Steigt die Startnummer, obwohl die Spannung stabil bleibt, such die Ursache bei Störungen oder in der Software; sinkt dabei der freie RAM immer weiter, hast du ein Speicherleck. Die interne 1,1-V-Referenz kann von Chip zu Chip um etwa 10 % abweichen; vergleiche die Messung deshalb einmal mit einem Multimeter: Zeigt das Multimeter 4,95 V und der Code 5,10 V, ändere die Konstante 1125300 auf 1125300 × 4,95 / 5,10 ≈ 1092200. Entferne den EEPROM-Zähler nach der Diagnose wieder aus dem Code; EEPROM-Zellen halten etwa 100.000 Schreibvorgänge aus.

Schritt-für-Schritt-Tabelle: Symptom, Ursache, Lösung

Lies die Tabelle von oben nach unten; die ersten Zeilen sind die häufigsten Ursachen. Ändere immer nur eine Sache und lass den Diagnose-Sketch erneut laufen. Änderst du drei Dinge gleichzeitig, weißt du nicht, welche das Problem gelöst hat, und derselbe Fehler begegnet dir im nächsten Projekt wieder.

USB-Port liefert zu wenig Strom und Reset durch den seriellen Monitor

Ein USB-2.0-Port liefert 500 mA, ein USB-3.0-Port 900 mA; da die USB-Sicherung des Uno aber bei 500 mA begrenzt, bringt dir ein USB-3.0-Port keinen zusätzlichen Strom. Ein passiver USB-Hub teilt den Strom eines Ports auf alle Geräte auf, Frontanschlüsse verlieren über dünne interne Kabel Spannung, und Laptops im Akkubetrieb versorgen ihre Ports im Energiesparmodus mitunter schwach. Stecke das Board direkt in einen hinteren Port, mit einem kurzen, hochwertigen Kabel. Es gibt auch einen Reset, der kein Fehler ist: Uno und Nano setzen sich über das DTR-Signal zurück, wenn der serielle Monitor oder ein Python-Programm den Port öffnet; genau diese Funktion macht das Hochladen möglich. Kommunizierst du aus Python, warte nach dem Öffnen des Ports 2 Sekunden (Arduino und Python über die serielle Schnittstelle). Willst du den Reset ganz abschalten, setze einen 10-µF-Kondensator zwischen RESET und GND und entferne ihn zum Hochladen. Details zur seriellen Schnittstelle findest du in Arduino Serial Monitor.

ESP32 startet ständig neu: den Reset-Grund auslesen

Der ESP32 reagiert noch empfindlicher auf dieselben Probleme, weil er mit 3,3 V arbeitet und beim WLAN-Senden etwa 240 mA zieht, in kurzen Spitzen mehr; Espressif empfiehlt eine Quelle, die mindestens 500 mA liefert. Das Gute: Der ESP32 sagt dir selbst, warum er neu gestartet ist. Die Meldung Brownout detector was triggered im seriellen Monitor bedeutet einen Spannungseinbruch, und die Zeilen rst:0xf (RTCWDT_BROWN_OUT_RESET) oder Guru Meditation Error beim Start nennen den Reset-Grund. Der folgende Code liest dieselbe Information mit esp_reset_reason() aus und übersetzt sie in lesbaren Text. Beim ESP32 schaltet die EN-Taste den Chip komplett aus und wieder ein, deshalb erscheint ein Reset über diese Taste ebenfalls als Einschalten. Alle Meldungen und ihre Lösungen findest du in ESP32: Brownout und Guru Meditation Error.

1#include <esp_system.h>
2
3// Reset sebebini yazıya çevir / turn the reset reason into text
4const char* reasonText(esp_reset_reason_t r) {
5  switch (r) {
6    case ESP_RST_POWERON:   return "Guc acilisi ya da EN tusu / power-on or EN button";
7    case ESP_RST_SW:        return "Yazilimla (ESP.restart) / software restart";
8    case ESP_RST_PANIC:     return "Cokme (Guru Meditation) / panic";
9    case ESP_RST_INT_WDT:   return "Kesme watchdog'u / interrupt watchdog";
10    case ESP_RST_TASK_WDT:  return "Gorev watchdog'u / task watchdog";
11    case ESP_RST_WDT:       return "Diger watchdog / other watchdog";
12    case ESP_RST_DEEPSLEEP: return "Derin uykudan uyanma / deep sleep wake-up";
13    case ESP_RST_BROWNOUT:  return "Gerilim dusmesi (brownout) / brownout";
14    default:                return "Bilinmeyen / unknown";
15  }
16}
17
18void setup() {
19  Serial.begin(115200);
20  delay(500);
21  esp_reset_reason_t r = esp_reset_reason();
22  Serial.print("Reset nedeni / reset reason: ");
23  Serial.println(reasonText(r));
24}
25
26void loop() {
27  Serial.print("Calisma suresi / uptime (s): ");
28  Serial.println(millis() / 1000);
29  delay(5000);
30}

Raspberry Pi Pico: Reset-Grund und Watchdog (MicroPython)

Dank seines Buck-Boost-Reglers läuft der Raspberry Pi Pico mit jeder Spannung zwischen 1,8 und 5,5 V am VSYS-Pin und verkraftet Spannungseinbrüche daher besser als ein Arduino. Hängst du einen Servo aber an den VBUS-Pin, der die USB-5-V führt, kommt der Strom direkt aus dem Port des Computers, und bricht der Port ein, geht auch der Pico aus; am 3V3-Pin solltest du insgesamt nicht mehr als 300 mA entnehmen. Der Reset-Pin des Pico, RUN, wird über einen chipinternen Widerstand von etwa 50 kΩ hochgezogen; ein langes Kabel daran öffnet Störungen die Tür, genau wie der RESET-Pin beim Arduino. In MicroPython liefert machine.reset_cause() auf dem Pico nur zwei Werte: PWRON_RESET für Einschalten oder den RUN-Pin und WDT_RESET für den Watchdog oder machine.reset(). Der Watchdog lässt sich auf höchstens 8388 ms einstellen und nach dem Start nicht mehr anhalten; er setzt das Board auch dann weiter zurück, wenn du das Programm in Thonny stoppst. Baue deshalb am Anfang deines Codes eine Wartezeit von 3 Sekunden ein.

1import machine, time
2from machine import Pin
3
4time.sleep(3)   # Thonny durdurabilsin diye bekle / wait so Thonny can stop the script
5
6neden = machine.reset_cause()
7if neden == machine.WDT_RESET:
8    print("Watchdog ya da machine.reset() / watchdog or machine.reset()")
9else:
10    print("Guc acilisi ya da RUN pini / power-on or RUN pin")
11
12led = Pin("LED", Pin.OUT)          # Pico ve Pico W dahili LED / onboard LED
13wdt = machine.WDT(timeout=5000)    # 5 sn; RP2040'ta en fazla 8388 ms / max 8388 ms on RP2040
14
15sayac = 0
16while True:
17    led.toggle()
18    sayac += 1
19    print("Calisiyor / running", sayac)
20    wdt.feed()                     # her turda besle / feed it every loop
21    time.sleep(1)

Die richtige Stromversorgung für dein Projekt

• Roboterauto: Versorge die Motoren über einen L298N oder L9110S aus einem 2S-18650-Pack und setze einen 100-nF-Kondensator an die Motoranschlüsse; den Aufbau zeigt Arduino-Roboterauto bauen.
• Roboterarm mit Servos: Für vier oder mehr Servos brauchst du eine 5–6-V-Quelle mit mindestens 3–5 A und 1000 µF an der Servoleitung; zur Auswahl siehe MG996R-Servo und Arduino-Roboterarm.
• Bewässerung mit Pumpe und Relais: Versorge die Pumpe getrennt, trenne das Relais über JD-VCC und halte lange Sensorkabel vom Pumpenkabel fern (Bodenfeuchtesensor).
• LED-Streifen und NeoPixel: Rechne mit etwa 2 A pro 30 LEDs, setze 1000 µF an den Streifeneingang und einen 300–500-Ω-Widerstand in die Datenleitung (WS2812B NeoPixel).
• Gleichstrommotoren ansteuern: Vergiss die Freilaufdiode an keinem Motor, den du mit Transistor oder MOSFET schaltest; zu fertigen Treiberplatinen siehe Gleichstrommotor mit L298N steuern.
• Sensorstation im Außeneinsatz: Aktiviere den Watchdog, setze einen I2C-Timeout und versorge alles über eine effiziente Quelle wie den LM2596-Step-down-Wandler.

Ein Arduino, der sich selbst zurücksetzt, ist ärgerlich, doch fast immer steckt eine messbare und behebbare Ursache dahinter: Erkenne zuerst das Symptom, miss dann Spannung und RAM mit dem Diagnose-Sketch, trenne die Versorgung, verbinde die Massen, ergänze Kondensator und Diode und sichere das Projekt bei Bedarf mit dem Watchdog ab. Steht dieser Aufbau einmal, laufen deine Projekte mit Servos, Motoren und Relais tagelang ohne Probleme. In der BlueGrays-App findest du Servosteuerung, ein Bluetooth-Auto mit L298N, einen Hindernis ausweichenden Roboter, die Steuerung einer 230-V-Lampe und eine intelligente Bewässerungsstation, jeweils mit Schaltplänen, die die richtige Stromversorgung zeigen, und Schritt-für-Schritt-Code.