Arduino si resetta da solo o si blocca: cause e soluzioni

Se il tuo Arduino si resetta da solo o si blocca dopo aver funzionato per un po', la scheda non è quasi mai guasta. Nella maggior parte dei casi la causa è l'alimentazione: quando un servo inizia a muoversi, un motore parte o un relè si eccita, la corrente improvvisa fa crollare per un attimo la linea a 5 V e la protezione contro la sottotensione del processore (brown-out) riavvia la scheda. Negli altri casi i colpevoli sono i disturbi elettrici di relè e motori, i cavi lunghi, la RAM piena, un watchdog dimenticato o una porta USB del computer che non fornisce abbastanza corrente.

In questa guida imparerai prima a capire se la scheda si riavvia davvero o se si blocca soltanto. Poi spiegheremo come funziona ogni causa con valori reali di corrente e tensione e ti mostreremo le soluzioni con il codice: alimentazione separata e GND comune, condensatori da 100–470 µF, diodi di ricircolo, buffer fissi al posto di String e il watchdog. Troverai anche uno sketch di diagnosi che misura la tensione di alimentazione e la RAM libera dell'Arduino stesso, una tabella passo passo dal sintomo alla soluzione ed esempi che leggono il motivo del reset su ESP32 e Raspberry Pi Pico.

Reset o blocco? Riconosci prima il sintomo

Un Arduino che si resetta esegue il programma dall'inizio, come se avessi scollegato e ricollegato il cavo USB: setup() viene eseguito di nuovo, il servo torna all'angolo iniziale, l'LCD mostra di nuovo il testo di avvio e il messaggio di avvio ricompare nel Monitor seriale. Un Arduino bloccato, invece, non risponde più a nulla; i LED restano nell'ultimo stato, l'uscita seriale si interrompe e la scheda rimane così finché non premi il pulsante di reset. Dato che cause e soluzioni sono diverse, comincia col capire quale dei due casi hai. Il modo più semplice è aggiungere in setup() una riga Serial.println("AVVIO") e lasciare aperto il Monitor seriale.

Perché Arduino si resetta da solo? Le sorgenti di reset

Solo poche sorgenti possono riavviare il processore ATmega328P di Arduino Uno e Nano, e ognuna ha il suo innesco. Quando la tensione di alimentazione scende sotto una certa soglia interviene il rilevatore di brown-out (BOD); su Uno e Nano i fuse di configurazione fissano questa soglia a 2,7 V. Anche tutto ciò che porta il pin RESET a LOW riavvia la scheda: il pulsante di reset, il segnale DTR del computer o i disturbi captati da un cavo lungo collegato a quel pin. C'è poi un caso che sembra un reset ma non lo è: a causa della memoria corrotta il programma salta all'indirizzo 0 e il codice riparte da capo, ma poiché le periferiche hardware non vengono azzerate, la scheda comincia a comportarsi in modo strano.

Corrente di servo, motori e relè: come un calo di tensione provoca il reset

Un servo SG90 assorbe 100–250 mA mentre si muove, ma all'avvio e quando il braccio è sotto sforzo la corrente sale oltre 0,5 A. La porta USB 2.0 di un computer fornisce al massimo 500 mA, e il fusibile sulla linea USB di Arduino Uno lavora allo stesso limite. Quando il servo, i 50 mA della scheda e qualche modulo superano questo limite, la porta o il fusibile limitano la corrente, la linea a 5 V crolla per un istante e, se la tensione scende sotto 2,7 V, il BOD riavvia la scheda. Il caso più subdolo è quando la tensione resta tra 2,7 V e circa 3,8 V: secondo il datasheet dell'ATmega328P, servono circa 3,8 V per funzionare in sicurezza a 16 MHz. In questa zona grigia il BOD non interviene, ma il processore lavora oltre il suo limite di velocità; la scheda può quindi bloccarsi invece di resettarsi, fornire valori assurdi, oppure display e sensori I2C possono bloccarsi internamente.

