Dai blocchi al codice Arduino: tabella C++ e MicroPython

Il modo più rapido per passare dai blocchi al codice Arduino è tenere accanto a te una tabella di una pagina che mostra in quale riga di codice vero si trasforma ogni blocco. La risposta breve: i blocchi non sono un nuovo linguaggio, sono la forma visiva delle righe di Arduino C++. Il blocco «imposta pin 13 come USCITA» è la riga pinMode(13, OUTPUT);, il blocco «attendi 1000 ms» è delay(1000); e il blocco «se … fai» è un’istruzione if. La tabella qui sotto mette le etichette reali dei blocchi dell’app BlueGrays accanto al loro codice Arduino C++ e al codice MicroPython sul Raspberry Pi Pico.

Questa pagina non è una lezione, è una scheda di consultazione. Puoi stampare la tabella, tenerla vicino al banco e controllare quale riga corrisponde a quale blocco mentre guardi un progetto. Dopo la tabella trovi gli errori più comuni nel passaggio, un metodo in quattro passi per lasciarti alle spalle i blocchi e lo stesso programma scritto a blocchi, in C++ e in MicroPython. L’esempio si compila nell’Arduino IDE e gira sul Pico con Thonny.

Prima di leggere la tabella: quattro differenze tra i tre

Blocchi, C++ e MicroPython esprimono la stessa idea, ma le regole di scrittura cambiano. Queste quattro differenze sono quelle su cui inciamperai di più. La prima è la struttura: un programma Arduino C++ ha due parti chiamate setup() e loop(), che nei blocchi compaiono come «setup (una volta)» e «ripeti per sempre». MicroPython non ha un setup separato; il file viene eseguito una volta dall’alto in basso e la parte che si ripete va dentro un ciclo while True:. La seconda sono i tipi: in C++ ogni variabile ha un tipo scritto (int, float, bool), nei blocchi è l’opzione «dichiara intero (int)», in Python il tipo non si scrive affatto.

La terza differenza sono gli intervalli numerici. Sull’Arduino Uno una lettura analogica va da 0 a 1023 e il PWM da 0 a 255; sull’ESP32 la lettura analogica arriva a 0–4095; sul Pico, MicroPython dà sia le letture sia il duty PWM nell’intervallo 0–65535. Per questo non puoi copiare una soglia da una scheda all’altra così com’è. La quarta differenza è l’unità di tempo: delay() vuole millisecondi, time.sleep() vuole secondi. Mezzo secondo è delay(500) in C++ e time.sleep(0.5) in MicroPython. Se tieni a mente queste quattro regole, la maggior parte delle righe della tabella va a posto da sola.

• I numeri nella tabella sono esempi: dove il blocco dice 13, il tuo progetto può usare 7, e il numero nella riga di codice cambia di conseguenza.
• I pin nella colonna MicroPython sono numeri GP del Pico (GP14, GP15, GP26). Non devono coincidere con i pin dell’Uno; guarda lo schema.
• Le righe con «Nessun blocco Pico» indicano che quel blocco non si usa nei progetti Pico; il codice MicroPython che fa lo stesso lavoro è comunque riportato.
• Anche l’ESP32 si programma in Arduino C++; la colonna C++ vale anche per lui, cambiano solo l’intervallo analogico e alcuni numeri di pin.

Tabella di corrispondenza: blocchi, Arduino C++ e MicroPython

La tabella è divisa in 12 gruppi: struttura del programma, pin, tempo, condizione, ciclo, variabili, matematica, porta seriale, analogico e PWM, suono, servo e sensore. Il testo nella colonna Blocco è l’etichetta scritta sui blocchi nell’app; «…» e «?» indicano lo spazio in cui si innesta un altro blocco. Quando una riga contiene più blocchi, sono separati da un punto.

Alcune righe sembrano corrispondenze dirette ma richiedono attenzione. In «conta con i da 0 a 5» il 5 è incluso e il ciclo fa 6 giri; per questo in C++ si scrive <= invece di <, e Python ha bisogno di range(0, 6), perché range esclude il numero finale. Anche il blocco della divisione è una trappola: dividendo due interi il C++ scarta i decimali e 7 / 2 dà 3, mentre Python dà 3.5. Per una divisione intera come in C++, in Python si usa //. La funzione map() dietro il blocco «mappa x» non è integrata in MicroPython; nell’esempio qui sotto una funzione arduino_map() di due righe fa lo stesso calcolo.

Come diventano codice i blocchi annidati?

Conoscere i singoli blocchi non basta; la vera abilità è trasformare blocchi annidati in una sola riga. Per farlo distingui due forme. I blocchi impilati uno sotto l’altro, con una tacca sul bordo, sono istruzioni e ognuno diventa una riga di codice. I blocchi ovali o appuntiti che si innestano nello spazio di un altro blocco sono valori; nel codice stanno tra parentesi, a destra di un segno uguale o dentro una condizione. Le righe qui sotto vengono dal progetto gratuito Impostazione della frequenza con cicalino: quattro pulsanti accendono e spengono il suono e ne alzano o abbassano la frequenza, che resta tra 50 e 5000 Hz.

