Progetto Arduino non funziona: la diagnosi in 10 minuti

Se il tuo progetto Arduino non funziona, non cercare il guasto staccando e riattaccando cavi a caso. Procedi dall'esterno all'interno: prima l'alimentazione (la scheda si accende?), poi il caricamento (il codice è davvero arrivato sulla scheda?), poi il cablaggio (la GND è in comune, ogni cavo è sul pin giusto?), poi verso e valore dei componenti (il LED è al contrario, la resistenza è quella giusta?), poi il codice (numeri dei pin e logica) e infine sensore e ambiente (luce, distanza, tensione di alimentazione). Fai un solo test per livello e cambia una sola cosa alla volta. Seguendo quest'ordine troverai la maggior parte dei guasti in 10 minuti, perché gli errori più comuni stanno nei livelli esterni, che sono anche i più economici da controllare.

Questo articolo non elenca i singoli messaggi di errore: ti dà un metodo di diagnosi. Prima vedrai le due regole del metodo, poi una tabella di flusso con il sintomo, un test da 1 minuto e la causa probabile per ogni livello. Seguono uno sketch di prova breve che divide il circuito in parti con Blink e il monitor seriale, 4 misure con il multimetro (e le alternative con LED e monitor seriale se non ce l'hai), la diagnosi passo dopo passo di un guasto in un progetto gratuito di BlueGrays, una tabella rapida per sintomo e una scheda di diagnosi in 8 punti da usare in classe.

Le due regole della diagnosi: dall'esterno all'interno, una sola variabile

La logica del procedere dall'esterno all'interno è semplice: i livelli interni dipendono da quelli esterni. Se la scheda non è alimentata, non importa che il codice sia giusto; se il codice non è mai arrivato sulla scheda, correggere il cablaggio non cambia nulla. I livelli esterni sono anche i più veloci da controllare: guardare il LED di alimentazione richiede 5 secondi e leggere il messaggio di caricamento 10, mentre trovare un errore di logica nel codice può richiedere minuti. La seconda regola è quella della variabile singola. Se cambi insieme il cavo, la resistenza e la soglia nel codice, non saprai cosa ha risolto il problema anche se il progetto riparte; e se non riparte, potresti aver aggiunto un nuovo guasto. Fai una modifica, prova, annota il risultato e passa alla successiva.

• Scrivi il sintomo in una frase: "Quando copro la LDR con la mano mi aspetto che il LED si accenda, ma non si accende mai." "Non funziona" non è un sintomo; scrivendo separatamente cosa ti aspettavi e cosa succede, il livello da controllare spesso diventa evidente da solo.
• Stacca l'USB mentre colleghi i cavi: se la scheda resta alimentata mentre cambi i collegamenti, un contatto sbagliato può causare un cortocircuito. Fai la modifica, controllala a occhio e poi ricollega.
• Sostituisci con un pezzo sicuramente funzionante: cambiare il LED, il cavo o il sensore sospetto con uno che sai che funziona è il test più efficace che puoi fare senza strumenti.
• Prendi appunti: brevi note come "spostato il cavo dal 7 all'8, nessun cambiamento" evitano di ripetere lo stesso test e diventano un riassunto pronto se chiedi sul forum o al tuo insegnante.
• Semplifica: se il progetto è grande, togli i moduli uno alla volta. Prima solo la scheda, poi la scheda con la parte di uscita, poi la parte di ingresso. Vedere quale pezzo fa smettere di funzionare tutto ti mostra dove si trova il guasto.

La tabella di flusso per la diagnosi in 10 minuti

Leggi la tabella dall'alto in basso e non scendere al livello successivo finché il test di quello attuale non è superato. Ogni test richiede circa un minuto, quindi tutti e sei i livelli si chiudono in 6–10 minuti. Per la maggior parte dei test bastano i tuoi occhi, i LED della scheda e il monitor seriale dell'Arduino IDE; un multimetro velocizza le cose ma non è obbligatorio. La colonna "Causa probabile" indica i primi punti da guardare quando un test fallisce, più o meno in ordine di frequenza.

Livelli 1 e 2: alimentazione e caricamento

Su un Arduino Uno due LED danno il primo indizio per questi due livelli. Il LED ON indica che la scheda è alimentata; se è spento, cambia prima il cavo USB, perché alcuni cavi servono solo a ricaricare e non trasportano dati. Se ON è acceso ma il suono USB del computer si interrompe quando colleghi la scheda, o il LED sfarfalla, nel circuito potrebbe esserci un cortocircuito: stacca l'USB, segui le linee 5V e GND e cerca un modulo inserito al contrario o un cavo che unisce le due linee. Un componente che si scalda è sempre un segnale serio; non alimentare di nuovo la scheda finché non l'hai tolto. Se usi un motore, un servo o un relè, la corrente dell'USB potrebbe non bastare; in questo caso il sintomo di solito non è "non funziona niente", ma riavvii casuali o tremolii. Per le opzioni con batterie e alimentatore vedi alimentare Arduino a batteria.

Nel livello del caricamento cerchi la risposta a una sola domanda: il codice sulla scheda è quello che vedi sullo schermo? A caricamento finito, l'Arduino IDE lo segnala nell'area di output in basso; se ci sono righe rosse, il codice non è mai arrivato sulla scheda, che continua a eseguire il programma precedente. È una trappola, perché penserai che la tua correzione non abbia funzionato. Per gli errori di avrdude, porta e driver, Arduino non carica il codice spiega ogni messaggio, e se ti blocchi in compilazione guarda errori di compilazione. Esiste anche una semplice prova del nove: cambia un'attesa nel codice da 100 a 1000 e carica. Se il ritmo del LED non cambia, il problema è nel caricamento. Alcune schede ESP32 richiedono di tenere premuto il tasto BOOT durante il caricamento; sul Raspberry Pi Pico controlla che in basso a destra in Thonny sia selezionato l'interprete MicroPython.

Livello 3: cablaggio, GND e pin

Scheda alimentata e codice caricato: tocca ai cavi. I due errori più frequenti sono dimenticare la GND in comune e leggere male la breadboard. Anche se un sensore o un modulo ha una propria alimentazione, la sua GND deve essere collegata alla GND di Arduino, altrimenti la tensione del segnale non ha un riferimento. Sulla breadboard il canale centrale separa le due metà, e nelle breadboard lunghe le linee di alimentazione sui bordi possono essere divise a metà; dare 5V a una metà della linea pensando di alimentare un componente sull'altra metà è un errore molto comune. Il metodo migliore per questo livello è il confronto uno a uno con lo schema: conta ogni cavo con i suoi due capi e indica con il dito il suo corrispondente sullo schema. Il digitale 2 confuso con l'analogico A2, 5V scambiato con VIN o un cavo spostato di una fila saltano subito fuori. Se i simboli ti sembrano strani, come leggere uno schema elettrico spiega passo dopo passo come riportarlo sulla breadboard.

Livello 4: verso e valore dei componenti

Se il cablaggio è giusto ma un componente continua a non rispondere, guarda il componente stesso. La gamba lunga del LED (anodo) va al pin attraverso la resistenza e quella corta (catodo) a GND; un LED al contrario di solito non si danneggia, semplicemente resta spento. Le resistenze sono i componenti che si confondono di più: 220 Ω ha le fasce rosso-rosso-marrone, 10 kΩ marrone-nero-arancione. Con una 10 kΩ accanto al LED, questo si accende così debolmente che non te ne accorgi; con una 220 Ω accanto a una LDR o a un pulsante, le letture smettono di avere senso. Puoi leggere le fasce con il calcolatore del codice colori e trovare il valore giusto per un LED con il calcolatore della resistenza per LED. Un pulsante a quattro gambe ruotato di 90 gradi risulterà sempre premuto o mai premuto. Nei moduli l'ordine di VCC, GND e segnale cambia da produttore a produttore; leggi le etichette dei pin sulla scheda stessa, non su un'immagine trovata in rete. Anche nei componenti a tre gambe come transistor e regolatori di tensione l'ordine dei piedini cambia in base al modello.

Livello 5: codice (numeri dei pin e logica)

Se l'hardware è a posto, controlla che il codice dica la stessa cosa del circuito. Il primo controllo sono i numeri dei pin: se il LED è fisicamente sull'8 ma il codice dice digitalWrite(9, HIGH), tutto sembra perfetto e non succede nulla. Il secondo controllo è pinMode: se in setup() manca pinMode(pin, OUTPUT), digitalWrite(pin, HIGH) non rende il pin un'uscita, attiva solo la resistenza di pull-up interna, e il LED si accende debolissimo. Dopo la resistenza, è la causa più frequente di un "LED debole". Il terzo controllo è la logica: scrivere if (valore = 100) non confronta nulla, assegna 100 alla variabile e la condizione è sempre vera; la forma corretta è ==. Anche soglie e attese appartengono a questo livello: una soglia non adatta al tuo ambiente fa sì che non scatti mai nulla, anche con un sensore che funziona perfettamente. Nei progetti con librerie controlla anche che sia installata quella giusta; i dettagli sono in installare una libreria Arduino.

Livello 6: sensore e ambiente

L'ultimo livello riguarda le condizioni esterne che rovinano il risultato anche quando circuito e codice sono giusti. Il valore di una LDR dipende dalla luce della stanza; una soglia che funziona di giorno vicino alla finestra può non andare bene la sera sotto una lampada. Un HC-SR04 non riceve l'eco dalle superfici morbide come il tessuto e non misura sotto i 2 cm. I sensori di gas della serie MQ hanno bisogno di qualche minuto di riscaldamento prima di misurare. Un DHT11 restituisce errori se lo leggi più di una volta al secondo. I pin dell'ESP32 e del Raspberry Pi Pico lavorano a 3,3 V; collegare direttamente un sensore con uscita a 5 V può dare letture sbagliate e danneggiare il pin. Cavi lunghi, disturbi dei motori e ingressi flottanti fanno anche saltare i valori. Lo strumento migliore per questo livello è il monitor seriale: osserva il valore grezzo del sensore e cambia di proposito le condizioni. Se un display o un sensore I2C non risponde affatto, lo sketch scanner di cos'è l'I2C ne mostra l'indirizzo.

Dividi e conquista: verifica la scheda con Blink e i passaggi con il monitor seriale

Il modo più veloce per attraversare i livelli è dividere circuito e codice in parti. La prima parte è la scheda stessa: senza collegare nulla, carica un codice che fa lampeggiare il LED L della scheda. Se L lampeggia, alimentazione, caricamento e scheda sono a posto, e da quel momento cerchi il problema fuori dalla scheda. La seconda parte è l'uscita: nello stesso codice fai lampeggiare anche il LED esterno. La terza è l'ingresso: stampa il valore del sensore sul monitor seriale. Lo sketch qui sotto fa tutte e tre le cose e a ogni passaggio scrive sul monitor seriale un punto di controllo numerato. Collega il LED esterno al pin 9 con una resistenza da 220 Ω e il segnale del sensore analogico da provare ad A0, e imposta il monitor seriale a 9600 baud.

1const int LED_PIN = 9;       // Harici LED pini / External LED pin
2const int SENSOR_PIN = A0;   // Analog sensör pini / Analog sensor pin
3
4void setup() {
5  Serial.begin(9600);                  // Seri monitör de 9600 olmalı / Serial Monitor must be 9600 too
6  pinMode(LED_BUILTIN, OUTPUT);        // Karttaki L ışığı / On-board L LED
7  pinMode(LED_PIN, OUTPUT);            // Harici LED çıkış / External LED as output
8  Serial.println("1) setup bitti");    // Kontrol noktası 1 / Checkpoint 1
9}
10
11void loop() {
12  digitalWrite(LED_BUILTIN, HIGH);     // Kart canlı mı? / Is the board alive?
13  digitalWrite(LED_PIN, HIGH);         // Harici LED açık / External LED on
14  Serial.println("2) LED acik");       // Kontrol noktası 2 / Checkpoint 2
15  delay(500);
16
17  digitalWrite(LED_BUILTIN, LOW);
18  digitalWrite(LED_PIN, LOW);          // Harici LED kapalı / External LED off
19  Serial.println("3) LED kapali");     // Kontrol noktası 3 / Checkpoint 3
20  delay(500);
21
22  int value = analogRead(SENSOR_PIN);  // 0-1023 arası okuma / Reading from 0 to 1023
23  Serial.print("4) A0 = ");
24  Serial.println(value);               // Sensör değeri / Sensor value
25}

La vera forza di questo sketch sono i punti di controllo. Usa lo stesso metodo nel tuo progetto: aggiungi un breve Serial.println() alla fine di setup() e dopo ogni passaggio importante di loop(), per esempio "pulsante premuto" o "soglia superata". L'ultimo messaggio che compare sul monitor seriale ti dice dove si è bloccato il programma. Per capire perché una condizione non scatta mai, stampa subito prima il valore che confronti; se "valore < 50" non è mai vero, vedrai lì stesso che il valore non scende mai sotto 50. Nei progetti grandi applica la stessa logica: commenta temporaneamente una parte del codice e prova i pezzi uno alla volta. Per le impostazioni del monitor seriale come velocità, fine riga e plotter, vedi usare il monitor seriale di Arduino.

4 misure con il multimetro (o con LED e monitor seriale)

Un multimetro trasforma la diagnosi da tentativo a misura, e bastano quattro misure per coprire la maggior parte dei guasti di Arduino. Prima di misurare, imposta lo strumento sulla funzione giusta: V in continua per la tensione, cicalino (continuità) per cavi e file, Ω per le resistenze. Fai sempre le prove di continuità e di resistenza con l'USB staccato. Se non hai un multimetro, i metodi dell'ultima colonna danno una risposta più grossolana ma sufficiente alla stessa domanda. Le portate dello strumento e le boccole in cui inserire i puntali sono spiegate con immagini in come usare il multimetro.

Esempio: il LED non si accende nel progetto Luce notturna con LDR

Proviamo il metodo su un progetto gratuito di BlueGrays: Luce notturna con LDR. Nel circuito un capo della LDR va a 5V e l'altro ad A0; tra A0 e GND c'è una resistenza da 10 kΩ, e le due formano un partitore di tensione. Il LED è collegato al pin 13 attraverso una resistenza da 330 Ω. Il codice legge A0 e, se il valore è sotto 50, considera l'ambiente buio e accende il LED. Il sintomo: "Copro la LDR con la mano e il LED non si accende mai." Invece di cambiare cavi a caso, attraversiamo i livelli in ordine.

1. Alimentazione: il LED ON è acceso e niente si scalda. Avanti.
2. Caricamento: il caricamento è terminato senza errori. Per esserne sicuro, cambia temporaneamente il 50 nel codice in 2000 e carica; dato che analogRead restituisce al massimo 1023, la condizione è sempre vera e il LED dovrebbe restare acceso.
3. Cablaggio e LED L: il pin 13 è collegato anche al LED L della scheda. Se con la soglia 2000 L si accende ma il LED esterno no, il codice funziona e il problema è nel percorso del LED. La gamba lunga del LED va al 13 attraverso 330 Ω e quella corta a GND?
4. Verso e valore: il LED non è al contrario, ma se accanto c'è una 10 kΩ invece della 330 Ω si accende troppo debolmente per accorgersene. Distingui le due resistenze dai colori.
5. Codice e sensore: se il LED esterno si accende con la soglia 2000, riportala a 50. Ora, per vedere i valori reali, carica sullo stesso circuito il codice del progetto Misurare l'intensità luminosa con LDR; usa lo stesso cablaggio della LDR e scrive A0 sul monitor seriale ogni mezzo secondo.
6. Leggi i valori: supponiamo che tu veda circa 600 allo scoperto e circa 120 coprendola con la mano. Il valore non scende mai sotto 50, quindi il LED non si accende mai. Torna al codice della luce notturna e alza la soglia a un valore tra 200 e 300.
7. Riconosci il comportamento invertito: se coprendo la LDR il valore sale invece di scendere, la LDR e la 10 kΩ sono state scambiate. Se il valore salta a caso con la mano ferma, il cavo di A0 non è inserito bene nella fila in cui si uniscono LDR e resistenza.

In questo esempio a trovare il guasto non è stata una conoscenza nuova, ma l'ordine: prima abbiamo dimostrato che il LED poteva accendersi, poi abbiamo guardato cosa leggeva davvero il sensore. Nell'app, la parte Se ti blocchi della sezione Capire il codice di questo stesso progetto contiene già cinque di questi sintomi come coppie di sintomo e soluzione: il LED esterno che non si accende mai al buio, il LED che si accende con la luce e si spegne al buio, che non si accende nemmeno coprendolo con la mano, che resta acceso o sfarfalla, e un errore di caricamento. La sezione Risoluzione dei problemi del progetto offre una lista generale di 10 passaggi che parte dall'alimentazione e passa per caricamento, numeri dei pin, breadboard, ponticelli, GND, LED e resistenza. Forse l'hai notato: quest'ordine è quasi identico ai livelli dell'inizio dell'articolo.

L'aiuto nell'app: dove guardare quando un progetto non funziona

• Risoluzione dei problemi: una lista ordinata nella pagina del progetto che inizia con "Se il tuo progetto non funziona, controlla i passaggi seguenti." È presente in oltre 170 progetti e si apre con Premium; anche nei progetti gratuiti questa sezione si vede con Premium. Se non hai idea di cosa non va, è il posto giusto per controllare tutto dall'inizio alla fine.
• Capire il codice > Se ti blocchi: coppie di sintomo e soluzione specifiche del codice e del circuito di quel progetto. Aperta a tutti nei progetti gratuiti, con Premium nei progetti Premium. Se riesci a scrivere il sintomo in una frase, guarda prima qui. Tutta la sezione è spiegata nell'articolo Capire il codice.
• Torna ai passaggi di Costruiamolo insieme: nella modalità guidata torna a 2. Monta il circuito e rimonta il circuito da capo con il cavo USB della scheda staccato; al passaggio 3. Carica il codice ricontrolla scheda e porta nel menu Strumenti dell'Arduino IDE. La modalità ricorda il passaggio in cui eri. Come funziona è spiegato in il tuo primo progetto Arduino.
• Ingrandisci lo schema: allarga con due dita lo Schema del Circuito e confronta il cablaggio collegamento per collegamento; se vuoi, salvalo con Salva nella Galleria e segna i cavi già controllati. Così trovi la maggior parte dei guasti del livello 3.
• La domanda giusta sul forum: se hai provato tutto e ancora non funziona, apri una discussione nella categoria Domanda di Impara › Forum. Indica la scheda, il codice completo, i collegamenti, il comportamento atteso e quello reale e quali livelli hai controllato, e aggiungi una foto nitida del circuito. Come scriverla è spiegato in fare una domanda sul forum.

Consultazione rapida per sintomo

Per gli insegnanti: una scheda di diagnosi in 8 punti

Supponiamo di avere una classe di 24 studenti con 8 gruppi che montano circuiti contemporaneamente, e che nei primi 15 minuti sei gruppi alzino la mano dicendo "non funziona". Metti la scheda qui sotto sul banco di ogni gruppo e fissa la regola fin dall'inizio: prima di alzare la mano, percorrete la scheda dall'alto in basso e scrivete sul retro a quale punto vi siete bloccati e cosa avete cambiato. Così recuperi tempo e gli studenti acquisiscono abitudini di problem solving; gli appunti di diagnosi sono anche una prova del processo che puoi usare per la valutazione. Per organizzare i gruppi in una classe numerosa vedi lezione di Arduino in una classe numerosa, e per valutare il processo la rubrica di valutazione.

1. Sintomo: cosa ci aspettavamo e cosa succede? Scrivetelo in una frase.
2. Alimentazione: il LED ON è acceso? Staccate l'USB: qualche componente è caldo?
3. Caricamento: il caricamento è terminato senza errori? Scheda e porta sono giuste nel menu Strumenti?
4. Scheda: dopo aver caricato Blink, il LED L della scheda lampeggia?
5. Cablaggio: ingrandite lo schema e contate ogni cavo ai due capi. La GND è in comune, i cavi sono sul pin giusto e nella fila giusta?
6. Componente: la gamba lunga del LED va al pin? Le fasce della resistenza corrispondono al valore dell'elenco? VCC e GND sono giusti sul modulo?
7. Codice: i numeri dei pin nel codice corrispondono al circuito? Stampando punti di controllo sul monitor seriale, quale compare per ultimo?
8. Sensore e passo successivo: il valore del sensore sul monitor seriale ha senso e cambia quando cambiano le condizioni? Se il problema non è ancora risolto, guardate Se ti blocchi e Risoluzione dei problemi, poi chiamate l'insegnante. Cambiate una sola cosa alla volta e prendete appunti.

La diagnosi è un'abilità e diventa più rapida a ogni guasto: una ricerca che al primo progetto richiede 20 minuti scende a 3 al quinto, perché inizi a indovinare il livello dal sintomo. La prossima volta che un progetto non funziona, apri quest'ordine prima di staccare qualsiasi cavo e procedi dall'alto in basso. I piccoli progetti come la luce notturna di questo articolo sono ideali per fare pratica; nell'app BlueGrays ognuno dei 60 progetti gratuiti ha già schema del circuito, codice e sezione Capire il codice, così al prossimo guasto saprai già dove guardare.