Codice Arduino spiegato passo passo: capirlo e modificarlo

Capire il codice è la scheda della sezione Codice Sorgente di ogni pagina progetto di BlueGrays che spiega passo passo il codice Arduino già pronto. Per capire che cosa fa davvero il codice che hai copiato e caricato, segui quest'ordine: leggi prima il riepilogo Cosa fa questo codice?, poi ritrova nel codice completo ogni frammento della sezione Passo dopo passo insieme alla sua spiegazione, guarda Se ti blocchi se il circuito non si comporta come previsto e, alla fine, usa l'esercizio Prova tu per cambiare una sola cosa nel codice e vedere il risultato sulla scheda. Queste quattro sezioni sono la strada più breve tra «funziona, ma non so perché» e «so cosa succede se cambio questa riga».

In questo articolo percorriamo Capire il codice dall'inizio alla fine con il contenuto reale di un progetto reale: il progetto numero 10, Accendere e spegnere un LED con un pulsante. È gratuito, di livello Principiante e ha anche la vista a blocchi, quindi chiunque può aprire la spiegazione sia del codice sia dei blocchi. Troverai le sezioni della scheda, un metodo per abbinare il codice alla spiegazione, una routine di studio di 15 minuti, una strategia per risolvere gli esercizi Prova tu, quale modifica insegna quale concetto, la vista Capire i blocchi, la differenza tra Se ti blocchi e Risoluzione dei problemi e alcune idee per gli insegnanti che vogliono usarla a lezione.

Dov'è Capire il codice e chi può usarlo?

Quando apri un progetto e scorri fino alla sezione Codice Sorgente, in alto vedi un selettore con due schede: Codice e Capire il codice. La scheda Codice mostra il programma completo, con i pulsanti Copia e Copia link. Passando a Capire il codice si apre la versione commentata dello stesso programma. Ognuno dei 200+ progetti ha questa scheda, che funziona allo stesso modo nei progetti Arduino, ESP32 e Raspberry Pi Pico. La regola di accesso è semplice: nei 60 progetti gratuiti (20 per piattaforma) Capire il codice è aperto a tutti; anche con un account gratuito vedi il riepilogo, tutti i passaggi, Se ti blocchi e l'esercizio Prova tu con la soluzione. Nei progetti Premium, al posto della scheda compare una scheda di blocco: «Sblocca con Premium la spiegazione del codice passo dopo passo.» Puoi quindi applicare il metodo di questo articolo a LED lampeggiante, Semaforo, Lampeggiante della polizia a LED e ai progetti con pulsante senza pagare nulla.

Le sezioni: a cosa serve ciascuna

L'ordine delle sezioni è voluto: prima il quadro generale, poi i pezzi, poi gli errori e infine il tuo esperimento. I frammenti non sono l'intero programma, solo le righe che quel passaggio spiega; la parentesi graffa di chiusura di un blocco aperto in un passaggio può comparire in quello successivo. Per questo leggere tutti i passaggi in ordine rende di più che guardarne uno solo. Il suggerimento è visibile subito sotto il testo dell'esercizio, mentre la soluzione resta nascosta finché non tocchi Mostra la soluzione. Così hai spazio per ragionare prima di vedere la risposta.

Esempio: Capire il codice nel progetto Accendere e spegnere un LED con un pulsante

Il progetto usa un pulsante e un LED. Un lato del pulsante va ai 5V e il lato opposto al pin 13 della scheda; lo stesso pin è portato a GND con una resistenza da 10 kΩ. La gamba lunga del LED va al pin 7 e quella corta a GND attraverso una resistenza da 330 Ω. Il riepilogo di Capire il codice descrive il programma così: ogni volta che premi il pulsante il LED inverte il suo stato una volta, si accende se era spento e si spegne se era acceso; anche se tieni premuto il pulsante il LED cambia una sola volta, e un'attesa di 50 ms ignora i rimbalzi del pulsante. Ecco il programma completo, con commenti in due lingue.

1int ledState = 0;     // LED durumu: 0 sönük, 1 yanık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Butonun önceki okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi, harici pull-down / Button input, external pull-down
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu tersine çevir / Flip the state
14      digitalWrite(7, ledState);  // Yeni durumu LED'e yaz / Write the new state to the LED
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}

Mentre leggi i passaggi, nota che la spiegazione non ti dice solo cosa succede, ma anche cosa succederebbe senza quella riga. Il passaggio 1 ricorda che ledState parte da 0 e che quindi il LED è spento all'accensione della scheda. Ne nasce una bella domanda: se lo metti a 1, il LED parte acceso? No, perché quella riga cambia solo la variabile; setup() non scrive nulla sul LED, quindi parte spento, e alla prima pressione ledState torna a 0, perciò resta spento. Il valore di una variabile e lo stato reale di un pin sono due cose diverse. Il passaggio 2 collega l'uso di INPUT sul pulsante alla resistenza da 10 kΩ del circuito: quando il pulsante non è premuto, la resistenza porta il pin a GND e si legge 0. Se togli la resistenza, il pin resta flottante e legge valori casuali; il sintomo «il LED si accende e si spegne da solo» in Se ti blocchi corrisponde proprio a questo.

