Gidsen · 16 min leestijd

Arduino reset steeds? Los problemen met servo, relais en vastlopen op

Arduino reset of loopt vast? Los het stap voor stap op: servo- en relaisstroom, spanningsdips, gemeenschappelijke GND, condensatoren van 470 µF, vol RAM en de watchdog.

Als je Arduino steeds reset of na een tijdje vastloopt, is het board bijna nooit kapot. Meestal ligt het aan de voeding: als een servo gaat bewegen, een motor aanloopt of een relais aantrekt, zakt de 5 V-lijn door de plotselinge stroomvraag even in en herstart de laagspanningsbeveiliging (brown-out) van de processor het board. In de overige gevallen is de oorzaak elektrische ruis van relais en motoren, lange draden, een vol RAM, een vergeten watchdog of een USB-poort van de computer die te weinig stroom kan leveren.

In deze gids leer je eerst vast te stellen of het board echt reset of alleen vastloopt. Daarna leggen we uit hoe elke oorzaak werkt, met echte stroom- en spanningswaarden, en laten we de oplossingen met code zien: aparte voeding en een gemeenschappelijke GND, condensatoren van 100–470 µF, vrijloopdiodes, vaste buffers in plaats van String en de watchdog. Je vindt ook een diagnosesketch die de eigen voedingsspanning en het vrije RAM van de Arduino meet, een stapsgewijze tabel om problemen op te lossen van symptoom tot oplossing, en voorbeelden die de resetreden op de ESP32 en de Raspberry Pi Pico uitlezen.

Arduino Uno R3-board
Arduino Uno R3: de 5 V van USB loopt via een herstelbare zekering van 500 mA. Als het board reset, start het programma opnieuw vanaf setup(); de RESET-knop en de RESET-pin doen hetzelfde.

Reset of vastlopen? Bepaal eerst het symptoom

Een Arduino die reset voert het programma helemaal opnieuw uit, alsof je de USB-kabel eruit en er weer in hebt gestoken: setup() draait opnieuw, de servo gaat terug naar zijn beginhoek, de LCD toont weer de starttekst en de startmelding verschijnt opnieuw in de Serial Monitor. Een Arduino die vastloopt reageert daarentegen nergens op; de leds blijven in hun laatste stand, de seriële uitvoer stopt en het board blijft zo wachten tot je op de resetknop drukt. Omdat de oorzaken en oplossingen verschillen, ga je eerst na welk geval het is. Dat doe je het makkelijkst door een regel Serial.println("STARTED") aan setup() toe te voegen en de Serial Monitor open te laten.

SymptoomResetVastlopen
Draait setup() opnieuw?Ja, de startmelding verschijnt opnieuwNee
Seriële uitvoerStopt en begint dan opnieuw met de startmeldingStopt en komt nooit meer terug
Uitgangen en ledsGaan kort uit en keren terug naar hun beginstandBlijven in hun laatste stand hangen
Meest voorkomende oorzaakSpanningsdip, ruis, watchdogOneindige lus, vastgelopen I2C-bus, beschadigd RAM
Controleer eerstVoeding, GND en bedradingCode, geheugengebruik en sensorbedrading

Waarom reset een Arduino zichzelf? Resetbronnen

Slechts een paar bronnen kunnen de ATmega328P-processor op de Arduino Uno en Nano herstarten, en elke bron heeft zijn eigen trigger. Als de voedingsspanning onder een bepaalde drempel zakt, springt de brown-out-detector (BOD) in actie; op de Uno en Nano leggen de fuse-instellingen deze drempel op 2,7 V. Alles wat de RESET-pin LAAG trekt, herstart het board ook: de resetknop, het DTR-signaal van de computer of ruis die wordt opgevangen door een lange draad aan die pin. Er is ook een geval dat op een reset lijkt maar er geen is: beschadigd geheugen laat het programma naar adres 0 springen en de code begint opnieuw, maar doordat de hardware-randapparatuur niet wordt gereset, gaat het board zich vreemd gedragen.

