Differenza tra Raspberry Pi e Arduino: quale scegliere e quando

La differenza tra Raspberry Pi e Arduino si riassume in una frase: il Raspberry Pi è un computer grande come una carta di credito che esegue un sistema operativo Linux, mentre Arduino è una scheda a microcontrollore che esegue in continuazione l'unico programma che ci carichi. Al Pi puoi collegare tastiera, mouse e monitor, navigare in internet, elaborare in Python le immagini di una fotocamera o tenere in casa un piccolo server. Arduino invece parte appena lo alimenti, legge i sensori con precisione al microsecondo, pilota motori e LED senza il minimo intoppo e può funzionare per giorni a batteria.

In breve, il Raspberry Pi è la scelta migliore per i progetti che richiedono una fotocamera, l'elaborazione delle immagini, un'interfaccia grafica o servizi di rete, mentre Arduino vince quando servono sensori, motori, temporizzazioni precise e bassi consumi. In questa guida confrontiamo le due piattaforme con numeri reali: tempo di avvio, consumi, GPIO e ingressi analogici, linguaggio di programmazione, tempo reale e prezzo. Poi ti mostriamo in una tabella quale scegliere per ogni progetto, ti diamo un esempio di codice che fa lavorare le due schede insieme tramite un cavo USB e ti spieghiamo dove si colloca il Raspberry Pi Pico che, nonostante il nome, somiglia molto di più a un Arduino.

Che cos'è il Raspberry Pi e che cos'è Arduino?

Il Raspberry Pi è un computer a scheda singola (SBC) sviluppato dalla Raspberry Pi Foundation nel Regno Unito. Il Raspberry Pi 5 ha un processore Arm Cortex-A76 quad-core a 2,4 GHz, da 1 a 16 GB di RAM, due uscite HDMI 4K, USB 3.0, Ethernet Gigabit, Wi-Fi e Bluetooth. Al posto del disco fisso usa una scheda microSD (o un SSD NVMe con una scheda aggiuntiva) su cui si installa Raspberry Pi OS, basato su Debian. In pratica hai davanti un fratello piccolo ed economico del tuo computer fisso; l'unica differenza è il connettore GPIO a 40 pin sul bordo, che ti permette di collegare direttamente LED, pulsanti e sensori.

Arduino, invece, è una piattaforma a microcontrollore open source nata in Italia. La sua scheda più diffusa, Arduino Uno R3, ha come cuore un ATmega328P a 8 bit che lavora a 16 MHz: processore, 2 KB di RAM, 32 KB di memoria programma e convertitore analogico-digitale stanno tutti nello stesso piccolo chip. Non ci sono sistema operativo, file system o uscita video. Il codice che scrivi nell'Arduino IDE sul tuo computer viene compilato e salvato nella memoria flash della scheda; a ogni accensione setup() viene eseguita una volta e poi loop() gira all'infinito. Per conoscere meglio la piattaforma, leggi Cos'è Arduino?.

Risposta rapida: quale scegliere in ogni situazione?

Tabella di confronto: Raspberry Pi 5, Arduino Uno e Raspberry Pi Pico

Una breve nota sui prezzi: poiché il costo dei chip di memoria LPDDR4 usati nei Raspberry Pi 4 e 5 è salito alle stelle per la domanda dei data center dedicati all'intelligenza artificiale, Raspberry Pi ha aumentato i prezzi più volte da dicembre 2025; a ottobre 2026 il Pi 5 da 2 GB ha un prezzo di listino di 77,50 $. Il Pi Zero 2 W, che usa una memoria più vecchia, è rimasto a 15 $. Inoltre il Pi ha bisogno di una scheda microSD, di un alimentatore USB-C da 27 W e possibilmente di un dissipatore, che aggiungono altri 20–30 $ al totale. Ad Arduino Uno e al Pico basta un cavo USB.

La differenza fondamentale tra un computer Linux e un microcontrollore

