Raspberry Pi Pico programmazione a blocchi: sensori e MicroPython

La programmazione a blocchi del Raspberry Pi Pico con MicroPython diventa molto più semplice quando sai già leggere un sensore con i blocchi. Leggere un sensore con i blocchi significa ottenere un valore senza scrivere codice: il blocco «lettura analogica A0» prende il livello di luce da un LDR e il blocco «stampa su seriale» invia quel numero al Monitor seriale del computer. In questo articolo leggerai prima i sensori con i blocchi su Arduino attraverso i progetti con LDR e HC-SR04, confrontando ogni blocco con la sua riga analogRead(), Serial.begin(), Serial.println() o pulseIn(). Poi farai il passo dalla programmazione a blocchi a MicroPython sul Raspberry Pi Pico e vedrai cosa cambia quando gli stessi blocchi diventano codice Python.

Finora tutti i programmi della serie agivano verso l'esterno: abbiamo acceso LED, letto un pulsante e costruito un contatore con un ciclo. Leggere un sensore funziona al contrario: la scheda misura l'ambiente e tu vedi il numero. Per questo qui entra in gioco la porta seriale, perché il modo più semplice per capire cosa misura un sensore è vederne il valore sullo schermo. Nella seconda metà, i blocchi dei progetti per Raspberry Pi Pico corrispondono a MicroPython invece che al C++. Tutti i progetti usati sono gratuiti in BlueGrays e il codice citato è esattamente quello del progetto.

Cosa significa leggere un sensore: ingressi digitali e analogici

Un pulsante segnala solo due stati: premuto o no. Lo leggi con il blocco di lettura digitale del pin (digitalRead) e il risultato è 0 o 1. Componenti come un LDR, un potenziometro o un sensore di umidità del terreno danno invece tutti i valori intermedi: la tensione sul pin varia in modo continuo tra 0 e 5 V. Il circuito che trasforma questa tensione in un numero è l'ADC (convertitore analogico-digitale). L'ADC dell'Arduino Uno è a 10 bit: divide la tensione in 1024 passi e restituisce un numero da 0 a 1023, con ogni passo pari a circa 4,9 mV. ESP32 e Pico hanno ADC a 12 bit che lavorano a 3,3 V. Questa differenza tra le schede è una delle fonti di confusione più comuni quando si passa dai blocchi al codice; trovi i dettagli nell'articolo ADC e conversione analogico-digitale.

Leggere un LDR con i blocchi su Arduino

Il nostro primo esempio è il progetto Misurare l'intensità luminosa con LDR. Un LDR è una resistenza il cui valore scende quando la luce aumenta; da solo non produce alcuna tensione. Per misurarlo lo mettiamo in serie con una resistenza fissa da 10 kΩ, formando un partitore di tensione, e colleghiamo il punto centrale ad A0. Con il collegamento qui sotto l'LDR sta dal lato dei 5V, quindi con più luce salgono la tensione su A0 e la lettura; se scambi l'LDR e la resistenza, il verso si inverte. Puoi calcolare l'uscita del partitore per diversi valori dell'LDR con il calcolatore del partitore di tensione e vedere quanti ohm ha un LDR al buio e in piena luce nell'articolo sensore di luce LDR. La colonna del Pico la useremo nell'esempio MicroPython alla fine.

Leggi i blocchi dall'alto verso il basso. Il blocco «dichiara intero (int) value = 0» dentro variabili globali (all’inizio) è la riga int value; in cima al codice. La sezione setup (una volta) contiene un solo blocco, «avvia seriale a 9600 baud», cioè Serial.begin(9600);. Dentro ripeti per sempre c'è prima «imposta value a lettura analogica A0», che è la riga value = analogRead(A0);. Poi ci sono due blocchi «stampa su seriale». Il primo stampa il testo «Value:» con l'opzione stessa riga e diventa Serial.print(); il secondo stampa value con a capo e diventa Serial.println(). Così ogni misura compare su una sola riga, per esempio «Value: 512». L'ultimo blocco, «attendi 500 ms», è delay(500);, quindi ottieni due letture al secondo. Per trasformare la lettura in tensione usa value × 5,0 / 1023: 512 corrisponde a circa 2,5 V. In una stanza buia il valore scende a qualche centinaio, con una torcia puntata sull'LDR supera 900; i numeri esatti dipendono dal tuo LDR e dalla luce ambiente.

1int value;   // Işık değeri / Light reading (0-1023)
2
3void setup() {
4  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
5}
6
7void loop() {
8  value = analogRead(A0);   // LDR gerilimini oku / Read the LDR voltage
9  Serial.print("Value: ");
10  Serial.println(value);
11  delay(500);               // 0,5 sn bekle / Wait 0.5 s
12}