ResetbronWat veroorzaakt het?Typisch symptoom
Power-on (POR)Kabel insteken, voeding valt helemaal wegNormale start
Externe reset (RESET-pin)Resetknop, openen van de Serial Monitor (DTR), ruis op de RESET-pinHerstart als de poort wordt geopend of een draad wordt aangeraakt
Brown-out (BOD, 2,7 V)Inschakelstroom van een servo, motor, relais of ledstrip, een zwakke batterijReset op het moment dat de belasting beweegt
Watchdogwdt_reset() is niet op tijd aangeroepenReset met vaste tussenpozen (bijvoorbeeld precies elke 2 seconden)
SoftwarecrashArray buiten bereik, RAM vol, foute pointerWillekeurige reset of vastlopen na minuten of uren

Stroom van servo, motor en relais: hoe een spanningsdip een reset veroorzaakt

Een SG90-servo neemt tijdens het bewegen 100–250 mA op, maar bij het opstarten en als zijn arm belast wordt, springt de stroom boven 0,5 A. De USB 2.0-poort van een computer levert maximaal 500 mA, en de zekering op de USB-lijn van de Uno werkt met dezelfde grens. Als de servo, de eigen 50 mA van het board en een paar modules deze grens overschrijden, beperkt de poort of de zekering de stroom, zakt de 5 V-lijn even in, en als de spanning onder 2,7 V komt, reset de BOD het board. Het gemenere geval is dat de spanning tussen 2,7 V en ongeveer 3,8 V blijft hangen: volgens de datasheet van de ATmega328P heeft de chip ongeveer 3,8 V nodig om veilig op 16 MHz te draaien. In dit grijze gebied springt de BOD niet aan, maar draait de processor buiten zijn snelheidsgrens, waardoor het board kan vastlopen in plaats van te resetten, rommelwaarden kan opleveren, of I2C-displays en -sensoren intern kunnen vastlopen.

BelastingNormale stroomPiekstroomVoeden via de 5V-pin van de Uno?
SG90-microservo100–250 mA0,5 A en meer (aanloop, belasting)Alleen één servo met een lichte belasting
MG996R servo0,5–0,9 ATot 2,5 ANee, een aparte voeding van 5–6 V is een must
TT-gelijkstroommotor met tandwielkast70–250 mA~1 A (aanloop, blokkeren)Nee, motordriver en aparte voeding
5V-relaismodule (enkelkanaals)70–90 mAKorte puls als de spoel bekrachtigd wordt1–2 kanalen ja, 4 of meer via een aparte voeding
WS2812B-led (per led)~20 mA (één kleur op volle helderheid)60 mA (volledig wit)Nee; 30 leds op volledig wit vragen 1,8 A

Ook draden doen ertoe. De dunne jumperdraden die je in breadboardprojecten gebruikt, zijn meestal 26–28 AWG, en koperdraad van 28 AWG heeft een weerstand van ongeveer 0,21 Ω per meter. Als je de servo voedt via twee draden van 20 cm (0,4 m heen en terug) en een breadboard, voegen de draden ongeveer 0,085 Ω toe en vier breadboardcontacten samen ongeveer 0,2 Ω. Volgens de wet van Ohm (V = I × R) verliest een servopuls van 1 A over deze 0,29 Ω ongeveer 0,3 V. Een dunne, lange USB-kabel, de zekering en de beveiligingsonderdelen op het board voegen er grofweg nog een halve ohm bij; tijdens dezelfde puls zakt de 5 V-lijn van de Arduino onder 4,5 V, en als de computerpoort de stroom gaat beperken, is de dip veel dieper. Je kunt de dip in je eigen schakeling berekenen met de rekenmachine voor de wet van Ohm.

Voed maximaal één SG90-servo met een lichte belasting via de 5V-pin van de Uno. Sluit grote servo's zoals de MG996R, gelijkstroommotoren of ledstrips nooit aan op de 5V- of 3.3V-pin van de Arduino: het board gaat resetten en op de lange termijn kunnen de USB-zekering, de regelaar en zelfs de USB-poort van je computer beschadigd raken.