Contano anche i cavi. I cavetti jumper sottili usati sulla breadboard sono di solito da 26–28 AWG, e un filo di rame da 28 AWG ha una resistenza di circa 0,21 Ω al metro. Se alimenti il servo con due cavetti da 20 cm (0,4 m tra andata e ritorno) passando per una breadboard, i cavi aggiungono circa 0,085 Ω e quattro contatti della breadboard circa 0,2 Ω in totale. Per la legge di Ohm (V = I × R), un picco di 1 A del servo perde circa 0,3 V su questi 0,29 Ω. Un cavo USB sottile e lungo, il fusibile e i componenti di protezione della scheda aggiungono circa un altro mezzo ohm; durante lo stesso picco la linea a 5 V di Arduino scende sotto 4,5 V, e se la porta del computer comincia a limitare la corrente, il calo è molto più profondo. Puoi calcolare la caduta nel tuo circuito con il calcolatore della legge di Ohm.

Soluzione 1: alimentazione separata e GND comune

1. Scegli un'alimentazione separata per servo e motori: per i servo, un alimentatore da 5–6 V che fornisca almeno 1 A per servo (2–3 A per un MG996R), un pacco da 4 pile AA NiMH o un modulo step-down LM2596 regolato a 5–6 V.
2. Collega il positivo dell'alimentazione solo ai fili rossi dei servo o all'ingresso di potenza del driver motore; non portare questa linea al pin 5V di Arduino.
3. Collega il negativo (GND) dell'alimentazione sia al carico sia al pin GND di Arduino. Senza questa GND comune la tensione del pin di segnale non ha riferimento; il servo trema o non si muove affatto.
4. Unisci le GND in un solo punto vicino all'alimentazione (massa a stella). La corrente del motore non deve tornare passando per Arduino e le sue piste di massa; altrimenti la GND di Arduino oscilla a ogni picco del motore.
5. Alimenta Arduino dal suo ingresso: USB, jack DC (7–12 V) o 5 V stabilizzati. Così il processore non ne risente anche se l'alimentazione dei servo crolla.
6. Infine misura tra i pin 5V e GND di Arduino mentre il servo si muove, oppure esegui lo sketch di diagnosi qui sotto; la tensione non deve scendere sotto 4,75 V.

Soluzione 2: condensatore (100–470 µF) e diodo

Un condensatore elettrolitico funziona come un piccolo serbatoio di energia accanto al carico: quando il servo chiede una corrente improvvisa, la fornisce lui finché cavi e alimentatore non recuperano. Quanto aiuta lo dice la formula ΔV = I × Δt / C. Un condensatore da 470 µF lascia scendere la tensione di soli 0,21 V durante un picco di 1 A che dura 100 µs; se lo stesso picco dura 1 ms, il calo è di 2,1 V. In altre parole, il condensatore assorbe i picchi brevi e il rumore delle spazzole dei motori, ma non sostituisce un alimentatore insufficiente. Metti 470–1000 µF sulla linea dei servo e 100 µF tra 5V e GND di Arduino, e aggiungi accanto a ciascuno un condensatore ceramico da 100 nF con la sigla 104 contro i disturbi ad alta frequenza. Per leggere le sigle usa lo strumento codice dei condensatori, per sommare condensatori in parallelo il calcolatore di reti di condensatori; le differenze tra i tipi sono spiegate in Cos'è un condensatore?.

Bobine dei relè, motori e solenoidi sono induttanze. Quando la corrente che le attraversa viene interrotta di colpo, la bobina si oppone al cambiamento e genera ai suoi capi un breve picco di tensione di decine o persino centinaia di volt, ben oltre la tensione di alimentazione. Questo picco si propaga sulla linea e resetta Arduino, e può anche distruggere il transistor di comando o il pin. La soluzione è un diodo di ricircolo (flyback) collegato in parallelo alla bobina e in senso inverso: il catodo di un 1N4007, il lato con la fascetta, va al positivo e l'altro capo al lato che va verso il transistor. I moduli relè pronti hanno già questo diodo; se usi un relè nudo, un solenoide o un motore comandato da un transistor o da un MOSFET, devi aggiungerlo tu. Per i motori con controllo di velocità in PWM, il diodo Schottky 1N5819, più veloce, dà risultati migliori. Trovi i dettagli in Cos'è un diodo? e in usare un MOSFET con Arduino.