Sul Raspberry Pi, il programma Python che scrivi è solo uno delle centinaia di processi che Linux gestisce contemporaneamente. Il kernel assegna a turno il processore alla connessione di rete, al display, ai dispositivi USB, ai servizi in background e al tuo programma. È un'organizzazione molto potente: puoi salvare log su file, far girare insieme un server web e uno stream video e modificare il codice via SSH da un'altra stanza. Su Arduino, invece, l'unica cosa che gira sul processore è il tuo codice. Senza un sistema operativo di mezzo, il comando digitalWrite cambia lo stato del pin in pochi microsecondi, e ci mette sempre lo stesso tempo. In pratica questa differenza comporta quanto segue:

• Multitasking: il Pi esegue insieme un browser, uno script Python e un database; Arduino lavora con un unico loop(), e sei tu a organizzare più attività con millis().
• Archiviazione: sul Pi puoi conservare gigabyte di foto, log e database; sull'Uno il programma deve stare in 32 KB e le variabili in 2 KB di RAM.
• Rete: il Pi si collega a internet via Wi-Fi ed Ethernet appena tolto dalla scatola; l'Uno non ha connessione di rete, quindi ti serve un ESP32 o un modulo aggiuntivo.
• Manutenzione: essendo un computer, il Pi richiede aggiornamenti, una password utente e attenzione alla sicurezza; su Arduino carichi il codice una volta e funziona allo stesso modo per anni.
• Quando qualcosa va storto: se un programma si blocca sul Pi, il sistema resta in piedi e puoi leggere il messaggio d'errore; se il codice si pianta su Arduino, la scheda si ferma in silenzio, ma un watchdog può riavviarla automaticamente.

Tempo di avvio e blackout improvvisi

Appena dai corrente ad Arduino, il programma parte in meno di un secondo; anche premendo il pulsante di reset, il bootloader aspetta solo un attimo. Il Raspberry Pi carica prima il bootloader, poi il kernel Linux e i servizi; a seconda del modello e della velocità della scheda SD, servono 15–40 secondi per arrivare al desktop. La differenza conta nei dispositivi che devono funzionare subito dopo un blackout, come un campanello, un allarme o un impianto di irrigazione. Ancora più delicato è lo spegnimento: Linux scrive di continuo sulla scheda SD e, se la corrente salta durante una scrittura, il file system può corrompersi e il Pi potrebbe non avviarsi più. Dato che il programma di Arduino resta fisso nella flash, puoi staccare la spina quando vuoi.

Consumi e funzionamento a batteria

Sui consumi la differenza va da 10 a 30 volte. Un Raspberry Pi 5 consuma circa 3 W a riposo e 7–8 W con la CPU al massimo, e ancora di più se aggiungi un disco USB e una fotocamera. Un Arduino Uno assorbe circa 50 mA, cioè 0,25 W a 5 V, e un Pico circa 0,1 W. Nella tabella qui sotto trovi le autonomie approssimative con un power bank da 10.000 mAh. Il calcolo è questo: i 10.000 mAh dell'etichetta si riferiscono a celle da 3,7 V, cioè circa 37 Wh; dopo le perdite di conversione a 5 V restano circa 30 Wh utilizzabili. Basta dividere questo valore per il consumo della scheda in watt. Per il tuo circuito puoi usare il calcolatore di durata della batteria.

Pin GPIO e ingressi analogici

Il connettore a 40 pin del Raspberry Pi ha 28 GPIO; GPIO 0 e 1 sono riservati alla EEPROM di identificazione delle schede HAT e di solito non si usano. Questi pin lavorano a 3,3 V, non tollerano i 5 V e possono fornire solo pochi milliampere per pin (al massimo circa 16 mA); puoi accendere un LED con una resistenza in serie, ma non dovresti pilotare direttamente la bobina di un relè o un motore. La lacuna più grande è l'assenza di ingressi analogici: sul Pi non esiste un equivalente di analogRead, quindi per leggere un sensore analogico come un potenziometro, una fotoresistenza (LDR) o un sensore di umidità del terreno serve un chip ADC esterno. Arduino Uno ha 6 ingressi analogici e quasi ogni sensore a 5 V si collega direttamente.

