Arduino Uno: hardware, pin, alimentazione, IDE e primo sketch
Dalla scheda elettronica al primo programma: riconoscere Arduino Uno R3, configurare l’ambiente di sviluppo, compilare uno sketch e far lampeggiare il LED integrato, senza circuiti aggiuntivi.
Prerequisiti: B2.01 (microcontrollori e sistemi embedded); nozioni elementari di variabili, funzioni e condizioni apprese nello studio di C e Python. Durata indicativa: 3–5 ore tra lettura, prova e verifica. Ambiente: Arduino Uno Rev3, Arduino IDE 2.x, Tinkercad Circuits.

1. Obiettivi e percorso
Questo capitolo passa dall’architettura generale studiata in B2.01 a una scheda programmabile concreta. Alla fine saprai identificare elementi e connettori di Uno R3; scegliere alimentazione e pin senza confonderli; preparare Arduino IDE 2; distinguere verifica del codice e caricamento; eseguire e interpretare Blink; documentare una prova in simulazione e, se disponibile, sulla scheda reale.
La competenza centrale è controllare un sistema fisico attraverso istruzioni riproducibili: una sequenza temporale scritta in C++ determina l’accensione e lo spegnimento del LED già montato sulla scheda.
- Non ripeteremo il funzionamento interno di CPU, memorie e registri.
- Non monteremo ancora LED esterni, resistenze e breadboard: sono oggetto della B2.03.
- Non useremo attuatori e sensori, né la programmazione non bloccante: saranno sviluppati in B2.04–B2.09.
2. Arduino: piattaforma, scheda e microcontrollore
Arduino è una piattaforma aperta per prototipazione elettronica e programmazione: comprende schede, software e risorse didattiche. La scheda Arduino Uno R3 è il dispositivo elettronico completo, con connettori, componenti di alimentazione e circuito USB-seriale. Il microcontrollore ATmega328P è invece uno dei chip presenti sulla scheda: esegue il programma che carichiamo.
Perché Arduino ha cambiato il physical computing
Perché Arduino è così importante? Arduino è oggi considerata una delle piattaforme open source di physical computing più diffuse e popolari al mondo. Ha contribuito a rendere accessibile la creazione di oggetti capaci di percepire l’ambiente e agire su di esso: studenti, docenti, maker, artisti e progettisti possono sperimentare senza progettare da zero ogni parte elettronica.
Il physical computing collega il programma al mondo fisico: un sensore trasforma una grandezza ambientale in un segnale leggibile, mentre un attuatore trasforma un comando elettrico in un’azione. In passato, modificare il comportamento di molti dispositivi richiedeva di cambiare il cablaggio; con un microcontrollore programmabile spesso è sufficiente modificare lo sketch, fermo restando che i collegamenti elettrici devono essere corretti e sicuri.
I vantaggi di una piattaforma aperta
La sua diffusione è favorita dall’hardware aperto, dagli strumenti software gratuiti e open source, dall’ampia comunità, dalla programmazione accessibile tramite C++ e API Arduino, dalle librerie riutilizzabili e dalle schede di espansione chiamate shield. Queste ultime aggiungono funzionalità e connessioni, ma devono sempre essere scelte in base alla compatibilità elettrica e meccanica della scheda.
In particolare, la distinzione è importante: se una fotografia mostra una scheda blu con la scritta UNO, non tutto il circuito è il microcontrollore. Analogamente Arduino IDE è un programma per il computer, non un elemento fisico della scheda.
Per questo motivo, in questa unità il riferimento è Arduino Uno Rev3 (R3) a 5 V, non Uno R4 Minima o WiFi: queste ultime sono schede differenti per microcontrollore e alcune caratteristiche elettriche. Uno R3 è ideale per imparare a controllare ingressi, uscite e semplici sistemi STEM.
3. Arduino Uno R3: dati essenziali
La tabella, quindi, è riferita alla Uno Rev3 ufficiale; non estendere automaticamente tali numeri alle altre schede Arduino.
| Caratteristica | Arduino Uno R3 | Significato operativo |
|---|---|---|
| Microcontrollore | ATmega328P | Esegue lo sketch caricato |
| Tensione di funzionamento logico | 5 V | Livello logico nominale della scheda |
| Pin digitali | 14 (D0–D13) | Usabili come ingressi o uscite, secondo configurazione |
| Pin digitali con PWM | 6 (D3, D5, D6, D9, D10, D11) | Supportano analogWrite() con uscita PWM, non tensione analogica continua |
| Ingressi analogici | 6 (A0–A5) | Ingressi per letture analogiche; sulla R3 possono anche svolgere funzioni digitali |
| Clock | 16 MHz | Riferimento temporale del microcontrollore |
| Memoria Flash | 32 KB, circa 0,5 KB riservati al bootloader | Programma memorizzato sul microcontrollore |
| SRAM / EEPROM | 2 KB / 1 KB | Dati temporanei / memorizzazione non volatile |
| LED integrato L | D13 | Consente la prima prova senza componenti esterni |
| Comunicazione con PC | USB tipo B, tramite ATmega16U2 nelle schede ufficiali standard | Caricamento dello sketch e collegamento seriale |
I dati tecnici principali provengono dalla scheda prodotto ufficiale Arduino. La memoria Flash non è tutta libera per lo sketch: la presenza del bootloader occupa una piccola porzione.
4. Anatomia della scheda
Osserva Arduino Uno R3 dall’alto, con serigrafia leggibile. Prima di collegare qualunque componente, individua le seguenti zone. La forma esatta del contenitore del microcontrollore può variare tra la versione tradizionale e la R3 SMD; la funzione resta la stessa.
| Componente | Come riconoscerlo | A cosa serve |
|---|---|---|
| ATmega328P | Chip principale sulla scheda | Esegue istruzioni e controlla i pin |
| Porta USB tipo B | Connettore metallico quadrangolare | Alimentazione da computer, caricamento e seriale |
| Jack cilindrico DC | Connettore nero per alimentatore esterno | Ingresso alimentazione tramite circuito di regolazione |
| Regolatori di tensione | Componenti vicino all’area di alimentazione | Gestione delle tensioni regolate della scheda |
| Header DIGITAL | Fila di connettori etichettati 0–13 | Accesso ai pin digitali |
| Header ANALOG IN | Fila A0–A5 | Letture analogiche |
| Header POWER | Pin etichettati 5V, 3.3V, GND, VIN, ecc. | Accesso alle linee di alimentazione e controllo |
| RESET | Pulsante marcato RESET | Riavvia lo sketch dall’inizio |
| LED ON | LED marcato ON | Indica la presenza dell’alimentazione |
| LED TX/RX | LED di attività seriale | Segnalano attività di comunicazione seriale |
| LED L | Piccolo LED marcato L | Associato al pin digitale 13 |
| ICSP | Header a sei contatti | Interfaccia di programmazione e collegamenti SPI |
| AREF | Pin AREF | Riferimento esterno ADC, da usare solo con conoscenza adeguata |
Per iniziare, segui questa procedura di riconoscimento: cerca prima USB e jack, poi la scritta DIGITAL e ANALOG IN, infine i gruppi POWER, RESET e i LED. Non confondere il LED L con quello ON: il primo è governabile dal programma, il secondo indica l’alimentazione. Il LED TX o RX può lampeggiare durante trasferimenti seriali senza che ciò costituisca un errore.

