RaspberryPI

Introduzione a Raspberry Pi Pico e MicroPython

Una guida pratica per configurare Raspberry Pi Pico e usare Thonny

Raspberry Pi Pico è una scheda a microcontrollore pensata per controllare ingressi, uscite, sensori, piccoli attuatori e periferiche digitali. A differenza di una Raspberry Pi tradizionale, non esegue un sistema operativo Linux: il programma viene caricato direttamente nella memoria della scheda e viene eseguito dal microcontrollore.

Questa guida mostra come preparare l’ambiente di sviluppo, con Thonny e MicroPython oppure con l’IDE Arduino, e offre una panoramica pratica dei primi comandi MicroPython utili per configurare la scheda, verificare il funzionamento dell’ambiente, pilotare i pin GPIO e dialogare con periferiche esterne.

MicroPython è una versione compatta del linguaggio Python pensata per dispositivi embedded. Il vantaggio principale è la possibilità di scrivere istruzioni semplici, provarle subito nel REPL e poi trasformarle in script permanenti salvati nella memoria della Pico.

Caratteristiche tecniche essenziali della scheda

Prima di scrivere il primo programma è utile fissare alcuni dati tecnici della Raspberry Pi Pico basata su RP2040. Queste informazioni sono importanti perché determinano tensioni, limiti dei pin e periferiche disponibili.

Scheda: Raspberry Pi Pico / Raspberry Pi Pico H
Microcontrollore: RP2040
CPU: dual-core Arm Cortex-M0+
Frequenza operativa di riferimento: fino a 133 MHz
SRAM: 264 kB
Memoria flash onboard: 2 MB
GPIO multifunzione disponibili: 26
Interfacce hardware principali: 2 SPI, 2 I2C, 2 UART
ADC: 3 ingressi analogici esterni a 12 bit
PWM: 16 canali
Tensione logica dei GPIO: 3,3 V
Programmazione iniziale: USB in modalità BOOTSEL con file UF2

Il dato più importante per i primi collegamenti è la tensione logica: i pin GPIO lavorano a 3,3 V. Non vanno collegati direttamente a segnali da 5 V, perché si rischia di danneggiare il microcontrollore. Per sensori o moduli a 5 V è necessario verificare la compatibilità logica oppure usare adattatori di livello.

Raspberry Pi Pico 2 e RP2350

Dal 2024 è disponibile anche la Raspberry Pi Pico 2 (e la variante wireless Pico 2 W), basata sul microcontrollore RP2350: stesso formato e stessa piedinatura della Pico, CPU dual-core Arm Cortex-M33 (in alternativa core RISC-V Hazard3) a 150 MHz, 520 kB di SRAM e 4 MB di memoria flash. Gli esempi MicroPython di questa guida si applicano anche alla Pico 2, a patto di caricare il firmware UF2 specifico per la scheda utilizzata.

Preparazione dell’ambiente con Thonny

Il percorso più semplice per iniziare è utilizzare Thonny. Dopo aver collegato la Pico al computer tenendo premuto BOOTSEL, la scheda viene vista come unità di archiviazione. A quel punto si carica il firmware MicroPython in formato UF2. Una volta riavviata, la Pico può essere gestita tramite USB seriale.

In Thonny occorre selezionare l’interprete MicroPython per Raspberry Pi Pico. Da quel momento è possibile eseguire comandi direttamente nella console oppure salvare file sulla scheda. Il lavoro iniziale si divide quindi in due modalità:

  • uso interattivo del REPL, adatto per test rapidi e verifica dei pin;
  • salvataggio di script, adatto per eseguire automaticamente un programma all’accensione.

Installare Thonny e il firmware MicroPython passo passo

Thonny è gratuito e disponibile per Windows, macOS e GNU/Linux: si scarica dal sito ufficiale thonny.org e si installa come una normale applicazione. Al primo avvio l’interfaccia è molto essenziale:

Interfaccia di Thonny su macOS al primo avvio, con editor, shell e selettore dell’interprete in basso a destra

  1. Tenendo premuto il pulsante BOOTSEL della scheda, collegare la Pico al computer tramite USB e rilasciare il pulsante: la scheda viene montata come unità esterna (RPI-RP2, oppure RP2350 sulla Pico 2).
  2. In Thonny fare clic sull’interprete indicato nell’angolo in basso a destra e scegliere MicroPython (Raspberry Pi Pico); dallo stesso menu, tramite la configurazione dell’interprete, si avvia l’installazione o l’aggiornamento di MicroPython.
  3. Nella finestra di installazione selezionare la variante della scheda (Pico, Pico W, Pico 2, Pico 2 W) e confermare: Thonny scarica il firmware UF2 e lo copia sulla scheda, che si riavvia automaticamente.