Oplossing 1: aparte voeding en gemeenschappelijke GND

  1. Kies een aparte voeding voor servo's en motoren: voor servo's een adapter van 5–6 V die minstens 1 A per servo levert (2–3 A voor een MG996R), een pakket van 4×AA NiMH of een LM2596-buckmodule ingesteld op 5–6 V.
  2. Verbind de plus van de voeding alleen met de rode draden van de servo's of met de voedingsingang van de motordriver; sluit deze lijn niet aan op de 5V-pin van de Arduino.
  3. Verbind de min (GND) van de voeding zowel met de belasting als met de GND-pin van de Arduino. Zonder deze gemeenschappelijke GND heeft de spanning op de signaalpin geen referentie; de servo trilt of beweegt helemaal niet.
  4. Verbind de GND's op één punt naast de voeding (sterpuntmassa). De motorstroom mag niet via de Arduino en zijn GND-banen terugvloeien; anders verschuift het GND-niveau van de Arduino bij elke motorpuls.
  5. Voed de Arduino via zijn eigen ingang: USB, de DC-jack (7–12 V) of een gestabiliseerde 5 V. Zo blijft de processor ongemoeid, ook als de servovoeding inzakt.
  6. Meet tot slot tussen de 5V- en GND-pin van de Arduino terwijl de servo beweegt, of draai de diagnosesketch hieronder; de spanning mag niet onder 4,75 V zakken.
LM2596 step-down spanningsregelaarmodule
LM2596-buckmodule: met de trimmer zet je een hogere spanning, zoals van een 12V-adapter of een 2S li-ionpakket, om naar 5–6 V. Het is de handigste manier om een servovoedingslijn te bouwen die los staat van de Arduino. Stel de uitgang in met een multimeter voordat je de belasting aansluit.
In Wat is GND? leggen we uit waarom een gemeenschappelijke GND essentieel is en hoe sterpuntmassa werkt, en in de gids over een Arduino voeden met batterijen hoe je batterijen en adapters kiest. De regel is simpel: signaaldraden komen van de Arduino, voedingsdraden komen van de voeding, en de GND's worden verbonden.

Oplossing 2: condensatoren (100–470 µF) en diodes

Een elco werkt als een kleine energievoorraad naast de belasting: als de servo plotseling stroom vraagt, levert hij die zelf totdat de draden en de voeding het overnemen. De formule ΔV = I × Δt / C laat zien hoeveel dat helpt. Een condensator van 470 µF laat de spanning tijdens een puls van 1 A van 100 µs maar 0,21 V zakken; als dezelfde puls 1 ms duurt, is de dip 2,1 V. Een condensator slikt dus korte pulsen en de ruis van motorborstels, maar vervangt geen ontoereikende voeding. Plaats 470–1000 µF op de servolijn en 100 µF tussen de 5V en GND van de Arduino, en zet naast elk daarvan een keramische condensator van 100 nF (opdruk 104) voor hoogfrequente ruis. Gebruik de tool condensatorcode om de opdruk te lezen en de rekenmachine condensatornetwerk om het totaal van parallelle condensatoren te bepalen; de verschillen tussen de typen staan in Wat is een condensator?.

Waar?WaardeWaarom?
Servovoedingslijn, naast de servo470–1000 µF / 10–16 V elco + 100 nFDempt de aanlooppuls
Over de twee aansluitingen van een gelijkstroommotor100 nF keramischFiltert de ruis van borstelvonken
Tussen 5V en GND van de Arduino100 µF elco + 100 nFBeschermt de voedingslijn van de processor tegen korte dips
Ingang van de WS2812B-strip1000 µF / 10 VVangt de inschakelstroom en de pulsen bij kleurwisselingen op
Voedingspins van sensoren en modules100 nF keramischFiltert ruis die door lange draden wordt opgepikt
Elco's met verschillende waarden
Elco's: een waarde als 470 µF / 16 V is ideaal voor een 5V-servolijn. De streep op de behuizing markeert het negatieve (−) pootje; de spanningswaarde moet minstens twee keer de lijnspanning zijn.

