Arduino bruciato? Sintomi, diagnosi e come ripararlo passo passo

«Il mio Arduino è bruciato?» è una domanda che quasi ogni appassionato di elettronica si pone prima o poi: un filo tocca il punto sbagliato, si collega un motore e la scheda all'improvviso tace. La buona notizia è che nella maggior parte dei casi non è bruciata tutta la scheda. Un Arduino Uno è fatto di diverse parti separate: il collegamento USB con il suo fusibile, il regolatore di tensione, il chip convertitore USB-seriale e il microcontrollore principale, l'ATmega328P. Quando una si guasta, le altre spesso sopravvivono e, con la diagnosi giusta, salvare la scheda a volte richiede due minuti.

In questa guida imparerai a leggere bene i sintomi e a isolare la scheda passo dopo passo fino a trovare la parte guasta. Seguiremo un ordine: alimentazione da Vin, controllo del polyfuse e del regolatore con il multimetro, ricerca di un chip caldo, prova del chip USB con il test di loopback e due sketch Arduino che verificano i pin uno per uno. Poi riscriveremo un bootloader danneggiato con un secondo Arduino, sostituiremo l'ATmega328P se serve e riassumeremo le regole per non bruciare mai più una scheda. La parte software degli errori di caricamento la trattiamo a parte in Arduino non carica lo sketch.

Arduino bruciato? Primi sintomi e cosa significano

Prima di iniziare la diagnosi, ascolta cosa ti dice la scheda. Il LED verde ON indica se la linea a 5 V è alimentata, il LED L (D13) se microcontrollore e bootloader funzionano e i LED TX/RX se il chip USB-seriale sta trasferendo dati. La tabella riassume i sintomi più comuni e dove guardare per primo.

Passo 1: primo controllo con occhi, naso e cavo

1. Esamina la scheda con una buona luce: cerchi un chip scurito o gonfio, un contenitore crepato, stagno fuso o una pista bruciata. Guarda soprattutto intorno a regolatore, polyfuse e chip USB.
2. Annusa la scheda. L'elettronica bruciata lascia un odore forte e riconoscibile, di solito più intenso vicino al pezzo guasto.
3. Controlla il lato inferiore. Un tavolo di metallo, un pezzo di filo o una spugna conduttiva possono collegare le saldature e causare un cortocircuito.
4. Prova un altro cavo USB e un'altra porta USB. Alcuni cavi economici hanno solo i fili di alimentazione e non trasmettono dati: è la causa più comune di una scheda che sembra morta.
5. Annota se il computer emette il suono di connessione USB quando colleghi la scheda e se il LED ON si accende; i passi successivi dipendono da queste due osservazioni.

Il percorso dell'alimentazione dell'Arduino Uno: quale componente alimenta cosa?

Il modo più rapido per trovare un guasto è conoscere il percorso della corrente sulla scheda. I 5 V dell'USB passano prima da un polyfuse da 500 mA (un fusibile che si ripristina da solo), poi da un piccolo MOSFET a canale P e arrivano alla linea a 5 V. La tensione del jack passa prima da un diodo che protegge dall'inversione di polarità, raggiunge la linea VIN e viene abbassata a 5 V dal regolatore NCP1117. Quando VIN supera circa 6,6 V, un comparatore spegne il MOSFET dal lato USB, così le due fonti non si scontrano mai. I 3,3 V sono ricavati dalla linea a 5 V con un piccolo regolatore LP2985. Il LED ON, il chip USB-seriale (un ATmega16U2 sulle schede originali, di solito un CH340 sui cloni) e l'ATmega328P sono tutti alimentati da questa linea a 5 V.

Passo 2: se il LED ON è spento, prova via USB e via Vin

Alimenta la scheda una volta via USB e una volta con un alimentatore da 9 V sul jack (o con 7–12 V sul pin Vin) e guarda ogni volta il LED ON. Poiché i due percorsi hanno in comune solo la linea a 5 V, questo semplice confronto restringe molto la ricerca del guasto. Se il polyfuse è scattato per sovracorrente, lascia la scheda senza alimentazione per qualche minuto perché si ripristini da solo; se il corto persiste, scatterà di nuovo quando la ricolleghi. Le opzioni di pile e alimentatori sono spiegate in alimentare Arduino a batteria.