I passaggi 3 e 5 vanno letti insieme. Il confronto del passaggio 3 funziona solo se lastButton viene aggiornato dopo ogni cambiamento, e quell'aggiornamento è la riga lastButton = button del passaggio 5. Abbinando i due passaggi emerge l'idea centrale del programma: il codice non controlla se il pulsante è premuto, ma se il suo stato è cambiato. Mentre lo tieni premuto, ogni giro legge 1, ma anche lastButton vale 1, il confronto è falso e il LED non cambia. L'operatore ! del passaggio 4 è un interruttore acceso/spento in due righe. Il passaggio 5 si chiude con un avvertimento: se l'attesa è troppo breve, il LED a volte può cambiare più di una volta per una sola pressione. Questo ti suggerisce un primo esperimento prima dell'esercizio: porta 50 a 5, premi qualche volta e osserva se ogni tanto il LED cambia due volte; il risultato dipende dalla qualità del pulsante. Per approfondire l'antirimbalzo leggi come collegare un pulsante ad Arduino.

La sezione Se ti blocchi di questo progetto elenca cinque sintomi: il LED non si accende mai; il LED cambia da solo senza toccare il pulsante; premendo non succede nulla; il pulsante si comporta come se fosse sempre premuto; il codice non si carica. Per ogni sintomo c'è un controllo concreto. Per «sempre premuto», per esempio, spiega che se le gambe del pulsante sono inserite nel verso sbagliato D13 resta sempre collegato ai 5V e che devi ruotare il pulsante di 90 gradi. L'esercizio Prova tu è questo: fai in modo che il LED cambi quando rilasci il pulsante, non quando lo premi. Il suggerimento ricorda che la variabile button diventa 1 al momento della pressione e 0 al momento del rilascio. La soluzione è una modifica di un solo carattere: la riga if (button == 1) diventa if (button == 0). Questo piccolo esercizio verifica se hai davvero capito il rilevamento del fronte del passaggio 3.

Metodo di lettura: riepilogo, abbinamento, prova

1. Leggi il riepilogo e scrivilo in una frase: Leggi Cosa fa questo codice?, poi scrivi il programma in una frase sul quaderno senza guardare il telefono. Per il progetto con pulsante: «Ogni pressione accende o spegne il LED una volta».
2. Abbina il codice ai passaggi dall'alto in basso: Apri il codice nell'Arduino IDE (Copia link in Codice Sorgente rende la cosa facile), ritrova il frammento di ogni passaggio nel codice completo e aggiungi accanto alla riga il numero del passaggio come commento. I passaggi seguono l'ordine del codice: variabili globali, setup(), loop().
3. Segna le righe senza abbinamento: Se resta una riga che non compare in nessun passaggio (di solito restano solo parentesi di chiusura), chiediti perché non è spiegata; se non è una parentesi, cercala di nuovo nelle spiegazioni.
4. Prova sul circuito: Carica il codice e verifica uno per uno i comportamenti del riepilogo. Per il progetto con pulsante bastano tre prove: una pressione, pulsante tenuto premuto e pressioni rapide in successione. Prima di ogni prova di' ad alta voce cosa succederà.

L'abbinamento è il passaggio che si salta più spesso, ma è quello che rende di più. Quando scrivi i numeri dei passaggi accanto alle righe, lo scheletro del codice diventa visibile: quale riga viene eseguita una volta e quale di continuo, dove ogni variabile viene letta e dove viene scritta. Nel progetto con pulsante lastButton compare in due punti: viene dichiarata nel passaggio 1 e aggiornata nel passaggio 5. Vederlo con i tuoi occhi resta in testa molto più che leggere «una variabile è una scatola». Se vuoi studiare a parte variabili, cicli e funzioni, leggi le basi della programmazione Arduino.

Una routine di 15 minuti con Capire il codice

Questa routine è pensata per un progetto con il circuito già montato. Se monti il circuito per la prima volta, dedicagli altri 10–15 minuti o rimanda la routine al giorno dopo. Gli ultimi due minuti sono la parte più preziosa: fare una tua piccola modifica dopo aver visto la soluzione mette alla prova l'idea che hai capito, non la risposta che hai memorizzato. Nel progetto con pulsante potresti, per esempio, spostare il LED su un altro pin o portare l'attesa da 50 a 300 ms e vedere cosa succede alle pressioni rapide. Un progetto al giorno a questo ritmo significa finire in una settimana cinque progetti gratuiti capendoli davvero. Per un piano più lungo, guarda la tabella di marcia di 30 giorni per Arduino.

