Programmazione a blocchi in classe: piano Arduino di 8 settimane

La robotica educativa, lato programmazione, significa scrivere programmi che permettono a una scheda di percepire l'ambiente, prendere una decisione e far succedere qualcosa: un pulsante o un sensore di luce percepisce, l'Arduino decide, un LED, un buzzer o un motore reagisce. In classe il modo più semplice per insegnare questo ciclo è partire dalla programmazione a blocchi e passare al codice vero dello stesso programma quando gli studenti hanno capito la logica. Qui trovi un piano pronto all'uso di programmazione a blocchi in classe con Arduino, pensato per insegnanti, club di robotica e genitori che organizzano un laboratorio a casa: 8 settimane, una lezione di 40 minuti a settimana, ognuna costruita attorno a un progetto a blocchi gratuito di BlueGrays.

Ogni settimana del piano ha un obiettivo, un progetto BlueGrays gratuito, il nuovo blocco della settimana e il suo equivalente nel codice vero. Seguono una lista dei materiali per una classe di 24, una lezione tipo minuto per minuto, una rubrica di valutazione, idee per differenziare tra gruppi veloci e più lenti, un'alternativa senza hardware con i simulatori e le note di sicurezza. Il piano è pensato per Arduino Uno, con una settimana facoltativa su Raspberry Pi Pico e MicroPython.

Cos'è la programmazione robotica e perché iniziare con i blocchi?

Quando si parla di robotica a scuola si pensa subito alla macchinina robot, ma ogni robot si basa sugli stessi tre compiti: percepire, decidere, agire. Leggere un pulsante è percepire, chiedersi "il pulsante è premuto?" è decidere, accendere un LED o far suonare un buzzer è agire. Quando uno studente ha capito questi tre passi con un LED e un pulsante, portare la stessa logica a motori e sensore di distanza è soprattutto una questione di cambiare componenti. Per questo il piano parte da LED e pulsanti invece che dai motori, e arriva agli "occhi" del robot con il sensore di distanza HC-SR04 nell'ultima settimana.

Perché iniziare con i blocchi? Tra i 10 e i 14 anni il nemico numero uno delle prime lezioni sono punti e virgola, parentesi graffe e maiuscole; lo studente finisce per chiedersi perché il codice non compila invece di capire cosa fa il programma. Con i blocchi questi errori spariscono e l'attenzione va dritta alla logica. Restare sui blocchi però non è l'obiettivo: nel mondo reale Arduino si programma in C++ e il Pico in MicroPython. I blocchi di BlueGrays sono pensati proprio per questo ponte; ogni blocco corrisponde uno a uno a una riga del codice vero che va sulla scheda. Gli studenti leggono prima i blocchi, poi guardano il codice dello stesso programma e abbinano ogni blocco alla sua riga. Tutti i progetti a blocchi e il loro funzionamento sono nella pagina sulla programmazione a blocchi.

Il piano di 8 settimane di programmazione a blocchi in classe

Ogni lezione è pensata per 40 minuti e gruppi da 2 o 3. Tutti i progetti della tabella sono completamente gratuiti in BlueGrays, blocchi e codice compresi, quindi agli studenti non serve Premium. L'ordine è voluto: prima l'uscita (LED), poi tempi, variabili e ripetizione, quindi ingresso (pulsante) e condizioni, memorizzare uno stato, un sensore analogico, array e cicli e infine suono e distanza. Ogni settimana aggiunge una sola idea nuova alla precedente.

Mentre applichi il piano, fai diventare una regola che alla fine di ogni lezione gli studenti cambino un solo valore. Nella settimana 1, vedere il LED rallentare quando l'attesa di 100 ms in LED lampeggiante diventa 1000 ms dà già alla prima lezione la sensazione "il programma lo comando io". Nella settimana 3, portare la variabile delayTime di Lampeggiante della polizia a LED da 60 a 200 mostra che un solo numero agisce su sei blocchi insieme; è il modo più rapido per spiegare a cosa servono le variabili. Nella settimana 6, regolare la soglia di 50 di Luce notturna con LDR in base alla luce dell'aula insegna che i valori di un sensore dipendono dall'ambiente. Nella settimana 7 dai a ogni gruppo un potenziometro da 10 kΩ per LED in sequenza a velocità regolabile; cambiare a mano la velocità dei LED di solito diventa il momento preferito della settimana.

Lista dei materiali per una classe di 24

Con 24 studenti in gruppi da 3 ottieni 8 gruppi; bastano 9 kit, uno di riserva. Se preferisci le coppie, calcola le quantità per 12 gruppi. Non serve saldare nulla: ogni componente si inserisce nella breadboard. Invece di comprare i pezzi uno a uno, confronta questa lista con il contenuto di uno starter kit; nella guida allo starter kit Arduino spieghiamo cosa contengono i kit più comuni.