Relaisspoelen, motoren en solenoïdes zijn allemaal spoelen. Als de stroom erdoor plotseling wordt onderbroken, verzet de spoel zich tegen de verandering en geeft hij een korte spanningspiek van tientallen of zelfs honderden volts af, ver boven de voedingsspanning. Deze piek verspreidt zich over de lijn en reset de Arduino, en kan ook de drivertransistor of de pin vernielen. De oplossing is een vrijloopdiode parallel aan de spoel, in sperrichting: het kathode-uiteinde met de streep van een 1N4007 gaat naar de plus, het andere uiteinde naar de kant die naar de transistor loopt. Kant-en-klare relaismodules bevatten deze diode al; als je een los relais, een solenoïde of een motor gebruikt die door een transistor of MOSFET wordt aangestuurd, moet je de diode zelf toevoegen. Bij motoren met PWM-toerenregeling geeft de snellere 1N5819-schottkydiode betere resultaten. Zie voor details Wat is een diode? en een MOSFET gebruiken met Arduino.

1N4007-gelijkrichterdiode
1N4007-diode: de grijze streep op de behuizing is het kathode-uiteinde (−). In sperrichting over een spoel aangesloten sluit hij de spanningspiek kort die ontstaat als de stroom wordt onderbroken.

Ruis, relaiscontacten en lange draden

Als het board precies reset op het moment dat een relais uitschakelt, ligt het probleem aan ruis en niet aan de voeding. Als een relais een waterpomp, ventilator, tl-lamp of contactor uitschakelt, ontstaat er een kleine vonk tussen de contacten en die vonk straalt breedbandige elektromagnetische ruis uit. De ruis koppelt in op nabijgelegen sensordraden, de RESET-lijn en de I2C-lijnen, waardoor de processor reset of een module vastloopt. Voorkom dit door een relaismodule met optocoupler te gebruiken, de JD-VCC-jumper te verwijderen en de relaisspoelen uit een aparte 5V-voeding te voeden; zo blijven de spoelstroom en de ruis weg van de voedingslijn van de Arduino. Bij inductieve netspanningsbelastingen onderdrukt een RC-snubber (100 Ω + 100 nF, X2-klasse) of een varistor over de contacten of de belasting de vonk sterk. De bedradingsdetails vind je in Wat is een relaismodule? en het idee achter isolatie in Wat is een optocoupler?.

  • Houd I2C kort: I2C is ontworpen voor korte afstanden op een printplaat. Houd de SDA- en SCL-draden onder 50 cm; verlaag bij langere stukken de pull-upweerstanden van 4,7 kΩ naar 2,2 kΩ en laat de snelheid op 100 kHz staan.
  • Gebruik getwiste draden: Twist elke signaaldraad samen met een GND-draad; de getwiste paren in een netwerkkabel zijn hier ideaal voor.
  • Scheid voeding en signaal: Leg sensordraden niet parallel aan motor-, relais- of netspanningsdraden; als ze elkaar moeten kruisen, kruis ze dan haaks.
  • Laat de RESET-pin met rust: Een lange draad aan de RESET-pin werkt als een antenne en reset het board als je hem aanraakt of als een motor in de buurt draait. Als je een externe resetknop nodig hebt, houd de draad dan kort.
  • Ferrieten en een behuizing: Ferrietringen om motordraden en een metalen behuizing verminderen hoogfrequente ruis.
  • Voeg een timeout toe: Als ruis de I2C-bus laat vastlopen, wacht de Wire-bibliotheek standaard eindeloos en loopt het board vast. De code hieronder voorkomt dit vastlopen met een timeout.
C++ (Arduino IDE)
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 vol en het gebruik van String

De Arduino Uno heeft maar 2 KB SRAM, en deze kleine ruimte wordt gedeeld door globale variabelen, dynamisch geheugen (de heap) en de stack die bij functieaanroepen wordt gebruikt. Als je aan het einde van het compileren de waarschuwing Low memory available, stability problems may occur. ziet, crasht het board waarschijnlijk na een tijdje. De gemeenste oorzaak is de klasse String: elke samenvoeging reserveert een nieuw stuk op de heap, het oude wordt vrijgegeven, en na verloop van tijd zit het geheugen vol gaten. Op een dag botst de stack met de heap en reset of loopt het programma op een willekeurig moment vast. Omdat dit meestal pas na minuten of uren optreedt, is het goed te onderscheiden van voedingsproblemen. Houd vaste tekst in flash met de macro F(), gebruik char-arrays met vaste grootte en snprintf() in plaats van String, en declareer geen grote lokale arrays binnen functies. De code hieronder print elke seconde het vrije RAM; als de waarde blijft dalen, heb je een geheugenlek. Het hele verhaal staat in Arduino heeft te weinig geheugen.