Aprire il Monitor seriale e leggere i valori

1. Incolla il codice nell'Arduino IDE, scegli scheda e porta e fai clic su Carica.
2. Al termine del caricamento fai clic sull'icona della lente in alto a destra oppure apri Strumenti > Monitor seriale (scorciatoia Ctrl+Maiusc+M).
3. Imposta la velocità del Monitor seriale uguale a quella del codice: 9600 baud in questo progetto.
4. Ogni mezzo secondo scorre una riga «Value: …». Copri l'LDR con la mano e guarda il numero scendere.
5. Se vuoi vedere la variazione come grafico, apri Strumenti > Plotter seriale; gli stessi dati vengono disegnati come linea nel tempo.
6. Le impostazioni di fine riga e l'invio di dati dal Monitor seriale alla scheda sono spiegati in dettaglio nell'articolo Monitor seriale di Arduino.

Distanza con l'HC-SR04: attesa in µs e durata dell'impulso

Il secondo progetto con sensore è HC-SR04 Misura della distanza (display seriale). Qui compaiono due blocchi nuovi. Il terzetto che comincia con «scrivi ALTO sul pin trigPin» dice al sensore di emettere un impulso di ultrasuoni: il blocco «attendi 10 µs» in mezzo è delayMicroseconds(10); ed è un'attesa mille volte più breve di «attendi … ms». Poi arriva «imposta duration a durata impulso ALTO sul pin echoPin (µs)», cioè la riga unsigned long duration = pulseIn(echoPin, HIGH);, che misura per quanti microsecondi il pin Echo resta ALTO. Il suono percorre nell'aria circa 0,034 cm/µs e quel tempo comprende andata e ritorno. Per questo «imposta totalPath a duration × 0.034» calcola il percorso completo e «imposta distance a totalPath ÷ 2» la distanza di sola andata. Per esempio, un impulso di 1000 µs vale 34 cm di percorso, quindi 17 cm di distanza; dato che distance è un int, i decimali vengono scartati. Infine il blocco «se distance > minDistance e distance < maxDistance» diventa if (distance > minDistance && distance < maxDistance) e stampa solo le misure tra 3 e 100 cm. Se il sensore non riceve l'eco, pulseIn() restituisce 0, e questo controllo tiene lontani dallo schermo anche quegli zeri sbagliati. Nel codice i pin sono trigPin = 7 ed echoPin = 6. Portata e precisione del sensore sono nell'articolo sensore di distanza HC-SR04.

La stessa idea sull'ESP32: un ADC a 12 bit

La versione ESP32 della stessa logica dell'LDR è il progetto Lettura dell'intensità luminosa con il modulo LDR ESP32. I blocchi corrispondono ancora al C++ e si leggono come su Arduino, con tre differenze. Primo, setup() fissa l'ADC a 12 bit con analogReadResolution(12), quindi analogRead() restituisce 0–4095 invece di 0–1023, e una soglia scritta per Arduino come «buio sotto 500» sull'ESP32 non ha lo stesso significato. Secondo, la porta seriale lavora a 115200 baud invece di 9600, quindi imposta anche il Monitor seriale a 115200. Terzo, sull'uscita AO del modulo LDR la tensione e il valore grezzo scendono quando la luce aumenta. Per questo il codice usa i valori di calibrazione RAW_DARK = 4000 e RAW_LIGHT = 100, mantiene la lettura in questo intervallo con constrain() e con map() la trasforma in 0 % per il buio e 100 % per la luce. Su un ESP32 DevKit classico l'LDR va al GPIO 34, un pin di solo ingresso collegato all'ADC1. Poiché i pin dell'ADC2 non si possono leggere con il Wi-Fi attivo, collegare i sensori analogici ai pin dell'ADC1 è una buona abitudine. Le caratteristiche generali della scheda sono nell'articolo Cos'è l'ESP32.

Dai blocchi a MicroPython sul Raspberry Pi Pico

Nei progetti per Pico i blocchi corrispondono a MicroPython invece che al C++. I blocchi hanno un aspetto familiare, ma il linguaggio sottostante è diverso: niente parentesi graffe né punti e virgola, i blocchi di codice sono delimitati dall'indentazione e non esistono le funzioni setup() e loop(). Facciamo il passaggio con il progetto più semplice, Accensione di un LED esterno con Raspberry Pi Pico (GP14 + breadboard). Il circuito è minimo: GP14 (pin fisico 19) va al piedino lungo del LED attraverso una resistenza da 220–330 Ω e il piedino corto va a GND (per esempio il pin fisico 18). Il programma accende il LED per mezzo secondo, lo spegne per mezzo secondo e a ogni passo scrive una riga nella Shell di Thonny. Se il Pico è nuovo per te, comincia dall'articolo Cos'è il Raspberry Pi Pico.

