
Uscite digitali di Arduino: LED, breadboard e monitor seriale
Dopo aver conosciuto Arduino Uno R3 e realizzato il primo Blink sul LED integrato, impariamo a costruire un circuito esterno, dimensionarlo e verificarlo tramite il monitor seriale.
1. Obiettivi e prerequisiti
Prerequisiti: B2.01 (microcontrollore, registri e periferiche) e B2.02 (Arduino Uno R3, pin, IDE, Blink). Alla fine saprai riconoscere una linea digitale di uscita, distinguere HIGH e LOW, calcolare una resistenza adatta per un LED, costruire e verificare un circuito su breadboard, usare pinMode(), digitalWrite(), Serial.begin(), Serial.print() e Serial.println(), interpretare un guasto comune e documentare una prova.
Confine: non affrontiamo ancora pulsanti e antirimbalzo (B2.04), ADC/PWM (B2.05), sensori (B2.06), motori (B2.07) o millis() e macchine a stati (B2.08).
2. Che cos’è un’uscita digitale?
Un pin configurato con pinMode(pin, OUTPUT) può pilotare due stati logici: HIGH (tensione prossima all’alimentazione logica, circa 5 V su Uno R3 in condizioni ordinarie) e LOW (tensione prossima a 0 V). Non sono una promessa di tensione ideale a qualsiasi carico: la tensione effettiva dipende anche dalla corrente. Il pin non è un alimentatore per carichi di potenza.

Il comando digitalWrite(8, HIGH) imposta il livello HIGH sul pin digitale D8; digitalWrite(8, LOW) lo imposta LOW. Prima si configura il pin come uscita. Evitiamo D0 e D1 nei primi esperimenti perché sono associati alla comunicazione seriale hardware USB della Uno.
3. LED: componente polarizzato
Un LED (diodo a emissione luminosa) conduce principalmente dall’anodo (+) al catodo (−) quando polarizzato direttamente. Nei comuni LED a due terminali, la gamba più lunga è spesso l’anodo; il lato piatto del contenitore identifica spesso il catodo, ma è preferibile verificare la documentazione del componente. Un LED collegato al contrario normalmente non si accende; non sperimentare collegamenti a tensioni inverse elevate.

Nel nostro circuito la corrente percorre pin D8 → resistenza → anodo LED → catodo LED → GND. La resistenza può stare prima o dopo il LED, purché sia in serie.
4. Perché serve una resistenza
Un LED non va collegato direttamente tra un’uscita Arduino e GND: la corrente potrebbe crescere oltre i valori sicuri. In prima approssimazione si usa la legge di Ohm:

R = (VOUT − VF)/I
Consideriamo un LED rosso con caduta diretta ipotizzata V_F = 2,0 V, un’uscita a 5,0 V e una corrente obiettivo di 9 mA: R = (5−2)/0,009 ≈ 333 Ω. Una resistenza commerciale da 330 Ω produce circa 3/330 = 9,1 mA; con 470 Ω circa 6,4 mA. Il calcolo è indicativo: i parametri reali del LED e del pin variano. La dissipazione prevista con 330 Ω è P = I²R ≈ 0,027 W, inferiore a 0,25 W. Arduino Uno Rev3 indica 20 mA come corrente DC per pin I/O nelle caratteristiche di scheda: progettiamo prudentemente al di sotto e consideriamo anche i limiti complessivi del microcontrollore.
Errore da evitare: 40 mA non va trattato come normale corrente di esercizio; un valore limite assoluto non equivale a una raccomandazione di progetto.
5. Breadboard: collegamenti invisibili
La breadboard consente collegamenti provvisori senza saldatura. Nella comune breadboard, ciascuna fila di cinque fori sul medesimo lato della fessura centrale costituisce un nodo elettrico; la fessura separa le due metà. I binari laterali di alimentazione possono essere continui oppure interrotti a metà: controlla il modello reale prima di presumere che siano uniti. Le scritte e i colori non creano da soli un collegamento elettrico.

