Escape Box didattica: Aurora Station

Negli ultimi mesi ho tenuto decine di corsi rivolti a studenti e docenti, e l’esperienza mi ha confermato che il gioco resta il veicolo più potente per trasmettere competenze e passione per lo studio. In particolare, i laboratori in cui trasformiamo concetti disciplinari in enigmi di un escape game scatenano partecipazione, cooperazione e ragionamento critico in un modo che la lezione frontale difficilmente eguaglia.
L’idea di condensare indizi e sfide in uno spazio portatile ‒ la cosiddetta escape box o valigia enigmatica ‒ è nata proprio da questa esigenza: avere uno strumento replicabile, modulare e a basso costo che possa viaggiare da una classe all’altra, da una disciplina all’altra, senza perdere il fascino “dell’avventura a tempo”».

Qualche settimana fa una collega della scuola secondaria di primo grado ha visto uno dei miei prototipi ‒ una valigia zeppa di schede elettroniche e LED che sviluppo per aziende ‒ e mi ha lanciato una sfida:

Riesci a progettare un dispositivo simile che i miei ragazzi possano ricostruire da soli, usando materiali di recupero, un pizzico di stampa 3D e un budget ridottissimo, così da adattarlo a qualunque materia?

Non potevo non aiutarla, la passione che mette nel suo lavoro meritava una risposta e quindi in un paio di ore di di schizzi e riflessioni è nata Aurora Station: una console di cartone con cinque interruttori e un pulsante, sormontata da un cristallo stampato in 3D ed ho deciso che dal prossimo anno scolastico entrerà all’interno di tutte quelle attività interdisciplinari che vanno dalla progettazione del gioco alla realizzazione fisica degli oggetti, passando per logica, elettronica di base, storytelling e teamwork.

Ovviamente tutto è migliorabile quindi mi perdonerete se l’oggetto non è tecnicamente elaborato, ma dai test fatti dai colleghi l’oggetto nella sua semplicità funziona.

Se volete saperne di più di questo e di altri progetti potete iscrivervi al mio prossimo corso in partenza domani:

ATTIVITÀ STEAM CON CARTA, CARTONE E CODING 4ª ed.

Di seguito una guida di massima sull’uso dello strumento, tenendo in conto che: la narrazione, il design e l’attività didattica può essere modificata come si ritiene.

Narrazione iniziale da leggere in classe

Operazione Aurora – Briefing di missione
Anno 2075. Nelle profondità della Base “Aurora Station” un temporale magnetico ha disattivato l’Aurora Core, il cristallo artificiale capace di ripulire l’aria terrestre dalla CO₂.

Davanti a voi c’è la Console di Emergenza:

  • cinque Chiavi Quantiche (interruttori ON/OFF) che canalizzano l’energia verso il Core;
  • un unico Pulsante di Convalida che dirà se la sequenza impostata è corretta;
  • il Cristallo incastonato sopra la console, pronto a illuminarsi quando la logica sarà corretta.

Dividetevi in squadre, risolvete i quesiti che vi verranno consegnati e sincronizzate le chiavi. Se anche un solo interruttore sarà errato, il Core rimarrà spento e la Terra perderà la sua ultima speranza.

Siete pronti a far brillare l’Aurora Core?

Dinamica di gioco

1. Preparazione

Materiale

  • Scatola di cartone (ex bobina di filamento) verniciata nero opaco
    riciclo e rapidità di assemblaggio
  • 5 interruttori economici ON/OFF
    acquistati in un brico
  • 1 pulsante recuperato
    da un vecchio giocattolo
  • Cristallo e piccoli decori
    Stampati in 3D con PLA traslucido
  • Cartoncini “Carta-Codice”
    ognuno contiene un enigma disciplinare

2. Setup in aula

  1. Fissare interruttori e pulsante sul coperchio della scatola; all’interno collega LED e pulsante in serie con i cinque interruttori ed il pulsante (così basta un solo errore per interrompere il circuito). Il codice di apertura può essere impostato girando gli interruttori.
  2. Incollare il cristallo stampato in 3D sopra il LED.
  3. Consegnare 5 carte gioco con quesiti diversi a ciascun gruppo (può riguardare matematica, scienze, storia, lingua, ecc.).

3. Svolgimento

  1. La console di gioco viene posta al centro dell’aula;
  2. divisione in squadre ‒ ad ogni gruppo viene consegnata una carta gioco;
  3. risoluzione enigmi ‒ quando la squadra crede di avere la risposta:
    • vero → sposta il proprio interruttore su ON
    • falso → lascia su OFF
  4. sincronizzazione ‒ quando tutti i cinque interruttori sono impostati, il docente invita un portavoce a premere il pulsante;
  5. feedback immediato
    • cristallo acceso: missione compiuta, breve esplosione di luce azzurro-bianca;
    • cristallo spento: la logica collettiva è sbagliata; si concede un secondo (ultimo) tentativo di revisione;
  6. debriefing ‒ si ripercorrono gli enigmi, si commenta perché la serie di interruttori funziona (o no) e si evidenzia il parallelismo con la programmazione: basta un solo 0 in un circuito di 1 per “rompere” il sistema.