Una strategia per risolvere gli esercizi Prova tu

Gli esercizi Prova tu sono brevi ma scelti con cura: ognuno chiede una sola modifica e il risultato si vede o si sente. Rispettare quest'ordine mentre li risolvi raddoppia quello che impari:

1. Prevedi: Leggi l'esercizio e di' prima quale riga toccherai e cosa vedrai dopo la modifica. Scrivere la previsione evita poi l'illusione del «lo sapevo già».
2. Modifica: Cambia una sola cosa. Se cambi due righe insieme, non riuscirai a capire quale modifica ha prodotto cosa.
3. Carica: Carica il codice sulla scheda e aspetta il messaggio che indica la fine del caricamento. Se compare un errore di compilazione, controlla il punto e virgola e le parentesi nella riga che hai cambiato.
4. Osserva: Confronta il risultato con la tua previsione. Negli esercizi sui tempi conta i secondi; in quelli sul suono ascolta il suono vecchio e quello nuovo uno dopo l'altro.
5. Guarda il suggerimento: Se la previsione non torna o non trovi la riga da toccare, leggi il suggerimento. Dato che è visibile subito sotto l'esercizio, coprirlo con la mano alla prima lettura aiuta.
6. Apri la soluzione per ultima: Tocca Mostra la soluzione solo dopo il tuo tentativo. Se coincide con la tua, chiediti perché è giusta; se è diversa, chiediti perché le due strade danno risultati diversi.

Un altro vantaggio di quest'ordine è che rende istruttivi gli errori. Supponi che nell'esercizio del progetto Semaforo tu voglia allungare a 1,5 secondi il giallo dopo il verde, ma per sbaglio cambi la prima riga delay(300). Invece del risultato atteso vedrai allungarsi il giallo dopo il rosso. Quell'errore ti insegna molto meglio della soluzione che il codice ha due fasi gialle distinte e che loop() viene eseguito riga per riga. La soluzione dell'esercizio lo dice: la riga delay(300) alla fine di loop() diventa delay(1500), mentre il giallo dopo il rosso resta a 0,3 secondi.

Tipi di modifica: quale concetto insegna ciascuno?

Guardando gli esercizi dei progetti gratuiti, vedrai che ognuno rientra in uno di pochi tipi. Riconoscere il tipo ti aiuta anche a inventare un tuo esercizio in un progetto nuovo. Gli esempi della tabella vengono da veri esercizi Prova tu dei progetti gratuiti; la riga sul cambio di pin è un esperimento che puoi fare tu nello stesso progetto.

Capire i blocchi: la stessa spiegazione a blocchi

I progetti con vista a blocchi hanno l'interruttore Mostra a blocchi nella sezione Codice Sorgente. Quando lo attivi, lo stesso programma compare come blocchi nella lingua dell'app al posto del codice, e la scheda accanto passa da Capire il codice a Capire i blocchi. In questa vista riepilogo, Se ti blocchi ed esercizio restano uguali; cambia la sezione Passo dopo passo: ogni passaggio mostra i propri blocchi al posto del frammento di codice, e toccando l'immagine si apre a schermo intero. Oltre 100 progetti hanno la vista a blocchi, tra cui più di 30 di quelli gratuiti. I blocchi servono solo per leggere; nell'app non si modificano e non si caricano sulla scheda, sulla scheda va sempre il codice vero.

Il modo migliore di usare Capire i blocchi è passare avanti e indietro tra le due viste. Nel progetto con pulsante, i blocchi del passaggio 3 sono un blocco «imposta button a leggi pin 13» e due blocchi «se» annidati; nel codice sono la riga int button = digitalRead(13); e due if annidati. Il blocco «imposta ledState a non ledState» del passaggio 4 è esattamente la riga ledState = !ledState;. Leggi prima il blocco e di' cosa fa, poi spegni l'interruttore e guarda il frammento di codice dello stesso passaggio. Abbinare così blocchi e codice è il modo più solido per passare dalla programmazione a blocchi al codice testuale; per riprendere l'argomento dall'inizio leggi cos'è la programmazione a blocchi e l'articolo sul blocco se.

Se ti blocchi o Risoluzione dei problemi: la differenza

In pratica l'ordine è questo: quando il circuito non funziona, descrivi il sintomo in una frase e cercalo in Se ti blocchi. Se il tuo sintomo c'è, la soluzione di solito è un singolo filo, una resistenza o una riga. Se non c'è, o la soluzione proposta non è bastata, percorri in ordine i passaggi di Risoluzione dei problemi; è probabile che trovi un controllo di base che avevi saltato (alimentazione della scheda, porta giusta, GND in comune). Se ti blocchi al caricamento ti aiuta Arduino non carica il codice, mentre per gli errori di compilazione c'è errori di compilazione Arduino.