5. La mappa dei pin digitali
I pin D0–D13 possono rappresentare due stati logici. Quando un pin è configurato come uscita, HIGH corrisponde in condizioni ordinarie a un livello vicino a 5 V e LOW a un livello vicino a 0 V rispetto a GND. Quando è un ingresso, il suo valore dipende dal segnale esterno e dalla modalità di ingresso configurata.
pinMode(13, OUTPUT); imposta D13 come uscita; digitalWrite(13, HIGH); richiede uno stato alto. Configurare e comandare sono due operazioni distinte. Uno stesso numero non rappresenta un alimentatore: un pin GPIO non è progettato per alimentare indiscriminatamente motori o carichi elevati.
| Gruppo | Pin su Uno R3 | Attenzione |
|---|---|---|
| UART seriale | D0 RX, D1 TX | Condivisi con la comunicazione seriale: circuiti esterni possono interferire col caricamento |
| Interruzioni esterne | D2, D3 | Funzionalità speciali da approfondire |
PWM (~) |
D3, D5, D6, D9, D10, D11 | PWM è una commutazione temporizzata, non un DAC analogico |
| SPI | D10 SS, D11 MOSI, D12 MISO, D13 SCK | I segnali SPI sono anche presenti sul connettore ICSP |
| LED L integrato | D13 | Primo sketch Blink senza collegamenti |
Inoltre, la tilde ~ stampata accanto ad alcuni pin segnala la disponibilità di PWM. Non indica che quei pin siano gli unici a funzionare come uscite digitali: anche D2, per esempio, può essere un’uscita normale.
6. Ingressi analogici e funzioni condivise
Gli ingressi A0–A5 permettono di misurare tensioni analogiche nell’intervallo legato al riferimento ADC. Nella configurazione iniziale ordinaria di Uno R3 il riferimento è circa 5 V; la conversione ha risoluzione di 10 bit e produce valori interi da 0 a 1023. Questa è una caratteristica da conoscere, ma gli esperimenti con potenziometri e sensori verranno svolti in B2.05.
Inoltre, alcune funzioni utilizzano gli stessi contatti: I²C/TWI usa A4 (SDA) e A5 (SCL), mentre SPI condivide D10–D13 e il collegamento ICSP. La Uno R3 dispone anche di pin SDA/SCL duplicati vicino ad AREF: non costituiscono bus indipendenti. I pin A0–A5 possono essere impiegati anche come I/O digitali secondo la programmazione prevista dal core Arduino.
Per un principiante la regola è semplice: ogni pin ha un’etichetta, un livello elettrico e possibili funzioni alternative. Prima di assegnarlo a un progetto si controlla sempre il pinout della specifica revisione della scheda.