Disturbi, contatti dei relè e cavi lunghi

Se la scheda si resetta proprio quando un relè si diseccita, il problema sono i disturbi e non l'alimentazione. Quando un relè spegne una pompa dell'acqua, una ventola, una lampada fluorescente o un contattore, tra i contatti si forma un piccolo arco che irradia disturbi elettromagnetici a banda larga. Questi disturbi si accoppiano ai cavi dei sensori vicini, alla linea RESET e alle linee I2C, riavviando il processore o bloccando un modulo. Per evitarlo usa un modulo relè con fotoaccoppiatore, togli il ponticello JD-VCC e alimenta le bobine dei relè con una sorgente a 5 V separata; così la corrente delle bobine e i disturbi restano lontani dalla linea di Arduino. Con carichi induttivi collegati alla rete, uno snubber RC (100 Ω + 100 nF, classe X2) o un varistore sui contatti o sul carico attenua molto l'arco. Trovi i collegamenti in Cos'è un modulo relè? e il principio dell'isolamento in Cos'è un fotoaccoppiatore?.

• I2C corto: l'I2C è nato per brevi distanze su un circuito stampato. Tieni i cavi SDA e SCL sotto i 50 cm; su tratte più lunghe scendi con le resistenze di pull-up da 4,7 kΩ a 2,2 kΩ e lascia la velocità a 100 kHz.
• Cavi intrecciati: intreccia ogni cavo di segnale con un cavo di GND; le coppie intrecciate di un cavo di rete sono ideali.
• Separa potenza e segnale: non far correre i cavi dei sensori in parallelo a quelli di motori, relè o rete elettrica; se devono incrociarsi, fallo ad angolo retto.
• Lascia libero il pin RESET: un cavo lungo sul pin RESET si comporta come un'antenna e resetta la scheda quando lo tocchi o quando un motore vicino è in funzione. Se ti serve un pulsante di reset esterno, usa un cavo corto.
• Ferriti e contenitore: anelli di ferrite sui cavi dei motori e un contenitore metallico riducono i disturbi ad alta frequenza.
• Imposta un timeout: se i disturbi bloccano il bus I2C, la libreria Wire per impostazione predefinita aspetta all'infinito e la scheda si blocca. Il codice qui sotto evita il blocco con un 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 esaurita e uso di String

Arduino Uno ha solo 2 KB di SRAM, e questo piccolo spazio è condiviso da variabili globali, memoria dinamica (heap) e stack usato dalle chiamate di funzione. Se al termine della compilazione vedi l'avviso Low memory available, stability problems may occur., molto probabilmente la scheda andrà in crash dopo un po'. La causa più subdola è la classe String: ogni concatenazione alloca un nuovo pezzo nello heap, il vecchio viene liberato e con il tempo la memoria si riempie di buchi. Un giorno lo stack si scontra con lo heap e il programma si resetta o si blocca in un momento casuale. Poiché il problema compare di solito dopo minuti od ore, è facile distinguerlo da quelli di alimentazione. Lascia i testi costanti nella flash con la macro F(), usa array di char di dimensione fissa e snprintf() al posto di String e non dichiarare grandi array locali dentro le funzioni. Il codice qui sotto stampa la RAM libera ogni secondo; se il valore continua a scendere, c'è una perdita di memoria. Tutto l'argomento è in Arduino: memoria insufficiente.

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: la cintura di sicurezza contro i blocchi