Finestra di Thonny per l’installazione del firmware MicroPython sulla Raspberry Pi Pico RP2040

Per eseguire un programma si usa il pulsante play (Esegui): Thonny chiede se salvare il file sul computer o direttamente sulla scheda.

REPL e primi comandi di verifica

Il REPL è la console interattiva di MicroPython. Permette di scrivere un’istruzione, premere invio e vedere subito il risultato. È il modo migliore per controllare che la scheda risponda correttamente.

import sys
sys.implementation

Questo comando restituisce informazioni sull’interprete MicroPython e sulla scheda per cui è stato compilato il firmware.

import machine
machine.freq()

Il comando mostra la frequenza corrente del microcontrollore. Su RP2040 è anche possibile impostare una frequenza diversa, ma per una prima gestione è consigliabile lasciare il valore predefinito.

import os
os.listdir()

Questo comando mostra i file presenti nella memoria MicroPython della scheda. All’inizio la memoria può essere vuota oppure contenere file già creati durante prove precedenti.

Gestione dei file sulla Pico

MicroPython dispone di un piccolo filesystem interno. I file più importanti sono generalmente main.py e boot.py. Il file main.py viene usato per il programma principale, mentre boot.py è destinato a inizializzazioni eseguite molto presto all’avvio.

import os

os.listdir()

Per creare un file direttamente da console è possibile usare la scrittura su file. In pratica, durante l’uso quotidiano, è più comodo salvare il programma da Thonny scegliendo come destinazione la Raspberry Pi Pico.

f = open("test.txt", "w")
f.write("Pico pronta")
f.close()

os.listdir()

Per leggere il contenuto:

f = open("test.txt", "r")
contenuto = f.read()
f.close()

print(contenuto)

Per cancellare un file:

import os
os.remove("test.txt")

Questi comandi sono utili per capire che la Pico non è solo una scheda da programmare al volo, ma possiede anche una piccola memoria interna dove salvare script, configurazioni e dati leggeri.

Gestire i GPIO

Il primo controllo hardware: LED integrato

Il test classico per verificare che tutto funzioni è il lampeggio del LED integrato. Sulle Pico non wireless il LED è associato al pin GP25; su alcune versioni e firmware è disponibile anche il nome simbolico LED. Sulla Pico W, invece, il LED è collegato al modulo wireless e GP25 è usato da quest’ultimo: il LED si pilota solo con Pin("LED") e il firmware MicroPython per Pico W, mentre il ripiego su Pin(25) dell’esempio vale soltanto per la Pico base. Per rendere l’esempio più robusto si può usare una piccola gestione alternativa.

from machine import Pin
from time import sleep

try:
    led = Pin("LED", Pin.OUT)
except (ValueError, TypeError):
    # firmware senza il nome "LED": ripiego valido solo per la Pico base
    print("Pin 'LED' non disponibile, uso GP25")
    led = Pin(25, Pin.OUT)

while True:
    led.on()
    sleep(0.5)
    led.off()
    sleep(0.5)

Se questo script viene eseguito da Thonny, il LED inizia a lampeggiare. Per interrompere il ciclo si usa il comando di stop dell’IDE oppure Ctrl+C nel REPL.

Pin GPIO in uscita

I GPIO sono i pin generici di ingresso e uscita. In uscita possono pilotare segnali logici, LED con resistenza, ingressi di moduli esterni o transistor di comando. Non devono essere usati per alimentare direttamente carichi importanti come motori, relè o strisce LED: ogni GPIO fornisce solo pochi milliampere (la corrente di uscita è configurabile a 2, 4, 8 o 12 mA, con 4 mA come valore predefinito) e va rispettato anche il limite complessivo di tutti i pin (circa 50 mA in totale secondo il datasheet dell’RP2040). Relè e motori si comandano tramite un transistor usato come interruttore, con diodo di ricircolo per i carichi induttivi, oppure con un modulo driver.

from machine import Pin
from time import sleep

uscita = Pin(2, Pin.OUT)

uscita.value(1)
sleep(1)
uscita.value(0)