C++ (Arduino IDE)
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: een veiligheidsgordel tegen vastlopen

De watchdogtimer is een teller in de processor die onafhankelijk draait op zijn eigen oscillator van 128 kHz. Je programma moet hem regelmatig voeden met wdt_reset(); als hij niet binnen de ingestelde tijd (tussen 15 ms en 8 seconden) wordt gevoed, reset de watchdog het board. Zo kan een vastgelopen I2C-bus, een functie die in een oneindige lus zit of een door ruis beschadigde sensormeting het board niet eeuwig laten vastlopen; het herstelt binnen een paar seconden. Onthoud dat de watchdog een veiligheidsgordel is en geen reparatie: hij lost voedings- of geheugenproblemen niet op, hij laat alleen een project in het veld zichzelf herstellen. Kies een timeout die duidelijk langer is dan de langste bewerking in je code; in code met delay(3000) reset een watchdog van 2 seconden het board steeds opnieuw.

C++ (Arduino IDE)
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}
De watchdog is gevaarlijk op kloon-Nano's met de oude bootloader. Deze bootloader zet de timer na een watchdogreset niet uit; de timer blijft draaien op zijn kortste periode (ongeveer 16 ms) en de bootloader kan zijn werk in die tijd niet afmaken. Het resultaat is een eindeloze resetlus waarin je code nooit start; het board herstelt pas als je de USB-kabel eruit haalt en er weer in steekt, en de lus begint opnieuw zodra de watchdog voor het eerst afgaat. Als je board ATmega328P (Old Bootloader) onder Tools > Processor nodig heeft, brand dan de Optiboot-bootloader voordat je de watchdog gebruikt; hoe dat moet, leggen we uit in Arduino-uploadfouten. De Optiboot-bootloader van de Uno heeft dit probleem niet.

Diagnosesketch: laat de Arduino zijn eigen spanning en RAM meten

Een multimeter is te traag om spanningsdips van milliseconden te zien. In plaats daarvan kun je de Arduino zelf als eenvoudig meetinstrument gebruiken: de code hieronder gebruikt de ADC om de interne referentie van 1,1 V van de chip te meten en berekent daaruit ongeveer 9000 keer per seconde de voedingsspanning, en print elke seconde de laagste waarde. Bij elke start verhoogt de code ook een teller in het EEPROM, zodat je ook als je de Serial Monitor later opent kunt zien hoe vaak het board is herstart. Als testbelasting beweegt hij elke 2 seconden de servo op D9 tussen 0 en 180 graden; als je een eigen project hebt, kun je het meetgedeelte aan die code toevoegen. Open de Serial Monitor op 115200 baud.

C++ (Arduino IDE)
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}

Lees de resultaten zo: op een gezonde Uno die via USB wordt gevoed, blijft de laagste waarde tussen 4,6 en 5,1 V. Als de waarde telkens onder 4,5 V zakt als de servo beweegt en de resets samenvallen met die momenten, ligt het probleem aan de voeding. Als het opstartnummer blijft oplopen terwijl de spanning stabiel blijft, zoek dan naar ruis of een softwareoorzaak; als het vrije RAM tegelijk blijft afnemen, heb je een geheugenlek. De interne referentie van 1,1 V kan van chip tot chip ongeveer 10% verschillen, dus vergelijk de meting één keer met een multimeter: als de multimeter 4,95 V toont terwijl de code 5.10 V print, verander dan de constante 1125300 in 1125300 × 4.95 / 5.10 ≈ 1092200. Haal de EEPROM-teller uit de code als je klaar bent; EEPROM-cellen zijn goed voor ongeveer 100.000 schrijfacties.

Stapsgewijze tabel om problemen op te lossen: symptoom, oorzaak, oplossing