Prendi un’abitudine mentre leggi questa tabella: traduci prima il blocco più interno, poi procedi verso l’esterno. In «imposta frequency a (costringi frequency da 50 a 5000)» la parte più interna è constrain(frequency, 50, 5000), e il blocco imposta esterno la trasforma in frequency = …. Un blocco valore non può essere una riga da solo; se lo lasci con un punto e virgola, il compilatore forse non si lamenta, ma il risultato non viene salvato da nessuna parte.

Errori comuni nel passaggio dai blocchi al codice

L’editor a blocchi non ti lascia fare la maggior parte di questi errori; la forma dei pezzi impedisce che si incastrino nel posto sbagliato. Nel codice questa protezione sparisce, quindi quasi tutti incontrano gli errori qui sotto nelle prime settimane. I messaggi di errore arrivano in inglese, ma gli schemi sono pochi e, dopo averli visti un paio di volte, li riconoscerai.

Lasciarsi alle spalle i blocchi: metodo in 4 passi

Cercare di cambiare tutto in una volta è faticoso. I quattro passi qui sotto vanno dalla lettura alla scrittura a piccoli passi. Uno o due progetti per passo bastano; sei pronto per il successivo quando riesci a fare quello attuale senza guardare la tabella.

1. Leggi fianco a fianco. Apri insieme i blocchi e il codice di un progetto e abbina con il dito ogni blocco alla sua riga di codice. In questo passo tieni sempre la tabella accanto. Obiettivo: saper collegare ogni riga di codice a un blocco.
2. Nascondi i blocchi e indovina. Guarda prima i blocchi, poi disattiva la vista a blocchi e scrivi su carta il C++ di quei blocchi senza guardare il codice. Poi confronta con il codice vero. Prova anche al contrario: leggi il codice e indovina i blocchi.
3. Cambia un valore nel codice. Porta il codice sul computer e cambia un solo numero: porta l’attesa da 100 a 500 o la soglia da 400 a 600. Caricalo e guarda la differenza con i tuoi occhi. Se compare un errore di compilazione, torna alla tabella degli errori qui sopra.
4. Scrivi una riga nuova. Aggiungi una riga che nei blocchi non c’è: un Serial.println() che mostra il valore nel monitor seriale, un secondo LED o un if che funziona con un pulsante. Ora non traduci più blocchi, scrivi codice direttamente.

Ogni passo ha la sua lezione nella serie. Per il primo, la tabella blocco-riga dell’articolo accendere un LED a blocchi è un buon inizio. Per condizioni e cicli nei passi due e tre, leggi il blocco se e cicli e variabili. Se passi a MicroPython con il Pico, dai blocchi a MicroPython spiega anche come installare Thonny. Se vuoi distribuire il passaggio su più settimane di lezione, il piano di robotica di 8 settimane offre un ordine già pronto.

Aprire blocchi e codice fianco a fianco nell’app BlueGrays

Userai questa tabella soprattutto passando avanti e indietro tra i blocchi e il codice di un progetto vero. L’app BlueGrays ha la vista a blocchi in oltre 100 progetti; in più di 30 progetti gratuiti anche i blocchi sono aperti, mentre nei progetti Premium i blocchi si sbloccano con Premium. I blocchi servono per leggere: nell’app i blocchi non si modificano e non vengono caricati sulla scheda. Sulla scheda va sempre il codice vero; lo prendi con Copia, oppure con Copia link per aprirlo sul computer, e lo incolli nell’Arduino IDE o, per il Pico, in Thonny.

• Mostra a blocchi: attiva questo interruttore accanto al codice sorgente nella pagina di un progetto e lo stesso programma compare come immagine a blocchi nella lingua dell’app. Tocca l’immagine per aprirla a schermo intero; attivarlo e disattivarlo è proprio l’esercizio dei passi uno e due.
• Capire i blocchi: con la vista a blocchi attiva, la scheda «Capire il codice» prende questo nome. Il programma è diviso in passi, ognuno con la sua parte e una spiegazione. Il compito «Prova tu» alla fine è un esercizio già pronto per il passo quattro.
• Guida al codice: ognuna delle 36 schede della sezione Impara (18 Arduino C++, 18 MicroPython) mostra il suo esempio in tre forme con le schede Blocchi, Arduino e MicroPython. Se vuoi vedere una riga della tabella più nel dettaglio, apri la scheda corrispondente.
• Progetti a blocchi: questa opzione in Filtra di Scopri > Progetti, elenca solo i progetti con la vista a blocchi e ti aiuta a scegliere un progetto per il passaggio.

Abbiamo spiegato come funziona la guida al codice nell’articolo sulla guida al codice, e le sezioni «Capire il codice» e «Prova tu» nella guida a Capire il codice. Per i singoli comandi spiegati uno a uno, l’elenco dei comandi Arduino si abbina bene a questa tabella.

Un programma in tre forme: luce notturna che si regola con la luce