Azioni che vengono attivate

  • Pensiero computazionale “hands-on” ‒ gli interruttori in serie traducono fisicamente l’idea di valore booleano e di errore bloccante;
  • cooperazione reale ‒ Ogni squadra è responsabile di un solo bit, ma la riuscita dipende da tutti.
  • riciclo creativo ‒ cartone, componenti recuperati e un tocco di stampa 3D dimostrano che la tecnologia può essere accessibile.
  • adattabilità disciplinare ‒ basta cambiare le Carte-Codice e la stessa escape box diventa laboratorio per qualunque materia.

Corso di Processing – lezione 07

Blocchi di Codice e Flusso di Esecuzione in Processing: setup() e draw()

Quando si scrive un programma in Processing, è fondamentale comprendere il flusso di esecuzione del codice. Un programma può essere composto da un insieme di istruzioni sequenziali, ma spesso abbiamo bisogno di strutturarlo in modo più organizzato, definendo ciò che deve accadere una sola volta e ciò che deve essere ripetuto continuamente.

Per questo motivo, Processing utilizza due funzioni principali:

  • setup(): eseguita una sola volta all’inizio del programma.
  • draw(): eseguita continuamente in un ciclo, permettendo di aggiornare la grafica in tempo reale.

1. Il Blocco setup()

La funzione setup() viene eseguita una sola volta all’avvio del programma. Qui possiamo definire le impostazioni iniziali, come la dimensione della finestra, il colore di sfondo e altre configurazioni che non devono cambiare nel tempo.

Esempio: Inizializzare una finestra con sfondo fisso

void setup() {
  size(400, 400); // Imposta la dimensione della finestra
  background(200, 200, 255); // Sfondo celeste
}

In questo caso, background(200, 200, 255); viene eseguito una sola volta all’inizio, quindi lo sfondo non cambia più.

Esercizio: Modificate il codice per impostare uno sfondo giallo e una finestra di dimensione 500×500.

2. Il Blocco draw()

La funzione draw() viene eseguita continuamente, creando un effetto di animazione o interattività.

Esempio: Disegnare un cerchio che segue il mouse

void setup() {
  size(400, 400);
  background(255); // Sfondo bianco
}

void draw() {
  fill(255, 0, 0, 150); // Rosso con trasparenza
  noStroke();
  ellipse(mouseX, mouseY, 50, 50); // Disegna un cerchio che segue il mouse
}

Esercizio: Modificare il codice per cambiare il colore del cerchio ogni volta che il mouse si muove (suggerimento: ricordate come usare la funzione random() vista nella lezione precedente).
Continua a leggere

Lezione 6 – Corso di Elettronica Creativa con Arduino Sensor Kit

Sensore di luminosità

Inizio questa lezione con un’informazione che va a correggere quanto scritto sul sito Arduino in riferimento al Grove Light Sensor in cui erroneamente viene indicato il dispositivo come fotoresistenza, in realtà si tratta di un fototransistor e ciò, soprattutto per i neofiti può creare qualche problema di comprensione, soprattutto perché lo sketch presentato non fornisce esattamente quanto indicato.

Fotoresistenza o fototransistor?

  • Versione 1.0 del Grove-Light Sensor – usava una classica CdS LDR GL5528, cioè una vera fotoresistenza.
  • Versione 1.1 / 1.2 (quella montata sullo Shield dell’Arduino Sensor Kit) – per ragioni RoHS (il cadmio delle CdS è vietato) Seeed ha sostituito l’LDR con un LS06-S: si tratta di un sensore a fototransistor lineare (tecnicamente una fotodiodo-transistor) che “mima” la vecchia fotoresistenza ma è più rapido e lineare.

Il sito di Arduino non ha aggiornato la terminologia e continua a chiamarlo “photo-resistor”.

Ora come possiamo fare per non creare problemi a chi inizia?

Innanzi tutto se volete utilizzare una fotoresistenza vi rimando alle mie slide: Alfabeto di Arduino – Lezione 3, ma attenzione in questo caso dovrete usare una breadboard e realizzare un circuito con un resistore da 10Kohm e una fotoresistenza, in questo modo usando lo sketch presente sul sito Arduino o quelli indicati nelle mie slide tutto funzionerà ed avrete valori che variano tra 0 e circa 900, coll’esempio sul sito Arduino avrete un valore massimo più basso.

Dal punto di vista teorico cosa succede (usando una fotoresistenza):

La fotoresistenza (o LDR, Light Dependent Resistor) per rilevare l’intensità della luce:

  • la resistenza della fotoresistenza diminuisce quando l’intensità luminosa aumenta;
  • la resistenza della fotoresistenza aumenta quando l’intensità luminosa diminuisce.