Passo 3: controllare corti, polyfuse e regolatore con il multimetro

1. Prova di cortocircuito (scheda non alimentata): Imposta il multimetro su resistenza o continuità e tocca con i puntali i pin 5V e GND. È normale che il valore parta basso e salga mentre i condensatori si caricano; un bip continuo o un valore che resta sotto pochi ohm indica un corto.
2. Prova del polyfuse (USB collegato): In tensione continua, metti il puntale nero su GND e misura i due capi del polyfuse. Dovresti leggere circa 5 V su entrambi; 5 V su un capo e quasi zero sull'altro indica che il polyfuse è aperto.
3. Prova del regolatore (9 V sul jack): Dovresti misurare circa 8,3 V sul piedino d'ingresso dell'NCP1117 (sul diodo cadono 0,7 V) e 5,0 V sull'uscita.
4. Prova dei 3,3 V: Tra il pin 3V3 e GND dovresti misurare 3,2–3,4 V.
5. Fai le misure in quest'ordine; ogni passo cambia il significato del successivo. Spieghiamo portate del multimetro e misure in sicurezza in come usare il multimetro.

Passo 4: trovare il chip che si scalda

Se c'è un corto sulla linea a 5 V, il componente in corto assorbe quasi tutta la corrente e si scalda in pochi secondi. Collega la scheda all'USB, aspetta 3–5 secondi, staccala e tocca per un attimo con la punta del dito l'ATmega328P, il chip USB e il regolatore, uno dopo l'altro. Se trovi un componente troppo caldo da toccare, il corto è lì. Se si scalda l'ATmega328P, di solito uno dei suoi pin ha ricevuto più di 5 V; se è il chip USB, il problema è sul lato USB; se è il regolatore, o è guasto lui o un carico sulla linea a 5 V assorbe troppa corrente. Non lasciare la scheda alimentata a lungo durante la prova, altrimenti possono danneggiarsi anche i componenti sani.

Passo 5: provare il chip USB se la porta non compare

Se il LED ON si accende ma il computer non vede la scheda, escludi prima la parte software: installa il driver del chip CH340 sui cloni, poi su Windows guarda in Gestione dispositivi alla voce «Porte (COM e LPT)», su macOS e Linux i dispositivi /dev/cu.* o /dev/ttyUSB*. Se il dispositivo non compare affatto o risulta sconosciuto, è il momento di provare il chip USB-seriale. Il test di loopback esclude l'ATmega328P e fa ricevere al chip USB i dati che lui stesso invia; così capisci se il problema è nel chip USB o nel microcontrollore.

1. Togli l'alimentazione alla scheda e collega il pin RESET a GND con un cavetto. Così l'ATmega328P resta in reset e lascia libere le linee TX/RX.
2. Collega tra loro i pin D0 (RX) e D1 (TX) con un secondo cavetto.
3. Collega la scheda all'USB, scegli la porta nell'Arduino IDE e apri il monitor seriale (la velocità non conta).
4. Scrivi qualcosa e premi Invia. Se il testo torna identico e i LED TX/RX lampeggiano, il chip USB è sano; il problema è nell'ATmega328P o nel bootloader.
5. Se il testo non torna e anche la porta non compare, sono danneggiati il chip USB o la presa USB. In questo caso puoi ancora caricare codice con un convertitore USB-TTL esterno o un programmatore ISP.

Passo 6: verificare se ci sono pin bruciati

Se la scheda carica il codice ma il progetto si comporta in modo strano, potrebbe essersi bruciato un solo pin. Collegare a un pin un motore, la bobina di un relè o un LED senza resistenza, cortocircuitare due uscite tra loro o dare a un pin più di 5 V può uccidere solo quel pin mentre il resto dell'ATmega328P continua a funzionare. Il primo sketch qui sotto imposta ogni pin come ingresso con pull-up interno: un pin sano deve leggere HIGH quando è libero. Poi colleghi un capo di un cavetto a GND e tocchi i pin uno per uno con l'altro capo; a ogni tocco dovresti vedere nel monitor seriale quel pin scendere a LOW.

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}