1from machine import Pin
2import time
3
4# ============ PIN / PIN ============
5LED_PIN = 14                    # Boştaki herhangi bir GPIO / Any free GPIO
6led = Pin(LED_PIN, Pin.OUT)
7
8print("== BlueGrays: Pico Harici LED Blink ==")
9print("LED pin: GP" + str(LED_PIN))
10print("500ms yakip 500ms sonduruyor / 500ms on 500ms off")
11
12# ============ ANA DÖNGÜ / MAIN LOOP ============
13while True:
14    led.on()                    # LED'i yak / Turn the LED on
15    print("[LED] ACIK / ON")
16    time.sleep(0.5)
17
18    led.off()                   # LED'i söndür / Turn the LED off
19    print("[LED] KAPALI / OFF")
20    time.sleep(0.5)

Nella tabella saltano all'occhio quattro cose. Primo, le righe from machine import Pin e import time non hanno un blocco; in Python importi in cima i moduli che ti servono e i blocchi lo danno per scontato. Secondo, il blocco Arduino «avvia seriale a 9600 baud» qui non ha equivalente: sul Pico l'uscita di print() va direttamente via USB alla Shell di Thonny, senza velocità da impostare. Terzo, è cambiata l'unità dell'attesa: su Arduino «attendi 500 ms» è delay(500), mentre sul Pico «attendi 0.5 secondi» è time.sleep(0.5). Quarto, e più importante, l'indentazione: ogni blocco incastrato dentro «ripeti per sempre» si scrive nel codice con quattro spazi di rientro sotto la riga while True:. Se cancelli il rientro di una riga, quella riga esce dal ciclo; in Python gli spazi fanno il lavoro delle parentesi graffe del C++. Le altre regole di base sono nell'articolo basi di MicroPython.

Le stesse operazioni in tre linguaggi: blocchi, C++ e MicroPython

Il tuo esempio: leggere un LDR sul Pico con MicroPython

Adesso portiamo il progetto LDR di Arduino sul Pico. Il collegamento segue la colonna del Pico nella tabella precedente: un piedino dell'LDR al pin 3V3(OUT), l'altro sia a GP26 sia a un capo della resistenza da 10 kΩ, e l'altro capo della resistenza a GND. Il Pico ha tre pin in grado di leggere valori analogici: GP26 (ADC0), GP27 (ADC1) e GP28 (ADC2). In MicroPython crei un oggetto ADC(26) e chiami read_u16(); anche se l'ADC del Pico è a 12 bit nell'hardware, questa funzione scala il risultato su 0–65535. Per ottenere la tensione moltiplica il valore per 3,3 e dividi per 65535. Il programma segue lo stesso flusso della versione Arduino: misura, stampa, attendi mezzo secondo. In più abbiamo aggiunto una soglia: quando la stanza diventa buia si accende il LED integrato. Ragionando a blocchi, le righe prima di while True sono la sezione «setup (una volta)», while True: è «ripeti per sempre», l'if/else è il blocco «se» della parte 3 della serie, led.on() è «accendi (on) il pin led», time.sleep(0.5) è «attendi 0.5 secondi» e il + str() dentro print() è il blocco «crea testo con». La riga ADC(26).read_u16() fa il lavoro del blocco Arduino «lettura analogica A0». Regola THRESHOLD in base ai numeri che vedi nella Shell nella tua stanza.

1from machine import Pin, ADC
2import time
3
4# ============ PIN / PIN ============
5ldr = ADC(26)                   # GP26 = ADC0, bölücünün orta noktası / divider midpoint
6led = Pin(25, Pin.OUT)          # Dahili LED; Pico W'de Pin("LED") / Onboard LED; Pico W: Pin("LED")
7THRESHOLD = 20000               # Karanlık eşiği, odana göre ayarla / Darkness threshold, tune for your room
8
9print("== BlueGrays: Pico LDR ==")
10
11# ============ ANA DÖNGÜ / MAIN LOOP ============
12while True:
13    value = ldr.read_u16()                      # 0-65535
14    voltage = value * 3.3 / 65535               # Volt / Volts
15    print("Value: " + str(value) + "  Voltage: " + str(round(voltage, 2)) + " V")
16
17    if value < THRESHOLD:                       # Az ışık = küçük değer / Little light = small value
18        led.on()
19    else:
20        led.off()
21
22    time.sleep(0.5)                             # 0,5 sn = 500 ms / 0.5 s = 500 ms