Il watchdog è un contatore interno al processore che funziona in modo indipendente con un proprio oscillatore a 128 kHz. Il programma deve ricaricarlo regolarmente con wdt_reset(); se non lo fa entro il tempo impostato (tra 15 ms e 8 secondi), il watchdog resetta la scheda. Così un bus I2C bloccato, una funzione intrappolata in un ciclo infinito o una lettura del sensore rovinata dai disturbi non possono bloccare la scheda per sempre; si riprende in pochi secondi. Ricorda che il watchdog è una cintura di sicurezza, non una riparazione: non risolve problemi di alimentazione o di memoria, permette solo a un progetto installato sul campo di ripartire da solo. Scegli un tempo nettamente più lungo dell'operazione più lunga del tuo codice; con un delay(3000) nel codice, un watchdog da 2 secondi resetterà la scheda in continuazione.

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}

Sketch di diagnosi: Arduino misura da solo la sua tensione e la sua RAM

Un multimetro è troppo lento per vedere cali di tensione di pochi millisecondi. Al suo posto puoi usare Arduino stesso come un semplice strumento di misura: il codice qui sotto misura con l'ADC il riferimento interno da 1,1 V del chip e ne ricava la tensione di alimentazione circa 9000 volte al secondo, e stampa il valore più basso di ogni secondo. Inoltre a ogni avvio incrementa un contatore nella EEPROM, così anche se apri il Monitor seriale più tardi vedi quante volte la scheda si è riavviata. Come carico di prova muove il servo su D9 tra 0 e 180 gradi ogni 2 secondi; se hai già un tuo progetto, puoi aggiungere la parte di misura al suo codice. Apri il Monitor seriale a 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}

Leggi i risultati così: su un Arduino Uno sano alimentato da USB, il valore minimo resta tra 4,6 e 5,1 V. Se scende sotto 4,5 V a ogni movimento del servo e i reset coincidono con quei momenti, il problema è l'alimentazione. Se il numero di avvio continua a salire mentre la tensione resta stabile, cerca la causa nei disturbi o nel software; se intanto la RAM libera continua a diminuire, c'è una perdita di memoria. Il riferimento interno da 1,1 V può variare di circa il 10 % da chip a chip, quindi confronta una volta la misura con un multimetro: se il multimetro indica 4,95 V e il codice 5,10 V, cambia la costante 1125300 in 1125300 × 4,95 / 5,10 ≈ 1092200. Finita la diagnosi, togli il contatore EEPROM dal codice; le celle della EEPROM reggono circa 100.000 scritture.

Tabella di diagnosi passo passo: sintomo, causa, soluzione

Leggi la tabella dall'alto in basso; le prime righe sono le cause più frequenti. Cambia una sola cosa alla volta ed esegui di nuovo lo sketch di diagnosi. Se cambi tre cose insieme non saprai quale ha risolto il problema, e lo stesso guasto si ripresenterà nel prossimo progetto.

La porta USB non dà abbastanza corrente e il reset del Monitor seriale

Una porta USB 2.0 fornisce 500 mA e una USB 3.0 900 mA; ma poiché il fusibile USB di Arduino Uno limita a 500 mA, una porta USB 3.0 non ti dà corrente in più. Un hub USB non alimentato divide la corrente di una sola porta tra tutti i dispositivi, le porte frontali del case perdono tensione per i sottili cavi interni e i portatili a batteria possono alimentare debolmente le porte in modalità risparmio energetico. Collega la scheda direttamente a una porta posteriore con un cavo corto e di buona qualità. Esiste anche un reset che non è un guasto: Uno e Nano si resettano tramite il segnale DTR quando il Monitor seriale o un programma Python apre la porta, ed è proprio questa funzione a rendere possibile il caricamento dello sketch. Se comunichi da Python, aspetta 2 secondi dopo aver aperto la porta (comunicazione seriale tra Arduino e Python). Se vuoi disattivare del tutto il reset, metti un condensatore da 10 µF tra RESET e GND e toglilo quando carichi lo sketch. I dettagli sulla porta seriale sono in Monitor seriale di Arduino.

ESP32 si resetta da solo: leggere il motivo del reset