7. Alimentazione della scheda
Uno R3 può essere alimentata dalla porta USB oppure da una sorgente esterna adeguata. Il collegamento USB normalmente fornisce 5 V da un computer o alimentatore USB appropriato. Per l’alimentazione esterna tramite jack DC o VIN, Arduino indica un intervallo raccomandato di 7–12 V; il limite d’ingresso pubblicato è 6–20 V, ma i limiti non sono condizioni consigliabili per l’uso continuativo.
| Collegamento | Uso corretto | Errore da evitare |
|---|---|---|
| USB tipo B | Collegare con cavo dati adeguato al PC; può alimentare e comunicare | Non assumere che ogni cavo USB trasferisca dati |
| Jack DC | Alimentatore DC di polarità corretta e tensione raccomandata 7–12 V | Invertire polarità o superare il limite |
| VIN | Ingresso alimentazione non regolata secondo specifiche della scheda | Applicare VIN come se fosse il pin 5V |
| 5V | Linea regolata a 5 V; alimentazione diretta solo in circostanze progettate con attenzione | Applicare 9 V a 5V o collegare sorgenti incompatibili |
| 3.3V | Uscita regolata 3,3 V, fino a 50 mA secondo Arduino | Prelevare correnti superiori alla capacità indicata |
| GND | Riferimento comune di potenziale | Trattarlo come un’uscita di tensione positiva |
Pertanto, per i primi esperimenti preferiamo una sola alimentazione USB da un computer, senza componenti esterni. Se si usano più sorgenti o dispositivi, bisogna comprendere i percorsi di corrente e verificare la compatibilità prima di collegarli. Alimentare una scheda direttamente dal pin 5V aggira parte delle protezioni e della regolazione e non è una procedura introduttiva consigliata.