Lezione tipo: settimana 5, accendere e spegnere un LED con un pulsante

Lo schema qui sotto è per una lezione di 40 minuti e puoi riusarlo ogni settimana: riscaldamento, lettura dei blocchi insieme, previsione, circuito, codice vero, modifica di un valore, domanda di uscita. Come esempio abbiamo scelto il progetto della settimana 5, Accendere e spegnere un LED con un pulsante, perché l'idea che "un programma può ricordare qualcosa" è uno dei punti di svolta della programmazione robotica.

1int ledState = 0;     // LED durumu: 0 = kapalı, 1 = açık / LED state: 0 = off, 1 = on
2int lastButton = 0;   // Önceki buton okuması / Previous button reading
3
4void setup() {
5  pinMode(13, INPUT);   // Buton girişi (harici pull-down) / Button input (external pull-down)
6  pinMode(7, OUTPUT);   // LED çıkışı / LED output
7}
8
9void loop() {
10  int button = digitalRead(13);   // Butonu oku / Read the button
11  if (button != lastButton) {     // Buton durumu değişti / Button state changed
12    if (button == 1) {            // Yalnız basış anında (LOW -> HIGH) / Only at the press (LOW -> HIGH)
13      ledState = !ledState;       // Durumu tersine çevir / Flip the state
14      digitalWrite(7, ledState);
15    }
16    delay(50);                    // Sıçramayı atlamak için kısa bekleme / Short wait to skip the bounce
17    lastButton = button;          // Bu okumayı sakla / Store this reading
18  }
19}
20

Mettendo blocchi e codice fianco a fianco, la corrispondenza è chiarissima: i due blocchi "dichiara intero (int)" dentro "variabili globali (all’inizio)" sono le prime due righe del codice, "setup (una volta)" diventa setup() e "ripeti per sempre" diventa loop(). Il blocco "imposta button a leggi pin 13" è la riga int button = digitalRead(13), il confronto "≠" è != e "non ledState" è !ledState. Nella fase di previsione quasi tutti i gruppi dicono "se tengo premuto il pulsante, il LED lampeggia"; provando, vedono che il LED cambia una sola volta, perché il "se" esterno si esegue solo quando lo stato del pulsante cambia. Il momento in cui una previsione sbagliata viene corretta è il minuto più istruttivo della lezione. Quando delay(50) diventa 0, notano che alcune pressioni cambiano il LED due volte e sembra che non sia successo nulla: è l'ingresso perfetto per spiegare il rimbalzo del pulsante. Ai gruppi curiosi di sapere perché il pulsante va a GND con 10 kΩ mostra la guida su come collegare un pulsante.

Come usare BlueGrays in classe

• Aprire il progetto: Gli studenti aprono il progetto della settimana sul proprio telefono o su un tablet. Il badge dei blocchi nella lista segnala i progetti a blocchi e il filtro può mostrare solo quelli. Ogni progetto ha la lista dei componenti e lo schema del circuito.
• Mostra a blocchi: Attivando questo interruttore nella sezione del codice, al posto del codice compaiono i blocchi dello stesso programma. Toccando l'immagine si apre a schermo intero, ideale per leggerla insieme al proiettore. I blocchi compaiono nella lingua dell'app.
• Capire i blocchi: Questa scheda spiega il programma passo per passo; a ogni passo si vedono solo i blocchi di quel passo e cosa fanno. Per i gruppi più lenti funziona come un assistente dell'insegnante.
• Passare al codice vero: Disattivando l'interruttore compare il codice dello stesso programma. Lo studente lo copia nell'IDE di Arduino (in Thonny per il Pico) e lo carica sulla scheda.
• Guida al codice: Qui ci sono esempi di comandi come digitalWrite, if/else e for, ognuno anche a blocchi. Gli studenti si abituano a guardare qui prima di chiederti, quando dimenticano un comando.
• Domande del giorno: Cinque domande al giorno, dai livelli A1 a C2, con classifica settimanale e badge. Puoi consigliarle per qualche minuto di ripasso al giorno tra una lezione e l'altra.

Niente hardware? Lezione con un simulatore

Se i kit non sono ancora arrivati o fai lezione a distanza, i simulatori nel browser come Tinkercad Circuits e Wokwi sono un'ottima alternativa. Entrambi hanno Arduino Uno, breadboard, LED, resistenze e pulsanti, oltre a molti sensori; costruisci il circuito sullo schermo e lo avvii incollando il codice vero del progetto. Il flusso resta lo stesso: si leggono i blocchi in BlueGrays, si incolla il codice nel simulatore, si cambia un valore e si osserva il risultato. Tinkercad ha anche un proprio editor a blocchi, e alcuni insegnanti passano lì interamente le prime settimane. Detto questo, vedere un LED vero accendersi e infilare i cavetti nella breadboard motiva moltissimo: conviene usare il simulatore prima dell'hardware, non al suo posto. Per l'installazione e il primo circuito guarda le guide sulla simulazione Arduino con Tinkercad e sulla simulazione con Wokwi.