L’ADC dell’Arduino la converte in un numero intero da 0 (buio) a 1023 (molta luce) quindi la lettura avviene tramite l’istruzione analogRead() per questo kit collegheremo direttamente il modulo al pin A3 e quindi nel codice scriveremo: analogRead(A3).

// Prof. Maffucci Michele
// Uso del sensore di luminosità
// 27.05.2025

int sensore_luce = A3;   // pin del sensore di luminosità

void setup() {
  analogReference(INTERNAL);   // 1,1 V; attivare PRIMA di qualsiasi analogRead
  delay(3);                    // attesa minima per la stabilizzazione della reference
  Serial.begin(9600);          // avvia la comunicazione seriale
}

void loop() {
  int luce_grezza = analogRead(sensore_luce);      // legge il valore grezzo dal pin A3
  int luce = map(luce_grezza, 0, 1023, 0, 100);    // converte 0–1023 in 0–100 (percentuale)

Serial.print("Livello di luce: ");
  Serial.println(luce);  // stampa il valore di luce sul Monitor Seriale

delay(1000);           // attende 1 secondo prima della prossima lettura
}

Le cose sono simili con il Grove-Light Sensor sull’Arduino Sensor Kit, ma avrete, come dicevo, valori massimi più bassi, che raggiungo circa i 750 con la torcia dello smartphone direttamente puntata sul fototransistor. Dal punto di vista funzionale nulla cambia ma è importante aver ben presente che siamo lavorando con componenti elettronici diversi che hanno comportamenti simili.

Con lo sketch precedente otterremo sulla serial monitor questi valori:

Il fatto che il valore massimo si fermi attorno a 750 è in realtà perfettamente coerente con l’elettronica del modulo.

Quindi per ora, per chi inizia potete far finta che il componente sull’Arduino Sensor Kit è una fotoresistenza e se desiderate potete fermarvi a questo punto.

Continua a leggere

Corso di Processing – lezione 06

Gestione del colore in Processing ed utilizzo dei commenti

Il colore è un elemento essenziale nella grafica digitale. In Processing, la gestione dei colori avviene tramite il modello RGB (Red, Green, Blue), in cui ogni colore è definito dalla combinazione di tre valori compresi tra 0 e 255. Esploriamo ora come applicare il colore agli oggetti grafici nei nostri sketch.

1. Il Modello RGB

I colori sugli schermi dei computer vengono generati combinando le tre componenti principali:

  • Rosso (Red)
  • Verde (Green)
  • Blu (Blue)

Ciascuna componente può assumere valori da 0 (assenza di colore) a 255 (massima intensità). Per esempio:

size(400, 400); // Imposta la finestra
background(0, 0, 255); // Sfondo blu

Alcuni esempi di colori nel modello RGB:

  • Nerofill(0, 0, 0);
  • Biancofill(255, 255, 255);
  • Rossofill(255, 0, 0);
  • Verdefill(0, 255, 0);
  • Blufill(0, 0, 255);
  • Giallofill(255, 255, 0);
  • Cianofill(0, 255, 255);
  • Magentafill(255, 0, 255);

Selezione del Colore in Processing

Quando si lavora con i colori in Processing, può sorgere una domanda fondamentale: come faccio a conoscere i valori RGB di un colore specifico?

Per facilitare questa operazione, Processing mette a disposizione un Color Selector, uno strumento intuitivo che permette di scegliere facilmente un colore e ottenere i relativi valori numerici.

Come accedere al Color Selector

È possibile aprire il selettore di colori direttamente dall’ambiente di sviluppo di Processing andando su:
MenuStrumentiSelezionatore dei colori…

Una volta aperta la finestra del selettore, si può esplorare la gamma di colori disponibili e ottenere i relativi valori RGB(Rosso, Verde, Blu). Inoltre, lo strumento fornisce informazioni anche sui valori:

  • HSB (Hue, Saturation, Brightness)
  • Esadecimale (Hex), utile per il web design e altre applicazioni grafiche.

2. Applicare il colore agli oggetti

Per impostare il colore di riempimento di una figura, utilizziamo la funzione fill(), mentre stroke() permette di cambiare il colore del contorno.

Esempio: disegnare un cerchio colorato

size(400, 400);
background(200); // Sfondo grigio
fill(255, 0, 0); // Colore rosso
stroke(0, 0, 0); // Contorno nero
ellipse(200, 200, 150, 150);

Esercizio: Prova a cambiare il colore del cerchio variando i valori RGB nella funzione fill().
Continua a leggere

Nuova sezione dedicata a Processing!

Ho appena pubblicato una pagina che raccoglie tutte le mie lezioni, esercizi e materiali su Processing in un unico posto comodo da consultare.

Trovate il link diretto nel banner “Processing”, ben visibile nella colonna destra del sito: cliccate e accedete alla raccolta completa, in continuo aggiornamento.

Se state seguendo il corso o cercate ispirazione per le vostre attività in classe, date uno sguardo e fatemi sapere cosa ne pensate ed ovviamente se avete suggerimenti nella realizzazione di lezioni non esitate a segnalarmeli.

Grazie