8. Regole di sicurezza elettrica
La sicurezza elettronica non dipende soltanto dalla tensione. Anche a 5 V un cortocircuito può causare surriscaldamento, danni alla porta USB e ai componenti. Un pin di I/O non è un generatore ideale: la scheda ufficiale riporta 20 mA come corrente DC per pin nelle specifiche, valore da non confondere con l’eventuale massimo assoluto del chip, che non è un obiettivo di funzionamento.
- Togli alimentazione prima di modificare i collegamenti.
- Identifica sempre GND, 5V, 3.3V e VIN: hanno ruoli differenti.
- Non collegare direttamente 5V e GND; non unire due uscite in conflitto.
- Non collegare motori e altri carichi energivori direttamente ai GPIO.
- Non applicare a un ingresso tensioni superiori al campo consentito.
- Non usare mai la tensione di rete domestica negli esperimenti del corso.
- Per alimentatori esterni controlla tensione, polarità, isolamento e corrente disponibili.
- Quando un componente scalda, c’è odore insolito o il PC segnala sovracorrente, interrompi la prova e ricontrolla il circuito.
In altre parole, il limite di 6–20 V all’ingresso esterno non significa che 20 V siano una buona scelta: maggiore differenza di tensione da smaltire significa possibile maggiore dissipazione del regolatore. La tensione logica della Uno R3 rimane nominalmente 5 V, indipendentemente dal fatto che un alimentatore appropriato al jack fornisca 9 V.
9. Arduino IDE 2.x: installazione
Arduino IDE 2.x è l’ambiente ufficiale per scrivere, verificare e trasferire sketch. Sul computer Windows apri la pagina ufficiale arduino.cc/en/software, individua Arduino IDE 2 e scarica l’installer adatto al sistema operativo. Usa il sito ufficiale: programmi distribuiti su portali non verificati possono essere obsoleti o alterati.
IDE: significato e attività principali
Che cosa significa IDE? La sigla IDE deriva dall’inglese Integrated Development Environment, in italiano Ambiente di Sviluppo Integrato. Riunisce in un unico programma gli strumenti necessari per preparare uno sketch: editing (scrittura e modifica del codice), verifica e compilazione (individuazione degli errori rilevabili dal compilatore e trasformazione del sorgente in programma eseguibile per la scheda), diagnostica e debugging (ricerca e correzione dei problemi con gli strumenti disponibili) e upload o caricamento (trasferimento del programma compilato alla scheda). Compilare correttamente non significa avere eliminato ogni errore logico e non prova che un circuito funzioni.
Di norma, uno sketch viene salvato in un file con estensione .ino. L’IDE permette di lavorare sullo stesso progetto, modificarlo, compilarlo e, quando la scheda è connessa, caricarlo. L’IDE 2.x è disponibile per i sistemi operativi desktop supportati, tra cui Windows, macOS e Linux; la compatibilità effettiva dipende dalla versione del sistema e dai requisiti indicati da Arduino.
Da IDE 1.x a IDE 2.x: che cosa è cambiato
Una distinzione storica utile: il precedente Arduino IDE 1.x era sviluppato in Java e collegato all’esperienza di Processing. L’attuale Arduino IDE 2.x utilizza invece tecnologie differenti: è basato sul framework open source Eclipse Theia ed è distribuito come applicazione desktop mediante Electron. Non bisogna attribuire all’IDE 2.x l’architettura software della versione precedente.
Installazione guidata su Windows
- Scarica la versione di Arduino IDE 2.x compatibile con il tuo computer.
- Esegui il programma di installazione e segui la procedura proposta dal sistema.
- Se vengono richiesti componenti o driver di Arduino, valuta l’installazione prevista dall’installer ufficiale.
- Avvia Arduino IDE 2 dal menu Start.
- Apri un nuovo sketch e salvalo in una cartella dedicata: per esempio
Blink_MEGISTONE. - Alla prima compilazione l’IDE potrebbe richiedere l’installazione o l’aggiornamento di piattaforme e strumenti.
Tuttavia, se non possiedi una scheda fisica puoi comunque preparare lo sketch e, selezionando la scheda e avendo installato il relativo core, verificarne la compilazione. Non puoi invece caricarlo su un dispositivo assente e osservarne il LED fisico.
10. Interfaccia e preparazione dell’IDE
L’interfaccia di IDE 2 contiene l’editor centrale, una barra dei comandi, il selettore della scheda e della porta, un’area dei messaggi e una barra laterale con strumenti come il Gestore delle schede e il Gestore delle librerie. La posizione precisa di icone e pannelli può dipendere dalla versione e dalle impostazioni della finestra.
Gli strumenti principali dell’ambiente
| Elemento | Azione dello studente | Risultato atteso |
|---|---|---|
| Editor | Scrive o modifica lo sketch | Il testo del programma appare sullo schermo |
| Verify / Verifica (✓) | Controlla e compila | Messaggio di successo oppure errori diagnostici |
| Upload / Carica (→) | Compila, quindi tenta il trasferimento | Sketch inviato alla scheda collegata se tutto è configurato |
| Selettore scheda | Sceglie Arduino Uno | Compilazione indirizzata all’architettura giusta |
| Selettore porta | Sceglie la porta USB/seriale effettiva | IDE sa con quale dispositivo comunicare |
| Boards Manager | Installa o aggiorna core, per Uno R3: Arduino AVR Boards | Disponibilità degli strumenti della piattaforma AVR |
| Library Manager | Cerca e gestisce librerie aggiuntive | Non necessario per Blink |
| Pannello output | Legge messaggi di compilazione/caricamento | Possibilità di diagnosticare eventuali errori |
Procedura per Uno R3: collega la scheda con un cavo USB tipo B che supporti il trasferimento dati. Apri il selettore delle schede e scegli Arduino Uno; controlla la porta rilevata. Se l’identificazione automatica fallisce, usa l’opzione per scegliere manualmente scheda e porta, oppure i menu Strumenti. Su Windows la porta spesso appare come COM..., ma il numero cambia da computer a computer.
Scheda, porta e collegamento USB
Infatti, la selezione della scheda stabilisce per quale piattaforma compilare; quella della porta identifica il collegamento fisico utilizzato per caricare. Si può compilare senza una porta collegata, mentre un normale caricamento USB richiede una porta disponibile. Se l’IDE non trova il core corretto, utilizza Boards Manager e installa Arduino AVR Boards.

11. Struttura di uno sketch Arduino
Uno sketch Arduino è un programma scritto in C++ con librerie e convenzioni Arduino. Non esiste qui un linguaggio completamente autonomo chiamato “linguaggio Arduino”. Il framework fornisce funzioni come pinMode(), digitalWrite() e delay(). In uno sketch standard esistono almeno due funzioni specifiche:
Il legame con Wiring. Storicamente l’ambiente e il linguaggio Arduino sono nati anche dall’esperienza di Wiring, un progetto pensato per semplificare la programmazione dell’hardware. È quindi corretto dire che il linguaggio Arduino si basa su Wiring; tuttavia non va presentato agli studenti come un linguaggio indipendente che sostituisce C/C++. Nel percorso odierno lo sketch .ino è compilato come C++ con l’aiuto del core, delle librerie e delle funzioni offerte da Arduino. Questa distinzione spiega perché ritroviamo graffe, variabili, funzioni e strutture di controllo già incontrate nello studio del C e perché possiamo usare molte caratteristiche del C++.
Le funzioni fondamentali: setup() e loop()
void setup() {
// Istruzioni eseguite all’avvio
}
void loop() {
// Istruzioni ripetute continuamente
}
setup() viene chiamata una volta dopo l’avvio o il reset; loop() viene richiamata ripetutamente durante il normale funzionamento. Le parentesi tonde () identificano le funzioni e i parametri, le graffe { } delimitano i blocchi e il punto e virgola ; termina molte istruzioni. I commenti // spiegano il codice senza essere eseguiti.
Inoltre, il C++ distingue maiuscole e minuscole: HIGH e high non sono equivalenti. OUTPUT è una costante Arduino; LED_PIN è un nome che scegliamo per rendere leggibile il programma. const int dichiara una costante intera, non una variabile che va modificata a ogni iterazione.