Ci sono due modi per collegare un sensore analogico al Pi. Il primo è usare un modulo ADC come l'MCP3008 a 8 canali e 10 bit su SPI o l'ADS1115 a 4 canali e 16 bit su I2C; la libreria gpiozero supporta l'MCP3008 già di serie. Il secondo è collegare i sensori a un Arduino o a un Pico e inviare le letture al Pi tramite USB; più avanti trovi il codice. Come funziona la lettura analogica lo spiega l'articolo Cos'è un ADC?, mentre le piedinature delle schede sono nello strumento Pinout.

Linguaggio di programmazione e ambiente di sviluppo

Arduino si programma con il linguaggio Arduino, basato su C/C++: scrivi il codice nell'Arduino IDE sul tuo computer, viene compilato e caricato sulla scheda via USB. Sul Raspberry Pi, invece, il codice si scrive e si esegue direttamente sul Pi, senza un passaggio di caricamento separato. Il linguaggio più usato è Python, e Raspberry Pi OS include già l'editor Thonny e la libreria gpiozero. Puoi usare anche qualsiasi linguaggio che giri su Linux, come C, C++, Node.js, Go o Java. Ecco come appare in Python sul Pi un programma "il LED si accende finché tieni premuto il pulsante":

1from gpiozero import LED, Button
2from signal import pause
3
4led = LED(17)       # GPIO17 = fiziksel pin 11 / GPIO17 = physical pin 11
5buton = Button(27)  # GPIO27 = fiziksel pin 13, dahili pull-up açık / physical pin 13, internal pull-up on
6
7buton.when_pressed = led.on    # Basınca LED yanar / LED on when pressed
8buton.when_released = led.off  # Bırakınca söner / LED off when released
9
10pause()  # Programı açık tut, olayları bekle / keep running and wait for events

Collega il pulsante tra GPIO27 e GND e il LED a GPIO17 con una resistenza da 220 Ω; la classe Button attiva da sola la resistenza di pull-up interna. Salva il file come buton_led.py ed eseguilo scrivendo python3 buton_led.py nel terminale. Attenzione: sul Raspberry Pi 5 i GPIO passano dal nuovo chip RP1, quindi la vecchia libreria RPi.GPIO non funziona e si ferma con "RuntimeError: Cannot determine SOC peripheral base address"; per i nuovi progetti usa gpiozero. Se sul Raspberry Pi OS attuale pip install restituisce l'errore "externally-managed-environment", installa il pacchetto con sudo apt install python3-... oppure crea un ambiente virtuale (venv). Sul Raspberry Pi Pico sfrutti le stesse conoscenze di Python con MicroPython.

Tempo reale: perché Arduino per motori e sensori?

Dato che Linux divide il processore tra i programmi, il tuo codice Python può essere messo in pausa per qualche millisecondo di tanto in tanto, e non puoi prevedere quando. Per una pagina web non importa, ma per l'hardware che dipende dalle temporizzazioni è un problema serio. Alcuni esempi concreti:

• Sensore di distanza HC-SR04: il suono impiega circa 58 µs per andata e ritorno per ogni centimetro di distanza. Se mentre misuri l'eco si insinua un ritardo di 100 µs, la lettura sbaglia di 1,7 cm; sul Pi scostamenti del genere sono frequenti.
• Servomotore: un servo si posiziona con un impulso di 1–2 ms in un segnale a 50 Hz, e 1 grado corrisponde a circa 5,5 µs. Un servo pilotato dal Pi con PWM software trema; con Arduino resta fermo.
• Striscia LED WS2812B: ogni bit dura 1,25 µs e la temporizzazione richiede una precisione di 0,15 µs; il Pi ci riesce solo con l'hardware SPI o PWM e il DMA, mentre Arduino e Pico la pilotano direttamente.
• Motori passo-passo ed encoder: migliaia di impulsi al secondo o i segnali veloci di un encoder vengono catturati su Arduino senza perderne nessuno grazie agli interrupt.

Quale scheda per quale progetto?