Il metodo value permette di impostare o leggere il valore logico del pin. In uscita, value(1) porta il pin a livello alto, mentre value(0) lo porta a livello basso.

uscita.on()
uscita.off()

I metodi on e off sono più leggibili quando il pin controlla un LED o un segnale digitale semplice.

Pin GPIO in ingresso

Un pin in ingresso serve per leggere pulsanti, contatti, segnali digitali provenienti da sensori o stati logici generati da altri circuiti. Per un pulsante è spesso utile attivare una resistenza interna di pull-up o pull-down.

from machine import Pin
from time import sleep

pulsante = Pin(14, Pin.IN, Pin.PULL_UP)

while True:
    stato = pulsante.value()
    print(stato)
    sleep(0.2)

Con pull-up attivo, il pin normalmente legge 1. Quando il pulsante collega il pin a GND, il valore letto diventa 0. Questa configurazione è molto usata perché riduce i componenti esterni necessari.

Ingressi analogici, PWM e temporizzazioni

Lettura analogica con ADC

La Pico può leggere segnali analogici tramite ADC. Gli ingressi analogici principali sono associati a GP26, GP27 e GP28. Il valore letto da MicroPython viene restituito su scala 0-65535, anche se il convertitore hardware è a 12 bit.

from machine import ADC, Pin
from time import sleep

adc = ADC(Pin(26))

while True:
    valore = adc.read_u16()
    print(valore)
    sleep(0.5)

Questo esempio è adatto per un potenziometro collegato tra 3,3 V e GND, con il cursore centrale collegato a GP26. Il valore stampato cresce o diminuisce ruotando il potenziometro.

Collegamento potenziometro:
estremo 1 -> 3V3
estremo 2 -> GND
centrale  -> GP26 / ADC0

Bisogna sempre verificare che il segnale analogico non superi 3,3 V.

L’RP2040 integra anche un sensore di temperatura collegato al canale ADC 4, utile come prima prova senza componenti esterni (la lettura è indicativa, con una precisione di qualche grado):

from machine import ADC

sensore = ADC(4)
tensione = sensore.read_u16() * 3.3 / 65535
temperatura = 27 - (tensione - 0.706) / 0.001721
print(temperatura)

PWM per luminosità LED e piccoli controlli

Il PWM consente di generare un segnale digitale a impulsi, utile per variare la luminosità di un LED, pilotare buzzer passivi o fornire segnali di controllo a moduli esterni. Il parametro più importante è il duty cycle, cioè la percentuale di tempo in cui il segnale rimane alto.

from machine import Pin, PWM
from time import sleep

pwm = PWM(Pin(15))
pwm.freq(1000)

while True:
    for duty in range(0, 65535, 1000):
        pwm.duty_u16(duty)
        sleep(0.02)

    for duty in range(65535, 0, -1000):
        pwm.duty_u16(duty)
        sleep(0.02)

Il valore duty_u16 varia da 0 a 65535. Un valore basso produce una luminosità ridotta, mentre un valore alto produce una luminosità maggiore. Per spegnere l’uscita PWM si può impostare il duty a zero oppure disattivare la periferica.

pwm.duty_u16(0)
pwm.deinit()

Timer software con sleep e sleep_ms

Per introdurre ritardi semplici si usa il modulo time. Nelle prime prove è sufficiente conoscere sleep, sleep_ms e ticks_ms.

from time import sleep, sleep_ms, ticks_ms

sleep(1)
sleep_ms(250)

inizio = ticks_ms()
print(inizio)

sleep usa i secondi, sleep_ms usa i millisecondi. Per programmi più evoluti è preferibile evitare pause bloccanti molto lunghe e usare una logica basata su ticks_ms, ma per i primi esempi i ritardi sono chiari e immediati.

Bus di comunicazione: UART, I2C e SPI

Negli esempi seguenti ogni periferica usa pin diversi (UART0 su GP0/GP1, I2C0 su GP4/GP5, SPI0 su GP16–GP19), così da poterli combinare nello stesso progetto senza conflitti.

Comunicazione seriale UART

UART è una comunicazione seriale semplice, utile per moduli GPS, lettori RFID, sensori seriali e collegamenti tra microcontrollori. La Pico mette a disposizione due UART hardware.

from machine import UART, Pin
from time import sleep

uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))

uart.write("ciao da Pico\n")

while True:
    if uart.any():
        dati = uart.read()
        print(dati)
    sleep(0.1)