Non inserire i due terminali del LED nella stessa fila elettricamente comune: provocheresti un cortocircuito dei suoi terminali e il LED non funzionerebbe come previsto. Colloca anodo e catodo in nodi distinti.
6. Il primo circuito esterno, passo dopo passo
- Disconnetti l’alimentazione USB prima del cablaggio.
- Inserisci un LED rosso nella breadboard, con i due terminali in nodi differenti.
- Connetti il pin D8 a un’estremità della resistenza 330 Ω.
- Connetti l’altra estremità della resistenza all’anodo del LED.
- Connetti il catodo del LED al GND di Arduino.
- Controlla continuità logica, polarità e assenza di cortocircuiti, poi collega USB.
Schema funzionale: D8 ── 330 Ω ── |>| LED ── GND. Non colleghiamo il circuito al pin 5V fisso: vogliamo comandarlo dal pin D8.
Nota: tutte le figure sono schemi didattici originali e semplificati; non sostituiscono il controllo dei contatti sul circuito reale.
7. Sketch 1 — lampeggio di un LED esterno
const byte LED_PIN = 8;
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Il LED resta acceso per circa un secondo e spento per circa un secondo. Il periodo nominale è T ≈ 2 s, la frequenza f ≈ 0,5 Hz e il duty cycle del comando è circa il 50%. I tempi sono nominali perché l’esecuzione delle istruzioni richiede un piccolo tempo aggiuntivo. Le pause sono bloccanti: l’uso strutturato di alternative è previsto in B2.08.
8. Il monitor seriale come strumento di osservazione
Arduino Uno R3 comunica con il computer attraverso l’interfaccia seriale collegata alla USB. Serial.begin(9600) inizializza la trasmissione a 9600 bit/s (baud rate per la configurazione ordinaria); il monitor seriale deve essere impostato allo stesso valore. Serial.print() scrive senza andare automaticamente a capo, mentre Serial.println() termina la riga. I messaggi aiutano a capire in quale fase si trova il programma, ma non misurano direttamente la luce né garantiscono che i fili siano corretti.

Il monitor seriale è uno strumento di diagnostica software: per misurare la tensione effettiva ai capi del LED o la corrente serve un opportuno strumento elettrico.
9. Sketch 2 — LED esterno e messaggi seriali
const byte LED_PIN = 8;
void setup() {
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
Serial.begin(9600);
Serial.println("MEGISTONE B2.03 - Avvio");
}
void loop() {
digitalWrite(LED_PIN, HIGH);
Serial.println("D8 = HIGH | LED comandato ACCESO");
delay(1000);
digitalWrite(LED_PIN, LOW);
Serial.println("D8 = LOW | LED comandato SPENTO");
delay(1000);
}
Output previsto: messaggio di avvio una volta (dopo avvio/reset), quindi righe alternate HIGH e LOW a intervalli nominali di circa un secondo. La scritta comandato ACCESO è voluta: il programma sa quale comando ha inviato, non se il LED fisico si è realmente acceso.
10. Leggere il livello di un pin configurato OUTPUT
digitalRead(LED_PIN), su Uno R3, consente di leggere il livello logico presente sul pin anche quando è configurato come uscita. Nella normale prova restituirà HIGH dopo digitalWrite(..., HIGH) e LOW dopo digitalWrite(..., LOW). Questa lettura non misura la corrente del LED né verifica il suo funzionamento ottico. Per un resoconto affidabile distinguiamo sempre comando, livello letto e stato fisico osservato.
Serial.print("Livello logico D8: ");
Serial.println(digitalRead(LED_PIN));
11. Sketch 3 — due LED alternati
Collega due rami indipendenti: D9 → 330 Ω → anodo LED rosso → GND e D8 → 330 Ω → anodo LED verde → GND. Ogni LED ha la sua resistenza.

