Raspberry Pi Pico vs Arduino Uno quale microcontrollore scegliere?

Per l’occasione ho deciso di confrontare la Raspberry Pi Pico ( di cui vi ho parlato nell’articolo “Raspberry Pi Pico il microcontrollore che costa solo 4$” ) con il dominatore indiscusso del settore a livello hobbystico, l’ Arduino UNO REV3.

Cosa è un microcontrollore

Prima di addentrarci nella comparazione delle due schede, iniziamo col contestualizzare l’ambito in cui ci troviamo, quello dei microcontrollori.

Un microcontrollore è un dispositivo elettronico programmabile col compito di svolgere autonomamente delle semplici funzioni in base al programma che implementa.

La funzione principale di un microcontrollore è quella di gestire in modo semplificato input e output di un apparato con complessità medio-bassa come ad esempio lavatrici, sistemi di allarme, dispositivi domotici, IoT e così via.

Caratteristiche dei microcontrollori da comparare

Vediamo ora le caratteristiche dei due microcontrollori a confronto, anche se c’è da premettere che l’Arduino UNO ha fatto il suo ingresso sul mercato nel 2005 mentre il Raspberry Pi Pico solo pochi giorni fa e questa differenza si farà sentire come vedremo in seguito.

	Raspberry Pi Pico	Arduino UNO REV 3
Dimensioni	21 mm × 51 mm	68.6 mm x 53.4 mm
Alimentazione	Tensione di Alimentazione : 1,8 – 5,5 V Tensione di funzionamento: 3,3 V	Tensione di Alimentazione : 7-12 V Tensione di funzionamento: 5 V
Processore	Chip RP2040 con due core ARM Cortex-M0+ a 48MHz espandibili fino a 133MHz	Chip Atmel modello ATMega328 a 16 MHz
Memoria	264KB SRAM 2MB memoria Flash	2KB RAM 32KB memoria Flash 1KB memoria EEPROM
Pin	26 x GPIO (di cui 3 analogici) 2 x I2C 2 x UART 2 x SPI 8 pin I/O Programmabili. 16 x canali PWM	14 pin digitali 6 Pin analogici 1 x I2C 1 x SPI 6 x canali PWM
Altre caratteristiche	1 Timer con 4 allarmi. 1 Contatore Real Time. Sensore di temperatura. Libreria esterna per i calcoli in virgola mobile. Modulo castellato per saldatura direttamente sui circuiti .	3 Timer
Linguaggio di programmazione	C/C++ MicroPyton	Java, C, C++
Sito ufficiale	www.raspberrypi.org	www.arduino.cc
Prezzo ufficiale	circa 4€	circa 24 €
	Acquista Ora	Acquista Ora

Programmazione del microcontrollore

Viste le caratteristiche andiamo ora a vedere come si procede per programmare questi microcontrollori caricandogli la funzione che andranno ad eseguire.

Da questo punto di vista distinguiamo due fasi, la prima che è la preparazione per l’ambiente di sviluppo. Questa operazione va fatta solo una volta, poi le successive avremo gli ambienti già configurati e si potrà procedere direttamente alla fase di sviluppo.

La seconda è appunto la fase di sviluppo, ovvero la scrittura del programma e il caricamento dello stesso sulla scheda.

Configurazione ambienti di sviluppo

Il primo passo da fare per poter sviluppare un software per un microcontrollore è quello di configurare il proprio ambiente di sviluppo.

Per quanto riguarda il Raspberry Pi Pico possiamo decidere se utilizzare il linguaggio C/C++ o il linguaggio MicroPython, una versione di Python appositamente sviluppata per i microcontrollori.

Fortunatamente la documentazione fornita dalla Raspberry Foundation per questa board è veramente esaustiva e ben fatta.
Vediamo insieme come configurare il proprio pc per entrambi i linguaggi. Per gli esempi userò un pc con sistema operativo Linux Debian, nel caso di Windows o Mac i passaggi sono più o meno simili e si rimanda alla documentazione ufficiale.

Utilizziamo le SDK per C/C++ di Raspberry Pi Pico

Vediamo quali sono i passi da seguire per poter configurare il nostro ambiente di sviluppo in modo da utilizzare le librerie SDK per C/C++ del Raspberry Pi Pico.
Io lo eseguirò su un sistema basato su SO Debian. Per gli altri sistemi si rimanda alla documentazione ufficiale.

Partiamo dalla nostra cartella di /home, per farlo basta eseguire:

cd ~

creiamo una cartella in cui metteremo le nostre librerie ed entriamoci.

mkdir pico-c
cd pico-c

A questo punto scarichiamo la libreria sdk, per farlo useremo git.
Questo comando ci creerà una nuova cartella “pico-sdk”.
Provvederò inoltre a scaricare anche gli esempi dal repository “pico-examples”

git clone -b master https://github.com/raspberrypi/pico-sdk.git
git clone -b master https://github.com/raspberrypi/pico-examples.git