Un pin che legge LOW quando è libero o non cambia affatto quando lo tocchi con GND è sospetto; il suo stadio d'ingresso è in corto o interrotto. Su alcune schede clone il LED L è collegato direttamente a D13, quindi D13 può leggere LOW da libero; non è un guasto. Il secondo sketch prova lo stadio di uscita: tutti i pin passano a HIGH e LOW una volta al secondo. Collega il catodo di un LED a GND e l'anodo a una resistenza da 220 Ω, poi tocca i pin uno per uno con l'altro capo della resistenza: il LED lampeggia su ogni pin sano; il valore giusto della resistenza lo trovi con il calcolatore della resistenza per LED. Con il multimetro dovresti leggere circa 5 V nello stato HIGH; un pin che non accende mai il LED, lo accende debole o resta molto sotto i 4 V è danneggiato.

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}

Mentre gira questo sketch non deve esserci nient'altro collegato ai pin, perché tutti vengono pilotati come uscite. Se vuoi provare anche gli ingressi analogici, collega A0 a turno a GND, 3V3 e 5V e leggilo con analogRead(): dovresti vedere circa 0, 675 e 1023. L'elenco completo dei pin e la funzione di ciascuno sono in piedinatura dell'Arduino Uno, e gli schemi della scheda nello strumento pinout.

Riscrivere il bootloader: Arduino as ISP

Se l'alimentazione è a posto e il test di loopback riesce, ma il LED L non lampeggia al reset e ogni caricamento termina con l'errore «avrdude: stk500_getsync(): not in sync», il bootloader potrebbe essere stato cancellato o danneggiato. Il bootloader è il piccolo programma che permette di caricare il codice via USB e si può riscrivere tramite ISP (programmazione nel circuito). Non serve comprare un programmatore: un secondo Arduino Uno sano diventa un programmatore con l'esempio ArduinoISP. Il collegamento ISP usa i pin SPI; puoi anche usare il connettore ICSP a 6 pin della scheda di destinazione.

1. Collega l'Uno sano al computer, apri File > Esempi > 11.ArduinoISP > ArduinoISP e caricalo su questa scheda.
2. Scollegalo dal computer, collega le due schede secondo la tabella qui sopra e monta il condensatore da 10 µF tra i pin RESET e GND dell'Uno programmatore.
3. Ricollega il programmatore all'USB. Nel menu Strumenti scegli Arduino Uno come scheda e la porta del programmatore.
4. In Strumenti > Programmatore scegli Arduino as ISP. L'opzione dal nome simile «ArduinoISP» serve per un programmatore USB separato: non sceglierla.
5. Esegui Strumenti > Scrivi il bootloader. Ci vogliono pochi secondi e termina con il messaggio «Done burning bootloader».
6. Togli i cavi, collega la scheda di destinazione con il suo USB e carica l'esempio Blink. Se al reset il LED L torna a lampeggiare velocemente, la scheda è salva.

Se l'operazione fallisce, il messaggio di firma (signature) di avrdude dice molto. «Device signature = 0x000000» o «0xffffff» significa che il programmatore non riesce affatto a parlare con il chip di destinazione: controlla collegamenti, condensatore da 10 µF e che la destinazione riceva 5 V; se è tutto giusto, l'ATmega328P è molto probabilmente morto. Una firma 1E 95 0F indica un ATmega328P e un collegamento funzionante. Se vedi 1E 95 14, il tuo chip è un ATmega328 senza la «P» e ti serve la definizione di scheda giusta per quel chip.

Sostituire l'ATmega328P

Sull'Arduino Uno R3 originale e su molti cloni l'ATmega328P è in contenitore DIP a 28 piedini montato su uno zoccolo, quindi si può sostituire senza saldare. Se il microcontrollore si scalda, non se ne legge la firma o la maggior parte dei pin è morta, è la soluzione più economica. Se togliendo il chip sparisce anche il corto (il LED ON si riaccende e la scheda resta fredda), è confermato che il guasto è nel chip. Quando ne compri uno nuovo, scegliere un ATmega328P-PU con il bootloader dell'Uno già caricato semplifica le cose; se hai comprato un chip vergine, puoi caricare tu stesso il bootloader con il metodo Arduino as ISP visto sopra. Su schede come il Nano e l'Uno SMD il chip è saldato; per sostituirlo servono una stazione ad aria calda ed esperienza.