Lees de tabel van boven naar beneden; de eerste rijen zijn de meest voorkomende oorzaken. Verander telkens maar één ding en draai de diagnosesketch opnieuw. Als je drie dingen tegelijk verandert, weet je niet welke het probleem heeft opgelost, en dezelfde fout komt terug in je volgende project.

SymptoomWaarschijnlijke oorzaakZo controleer je hetOplossing
Reset als een servo of motor beweegtInschakelstroom laat de 5 V-lijn inzakkenLaagste spanning in de diagnosesketch zakt onder 4,5 VAparte voeding van 5–6 V, gemeenschappelijke GND, 470–1000 µF
Reset als een relais loslaat, niet als het aantrektContactvonk en spoelpiek (ruis)Probleem verdwijnt als de belasting van het relais wordt losgehaaldAparte voeding via JD-VCC, snubber of varistor, vrijloopdiode
Begint opnieuw als de Serial Monitor opentDTR-auto-reset (normaal gedrag)STARTED verschijnt elke keer dat de poort opentGeen fout; zo nodig 10 µF tussen RESET en GND
Reset alleen op de computer, prima op een adapterUSB-poort of hub kan niet genoeg stroom leverenVerholpen met een andere poort en een korte, dikke kabelGebruik een poort aan de achterkant of een hub met eigen voeding, voed belastingen apart
Reset bij beweging op een 9V-batterijHoge interne weerstand, spanning zakt inVin zakt tijdens beweging onder 7 V6×AA of een 2S 18650-pakket
Reset of loopt vast na minuten of urenRAM vol, String-fragmentatieHet vrije RAM blijft afnemenF(), char-arrays, snprintf, kleine lokale arrays
Reset met exact vaste tussenpozenWatchdog wordt niet op tijd gevoedResetinterval is gelijk aan de watchdogtimeoutVoeg wdt_reset() toe of verleng de timeout, vermijd lange delay()
Op een Nano start de code nooit na een watchdogresetWatchdogbug van de oude bootloaderBoard uploadt alleen met de optie Old BootloaderBrand de Optiboot-bootloader
Willekeurig vastlopen als er een lange sensorkabel is aangeslotenI2C-bus loopt vast door ruisWire-timeoutvlag is gezetKorte getwiste draden, pull-ups van 2,2 kΩ, setWireTimeout, watchdog
Reset als je je hand dichtbij brengt of het aanraaktLange draad op de RESET-pin, statische elektriciteitVerholpen als de draad wordt verwijderdHoud de RESET-lijn kort, plaats de schakeling in een behuizing
Regelaar wordt erg heet en reset danHoge stroom met 12 V op de jack, thermische uitschakeling van de regelaarRegelaar te heet om aan te rakenAdapter van 7–9 V of een 5V-buckmodule
Board krijgt geen spanning of de poort verdwijntKortsluiting, USB-zekering doorgeslagenBoard start op als de modules zijn losgehaaldZoek de kortsluiting, controleer of het board beschadigd is

USB-poort kan niet genoeg stroom leveren, en de reset van de Serial Monitor

De USB 2.0-poort van een computer levert 500 mA en een USB 3.0-poort 900 mA; maar omdat de USB-zekering van de Uno bij 500 mA beperkt, geeft een USB 3.0-poort je geen extra stroom. Een USB-hub zonder eigen voeding verdeelt de stroom van één poort over al zijn apparaten, poorten aan de voorkant verliezen spanning via dunne interne kabels, en laptops op batterij voeden hun poorten in de energiespaarstand soms zwak. Steek het board rechtstreeks in een poort aan de achterkant met een korte kabel van goede kwaliteit. Er is ook een reset die geen fout is: de Uno en Nano resetten zichzelf via het DTR-signaal als de Serial Monitor of een Python-programma de poort opent, en dat is precies de functie die uploaden mogelijk maakt. Als je vanuit Python communiceert, wacht dan 2 seconden na het openen van de poort (seriële communicatie tussen Arduino en Python). Als je de reset helemaal wilt uitschakelen, plaats dan een condensator van 10 µF tussen RESET en GND en haal hem weg als je uploadt. Details over de seriële poort staan in Arduino Serial Monitor.

