Arduino è una piattaforma per prototipazione elettronica e sviluppo embedded che permette di collegare software e mondo fisico: puoi leggere un sensore, controllare un motore, accendere LED, gestire relè, comunicare con altri dispositivi o costruire un nodo IoT senza progettare da zero tutta l’elettronica di controllo.
Definirlo semplicemente come “una scheda con un microcontrollore”, però, oggi è riduttivo. L’ecosistema comprende numerose famiglie hardware, ambienti di sviluppo, librerie, servizi cloud e piattaforme che vanno dalle classiche board a microcontrollore fino a sistemi ibridi capaci di combinare Linux, elaborazione avanzata e controllo real-time.
È una distinzione importante perché cambia anche il modo di scegliere.
Per un primo progetto può bastare una board della famiglia UNO. Per un dispositivo compatto può essere più indicata una Nano. Un sistema industriale può richiedere Portenta o Opta. Se invece servono Linux, computer vision o AI locale, piattaforme come UNO Q e VENTUNO Q appartengono a una categoria molto diversa dalle Arduino tradizionali.
In questa guida partiamo quindi dal meccanismo, non dal catalogo: cos’è Arduino, come funziona realmente, come si programma, quali schede esistono e soprattutto come capire quale architettura serve al progetto.
Cos’è Arduino: scheda, microcontrollore o piattaforma?
Arduino non identifica una singola scheda.
La documentazione ufficiale Arduino separa infatti l’ecosistema in hardware, software, Cloud e strumenti di programmazione. Una board come UNO R3 è soltanto una delle possibili implementazioni della piattaforma.
La distinzione più utile è questa:
Arduino = hardware + ambiente software + API/librerie + strumenti + ecosistema
Una normale scheda a microcontrollore contiene il componente che esegue il programma, ma aggiunge anche circuiti di alimentazione, connessioni, pin, interfacce USB e altri elementi che rendono molto più semplice utilizzare quel microcontrollore in un progetto reale.
Scheda Arduino e microcontrollore non sono la stessa cosa
Il microcontrollore è il circuito integrato che esegue il firmware e controlla le periferiche.
La scheda Arduino è invece il sistema costruito attorno a quel componente.
Per esempio, la classica UNO R3 utilizza un ATmega328P. Sulla board trovi però anche connettore USB, regolazione dell’alimentazione, pin di input/output, reset, componenti passivi e tutto ciò che permette di alimentare, programmare e collegare facilmente il microcontrollore.
Questo è uno dei motivi per cui iniziare con una board è molto più semplice che acquistare soltanto il chip.
Non devi prima progettare una PCB, realizzare il circuito di programmazione e predisporre manualmente ogni connessione: gran parte dell’infrastruttura è già pronta.
Hardware, software e librerie: cosa forma davvero l’ecosistema Arduino
L’hardware da solo sarebbe poco utile senza il software che permette di programmarlo.
Il flusso tradizionale è semplice:
codice → compilazione → firmware → microcontrollore → periferiche
Scrivi un programma, selezioni la board, lo compili e lo trasferisci sulla scheda. Da quel momento il microcontrollore esegue autonomamente il firmware.
A questo si aggiungono le librerie, che forniscono funzioni già pronte per comunicare con sensori, display, bus, moduli radio, motori e moltissime altre periferiche.
È qui che l’ecosistema diventa particolarmente utile. Il vantaggio non consiste soltanto nell’avere una board semplice da collegare: consiste nel poter riutilizzare software, esempi, documentazione e componenti sviluppati attorno a interfacce relativamente uniformi.
Perché l’open source ha reso Arduino diverso dalle normali schede elettroniche
Arduino è cresciuto attorno a una forte cultura open source.
Per molte board sono disponibili schemi elettrici, pinout, file di progettazione e documentazione tecnica, mentre buona parte dello stack software è sviluppata pubblicamente. Arduino IDE 2, per esempio, è open source.
Questo ha favorito un ecosistema enorme di schede compatibili, librerie, shield, sensori, moduli e progetti.
Non significa però che qualunque prodotto che utilizzi il nome Arduino, qualunque componente dell’ecosistema o qualunque servizio abbia necessariamente la stessa licenza. Quando la licenza è materialmente importante conviene verificare il singolo progetto o prodotto, non applicare automaticamente l’etichetta “open source” a tutto ciò che gli ruota attorno.
Da Ivrea all’ecosistema attuale: cosa è cambiato
Arduino nasce nei primi anni Duemila come progetto orientato a rendere elettronica e programmazione più accessibili a studenti, designer, maker e persone che non provenivano necessariamente dall’ingegneria embedded.
La semplicità iniziale era una parte essenziale dell’idea: collegare la board, scrivere poche righe, caricare uno sketch e ottenere un risultato fisico.
Quell’approccio è rimasto, ma l’hardware è cambiato profondamente.
Accanto alle classiche piattaforme a microcontrollore oggi esistono prodotti per IoT, automazione industriale, edge computing, robotica e AI. Arduino è inoltre entrata nella famiglia Qualcomm mantenendo il proprio brand e dichiarando di voler continuare a supportare un ecosistema aperto e multi-vendor.
Per questo una descrizione costruita esclusivamente attorno alla vecchia UNO con ATmega328P racconta ancora bene una parte importante della piattaforma, ma non più l’intero panorama.
Come funziona Arduino: dal sensore allo sketch e all’azione
Il modo più semplice per capire il funzionamento di una scheda a microcontrollore è pensare a un ciclo:
input → elaborazione → output
Un input può essere la temperatura letta da un sensore, la pressione di un pulsante, la posizione di un potenziometro o un messaggio ricevuto da un altro dispositivo.
Il firmware elabora quell’informazione e decide cosa fare.
L’output può essere un LED, un display, un motore, un relè, un messaggio seriale oppure un dato inviato attraverso la rete.
Supponiamo di voler accendere una ventola quando la temperatura supera una soglia.
Il processo concettuale è:
temperatura → sensore → microcontrollore → confronto → comando → ventola
La board non “capisce” la temperatura nel senso umano del termine. Legge un valore elettrico o digitale, lo interpreta secondo il programma che hai scritto e modifica un’uscita.
Questa relazione diretta con il mondo fisico è uno dei motivi principali per cui Arduino viene usato in elettronica, automazione, robotica e prototipazione.
Input, elaborazione e output
Gli input possono essere digitali o analogici.
Un ingresso digitale distingue normalmente stati logici come HIGH e LOW.
Un ingresso analogico viene invece convertito in un valore numerico attraverso un convertitore analogico-digitale, o ADC. Questo consente di misurare tensioni variabili prodotte, per esempio, da sensori o potenziometri.
Il firmware può quindi eseguire condizioni, calcoli e temporizzazioni.
Esempio concettuale:
if (temperatura > soglia) {
accendiVentola();
} else {
spegniVentola();
}
Il codice reale dipenderà dal sensore, dalla board e dal circuito utilizzato, ma il meccanismo rimane quello.
GPIO, ingressi analogici, PWM e protocolli di comunicazione
I pin GPIO, General Purpose Input/Output, permettono di usare determinate connessioni della scheda come ingressi o uscite.
Non tutti i pin hanno però le stesse capacità.
A seconda della board puoi trovare:
- input/output digitali;
- ingressi analogici;
- PWM;
- UART;
- I2C;
- SPI;
- CAN;
- altre periferiche specifiche dell’hardware.
Il PWM, Pulse Width Modulation, merita una precisazione. Sulle board dove viene utilizzato per analogWrite(), non significa necessariamente che il pin stia producendo una vera tensione analogica continua. Il segnale digitale viene acceso e spento rapidamente modificando il duty cycle.
Per pilotare la luminosità di un LED o controllare determinati carichi può essere sufficiente. Se serve un vero output analogico, devi verificare se la board mette a disposizione un DAC.
Cosa succede quando carichi un programma sulla scheda
I programmi Arduino vengono chiamati sketch.
La specifica ufficiale degli sketch prevede normalmente un file .ino, ma un progetto può contenere anche file C++, C, assembly e header.
Quando premi il pulsante di compilazione non viene inviato direttamente il testo dello sketch alla board.
Il processo comprende varie fasi:
sketch → preprocessing → compilazione → linking → firmware → upload
Il processo di build documentato da Arduino aggiunge al codice .ino alcuni elementi necessari, prepara il sorgente per il compilatore, compila il progetto insieme al core e alle librerie richieste, collega i componenti e produce il file binario destinato all’hardware.
Il metodo esatto di upload cambia in base alla piattaforma.
Sulle board tradizionali il firmware può essere trasferito attraverso USB/seriale e un bootloader; altre architetture utilizzano procedure differenti.
Microcontrollore e firmware: perché non serve un sistema operativo
Una board Arduino classica non ha bisogno di Windows, macOS o di una distribuzione Linux per eseguire il proprio sketch.
Il firmware gira direttamente sul microcontrollore, con un livello software molto più piccolo rispetto a un sistema operativo general-purpose.
Questo permette:
- avvio rapido;
- controllo diretto delle periferiche;
- consumi ridotti;
- comportamento relativamente prevedibile;
- utilizzo di hardware con memoria e potenza limitate.
È uno dei motivi per cui un microcontrollore può essere più adatto di un computer quando deve svolgere una funzione precisa e ripetitiva.
L’eccezione moderna: cosa cambia con Arduino UNO Q
La distinzione “Arduino non esegue Linux” oggi richiede una precisazione.
Arduino UNO Q utilizza un’architettura ibrida: combina un microprocessore Qualcomm Dragonwing QRB2210 capace di eseguire Debian Linux con un microcontrollore STM32U585 dedicato alle attività real-time.
I due mondi possono comunicare attraverso un meccanismo RPC.
In forma semplificata:
Linux / applicazioni → bridge RPC → microcontrollore → controllo real-time
Questo permette di affiancare workload relativamente complessi — elaborazione, networking, Python o AI — al controllo deterministico dell’hardware.
UNO Q non rende quindi sbagliato il modello classico del microcontrollore: mostra piuttosto che Arduino oggi comprende anche piattaforme che vanno oltre quel modello.
Com’è fatta una scheda Arduino
Non esiste una struttura identica per tutte le board, ma alcuni elementi tornano frequentemente.
Capire il ruolo dei componenti è più utile che imparare a memoria il pinout di un singolo modello.
Microcontrollore, memoria e clock
Il microcontrollore determina una parte importante delle capacità della scheda.
Al suo interno trovi normalmente CPU, memoria e periferiche integrate.
Tre parametri sono particolarmente facili da incontrare nelle specifiche:
Flash
Conserva il firmware.
RAM
Contiene dati e variabili utilizzati durante l’esecuzione.
Clock
Indica la frequenza operativa del processore, ma non è una misura universale delle prestazioni.
Confrontare due board soltanto in MHz è quasi sempre troppo semplicistico. Architettura della CPU, periferiche, acceleratori, memoria e software incidono sul risultato finale.
Pin digitali e analogici
I pin digitali permettono di leggere o impostare stati logici.
Puoi usarli, per esempio, per:
- leggere un pulsante;
- accendere un LED;
- controllare un relè attraverso il circuito appropriato;
- rilevare un segnale digitale;
- interagire con moduli elettronici.
Gli ingressi analogici servono invece a misurare segnali continui entro i limiti elettrici previsti dalla board.
Il pin non è una sorgente di potenza generica.
Motori, strisce LED, relè e altri carichi possono richiedere transistor, MOSFET, driver, alimentatori esterni o circuiti di protezione. Collegare un carico troppo esigente direttamente a un GPIO può danneggiare l’hardware.
Alimentazione, USB e tensioni operative
L’alimentazione è uno degli aspetti più sottovalutati nei primi progetti.
A seconda della board puoi alimentare il sistema attraverso USB, connettori dedicati o pin specifici. I limiti di tensione e corrente cambiano però fra i modelli.
Anche la tensione logica non è universale.
Alcune piattaforme lavorano a 5 V, altre a 3,3 V. Collegare due dispositivi senza controllare i livelli elettrici può causare malfunzionamenti e, nei casi peggiori, danni permanenti.
Prima di collegare un modulo esterno, controlla sempre:
- tensione di alimentazione;
- tensione logica;
- corrente richiesta;
- pinout;
- eventuali level shifter necessari.
I2C, SPI, UART e altre interfacce
Quando un sensore o un modulo deve scambiare più informazioni di un semplice stato acceso/spento, entrano in gioco i bus di comunicazione.
UART viene spesso utilizzato per comunicazioni seriali punto-punto.
I2C permette a più dispositivi di condividere lo stesso bus utilizzando indirizzi.
SPI offre generalmente una comunicazione più veloce e utilizza linee dedicate per clock, dati e selezione dei dispositivi.
La scelta non è puramente software: il dispositivo collegato deve supportare il protocollo e devi utilizzare i pin corretti previsti dalla board.
Shield, moduli, sensori e attuatori
Uno shield è una scheda di espansione progettata per essere montata sopra una board compatibile e aggiungere determinate funzioni.
Un modulo è invece un termine più generale. Può essere un sensore, un display, un convertitore, un’interfaccia radio, un driver per motori o un altro circuito collegato attraverso pin e bus.
I sensori trasformano grandezze fisiche in informazioni utilizzabili dal sistema.
Gli attuatori compiono il percorso inverso: trasformano un comando del controller in un’azione fisica.
È questa catena che rende l’elettronica programmabile:
sensore → dato → firmware → decisione → attuatore
Software Arduino: IDE, Cloud Editor, App Lab e librerie
Per programmare una board non basta un editor di testo.
Serve una toolchain capace di conoscere l’architettura dell’hardware, compilare il progetto con il core corretto, includere le librerie e trasferire il firmware.
L’ecosistema offre più strumenti perché non tutti i progetti hanno le stesse esigenze.
Arduino IDE 2 e perché il vecchio IDE 1.x è ormai legacy
Arduino IDE rimane il punto di partenza più naturale per chi vuole programmare le board dal computer.
IDE 2 ha sostituito il vecchio ramo 1.x come ambiente desktop corrente e offre un editor moderno, completamento del codice, navigazione e altri strumenti assenti o più limitati nella generazione precedente.
La vecchia release 1.8.19 è ancora disponibile nella sezione Legacy IDE.
Se trovi un tutorial che utilizza l’interfaccia 1.x, il codice può essere ancora perfettamente utile. Non bisogna però aspettarsi che menu, gestione delle board e interfaccia coincidano esattamente con l’ambiente moderno.
Board Manager e Library Manager
Arduino IDE non contiene nativamente ogni possibile board e libreria.
Il Boards Manager installa i pacchetti necessari per supportare specifiche famiglie hardware.
Il Library Manager consente invece di cercare e installare librerie.
La distinzione è utile quando compare un errore.
Se l’IDE non conosce la board o non riesce a compilarne il core, il problema può riguardare il pacchetto hardware.
Se invece manca un header richiesto dallo sketch, potresti dover installare una libreria.
Cambiare codice prima di capire quale dei due livelli sta fallendo spesso porta soltanto ad aggiungere un secondo problema al primo.
Arduino Cloud Editor: quando usare il browser
Arduino Cloud permette di configurare, programmare e collegare dispositivi attraverso servizi online.
Il Cloud Editor può essere comodo quando vuoi lavorare dal browser, mantenere sketch nell’ambiente cloud o integrare il codice con funzionalità IoT, dashboard e variabili sincronizzate.
Non è però obbligatorio.
Per un progetto locale che deve semplicemente compilare e caricare firmware sulla board, Arduino IDE può essere più lineare e ridurre le dipendenze esterne.
La scelta dovrebbe dipendere dal workflow, non dall’idea che cloud significhi automaticamente “più moderno”.
Arduino App Lab e le nuove schede Linux-capable
Arduino App Lab nasce per una classe diversa di hardware.
Su UNO Q e VENTUNO Q puoi avere contemporaneamente un ambiente Linux e un microcontrollore. App Lab serve proprio a orchestrare applicazioni che possono combinare sketch, codice Python, componenti software e modelli AI.
Non lo considererei quindi il sostituto universale dell’IDE.
Su una normale board a microcontrollore, IDE 2 continua ad avere perfettamente senso.
Su una piattaforma dual-architecture, App Lab permette invece di lavorare su livelli che il tradizionale sketch da solo non copre.
Arduino CLI e strumenti avanzati: a chi servono davvero
Arduino CLI porta molte funzioni dell’ecosistema nella riga di comando.
Permette di gestire board, librerie, compilazione e upload senza dipendere dall’interfaccia grafica dell’IDE.
Diventa particolarmente interessante quando vuoi:
- automatizzare build;
- utilizzare CI/CD;
- integrare Arduino in altri editor;
- riprodurre ambienti di sviluppo;
- gestire più progetti in modo scriptabile.
Per il primo LED lampeggiante sarebbe complessità inutile.
Per un progetto mantenuto in team o inserito in una pipeline software, può diventare il workflow più pulito.
Come si programma Arduino
Una delle frasi più ripetute è che Arduino usa “il linguaggio Arduino”.
È una semplificazione comprensibile, ma rischia di creare l’idea di un linguaggio completamente separato.
Nella pratica tradizionale lavori principalmente con C++ e con le API fornite dal framework Arduino.
Se vuoi approfondire tipi, compilazione, gestione delle risorse e differenze rispetto ad altri linguaggi, nella guida a C++ analizziamo separatamente il linguaggio e i suoi principali trade-off.
Quale linguaggio usa Arduino e qual è il rapporto con C++
Uno sketch .ino viene preprocessato prima della normale compilazione.
L’ambiente aggiunge automaticamente elementi che in un progetto C++ tradizionale dovresti gestire esplicitamente e mette a disposizione funzioni semplici come:
pinMode() digitalRead() digitalWrite() analogRead() delay()
Questa astrazione rende più semplice iniziare.
Sotto, però, rimane una toolchain compilata e puoi organizzare progetti più complessi utilizzando file .cpp, header, classi, funzioni e molte normali caratteristiche di C++.
Quindi:
Arduino non richiede di imparare tutto C++ prima di accendere un LED, ma capire progressivamente C++ diventa molto utile quando i progetti crescono.
Come funzionano setup() e loop()
Lo sketch più semplice contiene normalmente due funzioni:
void setup() {
}
void loop() {
}
setup() viene utilizzata per l’inizializzazione.
Qui puoi configurare pin, avviare comunicazioni seriali, inizializzare sensori o preparare altre risorse.
loop() contiene invece la logica che viene eseguita ripetutamente durante il normale funzionamento.
Un modello mentale utile è:
avvio → setup() una volta → loop() → loop() → loop() → ...
Questo non significa che tutto il software embedded debba essere scritto come un unico enorme ciclo. Timer, interrupt, RTOS e architetture più complesse permettono di costruire sistemi molto più articolati.
Per iniziare, però, setup() e loop() rendono esplicito il flusso fondamentale.
Compilazione, upload e bootloader
Quando compili, il codice viene trasformato in istruzioni adatte all’architettura selezionata.
È per questo che nell’IDE devi scegliere la board corretta.
Uno sketch non è semplicemente un file universale che viene copiato su qualunque microcontrollore. Core, compilatore, opzioni e librerie possono dipendere dall’hardware.
L’upload trasferisce poi il risultato della compilazione alla scheda.
Su molte piattaforme tradizionali interviene un bootloader, cioè un piccolo programma già presente nel dispositivo che permette di caricare nuovo firmware senza ricorrere ogni volta a un programmatore hardware esterno.
Il primo sketch: Blink spiegato senza magia
Il classico esempio Blink accende e spegne il LED integrato.
Una versione minimale è:
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
Non è interessante perché fa lampeggiare una luce.
È interessante perché contiene già l’intero modello operativo.
pinMode() configura il pin come uscita.
digitalWrite() modifica lo stato elettrico.
delay() sospende l’esecuzione per il tempo specificato.
loop() ripete il comportamento.
Da qui puoi sostituire il LED con un circuito più complesso, aggiungere input e prendere decisioni.
C’è però subito una lezione importante: delay() blocca il normale flusso del programma. È perfetta per imparare, molto meno per sistemi che devono gestire contemporaneamente più eventi.
Un buon percorso didattico usa Blink per capire il modello, non come architettura definitiva di qualsiasi progetto.
Librerie: perché evitano di riscrivere tutto da zero
Una libreria racchiude codice riutilizzabile dietro un’interfaccia più semplice.
Se devi pilotare un display, leggere un sensore o comunicare con un modulo complesso, implementare personalmente ogni dettaglio del protocollo sarebbe spesso inutile.
Le librerie accelerano il lavoro, ma introducono anche una dipendenza.
Prima di sceglierne una controllerei almeno:
- board supportate;
- architetture compatibili;
- manutenzione recente;
- documentazione;
- dipendenze;
- licenza se rilevante per il progetto.
Il fatto che una libreria compili sulla UNO R3 non garantisce automaticamente che funzioni su un’architettura completamente diversa.
A cosa serve Arduino: i progetti in cui ha davvero senso
Il punto forte di Arduino è il controllo programmabile dell’hardware.
Questo lo rende particolarmente efficace quando il software deve misurare, controllare o reagire a qualcosa nel mondo fisico.
Sensori, automazione e domotica
Puoi utilizzare una board per acquisire temperatura, umidità, luce, distanza, pressione, movimento e molte altre grandezze.
Il firmware può quindi controllare:
- illuminazione;
- pompe;
- valvole;
- ventole;
- allarmi;
- serrature;
- sistemi di irrigazione;
- altri dispositivi.
Non tutto ciò che può essere automatizzato dovrebbe però essere affidato a un prototipo montato su breadboard.
Quando un sistema deve controllare carichi pericolosi, tensione di rete, dispositivi di sicurezza o processi critici, progettazione elettrica, isolamento, fail-safe e conformità diventano molto più importanti del semplice sketch.
Robotica e controllo di motori
La robotica è un altro caso d’uso naturale.
Sensori e algoritmi forniscono informazioni al controller, che deve comandare motori e attuatori.
Lo schema diventa:
sensori → controller → decisione → driver → motori
Il driver è importante.
Un microcontrollore non dovrebbe normalmente alimentare direttamente un motore attraverso i GPIO. Correnti, disturbi e tensioni richiedono elettronica adatta al carico.
Su robot semplici una board a microcontrollore può gestire quasi tutta la logica.
Quando entrano in gioco computer vision, modelli AI o elaborazioni molto più pesanti, può invece essere affiancata a un computer oppure sostituita da piattaforme ibride.
IoT e dispositivi connessi
Con una board dotata di Wi-Fi, Ethernet, Bluetooth o altre interfacce puoi creare un nodo IoT capace di misurare dati e scambiarli con altri sistemi.
La catena può diventare:
sensore → Arduino → rete → piattaforma → dashboard → comando
Il microcontrollore non deve necessariamente fare tutto.
Può occuparsi dell’interazione con sensori e attuatori mentre server, gateway o cloud gestiscono storage, dashboard, automazioni e analisi.
Questa separazione è spesso più robusta di un dispositivo che tenta di concentrare ogni funzione nello stesso firmware.
Prototipazione ed elettronica didattica
Arduino è particolarmente utile quando vuoi capire rapidamente se un’idea funziona.
Puoi collegare componenti su breadboard, modificare il codice e cambiare il circuito senza dover produrre immediatamente una PCB definitiva.
È perfetto per:
- studio;
- laboratorio;
- proof of concept;
- test di sensori;
- prototipi di interfaccia;
- validazione di logiche di controllo.
Il prototipo deve però essere riconosciuto per ciò che è.
Una breadboard con cavetti volanti può dimostrare che il principio funziona. Non dimostra automaticamente che il sistema sia pronto per funzionare anni in un ambiente industriale.
Edge AI e applicazioni più avanzate
Le piattaforme Q spostano ulteriormente il confine.
UNO Q combina Linux con un microcontrollore real-time, mentre VENTUNO Q utilizza un processore Qualcomm Dragonwing IQ8 con accelerazione AI insieme a un STM32H5 dedicato al controllo.
Questo tipo di architettura permette di associare attività come:
- computer vision;
- inferenza AI locale;
- riconoscimento audio;
- robotica;
- analisi di dati;
a funzioni che richiedono controllo puntuale dell’hardware.
Sono casi molto diversi dal primo sensore collegato a una UNO, ma appartengono ormai allo stesso ecosistema.
Quando Arduino non è la piattaforma giusta
Non sceglierei una normale board a microcontrollore se il progetto richiede soprattutto:
- un desktop completo;
- molte applicazioni general-purpose;
- grandi quantità di RAM;
- browser moderno;
- database importanti;
- container;
- filesystem complesso;
- elaborazione multimediale pesante.
In questi casi un single-board computer, un mini PC o un computer tradizionale può essere più adatto.
Al contrario, utilizzare un intero computer Linux soltanto per leggere un pulsante e pilotare un relè può aggiungere consumi, tempi di boot e complessità senza un beneficio reale.
Quali schede Arduino esistono e quale scegliere
Il catalogo è troppo ampio per avere senso come lista da memorizzare.
Conviene partire dallo scenario.
| Scenario | Famiglia da valutare | Perché | Cosa controllare |
|---|---|---|---|
| Primo progetto ed elettronica general-purpose | UNO | Formato consolidato, documentazione, semplicità | R3 vs R4 e compatibilità delle librerie |
| Progetto compatto | Nano | Dimensioni ridotte e diverse opzioni di connettività | Tensione, pinout e MCU della variante |
| Molti I/O o progetto più ampio | Mega / GIGA | Maggiori risorse e possibilità di espansione | Ingombro e complessità |
| IoT | Board con connettività integrata | Wi-Fi/Bluetooth o altre reti senza moduli separati | Protocollo, consumi, alimentazione |
| Automazione professionale | Portenta / Opta | Hardware e interfacce orientati a scenari professionali | Toolchain, I/O e requisiti industriali |
| Linux + microcontrollore | UNO Q | Computing Linux e controllo real-time sulla stessa piattaforma | Complessità software e necessità reale di Linux |
| Edge AI e robotica avanzata | VENTUNO Q | Elaborazione AI + MCU dedicato all’actuation | Prestazioni richieste, costi e architettura |
La tabella non stabilisce quale sia “la migliore Arduino”.
Serve a eliminare le famiglie sbagliate prima di confrontare modelli specifici.
Arduino UNO: il riferimento general-purpose
UNO rimane il formato più riconoscibile.
La UNO R3 utilizza l’ATmega328P, 14 pin digitali e 6 ingressi analogici ed è ancora supportata.
Questo conta perché “vecchia” non equivale automaticamente a “obsoleta”.
La R3 ha una quantità enorme di materiale didattico e una piattaforma AVR molto conosciuta. Può continuare ad avere senso se vuoi studiare quell’architettura, utilizzare librerie AVR specifiche o seguire progetti costruiti espressamente attorno al modello.
UNO R4 Minima e UNO R4 WiFi: cosa cambia davvero
UNO R4 mantiene formato, pinout e funzionamento logico a 5 V compatibili con la filosofia della famiglia, ma cambia profondamente l’architettura.
Il confronto ufficiale fra UNO R3 e R4 mostra il passaggio dall’ATmega328P 8-bit della R3 al Renesas RA4M1 Arm Cortex-M4 32-bit delle R4.
La R4 offre più memoria, maggiore frequenza di clock, periferiche aggiuntive e un DAC.
R4 WiFi aggiunge inoltre un ESP32-S3 per Wi-Fi e Bluetooth, una matrice LED e altre funzioni integrate.
Il punto importante non è però “R4 è più veloce, quindi compra R4”.
Una libreria che utilizza esclusivamente le API Arduino può essere facilmente portabile. Codice che dipende direttamente dai registri AVR o da caratteristiche specifiche dell’ATmega può invece richiedere modifiche.
Compatibilità fisica e compatibilità software non sono la stessa cosa.
Arduino Nano: quando dimensioni e integrazione contano
Nano indica una famiglia più compatta, non un’unica configurazione hardware.
È particolarmente interessante quando devi integrare la board dentro un dispositivo e il footprint della UNO diventa eccessivo.
La famiglia comprende piattaforme con microcontrollori e capacità differenti, quindi eviterei di scegliere genericamente “una Nano” prima di aver definito:
- I/O necessari;
- connettività;
- memoria;
- tensioni;
- consumo;
- periferiche;
- dimensioni.
Il formato da solo non definisce il comportamento della scheda.
Mega, GIGA e famiglie più espandibili
Quando aumentano sensori, attuatori, bus e periferiche, il numero di pin e le risorse della piattaforma possono diventare un limite.
Mega è storicamente associata a una grande disponibilità di I/O.
GIGA appartiene invece a una generazione molto più potente e non dovrebbe essere interpretata come una semplice “Mega più veloce”.
Sono famiglie da considerare quando il progetto supera realmente le capacità delle piattaforme più piccole, non soltanto perché una scheda con specifiche superiori sembra più conveniente sulla carta.
Portenta, Opta e hardware professionale
Portenta è una famiglia orientata a scenari professionali e industriali, con hardware e possibilità di integrazione significativamente più avanzati rispetto alle board didattiche classiche.
Opta porta invece la piattaforma verso l’automazione e il controllo industriale.
Se il progetto è un sistema destinato alla produzione, la domanda non dovrebbe essere soltanto:
“quale microcontrollore è più potente?”
Diventano importanti anche:
- form factor;
- alimentazione;
- interfacce industriali;
- robustezza;
- disponibilità;
- manutenzione;
- toolchain;
- certificazioni richieste dal prodotto finale.
UNO Q e VENTUNO Q: quando Arduino entra nel territorio Linux ed edge AI
UNO Q modifica radicalmente la definizione classica della famiglia UNO.
Il microprocessore Qualcomm esegue Debian Linux, mentre il microcontrollore STM32 gestisce la parte real-time.
VENTUNO Q porta lo stesso principio verso carichi di AI e robotica molto più impegnativi, combinando un processore Dragonwing IQ8 e un microcontrollore STM32H5.
Qui il modello mentale non è più:
sketch → microcontrollore
ma:
app Linux / AI ↔ microcontrollore real-time ↔ mondo fisico
Se devi soltanto leggere un sensore di temperatura, tutto questo è probabilmente inutile.
Se devi analizzare immagini localmente e reagire con un motore entro vincoli temporali precisi, l’architettura comincia invece ad avere senso.
La scheda da scegliere dipende dal progetto, non dalla potenza massima
Prima di confrontare i modelli scriverei i requisiti.
Per esempio:
- quanti pin servono?
- quali protocolli?
- quanta memoria?
- Wi-Fi o Bluetooth?
- alimentazione a batteria?
- dimensioni massime?
- sistema operativo sì o no?
- hard real-time?
- AI locale?
- quali librerie esistono già?
- quale tensione utilizzano le periferiche?
Solo dopo passerei al catalogo.
È molto più efficace di acquistare la board con le specifiche maggiori e cercare successivamente un problema abbastanza grande da giustificarla.
Cosa serve per iniziare con Arduino
Per un primo esperimento non serve un laboratorio completo.
Un set minimale può comprendere:
- una board;
- cavo dati compatibile;
- computer;
- breadboard;
- alcuni LED;
- resistenze;
- pulsanti;
- jumper.
Sensori e moduli possono essere aggiunti quando servono.
Acquistare subito decine di componenti rende il kit più impressionante, ma non necessariamente l’apprendimento più veloce.
Scheda, cavo USB, breadboard e componenti essenziali
Per un principiante sceglierei una board ben documentata e diffusa prima di una piattaforma esotica con specifiche migliori.
La disponibilità di esempi e documentazione riduce infatti il numero di variabili quando qualcosa non funziona.
Anche il cavo merita attenzione.
Esistono cavi USB destinati esclusivamente all’alimentazione e privi delle linee dati. Una board che si accende ma non compare sul computer può quindi avere un problema molto più semplice del previsto.
Installare Arduino IDE e collegare la scheda
Il percorso base è:
- installare Arduino IDE;
- collegare la board;
- installare il package hardware se richiesto;
- selezionare il modello corretto;
- selezionare la porta;
- aprire o scrivere uno sketch;
- compilare;
- caricare.
Se l’ambiente rileva correttamente una board supportata, parte del processo può essere molto semplice.
Con hardware differente o compatibile di terze parti potrebbero essere necessari core, driver o procedure specifiche.
Selezionare board e porta
Board e porta identificano due cose differenti.
La board dice alla toolchain per quale piattaforma deve compilare.
La porta identifica il collegamento utilizzato per comunicare con il dispositivo.
Se selezioni la porta corretta ma la board sbagliata, la compilazione può produrre un firmware non adatto oppure fallire.
Se selezioni la board corretta ma la porta sbagliata, potresti compilare perfettamente e non riuscire comunque a fare l’upload.
Separare questi due problemi rende il troubleshooting molto più rapido.
Compilare e caricare il primo sketch
Prima di costruire un circuito complesso farei un test elementare con il LED integrato.
Se Blink compila e viene caricato correttamente, hai già verificato una parte importante della catena:
computer → IDE → toolchain → USB → board → firmware
A quel punto puoi aggiungere un componente alla volta.
Se colleghi immediatamente display, sensore, motore, alimentatore esterno e tre librerie, qualsiasi errore diventa molto più difficile da isolare.
Gli errori iniziali più comuni: cavo, porta, tensione e librerie
Quando un progetto non funziona, partirei da controlli economici.
La board riceve alimentazione?
Il cavo trasporta dati?
La porta selezionata è quella corretta?
Hai scelto la board corretta?
Il package hardware è installato?
La libreria richiesta è presente e compatibile?
GND è condiviso dove necessario?
I livelli di tensione sono corretti?
Solo dopo inizierei a cambiare parti importanti dello sketch.
Il debugging embedded diventa molto più gestibile quando separi:
hardware → collegamento → alimentazione → toolchain → firmware → logica
Arduino o Raspberry Pi: quale scegliere
Arduino e Raspberry Pi vengono confrontati continuamente perché entrambi permettono di costruire progetti elettronici.
La sovrapposizione esiste, ma scegliere soltanto sulla base delle dimensioni o del prezzo porta facilmente alla piattaforma sbagliata.
La guida dedicata a Raspberry Pi approfondisce modelli, sistemi operativi, GPIO e casi d’uso; qui interessa soprattutto capire la differenza architetturale.
Microcontrollore e single-board computer risolvono problemi diversi
Una classica scheda a microcontrollore esegue firmware.
Un Raspberry Pi della famiglia computer esegue normalmente un sistema operativo.
In forma semplificata:
microcontrollore → firmware → funzione dedicata
SBC → sistema operativo → processi → applicazioni
Questo cambia boot, memoria, storage, gestione dei processi, consumi e complessità.
Se devi controllare un motore con timing preciso, leggere sensori continuamente e avviarti in modo rapido, un microcontrollore può essere la soluzione più naturale.
Se devi eseguire un server Web, usare database, gestire più processi o utilizzare normali applicazioni Linux, un SBC è generalmente molto più adatto.
Real-time, sistema operativo, consumi e periferiche
Un sistema operativo general-purpose deve gestire molti processi e risorse contemporaneamente.
Non è quindi automaticamente progettato per garantire che una determinata istruzione venga eseguita sempre nello stesso preciso intervallo temporale.
Un microcontrollore può offrire un controllo molto più diretto del timing e delle periferiche.
Dall’altra parte, Linux mette a disposizione networking, filesystem, package manager, driver, processi, sicurezza e un ecosistema software impossibile da replicare ragionevolmente dentro un piccolo firmware.
Non esiste un vincitore.
Esiste l’architettura più adatta al lavoro.
Raspberry Pi Pico rende il confine meno banale
C’è un dettaglio che impedisce di ridurre il confronto a:
“Arduino è il microcontrollore, Raspberry Pi è il computer”.
Raspberry Pi Pico è una famiglia a microcontrollore.
Non esegue il normale Raspberry Pi OS ed è pensata per firmware, sensori e controllo diretto dell’hardware.
Il confronto corretto può quindi diventare:
Arduino MCU ↔ Raspberry Pi Pico
oppure:
Arduino tradizionale ↔ Raspberry Pi computer
a seconda della classe di prodotto che stai analizzando.
UNO Q rende il confine ancora meno netto
Dall’altra parte è Arduino a superare la distinzione tradizionale.
UNO Q contiene sia un computer Linux sia un MCU real-time.
Può quindi occupare uno spazio intermedio interessante:
Linux + elaborazione avanzata + controllo deterministico
Non significa che sostituisca automaticamente Raspberry Pi.
Significa che ormai il logo sulla scheda non basta più per dedurne l’architettura.
Devi guardare processore, microcontrollore, sistema operativo e ruolo previsto dal progetto.
Arduino e Raspberry Pi possono lavorare nello stesso progetto
Le due piattaforme possono anche essere complementari.
Un microcontrollore può occuparsi di:
- lettura sensori;
- timing;
- motori;
- acquisizione;
- fail-safe locali.
Il Raspberry può gestire:
- interfaccia Web;
- database;
- rete;
- elaborazione;
- dashboard;
- servizi.
La comunicazione può avvenire attraverso seriale, USB, I2C, SPI, rete o altri protocolli appropriati.
Questo tipo di divisione permette a ogni componente di fare il lavoro per cui è più adatto.
Limiti di Arduino: gli errori di valutazione più comuni
La semplicità della piattaforma può dare l’impressione che qualsiasi progetto possa crescere indefinitamente aggiungendo librerie e moduli.
Non funziona così.
Hardware embedded significa lavorare entro risorse e vincoli reali.
Memoria e capacità di elaborazione non sono infinite
Su un microcontrollore RAM e flash possono essere estremamente limitate rispetto a un normale computer.
Allocazioni eccessive, buffer troppo grandi, stringhe gestite male o librerie pesanti possono consumare rapidamente le risorse disponibili.
Il fatto che lo sketch compili non dimostra inoltre che il comportamento a runtime sia corretto.
Nei progetti più complessi occorre controllare:
- memoria;
- stack;
- heap;
- timing;
- interrupt;
- blocchi del codice;
- watchdog;
- gestione degli errori.
Il modello “scrivo lo sketch e premo Upload” rimane comodo, ma non elimina i problemi classici dei sistemi embedded.
3,3 V e 5 V: perché la tensione non è un dettaglio
Uno degli errori più pericolosi consiste nell’assumere che tutti i pin digitali siano elettricamente equivalenti.
Non lo sono.
Una periferica progettata per segnali a 3,3 V potrebbe non tollerare 5 V.
Allo stesso modo un segnale a 3,3 V potrebbe non essere interpretato correttamente da qualunque ingresso a 5 V.
Le specifiche elettriche devono essere controllate sul datasheet della board e del componente.
La compatibilità del protocollo non implica compatibilità elettrica.
Due dispositivi possono entrambi parlare SPI ed essere comunque collegati male.
Compatibilità fra architetture, librerie e vecchi tutorial
Un tutorial scritto per UNO R3 può assumere un microcontrollore AVR.
UNO R4 usa invece un’architettura Arm.
UNO Q introduce ancora un’altra struttura.
Il codice costruito esclusivamente con API Arduino standard può risultare facilmente portabile. Codice che accede direttamente a registri del processore, interrupt specifici o istruzioni dell’architettura può richiedere modifiche sostanziali.
Quando un tutorial vecchio non funziona su hardware moderno non è quindi sempre colpa dell’IDE o della libreria.
Potrebbe essere stato scritto per una macchina diversa.
Connettività e sistema operativo: non tutte le board fanno le stesse cose
“Arduino supporta Wi-Fi” è una frase troppo generica.
Alcune board hanno connettività integrata, altre no.
Alcune possono essere espanse con moduli.
Le piattaforme Q possono eseguire Linux, mentre la UNO R3 tradizionale no.
Lo stesso vale per Bluetooth, Ethernet, CAN, USB host e numerose altre funzioni.
Prima di progettare l’architettura software controlla quindi le capacità della board specifica, non dell’ecosistema nel suo complesso.
Prototipo e prodotto finale non sono automaticamente la stessa cosa
Uno dei maggiori pregi di Arduino è permettere di costruire rapidamente prototipi.
Questo non significa che la stessa identica configurazione sia sempre appropriata per il prodotto finale.
Un prodotto commerciale può richiedere:
- PCB dedicata;
- protezioni elettriche;
- gestione termica;
- alimentazione robusta;
- connettori appropriati;
- watchdog;
- test EMC;
- conformità normativa;
- sicurezza;
- supply chain;
- possibilità di manutenzione e aggiornamento.
In alcuni casi una board Arduino può rimanere nel prodotto.
In altri il prototipo serve soprattutto a verificare la logica prima di progettare l’hardware definitivo.
Domande frequenti su Arduino
Serve saper programmare per usare Arduino?
Non serve conoscere già C++ a livello avanzato.
Puoi iniziare modificando sketch molto semplici e imparare progressivamente variabili, condizioni, funzioni e strutture dati.
Arriva però un punto in cui comprendere il linguaggio diventa più utile che continuare a copiare esempi.
Se il progetto cresce, sapere perché il codice funziona è più importante del riuscire semplicemente a compilarlo.
Arduino può funzionare senza essere collegato al computer?
Sì.
Il computer serve normalmente per sviluppare e caricare il firmware. Una volta programmata, una classica board a microcontrollore può funzionare autonomamente se riceve l’alimentazione corretta.
Naturalmente eventuali funzioni che dipendono da un PC, dalla rete o da altri sistemi esterni richiedono ancora quei componenti.
Arduino usa C o C++?
Gli sketch tradizionali vengono principalmente trattati come C++ attraverso la toolchain Arduino.
L’ambiente aggiunge però preprocessing, core e API che rendono la programmazione più accessibile rispetto a un progetto C++ embedded configurato interamente a mano.
Un progetto può contenere anche file C e assembly.
Dire semplicemente “Arduino usa C” è quindi una semplificazione poco precisa.
Si può programmare Arduino in Python?
Dipende dall’hardware e dal significato della domanda.
Lo sviluppo tradizionale degli sketch usa l’ecosistema C/C++. Alcune board e superfici dell’ecosistema supportano però MicroPython o workflow Python.
Su UNO Q e VENTUNO Q la presenza di Linux e Arduino App Lab permette inoltre di combinare applicazioni Python e sketch eseguiti sul microcontrollore.
Non bisogna quindi concludere che qualunque vecchia Arduino UNO possa eseguire normalmente uno script Python al posto dello sketch.
Arduino è ancora open source dopo l’acquisizione da parte di Qualcomm?
Arduino dichiara che l’acquisizione non cambia la propria missione e che apertura e supporto hardware multi-vendor restano parte della strategia.
La risposta più precisa, però, è verificare la licenza del componente che ti interessa.
“Arduino” comprende oggi hardware, IDE, librerie, servizi cloud e altri prodotti: non è corretto presumere che ogni elemento abbia automaticamente la stessa licenza.
Arduino UNO R3 è ormai obsoleta?
Non nel senso di prodotto abbandonato.
Arduino continua a documentare e supportare UNO R3 e ha chiarito che R4 non ne determina automaticamente la fine del supporto.
R4 è tecnologicamente molto più moderna e offre più risorse, ma R3 conserva un ecosistema AVR enorme e può essere ancora utile per didattica, compatibilità e progetti esistenti.
La domanda migliore è quindi:
il progetto ha un motivo concreto per restare su AVR oppure trae beneficio dalla piattaforma più moderna?
Se inizi oggi senza vincoli precedenti, vale la pena confrontare R3 e R4 prima di acquistare.
Conclusione
Arduino rimane uno dei modi più accessibili per trasformare codice in un comportamento fisico, ma oggi il suo ecosistema è molto più ampio della classica board utilizzata nei primi tutorial.
Per imparare elettronica, leggere sensori, controllare attuatori e costruire prototipi, una piattaforma a microcontrollore continua a essere un punto di partenza eccellente.
Se servono connettività, più memoria o periferiche particolari, conviene scegliere la board sulla base dei requisiti invece di restare automaticamente sulla UNO.
Se il progetto richiede applicazioni Linux, computer vision o AI locale, UNO Q e VENTUNO Q mostrano quanto il confine tra microcontrollore e single-board computer sia diventato meno netto.
E se il problema richiede soprattutto un vero computer general-purpose, un Raspberry Pi o un’altra piattaforma SBC può essere più adatto.
Il criterio che userei è semplice: parti dal lavoro che deve svolgere il dispositivo, definisci I/O, timing, connettività, memoria e software necessari, poi scegli l’hardware.
È un processo meno affascinante di confrontare le specifiche sulla confezione, ma porta molto più spesso alla scheda giusta.