Entriamo nella cartella “pico-sdk” appena creata e inizializziamo, sempre mediante git, il sottomodulo del repository appena scaricato

cd pico-sdk
git submodule update --init

Abbiamo scaricato le librerie necessarie, non ci resta che configurare una variabile di ambiente ( “PICO_SDK_PATH” ) di modo che sia possibile compilare correttamente gli script.

Prima di procedere però eseguiamo il comando pwd e copiamo da qualche parte il valore che ci viene mostrato:

pwd
/home/makermiky/pico-c/pico-sdk

Ritorniamo nella nostra cartella /home e modifichiamo il file .bashrc mediante il tool vi.

cd ~
vi .bashrc

In questo file ci sono le configurazioni del nostro terminale bash. Aggiungiamo alla fine del file la riga seguente:

export PICO_SDK_PATH=/home/[utente]/pico-c/pico-sdk

dove al posto di [utente] va sostituito il valore dell’utente connesso, che altro non è che il valore restituito dal comando pwd che abbiamo eseguito pochi step fa.

Effettuato il salvataggio ricordiamoci di far ricaricare il file mediante il comando:

source ~/.bashrc

Una volta configurato il sistema dobbiamo procurarci gli strumenti per compilare. Possiamo scaricarli mediante il comando:

sudo apt update
sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi build-essential 

Avendo tutto configurato possiamo a questo punto recarci nella cartella degli esempi per verificare che tutta la toolchain (ovvero l’insieme di programmi utilizzati per lo sviluppo di un software) sia correttamente configurata.

Portiamoci nella cartella degli esempi

cd /home/[utente]/pico-c/pico-examples

creiamo una cartella di build ed eseguiamo il comando cMake per preparare i file necessari ad effettuare la compilazione

mkdir build
cd build
cmake ..

Questo comando ci creerà l’albero delle dipendenze necessarie per poter andare avanti.

Andiamo ora nella specifica cartella di esempio “blink” per compilare unicamente questo esempio. Per gli altri il procedimento è analogo.

cd blink
make

Al termine dell’esecuzione di questo comando vedremo che sarà presente, tra gli altri, un file nominato “blink.uf2“.

Questo è il file che dovremo caricare sulla nostra board per farle eseguire il programma indicato.

Per caricare un file sulla scheda è sufficiente seguire le indicazioni riportate sotto nel paragrafo “Carichiamo il file UF2 per MicroPython” sostituendo ovviamente il file li indicato con quello appena generato.

Utilizziamo le SDK per Python di Raspberry Pi Pico

La prima cosa da fare è impostare il Raspberry Pi Pico in modo da essere in grado di interpretare il programma in Python che gli andremo a caricare.

Carichiamo il file UF2 per MicroPython

Scarichiamo il file UF2 per MicroPython dal sito ufficiale.

Premiamo il pulsante BOOTSEL sulla scheda e teniamolo premuto mentre la colleghiamo al pc mediante la microUSB come da immagine.
A questo punto la scheda verrà riconosciuta come unità di archiviazione e possiamo copiare il file UF2 scaricato poco fa.

Per la scrittura del codice scegliamo di usare l’IDE Thonny.

Verifichiamo che nelle opzioni l’interprete impostato sia “MicroPython (Raspberry Pi Pico)”

Scriviamo il nostro programma in Python.

Per caricare il nostro script sulla scheda Raspberry Pi Pico i comando sono i seguenti:

1. Premiamo F5 o il pulsante Run
2. Selezioniamo ‘Raspberry Pi Pico’ come posizione di Salvataggio
3. Nominiamo il file ‘main.py‘ per farlo eseguire dalla scheda all’infinito
4. Clickiamo su OK e verifichiamo che il nostro codice sia in esecuzione.

Configuriamo il pc per utilizzare Arduino UNO

A differenza di quanto visto prima la configurazione per l’arduino è molto più rapida. Basta infatti scaricare l’Arduino IDE dal sito ufficiale, installarlo e selezionare nel menu Strumenti la scheda “Arduino UNO“.

Ci basterà a questo punto scrivere il nostro programma e caricarlo alla scheda Arduino collegata mediante l’USB clickando sul pulsante “Carica“.

Sviluppo di un programma

Una volta che gli ambienti sono configurati è il momento di vedere la struttura di un generico programma.

Per quanto riguarda il Raspberry Pi Pico, usando il linguaggio C++, il contenuto minimo di un file è un unico metodo, che viene eseguito all’avvio (o al reset) della scheda un’istruzione dopo l’altra e poi termina ritornando un valore, di solito 0 in caso di esecuzione senza errori.

int main() {
   ...
   return 0;
}

Per questo motivo spesso all’interno del metodo principale si trova una istruzione che esegue un ciclo all’infinito.

int main() {
   ...
   while(true) {
      ...
   }
   return 0;
}