12. Primo programma completo: Blink
Il primo progetto utilizza esclusivamente il LED L già integrato nella scheda. Collega Uno R3 via USB e copia il seguente programma. Lo sketch è completo e non richiede sensori, resistori o LED esterni:
const int LED_PIN = LED_BUILTIN;
void setup() {
pinMode(LED_PIN, OUTPUT);
}
void loop() {
digitalWrite(LED_PIN, HIGH);
delay(1000);
digitalWrite(LED_PIN, LOW);
delay(1000);
}
Salva con nome Blink_MEGISTONE. Dopo compilazione e caricamento corretti il LED L si accende per circa un secondo, poi si spegne per circa un secondo, e la sequenza continua. Il LED ON, invece, normalmente rimane acceso per indicare l’alimentazione.
In questo modo, l’uso di LED_BUILTIN evita di inserire direttamente il numero 13 nel codice: sulla Uno R3 corrisponde a D13. La costante rende più leggibile lo sketch e ne facilita l’adattamento a schede che adottano un pin integrato differente.
13. Leggere Blink riga per riga
| Riga / costrutto | Significato e comportamento |
|---|---|
const int LED_PIN = LED_BUILTIN; |
Assegna a un nome chiaro il pin associato al LED integrato. |
void setup() |
Definisce la fase iniziale dello sketch, invocata a ogni nuovo avvio/reset. |
pinMode(LED_PIN, OUTPUT); |
Configura il pin come uscita digitale: condizione necessaria per comandare correttamente il LED. |
void loop() |
Contiene la sequenza che il programma ripete. |
digitalWrite(LED_PIN, HIGH); |
Porta il segnale del pin allo stato alto: sulla Uno R3 il LED integrato si accende. |
delay(1000); |
Attende circa 1000 millisecondi, cioè un secondo, senza passare subito alla riga seguente. |
digitalWrite(LED_PIN, LOW); |
Porta il segnale allo stato basso: il LED integrato si spegne. |
Secondo delay(1000); |
Mantiene lo stato spento per circa un secondo prima di ripetere il ciclo. |
Attenzione: digitalWrite() imposta un livello logico; delay() non cambia direttamente alcun pin. Di conseguenza, il LED rimane nello stato impostato dall’ultima scrittura durante l’attesa. Questo fatto spiega perché il LED resti acceso o spento invece di emettere un brevissimo impulso.
14. Il tempo del LED e i limiti di delay()
Dal codice ricaviamo la sequenza ON → attesa 1 s → OFF → attesa 1 s → ON. Nella configurazione ideale ogni ciclo completo dura circa 2 s, quindi si osserva un lampeggio completo ogni due secondi, pari a circa 0,5 cicli al secondo. Il tempo reale include piccoli tempi di esecuzione delle istruzioni.
Per esempio, per una prova di lettura del codice, immagina di sostituire il primo delay(1000) con delay(250) e il secondo con delay(750). Il LED resta acceso circa un quarto di secondo e spento tre quarti di secondo: il periodo resta circa 1 s. Non confondere periodo (accensione più spegnimento) con la sola durata dell’accensione.
Limite importante: delay() è una funzione bloccante per il normale avanzamento del codice nello sketch: durante quell’attesa non vengono eseguite le istruzioni successive di loop(). Non significa che il microcontrollore interrompa qualsiasi attività hardware o ogni possibile interrupt. In B2.08 studieremo millis() e le macchine a stati per gestire più attività senza queste attese bloccanti.