Caricare il codice sul Pico con Thonny e main.py

1. Installa Thonny sul computer. Se il Pico non ha ancora MicroPython, tieni premuto il pulsante BOOTSEL mentre colleghi il cavo USB; alla prima connessione Thonny propone di installare MicroPython.
2. In basso a destra in Thonny scegli MicroPython (Raspberry Pi Pico) come interprete. Se nella Shell in basso vedi il prompt >>>, la connessione è pronta.
3. Copia il codice del progetto da BlueGrays e incollalo nell'editor di Thonny.
4. Fai clic sul pulsante verde Esegui o premi F5. Il codice gira sul Pico e l'uscita di print() compare nella Shell. Per fermarlo usa il pulsante Stop (Ctrl+F2).
5. Se vuoi che il codice funzioni senza computer, scegli File > Salva con nome, seleziona Raspberry Pi Pico nella finestra e chiama il file main.py. Il Pico esegue questo file automaticamente a ogni accensione, quindi basta un caricatore USB o un power bank.
6. Se Thonny non vede la scheda, controlla cavo e driver nell'ordine indicato nell'articolo Raspberry Pi Pico non riconosciuto.

Altri progetti gratuiti a blocchi per Pico

• Lampeggio LED integrato Raspberry Pi Pico (GP25): nessun cablaggio; fa lampeggiare il LED della scheda con LED_PIN = 25. Il codice è quasi identico a quello del progetto precedente: aprili uno accanto all'altro e vedrai che cambia solo il numero del pin. Sul Pico W il LED integrato è collegato al chip Wi-Fi, quindi si usa Pin("LED").
• Raspberry Pi Pico Due LED alternati (GP14 + GP13): parte da stati opposti con led1.value(1) e led2.value(0) e nel ciclo applica toggle() a entrambi i LED. Poiché il codice scrive from time import sleep, l'attesa appare come sleep(0.5) invece di time.sleep(0.5).
• Simulatore semaforo Raspberry Pi Pico (GP11/GP12/GP13): una funzione chiamata all_off() spegne tutti i LED; il verde resta acceso 4 secondi, il giallo 1,5 e il rosso 3, poi arriva una fase di partenza rosso+giallo di 1 secondo.
• Raspberry Pi Pico Effetto lampeggiante polizia (GP11 + GP12): questa volta l'attesa è in millisecondi con sleep_ms(WAIT_MS), dove WAIT_MS = 300. Vedere la funzione in secondi e quella in millisecondi in due progetti diversi è il modo migliore per evitare l'errore più comune qui sotto.

Errori comuni e soluzioni

Continuare con i blocchi nell'app BlueGrays

Tutti i progetti di questo articolo sono gratuiti nell'app BlueGrays. Attivando l'interruttore Mostra a blocchi nella sezione codice di un progetto, al posto del codice compare lo stesso programma a blocchi; tocca l'immagine per aprirla a schermo intero. La scheda Capire i blocchi spiega il programma passo per passo e a ogni passo mostra solo i blocchi di quel passo e cosa fanno. Lì puoi vedere con calma cosa misura il blocco della durata dell'impulso nel progetto HC-SR04, o perché la parte di setup di un progetto per Pico viene prima di while True. Anche tutti gli esempi di comandi Arduino e MicroPython della Guida al codice sono mostrati a blocchi. Per mettere alla prova ciò che hai imparato, le Domande del giorno offrono ogni giorno 5 domande dal livello A1 al C2, una classifica settimanale e dei badge. Ricorda che i blocchi non vengono mai caricati direttamente sulla scheda: la scheda riceve sempre il codice reale del progetto, che copi nell'Arduino IDE per Arduino ed ESP32 o in Thonny per il Pico. Puoi filtrare l'elenco dei progetti per il badge dei blocchi e trovare tutti i progetti a blocchi per Arduino, ESP32 e Pico nella pagina programmazione a blocchi.

Con la porta seriale e la lettura dei sensori ora sai leggere tutti i mattoni di base di un progetto, sia a blocchi sia in codice. L'ultima parte della serie porta questi passi in classe: un piano di lezione di robotica con la programmazione a blocchi per insegnanti. Nel frattempo, nell'app BlueGrays puoi seguire passo per passo gli schemi e il codice dei progetti con LDR, HC-SR04 e LED su Pico, passare alla versione a blocchi dello stesso programma con Mostra a blocchi e seguire cosa fa ogni passo con Capire i blocchi.