Passando invece al linguaggio MicroPython il programma verrà eseguito istruzione dopo istruzione dall’inizio alla file. In questo caso bisogna prestare particolarmente attenzione all’utilizzo della spaziatura in quanto è un carattere distintivo del linguaggio.

# Esempio di programma Python con un ciclo infinito
print('Esempio di programma Python')
while true:
    print('Questa riga verrà stampata all\'infinito!')

Viceversa Arduino UNO usa una struttura diversa per i suo sketch (il nome che Arduino usa per indicare i suoi programmi).

In questo caso infatti abbiamo un metodo che viene eseguito una unica volta all’avvio ( o al reset della scheda ), il metodo setup(), utilizzato principalmente per l’inizializzazione dei pin e dei parametri che ci serviranno, e un metodo che viene eseguito all’infinito fintanto che la scheda è alimentata: il metodo loop() , dove c’è la logica applicativa vera e propria.

void setup() {
  // Il codice in questo blocco verrà eseguito una sola volta all'avvio 
  // della scheda

}

void loop() {
  // Il codice in questo blocco verrà eseguito una istruzione dopo l'altra
  // arrivato alla fine del blocco l'esecuzione riprende dall'inizio
  // Questo ciclo continua all'infinito fintanto che la scheda è alimentata
  
}

Un esempio pratico: facciamo lampeggiare un led

Andiamo ora a vedere come è possibile eseguire la stessa funzione sulla Raspberry Pi Pico e sull’Arduino al fine di capire meglio le differenze tra gli stili di programmazione.

Useremo come esempio il classico “Hello World” dei microcontrollori: faremo lampeggiare un led.

Per evitare di essere oltremodo scontato ho optato per far lampeggiare un led esterno e non quello presente in entrambe le schede (GPIO 25 per Raspberry Pi Pico, pin 13 per Arduino UNO).

Dal punto di vista dei componenti elettronici non c’è alcuna differenza tra le due schede, userò un led rosso con una tensione di funzionamento di circa 2V e una corrente di circa 20mA e una resistenza da 220 Ohm, considerando che la tensione in uscita dai pin è rispettivamente 3,3V per il Raspberry Pi Pico e 5V per l’Arduino UNO.

Di seguito vediamo il codice Python per Raspberrry Pi Pico e quello C like per Arduino per eseguire questo semplice compito.
Si è scelto come si evince anche dallo schema di sotto di utilizzare come output il pin 1 nel caso di Raspberry Pi Pico e il pin 4 nel caso di Arduino UNO

Raspberry Pi Pico

from machine import Pin, Timer
    
led = Pin(1, Pin.OUT)
tim = Timer()
def tick(timer):
    global led
    led.toggle()

tim.init(freq=2.5, mode=Timer.PERIODIC, callback=tick)

Nel codice sopra viene definito un pin di output. viene inoltre definita una funzione di callback che viene invocata all’infinito con una frequenza di 2,5 herz e che cambia lo stato del valore di led (da 1 a 0 e viceversa).

Arduino UNO rev3

void setup() {
  pinMode(4, OUTPUT);
}

void loop() {
  digitalWrite(4, HIGH);   
  delay(1000);              
  digitalWrite(4, LOW);   
  delay(1000);             
}

Nel metodo setup definiamo che il pin 4 sia un pin di output.

Nella funzione loop diciamo che il pin 4 deve avere un valore di 5V (lo accendiamo), aspettare 1 secondo, avere un valore di 0V (lo spegniamo) e aspettiamo di nuovo 1 secondo.

Dopo di che il ciclo ricomincia all’infinito

Conclusioni quale microcontrollore scegliere

Senza ombra di dubbio il microcontrolore Raspberry Pi Pico offre delle caratteristiche migliori, dove l’Arduino UNO risente un pò dell’età in questa circostanza, di contro può vantare di una vasta community e di una miriade di progetti ed esempi online.

Vero è che il confronto corretto sarebbe dovuto essere con un modello magari diverso dell’Arduino come potrebbe essere l’Arduino Nano o ancor di più l’ Arduino Portenta H7, ma specie in questo secondo caso la board non è rivolta prettamente ad un pubblico hobbystico e il prezzo è assolutamente non paragonabile a quello della Raspberry Pi Pico.

Inoltre è doveroso dire che nella realtà Arduino e Raspberry non saranno davvero dei competitor, bensì la Raspberry Foundation fornirà il proprio chip RP2040 ai vari player del mercato come Adafruit, Arduino, Pimoroni e Sparkfun al fine di poter includere questo microcontrollore nelle proprie board in futuro.

Ne è dimostrazione il tweet ufficiale di Arduino che da il benvenuto all’ RP2040 annunciando anche un suo futuro utilizzo nella scheda Arduino Nano RP2040 Connect

E voi per cosa utilizzereste il microcontrollore Raspberry Pi Pico e per cos’altro l’Arduino UNO?