In questo esempio TX è su GP0 e RX su GP1. Il collegamento con un altro dispositivo deve sempre incrociare le linee: TX della Pico verso RX del dispositivo, RX della Pico verso TX del dispositivo, con GND in comune.

Collegamento UART:
Pico GP0 TX -> RX dispositivo
Pico GP1 RX -> TX dispositivo
Pico GND    -> GND dispositivo

Bus I2C per sensori e display

I2C è un bus a due fili molto diffuso per sensori ambientali, display OLED, espansori di I/O, memorie e convertitori. Usa una linea dati SDA e una linea clock SCL. Una prima operazione utile è la scansione degli indirizzi presenti sul bus.

from machine import Pin, I2C

i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=400000)

dispositivi = i2c.scan()
print(dispositivi)

Se il collegamento è corretto, scan restituisce una lista di indirizzi numerici. Se la lista è vuota, bisogna controllare alimentazione, massa comune, linee SDA/SCL e presenza delle resistenze di pull-up, spesso già integrate nei moduli.

Collegamento I2C tipico:
Pico 3V3 -> VCC modulo
Pico GND -> GND modulo
Pico GP4 -> SDA
Pico GP5 -> SCL

Bus SPI per periferiche veloci

SPI è usato per display, memorie, convertitori, moduli radio e periferiche che richiedono comunicazioni più veloci rispetto a I2C. Usa almeno tre linee principali: SCK, MOSI e MISO. Spesso si aggiunge una linea CS per selezionare il dispositivo.

from machine import Pin, SPI

spi = SPI(
    0,
    baudrate=1000000,
    polarity=0,
    phase=0,
    sck=Pin(18),
    mosi=Pin(19),
    miso=Pin(16)
)

cs = Pin(17, Pin.OUT)
cs.value(1)

Per inviare dati si abbassa CS, si esegue il trasferimento, poi si rialza CS.

cs.value(0)
spi.write(b"1234")
cs.value(1)

La configurazione esatta di polarity e phase dipende dalla periferica collegata. Questi valori sono indicati nel datasheet del modulo SPI.

Connessione Wi-Fi su Raspberry Pi Pico W

La gestione Wi-Fi riguarda solo le versioni Pico W e Pico WH, non la Pico base. Prima di usare il Wi-Fi è necessario caricare un firmware MicroPython adatto alla variante wireless.

import network
from time import sleep

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("NOME_RETE", "PASSWORD_RETE")

tentativi = 0
while not wlan.isconnected() and tentativi < 15:
    print("connessione in corso...")
    sleep(1)
    tentativi += 1

if wlan.isconnected():
    print(wlan.ifconfig())
else:
    print("connessione non riuscita: controllare nome rete e password")

Questo esempio attiva l’interfaccia Wi-Fi in modalità station, tenta la connessione alla rete per al massimo 15 secondi circa e stampa la configurazione IP ottenuta, oppure un messaggio di errore. Nelle versioni recenti di MicroPython è disponibile anche il metodo wlan.ipconfig('addr4'), che sostituisce progressivamente ifconfig(). In un progetto reale è opportuno non scrivere le credenziali direttamente nel programma principale, ma salvarle in un file separato o gestirle con maggiore attenzione.

Programmi salvati e riepilogo dei comandi

Reset e riavvio della scheda

Durante le prove può essere necessario riavviare la scheda via software. Il comando principale è machine.reset.

import machine
machine.reset()

Nel REPL è anche utile conoscere Ctrl+C per interrompere un programma in esecuzione e Ctrl+D per eseguire un riavvio software dell’ambiente MicroPython.

Struttura minima di un programma salvato

Quando uno script deve partire automaticamente all’alimentazione, va salvato come main.py nella memoria della Pico. Una struttura ordinata separa import, configurazione dei pin e ciclo principale.

from machine import Pin
from time import sleep

try:
    led = Pin("LED", Pin.OUT)
except (ValueError, TypeError):
    led = Pin(25, Pin.OUT)  # solo Pico base

pulsante = Pin(14, Pin.IN, Pin.PULL_UP)

while True:
    if pulsante.value() == 0:
        led.on()
    else:
        led.off()

    sleep(0.05)

Questo programma accende il LED quando il pulsante viene premuto. È un esempio semplice, ma contiene già la struttura tipica di molti progetti embedded: inizializzazione, lettura di un ingresso, decisione logica e controllo di un’uscita.

Comandi essenziali da ricordare