ESP32 reset steeds: de resetreden uitlezen

De ESP32 is nog gevoeliger voor dezelfde problemen omdat hij op 3,3 V draait en tijdens Wi-Fi-transmissie rond 240 mA opneemt, in korte pieken meer; Espressif raadt een voeding aan die minstens 500 mA kan leveren. Het goede nieuws is dat de ESP32 zelf vertelt waarom hij herstartte. De melding Brownout detector was triggered in de Serial Monitor betekent een spanningsdip, en de regels rst:0xf (RTCWDT_BROWN_OUT_RESET) of Guru Meditation Error bij het opstarten tonen de resetreden. De code hieronder leest dezelfde informatie uit met esp_reset_reason() en maakt er leesbare tekst van. Op de ESP32 schakelt de EN-knop de chip volledig uit en aan, dus een reset met deze knop verschijnt ook als een power-on. Voor alle meldingen en hun oplossingen zie ESP32 brownout- en Guru Meditation-fouten.

C++ (Arduino IDE)
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: resetoorzaak en watchdog (MicroPython)

Dankzij zijn buck-boostregelaar draait de Raspberry Pi Pico op elke spanning tussen 1,8 en 5,5 V op de VSYS-pin, dus hij verdraagt spanningsdips beter dan een Arduino. Toch wordt de stroom, als je een servo op de VBUS-pin aansluit, die de USB-5 V voert, rechtstreeks uit de poort van de computer getrokken, en als de poort inzakt, gaat de Pico ook neer; je mag bovendien in totaal niet meer dan 300 mA uit de 3V3-pin halen. De resetpin van de Pico, RUN, wordt omhooggetrokken door een weerstand van ongeveer 50 kΩ op de chip; een lange draad daaraan laat de deur open voor ruis, net als de RESET-pin op de Arduino. In MicroPython geeft machine.reset_cause() op de Pico maar twee waarden terug: PWRON_RESET voor power-on of de RUN-pin, en WDT_RESET voor de watchdog of machine.reset(). De watchdog kan op maximaal 8388 ms worden gezet en kan na het starten niet meer worden gestopt; hij blijft het board resetten, ook als je het programma in Thonny stopt. Daarom moet je aan het begin van je code 3 seconden wachten.

MicroPython
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)

De juiste voedingsopzet voor je project

  • Robotauto: Voed de motoren uit een 2S 18650-pakket via een L298N of L9110S en plaats een condensator van 100 nF over de motoraansluitingen; de bouw staat in een Arduino-robotauto bouwen.
  • Robotarm met servo's: Gebruik voor vier of meer servo's een voeding van 5–6 V die minstens 3–5 A levert en voeg 1000 µF toe aan de servolijn; voor de keuze van onderdelen zie MG996R-servo en Arduino-robotarm.
  • Besproeiingssysteem met pomp en relais: Voed de pomp uit een aparte voeding, isoleer het relais met JD-VCC en houd lange sensordraden uit de buurt van de pompkabel (bodemvochtsensor).
  • Ledstrips en NeoPixels: Reken op ongeveer 2 A per 30 leds, en plaats 1000 µF aan de ingang van de strip en een weerstand van 300–500 Ω op de datalijn (WS2812B NeoPixel).
  • Gelijkstroommotoren aansturen: Vergeet de vrijloopdiode niet op elke motor die je met een transistor of MOSFET aanstuurt; voor kant-en-klare driverboards zie gelijkstroommotor aansturen met de L298N.
  • Sensorstation in het veld: Schakel de watchdog in, stel een I2C-timeout in en neem de voeding van een efficiënte bron zoals de LM2596 step-down-converter.

Een Arduino die zichzelf reset is vervelend, maar er is bijna altijd een meetbare, op te lossen oorzaak: stel eerst het symptoom vast, meet dan de spanning en het RAM met de diagnosesketch, scheid vervolgens de voeding, verbind de GND's, voeg de condensator en de diode toe en beveilig het project zo nodig met de watchdog. Met deze opzet draaien je servo-, motor- en relaisprojecten dagenlang zonder problemen. In de BlueGrays-app vind je servomotorbesturing, een Bluetooth-auto met de L298N, een robot die obstakels ontwijkt, 230 V-lampbediening en een slim besproeiingsstation, met schakelschema's die de juiste voedingsaansluitingen tonen en code stap voor stap.