1. Togli l'alimentazione alla scheda e scatta una foto del verso della tacca del chip (lato del piedino 1).
2. Infila un piccolo cacciavite a taglio tra chip e zoccolo e solleva il chip poco alla volta, alternando le due estremità; se fai leva da un solo lato, i piedini si piegano.
3. I piedini di un chip nuovo di solito sono un po' aperti verso l'esterno. Appoggia il chip di lato su un tavolo piano e premi per piegare un poco verso l'interno le due file insieme.
4. Allinea il chip allo zoccolo con la tacca nello stesso verso del vecchio, verifica che tutti i piedini entrino nei fori e poi premi in modo uniforme.
5. Collega la scheda all'USB, controlla che il LED L lampeggi al reset e completa la prova caricando l'esempio Blink.

Note rapide per ESP32 e Raspberry Pi Pico

La stessa logica vale per le altre schede; cambiano solo i componenti. Le schede di sviluppo ESP32 hanno un regolatore tipo AMS1117 che abbassa i 5 V a 3,3 V e un chip USB CP2102 o CH340; se il regolatore si scalda, cerca un corto sulla linea a 3,3 V. I pin dell'ESP32 non tollerano i 5 V, quindi il guasto più comune è dare 5 V a un pin. L'errore «Failed to connect» durante il caricamento spesso non è un guasto, ma un caso in cui va tenuto premuto il pulsante BOOT; i dettagli sono in Arduino non carica lo sketch. Sul Raspberry Pi Pico il test più rapido è collegarlo all'USB tenendo premuto BOOTSEL: se sul computer compare un'unità chiamata RPI-RP2, l'RP2040 e il collegamento USB sono a posto. Anche i pin del Pico non tollerano i 5 V, e sul pin 3V3(OUT) dovresti misurare circa 3,3 V.

10 regole per non bruciare il tuo Arduino

• 20 mA per pin: Non prelevare più di 20 mA da un pin; il limite assoluto è 40 mA e la somma di tutti i pin non deve superare 200 mA.
• Sempre una resistenza con il LED: Un LED senza resistenza affatica pin e LED; a 5 V bastano 220–330 Ω.
• Mai più di 5 V su un pin: La tensione di un ingresso non deve superare l'alimentazione di oltre 0,5 V; un segnale a 12 V uccide il pin all'istante.
• Motori, relè e pompe mai direttamente su un pin: Usa un transistor o un MOSFET e un diodo di ricircolo; trovi un circuito d'esempio nella guida alla mini pompa acqua.
• 7–12 V su Vin: È l'intervallo consigliato; sopra i 12 V il regolatore scalda, sopra i 20 V si supera il limite.
• Non invertire mai l'alimentazione sul pin Vin: Il diodo di protezione del jack non protegge ciò che entra dal pin Vin; scambiare positivo e negativo brucia la scheda.
• Non chiedere più di 50 mA al pin 3V3: Per carichi come un modulo Wi-Fi o un display grande usa un regolatore a 3,3 V separato.
• Togli l'alimentazione quando ricabli: Inserire e togliere cavi a circuito acceso è la causa più comune di brevi cortocircuiti.
• Non appoggiare la scheda sul metallo: Le saldature sotto vanno in corto se toccano un tavolo metallico, un attrezzo o un pezzo di filo; usa piedini in plastica o un contenitore.
• Massa comune e alimentazione separata: Unisci le masse dei carichi alimentati dall'esterno, ma non far passare correnti forti attraverso la scheda.

Prima di dichiarare morto il tuo Arduino, capire quale parte si è ammutolita spesso salva la scheda: il LED ON controlla il percorso dell'alimentazione, il test di loopback il chip USB, il LED L al reset il bootloader e gli sketch di prova ogni piedino dell'ATmega328P uno per uno. Il bootloader si può riscrivere, un chip su zoccolo si cambia in pochi minuti e, con le regole qui sopra, la tua prossima scheda vivrà a lungo. Per vedere la scheda di nuovo in salute, prova nell'app BlueGrays i progetti Accendere un LED, Semaforo, LED con pulsante e Voltmetro digitale con LCD, con schemi e codice passo dopo passo.