Per vedere la tabella all’opera costruiamo un piccolo programma. Un LDR misura la luce; finché la stanza è illuminata il LED resta spento, e man mano che si fa buio il LED si accende piano piano. Il programma usa blocchi di variabile, lettura analogica, condizione, mappatura, PWM, porta seriale e attesa: più di metà della tabella compare in un solo esempio. L’idea si basa sul progetto gratuito Luce notturna con LDR; lì il LED è solo acceso o spento, qui il PWM lo regola. Per il collegamento dell’LDR puoi guardare anche lo schema del progetto Misurare l'intensità luminosa con LDR.

Prima la versione a blocchi. Con le etichette dell’app, il programma è formato da questi blocchi; ogni voce corrisponde a una o più righe del codice C++ che segue:

1. variabili globali (all’inizio): dichiara intero (int) lightValue = 0 e dichiara intero (int) brightness = 0
2. setup (una volta): avvia seriale a 9600 baud, poi imposta pin 9 come USCITA
3. ripeti per sempre: imposta lightValue a (lettura analogica A0)
4. se (lightValue < 400) fai: imposta brightness a (mappa lightValue : 0 – 400 → 255 – 0); altrimenti: imposta brightness a 0
5. scrivi PWM brightness sul pin 9
6. stampa su seriale «Light: » stessa riga, stampa su seriale lightValue stessa riga, stampa su seriale « PWM: » stessa riga, stampa su seriale brightness a capo
7. attendi 200 ms

1// ─────────────────────────────────────────
2//   BlueGrays · bluegrays.com
3//   Işığa göre kısılan gece lambası / Dimming night light
4// ─────────────────────────────────────────
5
6int lightValue = 0;   // LDR okuması / LDR reading (0-1023)
7int brightness = 0;   // LED parlaklığı / LED brightness (0-255)
8
9void setup() {
10  Serial.begin(9600);   // Seri port 9600 baud / Serial at 9600 baud
11  pinMode(9, OUTPUT);   // LED, PWM pini D9 / LED on PWM pin D9
12}
13
14void loop() {
15  lightValue = analogRead(A0);   // Az ışık = küçük değer / Little light = small value
16
17  if (lightValue < 400) {
18    // Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
19    brightness = map(lightValue, 0, 400, 255, 0);
20  } else {
21    brightness = 0;   // Oda aydınlık, LED kapalı / Room is bright, LED off
22  }
23
24  analogWrite(9, brightness);   // PWM 0-255 / PWM 0-255
25
26  Serial.print("Light: ");
27  Serial.print(lightValue);
28  Serial.print("  PWM: ");
29  Serial.println(brightness);
30
31  delay(200);   // 0,2 sn bekle / Wait 0.2 s
32}
33

1# ─────────────────────────────────────────
2#   BlueGrays · bluegrays.com
3#   Işığa göre kısılan gece lambası / Dimming night light
4# ─────────────────────────────────────────
5from machine import Pin, ADC, PWM
6import time
7
8ldr = ADC(26)                # GP26 = ADC0 / GP26 = ADC0
9led = PWM(Pin(15))           # LED, GP15 / LED on GP15
10led.freq(1000)               # PWM frekansı 1000 Hz / PWM frequency 1000 Hz
11
12THRESHOLD = 25600            # Uno'daki 400'ün karşılığı / Same as 400 on the Uno
13
14
15def arduino_map(x, in_min, in_max, out_min, out_max):
16    # Arduino map() ile aynı hesap / Same math as Arduino map()
17    return (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
18
19
20while True:
21    light_value = ldr.read_u16()          # 0-65535 / 0-65535
22
23    if light_value < THRESHOLD:
24        # Karanlık arttıkça LED parlar / The darker it gets, the brighter the LED
25        brightness = arduino_map(light_value, 0, THRESHOLD, 65535, 0)
26    else:
27        brightness = 0                    # Oda aydınlık, LED kapalı / Room is bright, LED off
28
29    led.duty_u16(brightness)              # PWM 0-65535 / PWM 0-65535
30
31    print("Light:", light_value, " PWM:", brightness)
32
33    time.sleep(0.2)                       # 0,2 sn bekle / Wait 0.2 s
34

Confrontando i due programmi riga per riga emergono tutte le differenze della tabella. Il setup() del C++ diventa in Python le righe prima di while True, e Serial.begin() sparisce. analogRead(A0) diventa ADC(26).read_u16() e l’intervallo passa da 0–1023 a 0–65535, per questo la soglia è 25600 invece di 400. Al posto di analogWrite(9, …) si crea prima un oggetto PWM e la luminosità si imposta con duty_u16() tra 0 e 65535. Poiché map() non è integrata, si scrive una funzione arduino_map(); la divisione intera // al suo interno corrisponde alla divisione intera del C++. Un solo print() sostituisce quattro Serial.print(), e delay(200) diventa time.sleep(0.2).

Passare dai blocchi al codice Arduino C++ significa meno imparare a memoria qualcosa di nuovo e più riconoscere la forma scritta di blocchi che già conosci. Tieni questa tabella accanto, in ogni progetto leggi prima fianco a fianco, poi nascondi i blocchi e scrivi da solo. Se vuoi vedere queste righe in progetti veri, apri nell’app BlueGrays un progetto con la vista a blocchi e passa tra le due forme dello stesso programma con Mostra a blocchi.