Valutazione: una rubrica per le lezioni di robotica

Nelle lezioni di robotica il processo conta quanto il risultato: il gruppo che ha acceso il LED e quello che ha capito perché non si accendeva possono aver imparato la stessa cosa. La rubrica qui sotto è più facile da usare concentrandosi su un criterio per lezione; alla fine delle 8 settimane basta che ogni studente sia stato osservato almeno una volta su tutti e sei i criteri. Anche le domande di uscita forniscono dati per la tabella.

Differenziare per gruppi veloci e più lenti

• Gruppi veloci, compito extra: aggiungere una quarta fase al codice di Semaforo (per esempio rosso e giallo insieme) o ricalcolarne i tempi per un incrocio reale. Cambiano il codice da soli nell'IDE di Arduino e usano i blocchi come riferimento.
• Gruppi veloci, combinare: nella settimana 8 unire HC-SR04 Misura della distanza (display seriale) e Uso del cicalino in un solo programma che fa suonare il buzzer quando la distanza scende sotto i 20 cm, un semplice sensore di parcheggio. È il primo vero passo dal leggere i blocchi allo scrivere il proprio codice.
• Gruppi veloci, cambiare piattaforma: i gruppi con un Pico aprono il progetto LED esterno con il Pico e confrontano la versione MicroPython con il codice C++ della settimana 1.
• Gruppi più lenti, circuito già montato: consegna il circuito già montato o metti sul banco lo schema stampato in grande. Questi gruppi usano il tempo per leggere i blocchi e fare previsioni.
• Gruppi più lenti, passo per passo: fai percorrere il programma con la scheda Capire i blocchi e chiedi di dire in una frase cosa succede alla fine di ogni passo. Cambiare un solo valore è un obiettivo più che sufficiente per quel giorno.
• Coppie miste: in ogni gruppo ci sia almeno un "lettore"; mettere insieme chi è veloce a montare ma lento a leggere con chi è l'opposto fa crescere entrambi.

Dai blocchi al testo: quando e come

Non c'è una settimana fissa per il passaggio; il momento giusto è quando uno studente, guardando i blocchi, sa dire cosa farà il programma prima di eseguirlo. In questo piano la maggior parte delle classi ci arriva alla settimana 4 o 5. Il contatto con il codice però inizia dal primo giorno: poiché in ogni lezione sulla scheda va il codice vero, gli studenti vedono le righe setup(), loop() e digitalWrite() fin dalla settimana 1. Il passaggio scivola piano piano da "guardo i blocchi e carico il codice" a "leggo il codice e guardo i blocchi se serve". Questa sequenza rende il passaggio più semplice:

1. Mettere blocchi e codice fianco a fianco e trovare insieme la riga di ogni blocco (settimane 1–3).
2. Nascondere i blocchi, leggere solo il codice e prevedere cosa farà il programma; poi controllare con Mostra a blocchi (settimane 4–5).
3. Cambiare i valori solo nel codice: tempo di attesa, numero del pin, soglia. Se compare un errore di compilazione, leggere la prima riga (settimane 5–6).
4. Scrivere una riga nuova: per esempio aggiungere un LED all'array di LED in sequenza e portare il limite del ciclo da 6 a 7 (settimana 7).
5. Unire due progetti in un piccolo programma proprio; se ci si blocca, guardare esempi e blocchi nella Guida al codice (settimana 8 e oltre).

Consigli di sicurezza

La serie Dai blocchi al codice in sintesi

• Parte 1: Cos'è la programmazione a blocchi e come un programma a blocchi diventa codice vero.
• Parte 2: Far lampeggiare un LED con la programmazione a blocchi: il primo programma, blocchi e C++ fianco a fianco.
• Parte 3: Il blocco se e un pulsante: le condizioni e il loro equivalente if/else.
• Parte 4: Cicli e variabili: ripeti per sempre e loop(), contare e for, array, contatori.
• Parte 5: Leggere i sensori a blocchi e MicroPython: porta seriale, LDR, HC-SR04 e il Pico.
• Parte 6: Questo articolo, che trasforma tutto ciò che hai imparato in un piano di 8 settimane per la classe.

Con questo la serie è conclusa; se vuoi ripassare la logica ancora una volta prima di iniziare in classe, torna all'inizio con cos'è la programmazione a blocchi. Tutti i progetti del piano sono nell'app BlueGrays con schema del circuito, lista dei componenti e codice; con Mostra a blocchi passi alla versione a blocchi dello stesso programma, con Capire i blocchi alla spiegazione passo per passo, e puoi condurre la lezione comodamente dal proiettore.