const byte ROSSO = 9;
const byte VERDE = 8;
void setup() {
pinMode(ROSSO, OUTPUT);
pinMode(VERDE, OUTPUT);
Serial.begin(9600);
}
void loop() {
digitalWrite(ROSSO, HIGH);
digitalWrite(VERDE, LOW);
Serial.println("Rosso ON - Verde OFF");
delay(1000);
digitalWrite(ROSSO, LOW);
digitalWrite(VERDE, HIGH);
Serial.println("Rosso OFF - Verde ON");
delay(1000);
}
Verifica che non ci siano stati in cui entrambi i LED risultano comandati HIGH. La commutazione dei due pin avviene in sequenza, non in modo strettamente simultaneo.
12. Sketch 4 — sequenza ciclica di tre LED
Collega LED e resistenze indipendenti ai pin D8, D9 e D10. Il seguente programma mostra un semplice esempio di iterazione applicata all’elettronica.
const byte LED[] = {8, 9, 10};
const byte N = sizeof(LED) / sizeof(LED[0]);
void setup() {
Serial.begin(9600);
for (byte i = 0; i < N; i++) {
pinMode(LED[i], OUTPUT);
digitalWrite(LED[i], LOW);
}
}
void loop() {
for (byte i = 0; i < N; i++) {
digitalWrite(LED[i], HIGH);
Serial.print("LED attivo sul pin D");
Serial.println(LED[i]);
delay(500);
digitalWrite(LED[i], LOW);
}
}
La sequenza prevista è D8, D9, D10, poi di nuovo D8. In ogni istante del ciclo il programma comanda acceso un solo LED, salvo brevissimi tempi di commutazione. Esegui il programma solo dopo aver controllato i tre rami indipendenti.
13. Sicurezza, errori e metodo diagnostico
LED spento
Controlla polarità, resistenza in serie, continuità dei nodi sulla breadboard, pin selezionato nel codice e connessione GND. Per distinguere errore software e cablaggio prova un semplice HIGH continuo, sempre con resistenza.
LED sempre acceso
Verifica se è stato collegato direttamente a 5V anziché all’uscita D8, oppure se lo sketch non alterna HIGH/LOW sul pin previsto.
Monitor seriale vuoto o illeggibile
Controlla Serial.begin(9600), porta seriale corretta, baud rate del monitor e reset. Non usare D0/D1 per LED durante questi esperimenti.
Regole elettriche
Non cortocircuitare uscite e GND; non collegare carichi potenti direttamente ai pin; scollega USB prima di spostare i fili; non collegare mai la rete elettrica domestica alla breadboard. Tieni conto sia della corrente per singolo pin sia dei limiti complessivi del chip.
| Controllo | Atteso | Esito |
|---|---|---|
| Resistenza in serie | 330 Ω per ogni ramo LED | □ |
| Pin e GND | D8/D9/D10 e massa corretti | □ |
| Comando HIGH/LOW | Alternanza coerente | □ |
| Monitor seriale | 9600 baud, messaggi leggibili | □ |
| LED osservato | Accensione verificata visivamente | □ |
14. Esperimenti Tinkercad — MEGISTONE Arduino STEM LAB
Quattro circuiti disponibili nella raccolta MEGISTONE — ARDUINO STEM LAB, realizzati e provati in simulazione. Premi Avvia simulazione nel progetto Tinkercad per osservare gli stati dei LED; se l’anteprima incorporata non è interattiva sul tuo dispositivo, usa il pulsante arancione per aprire il progetto.
Nota didattica: T04 usa D13 e 220 Ω, mentre lo Sketch 1 dell’articolo mostra D8 e 330 Ω: sono due varianti dello stesso principio. T07 utilizza la sequenza avanti-indietro, diversa dalla sequenza circolare dello Sketch 4. I collegamenti descritti qui fanno riferimento ai progetti Tinkercad.
T04 — LED esterno lampeggiante ✓ Simulazione collaudata
Circuito: LED rosso collegato al pin D13 con resistenza da 220 Ω; un secondo acceso e un secondo spento.
Obiettivo: Osservare la differenza fra LED integrato e LED esterno e verificare la polarità.
T05 — Due LED alternati ✓ Simulazione collaudata
Circuito: Due rami indipendenti: D9 → resistenza 330 Ω → LED rosso → GND; D8 → resistenza 330 Ω → LED verde → GND. Alternanza ogni 1000 ms.
Obiettivo: Verificare il controllo separato delle due uscite e confrontare i messaggi seriali con gli stati luminosi.
T06 — Mini semaforo Arduino ✓ Simulazione collaudata
Circuito: Tre LED, ciascuno con resistenza da 330 Ω: rosso su D10 (3 s), verde su D8 (3 s), giallo su D9 (1 s).
Obiettivo: Osservare una sequenza ciclica di tre uscite digitali e i relativi messaggi seriali.
T07 — Tre LED con ciclo for ✓ Simulazione collaudata
Circuito: Stesso cablaggio a tre LED del T06: D10 rosso, D9 giallo, D8 verde; sequenza D10 → D9 → D8 → D9 → D10, con intervalli da 500 ms.
Obiettivo: Comprendere array, funzione di controllo e cicli for per gestire uscite multiple.
Collaudo: accensione e sequenze confermate nelle simulazioni Tinkercad. Il collaudo fisico su una breadboard reale resta distinto dalla verifica virtuale.
15. Allenati con MEGI — 20 esercizi graduati
- Spiega cosa significa configurare D8 come OUTPUT.
- Descrivi HIGH e LOW su Uno R3 senza trattarli come tensioni ideali.
- Indica anodo e catodo di un LED.
- Spiega perché un LED richiede una resistenza di limitazione.
- Calcola R per Vout=5 V, Vf=2 V e I=10 mA.
- Stima I per una resistenza da 470 Ω e Vf=2 V.
- Spiega perché due LED separati devono avere ciascuno una resistenza.
- Riconosci il guasto quando anodo e catodo sono nello stesso nodo.
- Indica la corretta sequenza dei componenti da D8 a GND.
- Modifica lo sketch 1 per usare D7.
- Modifica lo sketch 1 per un lampeggio 250/750 ms e calcola il duty cycle nominale.
- Spiega la differenza fra Serial.print e Serial.println.
- Motiva il valore 9600 e cosa succede se il monitor usa un baud rate diverso.
- Distingui lo stato comandato del LED dalla sua effettiva emissione luminosa.
- Indica perché digitalRead su OUTPUT non è una misura della luce.
- Prevedi l’ordine dei LED dello sketch 4.
- Modifica lo sketch 3 affinché i due LED restino accesi insieme per 500 ms, poi spenti per 500 ms.
- Scrivi un test per rilevare un LED montato al contrario.
- Spiega perché D0 e D1 non sono ideali per questi esperimenti con seriale.
- Progetta una tabella di collaudo contenente: circuito, pin, resistenza, comando, messaggio seriale, osservazione e risultato.
16. Soluzioni guidate — verificare prima di leggere
Mostra le soluzioni
- D8 diventa un pin capace di pilotare HIGH o LOW.
- HIGH è prossimo a 5 V; LOW è prossimo a 0 V, sotto carico appropriato.
- Anodo è il terminale positivo in polarizzazione diretta, catodo quello negativo.
- Limita la corrente e protegge LED e pin.
- (5−2)/0,010 = 300 Ω; 330 Ω è una scelta commerciale prudente.
- (5−2)/470 ≈ 0,0064 A = 6,4 mA.
- Ogni ramo ha caratteristiche proprie e deve limitare la propria corrente.
- I due terminali risultano equipotenziali; il LED viene bypassato.
- D8 → R 330 Ω → anodo LED → catodo LED → GND.
- Sostituire
const byte LED_PIN = 8;con7e ricablare su D7. - HIGH per 250 ms, LOW per 750 ms, periodo 1000 ms, duty cycle 25%.
printnon va a capo;printlntermina la riga.- Baud rate della comunicazione seriale: i due lati devono avere configurazioni compatibili.
- Il comando è software; luce reale dipende anche da LED e cablaggio.
- Legge un livello logico, non un’intensità luminosa.
- D8, D9, D10 e ripete.
- Mettere entrambi HIGH, pausa 500 ms; entrambi LOW, pausa 500 ms.
- Con alimentazione scollegata invertire correttamente i terminali, poi ripetere il test con la resistenza in serie.
- D0/D1 sono coinvolti nella seriale hardware, con possibili interferenze.
- Una riga per esperimento, valori attesi ed effettivi separati, esito OK/KO e nota diagnostica.
17. Archivio storico MEGISTONE e continuità didattica
Il progetto storico Progetto 1: LED lampeggiante anticipava già il monitor seriale. Questa lezione ne riprende il problema didattico ma distingue con maggiore rigore corrente, comando e osservazione. La raccolta Arduino: esercizi risolti resta un archivio autonomo; gli esercizi con pulsanti, fotoresistenze, dimmer e motori sono raccordati alle unità dedicate. Per hardware, IDE e primo Blink consulta B2.02 — Arduino Uno R3. Prossima unità B2.04: ingressi digitali, pulsanti, resistori pull-up e antirimbalzo.
18. Fonti, riproducibilità e nota di revisione
- Arduino Uno Rev3 — caratteristiche ufficiali
- Arduino — digitalWrite()
- Arduino — Serial.begin()
- Arduino — Serial.println()
- MEGISTONE — roadmap consolidata Informatica v3.13, 21 novembre 2026.
Articolo pubblicato e aggiornato con quattro esperimenti Tinkercad (T04–T07), verificati e funzionanti in simulazione, e con il MEGISTONE STEM LAB B2.03, laboratorio virtuale autonomo comprendente cinque modalità interattive (A–E).
Sono stati verificati il funzionamento dei comandi, l’apertura dei progetti e del laboratorio tramite i pulsanti dedicati, nonché la compatibilità responsive su desktop e iPhone 11.
Gli sketch sono destinati all’ambiente Arduino C/C++. Le verifiche virtuali non sostituiscono un collaudo elettrico completo su Arduino Uno R3 reale. Le fonti editoriali MEGISTONE preesistenti sono state utilizzate come base di revisione e approfondimento didattico, senza riproduzione integrale di materiali di terzi.