Veelgestelde vragen

Waarom reset mijn Arduino steeds?

De meest voorkomende oorzaak is de plotselinge stroom van een servo, motor of relais die de 5 V-lijn even naar beneden trekt, waardoor de laagspanningsbeveiliging van 2,7 V van de processor het board herstart. Ruis van relaiscontacten, een vol RAM, een watchdog die niet wordt gevoed en een USB-poort die niet genoeg stroom kan leveren veroorzaken ook resets. Servo's en motoren voeden uit een aparte voeding en de GND's verbinden lost de meeste gevallen op.

Waarom reset mijn Arduino als de servo beweegt?

Zelfs een kleine SG90-servo neemt bij het opstarten meer dan 0,5 A op en overschrijdt samen met de andere belastingen van het board de grens van de USB-poort en van de zekering van 500 mA op de Uno. Als de spanning inzakt, reset het board. Voed de servo uit een aparte voeding van 5–6 V, verbind de GND van die voeding met de GND van de Arduino en voeg een condensator van 470–1000 µF toe aan de servolijn.

Waarom reset mijn Arduino als een relais schakelt?

Een relaisspoel neemt bij bekrachtiging plotseling stroom op, en de spoel en de contacten veroorzaken ruis bij het loslaten. De vonk die ontstaat als inductieve belastingen zoals pompen, ventilatoren of tl-lampen worden uitgeschakeld, kan de Arduino resetten. Verwijder bij een module met optocoupler de JD-VCC-jumper en voed de relais uit een aparte voeding, plaats een snubber of varistor over de belasting en houd sensordraden uit de buurt van belastingdraden.

Waarom loopt mijn Arduino na een tijdje vast?

Vastlopen na minuten of uren wordt meestal veroorzaakt doordat het RAM volloopt en String-samenvoegingen het geheugen fragmenteren. Een door ruis vastgelopen I2C-bus of code die in een oneindige lus wacht, kan het board ook laten vastlopen. Meet het vrije RAM, gebruik char-arrays in plaats van String, stel een timeout in met Wire.setWireTimeout() en schakel de watchdog in als vangnet.

Welke condensator moet ik aan mijn Arduino-schakeling toevoegen?

470–1000 µF op de voedingslijn van servo en motor en een elco van 100 µF tussen 5V en GND van de Arduino werken goed. Een keramische condensator van 100 nF (104) naast elk daarvan filtert ook hoogfrequente ruis. De spanningswaarde van de elco moet minstens twee keer de lijnspanning zijn, en het negatieve pootje met de streep gaat naar GND.

Waarom reset mijn Arduino als ik de Serial Monitor open?

De Uno en Nano resetten zichzelf via het DTR-signaal als de seriële poort wordt geopend; dit is geen fout maar de auto-resetfunctie die uploaden mogelijk maakt. Als je communiceert vanuit een programma zoals Python, wacht dan 2 seconden na het openen van de poort. Om de reset uit te schakelen plaats je een condensator van 10 µF tussen RESET en GND en haal je hem weg voordat je uploadt.

Alle projecten bekijken
Een servomotor gebruiken
AR-35Beginner
Premium

Een servomotor gebruiken

De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

4.7(48)
67
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

230V-lamp laten branden met een drukknop

Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

4.4(30)
38
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57
Servocirkelchoreografie: geanimeerde patronen met 32 servo's
AR-97Gevorderd
Premium

Servocirkelchoreografie: geanimeerde patronen met 32 servo's

Een visueel animatieproject met 32 servomotoren in een cirkel op een Arduino Mega. De servo's worden in één array beheerd, zijn aangesloten op pin 22–53 van de Mega en voeren vier bewegingsreeksen uit: een chaotische trilling met willekeurige hoeken, een gesynchroniseerde zwaai, een golf die rond de cirkel loopt en een kompasnaald die heen en weer zwaait.

4.5(40)
62
ESP32-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

ESP32-servomotor (bediening met potentiometer)

In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

4.3(29)
42