L'ESP32 è ancora più sensibile agli stessi problemi, perché funziona a 3,3 V e assorbe circa 240 mA durante la trasmissione Wi-Fi, di più nei picchi brevi; Espressif consiglia un'alimentazione in grado di fornire almeno 500 mA. La buona notizia è che l'ESP32 ti dice da solo perché si è riavviato. Il messaggio Brownout detector was triggered nel Monitor seriale indica un calo di tensione, mentre le righe rst:0xf (RTCWDT_BROWN_OUT_RESET) o Guru Meditation Error all'avvio mostrano il motivo del reset. Il codice qui sotto legge la stessa informazione con esp_reset_reason() e la trasforma in un testo leggibile. Sull'ESP32 il pulsante EN spegne e riaccende completamente il chip, quindi anche un reset con questo pulsante risulta come un'accensione. Tutti i messaggi e le relative soluzioni sono in ESP32: errori brownout e Guru Meditation.

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: motivo del reset e watchdog (MicroPython)

Grazie al suo regolatore buck-boost, il Raspberry Pi Pico funziona con qualsiasi tensione tra 1,8 e 5,5 V sul pin VSYS, quindi sopporta i cali di tensione meglio di un Arduino. Tuttavia, se colleghi un servo al pin VBUS, che porta i 5 V dell'USB, la corrente viene prelevata direttamente dalla porta del computer e, se la porta crolla, si spegne anche il Pico; inoltre non dovresti prelevare più di 300 mA in totale dal pin 3V3. Il pin di reset del Pico, RUN, è tenuto alto da una resistenza interna al chip di circa 50 kΩ; collegarci un cavo lungo apre la porta ai disturbi, proprio come il pin RESET di Arduino. In MicroPython, machine.reset_cause() sul Pico restituisce solo due valori: PWRON_RESET per l'accensione o il pin RUN e WDT_RESET per il watchdog o machine.reset(). Il watchdog si può impostare al massimo a 8388 ms e, una volta avviato, non si può più fermare; continua a resettare la scheda anche se fermi il programma in Thonny. Per questo conviene mettere un'attesa di 3 secondi all'inizio del codice.

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)

L'alimentazione giusta per ogni progetto

• Auto robot: alimenta i motori con un pacco 2S 18650 tramite un L298N o un L9110S e metti un condensatore da 100 nF sui terminali di ogni motore; il montaggio è in costruire un'auto robot con Arduino.
• Braccio robotico con servo: per quattro servo o più usa un alimentatore da 5–6 V che fornisca almeno 3–5 A e aggiungi 1000 µF sulla linea dei servo; per la scelta vedi servo MG996R e braccio robotico con Arduino.
• Irrigazione con pompa e relè: alimenta la pompa a parte, isola il relè con JD-VCC e tieni i cavi lunghi dei sensori lontani dal cavo della pompa (sensore di umidità del terreno).
• Strisce LED e NeoPixel: calcola circa 2 A ogni 30 LED, metti 1000 µF all'ingresso della striscia e una resistenza da 300–500 Ω sulla linea dati (WS2812B NeoPixel).
• Comando di motori DC: non dimenticare il diodo di ricircolo su ogni motore comandato con un transistor o un MOSFET; per le schede driver già pronte vedi controllo di motori DC con L298N.
• Stazione di sensori all'aperto: attiva il watchdog, imposta un timeout I2C e prendi l'alimentazione da una sorgente efficiente come lo step-down LM2596.

Un Arduino che si resetta da solo è frustrante, ma c'è quasi sempre una causa misurabile e risolvibile: prima riconosci il sintomo, poi misura tensione e RAM con lo sketch di diagnosi, separa l'alimentazione, unisci le GND, aggiungi condensatore e diodo e, se serve, metti in sicurezza il progetto con il watchdog. Una volta sistemato tutto, i tuoi progetti con servo, motori e relè funzioneranno per giorni senza problemi. Nell'app BlueGrays trovi il controllo dei servomotori, un'auto Bluetooth con L298N, un robot che evita gli ostacoli, il comando di una lampadina a 230 V e una stazione di irrigazione intelligente, con schemi che mostrano i collegamenti di alimentazione corretti e codice passo passo.