Fotocamera ed elaborazione delle immagini sono il punto di forza del Raspberry Pi. La Camera Module 3 da 12 MP con autofocus si collega al connettore della fotocamera con un cavo piatto; puoi scattare una foto con rpicam-still -o foto.jpg e, con le librerie Picamera2 e OpenCV, fare in Python rilevamento del movimento, inseguimento dei colori, lettura di codici QR o riconoscimento facciale. Per modelli di IA più pesanti esistono schede acceleratrici come l'AI HAT+ o l'AI Camera, che elabora l'immagine direttamente all'interno della fotocamera. I connettori per fotocamera del Raspberry Pi 5 sono più piccoli (22 pin) rispetto ai modelli precedenti, quindi le vecchie fotocamere richiedono un cavo adattatore adatto. I 2 KB di RAM di Arduino Uno, invece, non bastano nemmeno per una piccola foto; se vuoi solo scattare foto e inviarle su Telegram, l'economica ESP32-CAM è un buon compromesso.

Su sensori e motori, invece, Arduino non ha praticamente rivali. Lavorando a 5 V, la maggior parte dei moduli in commercio, come l'HC-SR04, i moduli relè, il driver per motori L298N o i display LCD a caratteri, si collega senza circuiti aggiuntivi, e gli shield per motori, relè e sensori si innestano direttamente sulla scheda. In un'auto robot Arduino legge il sensore di distanza decine di volte al secondo e ferma i motori nell'istante in cui vede un ostacolo; questo tempo di reazione non dipende mai da quanto è occupato un sistema operativo. Per lo stesso motivo, i servomotori e i motori passo-passo funzionano in modo fluido su Arduino.

Usarli insieme: Raspberry Pi + Arduino

Nella maggior parte dei progetti avanzati, la soluzione migliore è usarli entrambi. Pensa al corpo umano: il Raspberry Pi è il cervello; elabora la fotocamera, si collega a internet, registra i dati e prende le decisioni. Arduino è il midollo spinale e i muscoli; legge i sensori, muove i motori e in caso di emergenza reagisce di riflesso senza chiedere al Pi. In un'auto robot con fotocamera, per esempio, il Pi individua la linea nell'immagine e invia il comando "gira a sinistra"; Arduino lo trasforma in velocità dei motori e si ferma da solo se compare un ostacolo. I modi più comuni per collegare le due schede sono:

1. Carica sulla scheda il codice Arduino qui sotto dal tuo computer (puoi farlo anche dal Pi con arduino-cli).
2. Collega Arduino al Pi con un cavo USB e trova il nome della porta scrivendo ls /dev/ttyACM* /dev/ttyUSB* nel terminale. Un Uno originale di solito compare come /dev/ttyACM0, i cloni con chip CH340 come /dev/ttyUSB0.
3. Se la libreria pyserial non è installata, installala con sudo apt install python3-serial.
4. Se il tuo utente non può accedere alla porta seriale, scrivi sudo usermod -a -G dialout $USER, poi esci e rientra nella sessione.
5. Salva il codice Python come pi_arduino.py ed eseguilo con python3 pi_arduino.py; se il monitor seriale dell'Arduino IDE è aperto, chiudilo prima.

1// Arduino Uno: A0 değerini Pi'ye gönderir, Pi'den gelen komutla LED'i yönetir
2// Arduino Uno: sends the A0 reading to the Pi and drives the LED on the Pi's command
3const int SENSOR_PIN = A0;      // LDR ya da potansiyometre / LDR or potentiometer
4const int LED_PIN = 13;         // Dahili LED / built-in LED
5unsigned long sonGonderim = 0;  // Son gönderim zamanı / time of the last send
6
7void setup() {
8  Serial.begin(115200);         // Pi tarafıyla aynı hız / same baud rate as the Pi
9  pinMode(LED_PIN, OUTPUT);
10}
11
12void loop() {
13  // Pi'den komut geldi mi? / has a command arrived from the Pi?
14  if (Serial.available()) {
15    String komut = Serial.readStringUntil('\n');  // Satır sonuna kadar oku / read up to the newline
16    komut.trim();                                  // Boşluk ve \r karakterlerini sil / strip spaces and \r
17    if (komut == "LED1") digitalWrite(LED_PIN, HIGH);
18    else if (komut == "LED0") digitalWrite(LED_PIN, LOW);
19  }
20
21  // 500 ms'de bir ölçüm gönder, loop'u bekletmeden / send a reading every 500 ms without blocking
22  if (millis() - sonGonderim >= 500) {
23    sonGonderim = millis();
24    int deger = analogRead(SENSOR_PIN);  // 0-1023
25    Serial.print("A0:");
26    Serial.println(deger);               // Örnek: A0:512 / example: A0:512
27  }
28}