15. Compilare, caricare ed eseguire
Preparare uno sketch, compilarlo, caricarlo ed eseguirlo non sono sinonimi. Il percorso è: codice sorgente C++ → verifica/compilazione per la piattaforma selezionata → codice macchina → trasferimento alla memoria della scheda → esecuzione da parte dell’ATmega328P.
- Apri lo sketch completo e salva il file.
- Seleziona Arduino Uno nel selettore scheda dell’IDE.
- Premi Verifica (✓): controlla il pannello di output; se esistono errori di sintassi correggili.
- Connetti Uno R3 con un cavo dati e verifica che il sistema riconosca una porta seriale.
- Seleziona la porta corretta, senza dedurne il numero a priori.
- Premi Carica (→): l’IDE compila e trasferisce lo sketch tramite il meccanismo di caricamento previsto dalla scheda.
- Attendi il messaggio di trasferimento completato e osserva il LED L: circa 1 s acceso, 1 s spento.
- Premi RESET: lo sketch ricomincia dall’inizio; dopo
setup()torna a eseguireloop().
Tuttavia, la verifica non garantisce che un circuito sia collegato bene e non prova da sola che un LED reale lampeggerà. La compilazione può riuscire anche con un errore logico, per esempio se gli stessi livelli sono scritti due volte. Dopo il caricamento, Uno R3 esegue lo sketch anche senza il computer, purché rimanga correttamente alimentata.
16. Diagnosticare gli errori più comuni
| Sintomo / messaggio | Possibile causa | Controllo ragionato |
|---|---|---|
expected ; before ... |
Punto e virgola mancante | Leggere la posizione dell’errore e la riga precedente; aggiungere il carattere dove serve |
expected } at end of input |
Blocco di funzione non chiuso | Controllare la corrispondenza delle graffe |
high was not declared |
Maiuscole errate | Usare HIGH e LOW |
pinmode was not declared |
Nome funzione sbagliato | Usare pinMode, rispettando le maiuscole |
Missing FQBN |
Scheda non selezionata o piattaforma non disponibile | Selezionare Arduino Uno e controllare il core AVR |
no upload port provided |
Porta non scelta | Collegare la scheda e selezionare la porta |
avrdude ... not in sync |
Comunicazione fallita, scheda/porta errata o conflitto | Verificare collegamento, porta, scelta Uno, eventuali dispositivi su D0/D1 |
| Compila, ma LED sempre spento | Pin non configurato correttamente oppure comando errato | Controllare pinMode, LED_BUILTIN e livelli |
| LED sempre acceso | I due comandi potrebbero impostare entrambi HIGH |
Confrontare i due digitalWrite() |
| Scheda assente dall’elenco | Cavo solo alimentazione, porta/driver o collegamento problematico | Cambiare cavo dati e porta USB; verificare rilevazione nel sistema |
| Verifica OK ma upload fallisce | Compilazione riuscita, trasmissione non riuscita | Separare problema di codice da collegamento fisico e porta |
Perciò, la diagnostica efficace consiste nel riprodurre un errore per volta e osservare il messaggio prima di intervenire. Per gli esperimenti didattici di errore sintattico usa una copia salvata dello sketch corretto, così puoi sempre tornare al punto di partenza.
È possibile che alcuni messaggi cambino fra versioni di IDE e core Arduino. Un avviso riguardante la porta è diverso da un errore di compilazione; per questo la sequenza di controllo deve partire dall’individuazione della fase che non riesce.
17. Primo esperimento in Tinkercad Circuits
Tinkercad Circuits è un servizio esterno con cui simulare circuiti e programmi Arduino. È utile quando non è disponibile una scheda fisica e come confronto con i risultati di laboratorio. Non è un componente di MEGISTONE STEM LAB e non lo incorporiamo artificialmente in quest’ultimo.
- Apri Tinkercad Circuits e accedi se richiesto.
- Crea un nuovo circuito, assegnando un nome riconoscibile, per esempio
MEGISTONE_B2_02_Blink. - Cerca il componente Arduino Uno R3 e posizionalo nell’area di lavoro. Per questa prova non sono richiesti fili né componenti esterni.
- Apri il pannello Code; se l’interfaccia corrente offre la modalità Text o equivalente, selezionala e conferma l’eventuale sostituzione del codice iniziale.
- Inserisci lo sketch completo mostrato nella sezione 12.
- Se presente, premi Start Simulation o il controllo equivalente per avviare la simulazione.
- Osserva il LED L integrato: annota se la resa grafica consente di distinguere gli intervalli acceso/spento.
- Arresta la simulazione, modifica entrambe le attese a 500 ms e ripeti la prova; confronta i due ritmi.
Tuttavia, i nomi o la posizione dei comandi possono cambiare nel servizio online; verifica l’interfaccia che hai davanti. Tinkercad può simulare il comportamento previsto dal codice, ma non misura le caratteristiche elettriche effettive della tua scheda fisica né sostituisce i controlli hardware.
Se la simulazione non parte o il LED non è visibile, descrivi il problema con precisione: non concludere che il codice non funziona soltanto perché un comando della piattaforma è cambiato.
Tre esperimenti MEGISTONE verificati in Tinkercad
I progetti T01, T02 e T03 sono stati eseguiti e collaudati in Tinkercad Circuits il 20 novembre 2026. Tutti usano il solo LED L integrato nella scheda Arduino Uno R3: nessun circuito esterno.
Apri un pannello alla volta, seleziona Avvia simulazione e osserva il comportamento. Se il simulatore incorporato risulta troppo piccolo su smartphone, usa il pulsante arancione per aprire il progetto a schermo intero in una nuova scheda.
T01 — Blink integrato (1000 ms ON + 1000 ms OFF)
Obiettivo: Osserva il LED L e distinguilo dal LED ON, che indica l’alimentazione.
Risultato atteso: Periodo circa 2 s; frequenza circa 0,5 Hz; duty cycle 50%.
T02 — Blink veloce (500 ms ON + 500 ms OFF)
Obiettivo: Confronta il ritmo con T01: il ciclo è due volte più rapido.
Risultato atteso: Periodo circa 1 s; frequenza circa 1 Hz; duty cycle 50%.
T03 — Duty cycle 25% (250 ms ON + 750 ms OFF)
Obiettivo: Osserva l’accensione breve seguita da uno spegnimento tre volte più lungo.
Risultato atteso: Periodo circa 1 s; frequenza circa 1 Hz; duty cycle 25%.
Confronto e verifica
Annota per ciascuna prova il tempo di accensione, quello di spegnimento, il periodo T, la frequenza f = 1/T e il duty cycle D = tON/T × 100%. Il tempo reale può discostarsi lievemente dai valori teorici.
Continua a sperimentare: ritrovi questi tre progetti e molti altri esperimenti di elettronica e programmazione nella raccolta MEGISTONE — ARDUINO STEM LAB su Tinkercad.
▶ APRI MEGISTONE STEM LAB — ARDUINO UNO R3
Laboratorio virtuale interattivo con cinque modalità
A–E: anatomia, alimentazione, sketch, Blink e verifica.
18. Esperimento riproducibile e relazione
In particolare, un esperimento scientifico è riproducibile quando altri studenti possono eseguire la stessa procedura, conoscere le variabili e verificare i risultati. Per Blink segui questo protocollo:
| Voce della relazione | Compilazione richiesta |
|---|---|
| Obiettivo | Osservare una sequenza digitale periodica sul LED L della Uno R3 |
| Materiale | Uno R3 e cavo USB dati oppure simulatore Tinkercad Circuits |
| Software | Arduino IDE 2.x (indicare versione reale) oppure Tinkercad (indicare data della prova) |
| Codice | Riportare lo sketch della sezione 12 e le eventuali modifiche |
| Variabile indipendente | Valori di delay() in millisecondi |
| Variabile osservata | Tempi acceso/spento e periodo visivo del LED |
| Previsione | Con 1000/1000 ms: circa 1 s ON, 1 s OFF, periodo circa 2 s |
| Osservazione | Registrare ciò che si è davvero visto; specificare fisico o simulato |
| Possibili errori | Porta errata, mancato caricamento, editor in modalità diversa, valori modificati |
| Conclusione | Dire se i dati osservati sono coerenti con l’ipotesi, segnalando limiti della misura |
Esegui tre prove: A con 1000/1000 ms; B con 500/500 ms; C con 250/750 ms. Prevedi prima il periodo per ciascuna prova e poi confrontalo con l’osservazione. Per tempi precisi, il semplice conteggio a occhio non basta: descrivi il risultato come osservazione qualitativa, non come misura strumentale.
19. Allenati con MEGI: 20 esercizi
Per questo motivo, le attività sono progressive: rispondi prima senza consultare le soluzioni. Le verifiche sperimentali richiedono una prova effettiva; non inventare osservazioni.
Comprensione, hardware e sicurezza
- Comprensione. Spiega con parole tue la differenza fra piattaforma Arduino, scheda Uno R3 e microcontrollore ATmega328P.
- Comprensione. Quanti pin digitali e quanti ingressi analogici sono presenti su Uno R3?
- Comprensione. Perché non è corretto chiamare Arduino un linguaggio completamente diverso dal C++?
- Analisi hardware. Individua sulla tua scheda, o su un pinout ufficiale, USB B, jack DC, RESET, LED ON e LED L. Descrivi la funzione di ciascuno.
- Analisi hardware. Quali pin della Uno R3 sono contrassegnati per il PWM? Che cosa indica il simbolo ~?
- Analisi hardware. Quali contatti sono associati alla seriale hardware e perché è prudente non usarli durante il primo caricamento?
- Sicurezza. Una persona propone di applicare 9 V al pin 5V perché il jack accetta 9 V. Spiega l’errore.
- Sicurezza. Distingui il valore 7–12 V raccomandato per ingresso esterno dal limite 6–20 V.
Lettura del codice e diagnosi degli errori
- Lettura codice. Quale istruzione imposta il pin del LED come uscita?
- Lettura codice. Quante volte viene chiamata setup() dopo l’avvio, in assenza di reset? Che cosa succede a loop()?
- Lettura codice. Quale comando spegne il LED integrato nel programma Blink?
- Tempi. Calcola il periodo teorico di Blink con 1000 ms acceso e 1000 ms spento.
- Tempi. Con 250 ms ON e 750 ms OFF, quale periodo teorico e quale frazione del tempo è ON?
- Debug. Correggi la riga errata
pinmode(LED_PIN, output). - Debug. Che cosa può succedere se scrivi
digitalWrite(LED_PIN, high);? Correggi. - Debug. Il programma compila ma segnala “no upload port provided”: è un errore di sintassi? Che cosa controlli?
Modifiche, simulazione e interpretazione
- Modifica. Scrivi i quattro comandi che rendono Blink acceso circa 200 ms e spento circa 800 ms.
- Modifica. Come faresti lampeggiare più rapidamente mantenendo tempi ON e OFF uguali? Proponi valori concreti.
- Tinkercad. Riproduci Blink in Tinkercad, avvia e arresta la simulazione, poi riporta due osservazioni verificabili.
- Interpretazione. Indica una differenza tra prova su scheda reale e prova simulata e spiega perché entrambe sono utili.
20. Soluzioni guidate e autoverifica
Infine, le soluzioni sono in pannelli richiudibili, separati dagli enunciati. Per le domande sperimentali la risposta modello indica soltanto cosa verificare: non certifica una prova non eseguita.
Risposte guidate: esercizi 1–10
Soluzione 1 — Comprensione
La piattaforma include hardware, software e risorse; Uno R3 è la scheda completa; ATmega328P è il chip che esegue lo sketch.
Soluzione 2 — Comprensione
14 digitali D0–D13 e 6 analogici A0–A5.
Soluzione 3 — Comprensione
Gli sketch usano C++ con framework e funzioni Arduino.
Soluzione 4 — Analisi hardware
USB B: dati/alimentazione; jack: alimentazione esterna; RESET: riavvio; ON: presenza alimentazione; L: LED comandabile su D13.
Soluzione 5 — Analisi hardware
D3, D5, D6, D9, D10, D11; ~ indica disponibilità PWM.
Soluzione 6 — Analisi hardware
D0 RX e D1 TX; dispositivi esterni possono interferire con la comunicazione di caricamento.
Soluzione 7 — Sicurezza
Il pin 5V è una linea a 5 V, non il jack regolato: applicare 9 V direttamente è scorretto e pericoloso per la scheda.
Soluzione 8 — Sicurezza
7–12 V è l’intervallo consigliato per jack/VIN; 6–20 V sono limiti pubblicati e non una raccomandazione operativa.
Soluzione 9 — Lettura codice
pinMode(LED_PIN, OUTPUT);
Soluzione 10 — Lettura codice
setup() una volta; loop() viene richiamata ripetutamente.
Risposte guidate: esercizi 11–20
Soluzione 11 — Lettura codice
digitalWrite(LED_PIN, LOW);
Soluzione 12 — Tempi
Circa 2000 ms = 2 s.
Soluzione 13 — Tempi
Periodo circa 1000 ms = 1 s; LED ON per il 25% del ciclo.
Soluzione 14 — Debug
pinMode(LED_PIN, OUTPUT);
Soluzione 15 — Debug
Errore di compilazione per identificatore high non definito; usare HIGH.
Soluzione 16 — Debug
No; è un problema di porta di caricamento. Controllare USB dati, riconoscimento e selezione porta.
Soluzione 17 — Modifica
digitalWrite(LED_PIN,HIGH); delay(200); digitalWrite(LED_PIN,LOW); delay(800);
Soluzione 18 — Modifica
Per esempio sostituire i due delay(1000) con delay(250): periodo circa 0,5 s.
Soluzione 19 — Tinkercad
Atteso: LED L alterna acceso/spento; con 500/500 ms il ciclo appare più veloce rispetto a 1000/1000 ms. Registrare solo osservazioni effettive.
Soluzione 20 — Interpretazione
La prova reale verifica la scheda e il collegamento fisico; la simulazione consente esercizi senza hardware ma dipende dal modello del servizio.
21. Sintesi e collegamento alla prossima unità
Hai imparato a distinguere il microcontrollore dalla scheda, leggere il pinout della Uno R3, proteggere i collegamenti di alimentazione, selezionare una scheda nell’IDE e comprendere perché verificare un programma è diverso dal caricarlo e osservarlo. Con Blink hai trasformato un semplice listato C++ in una sequenza temporale fisica.
L’unità B2.03 — Uscite digitali: LED, breadboard e monitor seriale ripartirà da queste competenze per introdurre componenti esterni, resistenze, collegamenti su breadboard e uso operativo del monitor seriale. I progetti con sensori e ingressi analogici verranno affrontati più avanti: non serve anticiparli ora.
Raccordo con B2.01 — Microcontrollori: architettura e funzionamento: qui abbiamo applicato a una scheda concreta i concetti generali già studiati.
22. Fonti, risorse e approfondimenti
Le fonti tecniche seguenti sono link ufficiali utili anche per controllare revisioni e differenze tra schede. Per materiali e interfacce che possono cambiare, verificare sempre la data e il modello riportato dal produttore.
- Arduino — documentazione ufficiale Uno Rev3.
- Arduino Store — specifiche tecniche Uno R3.
- Arduino — scaricamento e installazione IDE 2.
- Arduino — verifica e caricamento di uno sketch.
- Arduino Help Center — selezionare scheda e porta.
- Autodesk — Tinkercad Circuits.
- MEGISTONE — B2.01.
- Arduino — che cos’è Arduino e principi open source
- Arduino — confronto dei linguaggi e relazione con Wiring
- Arduino — IDE 2 e architettura Eclipse Theia
Nota editoriale: in questa versione il pulsante arancione 3D non è ancora presente. Verrà aggiunto soltanto dopo realizzazione, pubblicazione e collaudo dello STEM LAB B2.02, secondo il protocollo della roadmap. Le figure 1–6 sono diagrammi didattici originali e semplificati; la HERO è una rappresentazione artistica, non una fotografia tecnica certificata. Per il cablaggio utilizzare sempre il pinout ufficiale della scheda.