Per una prima gestione della scheda è utile memorizzare un piccolo set di istruzioni. Questi comandi coprono controllo generale, file, GPIO, conversione analogica e periferiche comuni.

Verifica ambiente:
import sys
sys.implementation

Controllo frequenza:
import machine
machine.freq()

Reset:
machine.reset()

Filesystem:
import os
os.listdir()
os.remove("nomefile.py")

GPIO uscita:
from machine import Pin
pin = Pin(2, Pin.OUT)
pin.on()
pin.off()
pin.value(1)
pin.value(0)

GPIO ingresso:
pulsante = Pin(14, Pin.IN, Pin.PULL_UP)
pulsante.value()

ADC:
from machine import ADC
adc = ADC(Pin(26))
adc.read_u16()

PWM:
from machine import PWM
pwm = PWM(Pin(15))
pwm.freq(1000)
pwm.duty_u16(32768)

I2C:
from machine import I2C
i2c = I2C(0, scl=Pin(5), sda=Pin(4), freq=400000)
i2c.scan()

UART:
from machine import UART
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))
uart.write("test")
uart.read()

SPI:
from machine import SPI
spi = SPI(0, baudrate=1000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
spi.write(b"test")

Alternativa: programmare la Pico con l’IDE Arduino

Oltre a MicroPython, la Pico può essere programmata in C/C++ con l’IDE Arduino tramite il core comunitario Arduino-Pico di Earle Philhower, che supporta sia RP2040 sia RP2350.

  1. Scaricare l’ultima versione dell’IDE da arduino.cc/en/software.
  2. Aprire le preferenze (File > Preferenze su Windows e Linux, Arduino IDE > Impostazioni su macOS) e alla voce URL aggiuntive per il Gestore schede aggiungere:
    https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
  3. Aprire il Gestore schede, cercare il pacchetto Raspberry Pi Pico/RP2040 di Earle F. Philhower e installarlo, quindi selezionare la scheda corretta dal menu Strumenti > Scheda.

Per il primo caricamento collegare la scheda tenendo premuto BOOTSEL, così viene montata come memoria esterna; nei caricamenti successivi l’IDE riesce di norma a riavviarla da solo in modalità di programmazione. Per verificare il funzionamento si può usare il classico Blink sul LED integrato:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);   // LED integrato come uscita
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);   // accende il LED
  delay(1000);                       // attende un secondo
  digitalWrite(LED_BUILTIN, LOW);    // spegne il LED
  delay(1000);
}

Errori comuni nelle prime prove

Uno degli errori più frequenti è confondere la numerazione fisica dei pin con il numero GPIO. In MicroPython, quando si scrive Pin(15), si fa riferimento a GP15, non necessariamente al piedino fisico numero 15 del connettore.

Un altro errore comune è collegare moduli alimentati a 5 V senza verificare il livello logico dei segnali. La Pico lavora a 3,3 V: questa regola va considerata prima di collegare sensori, display o schede relè.

Se un programma salvato come main.py entra in un ciclo infinito e rende difficile usare la console, si può interrompere l’esecuzione con Ctrl+C subito dopo il collegamento (oppure con il pulsante di stop di Thonny) e poi rinominare o cancellare main.py. Ricaricare soltanto il firmware MicroPython non basta, perché il filesystem e quindi main.py restano in memoria: nei casi più critici occorre prima azzerare la flash copiando in modalità BOOTSEL il file flash_nuke.uf2 fornito da Raspberry Pi (cancella tutto il contenuto della memoria), quindi ricaricare il firmware MicroPython.

Metodo consigliato per imparare

Il modo più efficace per iniziare è procedere per piccoli test. Prima si verifica il LED integrato, poi un pulsante, poi un ingresso analogico, quindi una periferica I2C o UART. Ogni nuovo componente dovrebbe essere provato con uno script minimo prima di essere integrato in un progetto più grande.

MicroPython rende questo processo rapido perché permette di sperimentare direttamente nel REPL. Una volta trovata la configurazione corretta, le istruzioni possono essere copiate in uno script main.py più ordinato e commentato.

Articoli collegati

Admin | MST-Tutorial

Appassionato di elettronica, elettrotecnica e programmazione. Fondatore di MST-Tutorial, condivido con entusiasmo conoscenze, esperienze e progetti legati all’innovazione tecnologica, con l’obiettivo di rendere accessibili concetti tecnici complessi attraverso tutorial chiari e pratici.

Articoli Correlati

Pulsante per tornare all'inizio