1import time
2import serial  # sudo apt install python3-serial
3
4# Orijinal Uno: /dev/ttyACM0, CH340'lı klon: /dev/ttyUSB0 / genuine Uno: /dev/ttyACM0, CH340 clone: /dev/ttyUSB0
5ser = serial.Serial("/dev/ttyACM0", 115200, timeout=1)
6time.sleep(2)             # Port açılınca Arduino yeniden başlar / opening the port resets the Arduino
7ser.reset_input_buffer()  # Eski verileri temizle / drop stale data
8
9ESIK = 300                # Karanlık eşiği, sensörüne göre ayarla / darkness threshold, tune it for your sensor
10led_durum = None
11
12while True:
13    satir = ser.readline().decode("utf-8", errors="ignore").strip()
14    if not satir.startswith("A0:") or not satir[3:].isdigit():
15        continue          # Boş ya da yarım satırı atla / skip empty or partial lines
16    deger = int(satir[3:])
17    print("Sensor:", deger)
18
19    yeni = "LED1" if deger < ESIK else "LED0"  # Karanlıkta LED'i yak / LED on in the dark
20    if yeni != led_durum:                      # Yalnız değişince gönder / send only on change
21        ser.write((yeni + "\n").encode())
22        led_durum = yeni

Ogni 500 ms Arduino invia una riga del tipo "A0:512" e ascolta i comandi "LED1" o "LED0" terminati da un a capo; dato che usa millis(), l'attesa dei comandi non rallenta mai le misure. Sul lato Python, la riga time.sleep(2) è importante: quando il Pi apre la porta seriale, Arduino si riavvia automaticamente e tutto ciò che viene inviato nei primi due secondi va perso. Adatta la soglia di 300 al tuo sensore; a seconda di come hai collegato la LDR, il valore al buio può salire o scendere. Per approfondire la comunicazione seriale, leggi Comunicazione seriale tra Arduino e Python e Cos'è la UART?.

Il posto del Raspberry Pi Pico: Raspberry Pi di nome, microcontrollore di fatto