Per gli insegnanti: usare Capire il codice a lezione

• Lettura comune al proiettore: All'inizio della lezione proietta lo schermo del telefono, leggete insieme il riepilogo Cosa fa questo codice? e chiedi alla classe di riassumere il programma in una frase. Poi mostra gli stessi passaggi con Mostra a blocchi attivo; per chi ha iniziato con i blocchi è un ponte.
• Un gruppo per passaggio: In un progetto da 5 passaggi dividi la classe in 5 gruppi; ogni gruppo legge un passaggio, ritrova il frammento nel codice completo e lo spiega alla classe in due minuti. Mentre un gruppo spiega, gli altri chiedono: «cosa succederebbe senza questa riga?».
• Foglietto delle previsioni: Scrivi l'esercizio Prova tu alla lavagna; ogni gruppo annota la sua previsione su un foglietto prima di modificare, poi cambia il codice e lo carica. Discutere la differenza tra previsione e risultato insegna più dell'esercizio stesso.
• Domanda di uscita: Negli ultimi due minuti della lezione tutti rispondono a una domanda. Esempi per il progetto con pulsante: cosa succederebbe tenendo premuto il pulsante se non ci fosse lastButton? Cosa cambia se cancelli delay(50)? Perché il LED può cambiare da solo se togli la resistenza da 10 kΩ?

Per organizzare l'accesso tieni presente questo: dato che Capire il codice è aperto a tutti nei progetti gratuiti, i tuoi studenti possono applicare questo metodo con LED lampeggiante, Semaforo, Lampeggiante della polizia a LED e i due progetti con pulsante senza pagare nulla. Nei progetti Premium Capire il codice si sblocca con Premium; se vuoi passare con la classe ai progetti Premium, puoi distribuire i codici dei pacchetti per educatori invece di far abbonare ogni studente, come spieghiamo in un'app Arduino per la classe. Se vuoi condividere un circuito progettato da te, puoi aprire una discussione Tutorial nel Forum; non arriva con i passaggi di Capire il codice né con la vista a blocchi, quindi la spiegazione la scrivi tu nel testo della discussione e aggiungi il codice con Aggiungi codice (fare lezione con il tuo progetto). Nell'app non c'è nemmeno un pannello che ti mostri quali esercizi ha risolto ogni studente; controlli l'esercizio a lezione, guardando il circuito funzionante o con una foto.

Errori frequenti e soluzioni semplici

• Aprire subito la soluzione: Se tocchi Mostra la soluzione appena letto l'esercizio, impari la risposta ma non l'idea. La regola: prima la previsione, poi il tentativo, poi il suggerimento e la soluzione per ultima.
• Copiare senza leggere i passaggi: Prendere il codice con Copia e caricarlo funziona, ma se passi al progetto successivo senza leggere Passo dopo passo, riparti da zero ogni volta. Dopo il caricamento leggi almeno il riepilogo e i passaggi.
• Scambiare un frammento per il programma intero: I frammenti contengono solo le righe di un passaggio; incollato da solo nell'IDE, un frammento non si compila. Fai sempre le modifiche nel codice completo.
• Cambiare più cose insieme: Se cambi due righe insieme e il risultato ti sorprende, non saprai quale delle due è responsabile. Una modifica per ogni caricamento.
• Cambiare il numero di pin in un solo punto: Cambiare pinMode e dimenticare digitalWrite o il filo è uno degli errori più comuni. Prima di cambiarlo, segna tutti i punti del codice in cui compare il numero.
• Saltare Se ti blocchi e chiedere subito nel forum: La risposta spesso è già nella lista Se ti blocchi di quel progetto. Guarda prima lì, poi in Risoluzione dei problemi; se il problema resta, chiedi nel forum con una foto del circuito e il tuo codice.
• Finire l'esercizio e fermarsi lì: Se dopo il confronto con la soluzione non fai una tua piccola modifica, quello che hai imparato resta legato a quell'esercizio. Scegli tu un numero, un pin o una condizione.

Quando avrai usato Capire il codice in quest'ordine su qualche progetto, il codice già pronto smetterà di essere una scatola chiusa: saprai dire in anticipo quale riga controlla cosa e cosa succederà se la cambi. Accendere e spegnere un LED con un pulsante è un buon punto di partenza per questa abitudine, perché in un codice breve mostra insieme variabile globale, rilevamento del fronte, toggle e antirimbalzo. Se vuoi provarlo, apri questo progetto nell'app BlueGrays e comincia dall'esercizio nella scheda Capire il codice; le stesse sezioni ti aspettano in tutti i 60 progetti gratuiti.