È il punto che crea più confusione. Pur essendo prodotto da Raspberry Pi, il Raspberry Pi Pico non è un computer ma una scheda a microcontrollore come Arduino: non ha sistema operativo, si avvia all'istante, consuma circa 0,1 W e lavora in tempo reale. Al suo interno c'è il chip dual-core RP2040 progettato dalla stessa Raspberry Pi (il Pico 2 usa l'RP2350 a 150 MHz). Rispetto ad Arduino Uno ha molta più RAM (264 KB), un ADC a 12 bit e blocchi PIO per i compiti di temporizzazione, e si programma in MicroPython, in C/C++ o con l'Arduino IDE. Con i suoi 4 $ costa meno di un Arduino Uno, ma lavorando a 3,3 V bisogna fare attenzione ai moduli a 5 V. Per i dettagli, leggi Cos'è il Raspberry Pi Pico?.

Il vantaggio principale del Pico in questo confronto è che lavora allo stesso livello di 3,3 V del Raspberry Pi: puoi collegare i suoi pin UART direttamente al Pi senza convertitore di livello, oppure collegarlo via USB e usarlo proprio come un Arduino. Il codice MicroPython qui sotto invia i dati nello stesso formato "A0:valore" del codice Arduino precedente e ascolta gli stessi comandi per il LED, così lo script Python sul Pi funziona senza alcuna modifica. Salva il codice sul Pico come main.py con Thonny, poi chiudi Thonny in modo che la porta seriale resti libera per lo script del Pi.

1import sys, select, time
2from machine import ADC, Pin
3
4sensor = ADC(26)        # GP26 = ADC0 (fiziksel pin 31) / GP26 = ADC0 (physical pin 31)
5led = Pin(25, Pin.OUT)  # Pico dahili LED; Pico W'de Pin("LED") / onboard LED; use Pin("LED") on Pico W
6poll = select.poll()
7poll.register(sys.stdin, select.POLLIN)  # USB'den gelen veriyi dinle / listen for data over USB
8son = time.ticks_ms()
9
10while True:
11    # Pi'den komut var mı? / is there a command from the Pi?
12    if poll.poll(0):
13        komut = sys.stdin.readline().strip()
14        if komut == "LED1":
15            led.on()
16        elif komut == "LED0":
17            led.off()
18
19    # 500 ms'de bir, Arduino ile aynı biçimde gönder / every 500 ms, same format as the Arduino
20    if time.ticks_diff(time.ticks_ms(), son) >= 500:
21        son = time.ticks_ms()
22        deger = sensor.read_u16() >> 6  # 0-65535 -> 0-1023
23        print("A0:" + str(deger))

I confini, poi, sono sempre più sfumati. Nel 2025 Arduino ha presentato Arduino UNO Q, che unisce i due mondi su un'unica scheda: questa scheda in formato Uno affianca un processore Qualcomm quad-core con Debian Linux a un microcontrollore STM32U585 che esegue gli sketch Arduino in tempo reale. In altre parole, l'architettura "Pi + Arduino" oggi sta su una sola scheda. La logica però non cambia: la parte Linux gestisce rete, immagini e applicazione, la parte microcontrollore gestisce pin e temporizzazioni. Chi ha capito le differenze descritte in questo articolo sfrutterà molto meglio anche queste schede ibride.

Errori comuni e falsi miti

• "Il Raspberry Pi Pico è un piccolo Raspberry Pi": non lo è; non esegue Linux e non ha uscita HDMI. Il Pico è un microcontrollore e appartiene alla stessa categoria di Arduino.
• Collegare un segnale a 5 V al Pi: se il pin ECHO dell'HC-SR04 o la linea TX di Arduino arrivano direttamente a un GPIO, il pin o addirittura il processore possono danneggiarsi in modo permanente; usa un partitore di tensione.
• Cercare analogRead sul Pi: il Raspberry Pi non ha ingressi analogici; usa un MCP3008, un ADS1115 oppure un Arduino o un Pico come aiutante.
• Spegnere staccando la spina: è il modo più rapido per rovinare una scheda SD; usa sempre sudo poweroff.
• Alimentare un Pi 5 con il caricabatterie del telefono: con un alimentatore che non fornisce 5 V 5 A, il Pi 5 limita la corrente totale delle porte USB a 600 mA e può riavviarsi sotto carico.
• L'errore "Permission denied: '/dev/ttyACM0'": il tuo utente non è nel gruppo dialout; esegui il comando usermod e rientra nella sessione. Con "Device or resource busy", un altro programma (il monitor seriale o Thonny) sta occupando la porta.
• Pensare che "Arduino è superato, ora c'è il Pi": non sono rivali ma strumenti per lavori diversi; la maggior parte degli apparecchi, dalla lavatrice all'automobile, funziona ancora oggi con microcontrollori.

In breve, il Raspberry Pi è un computer che pensa e vede, mentre Arduino è un controllore che trasforma all'istante ciò che percepisce in azione; un buon progetto spesso unisce i punti di forza di entrambi. Nell'app BlueGrays trovi decine di progetti con Arduino, ESP32 e Raspberry Pi Pico, dai LED e sensori fino ai robot e ai progetti Wi-Fi, ognuno con schema di collegamento passo passo e codice pronto, e puoi iniziare da quelli gratuiti.