Archivi categoria: i miei allievi

Costruire un sistema per la rilevazione del particolato (PM2.5 – PM10) a bassissimo costo

Come sapete da tempo mi occupo di progettazione di sistemi di monitoraggio ambientale e ultimamente per diversi motivi lavorativi, ma soprattutto per passione, ho ripreso a sperimentare in tal senso.

Ciò che scrivo di seguito è la bozza di un progetto didattico più ampio che sto sviluppando che condivido con voi.

Secondo l’Organizzazione mondiale della sanità, “L’inquinamento atmosferico causa 7 milioni di morti premature ogni anno”. L’Oms nel 2021 ha pubblicato le nuove linee guida (le precedenti erano del 2005) sulla qualità dell’aria abbassando i livelli minimi di tolleranza per particolato fine e inalabile, biossido di azoto e monossido di carbonio. Il documento fornisce nuove evidenze sui rischi per la salute, dovuti all’inquinamento atmosferico.

Dal documento si evidenzia che i livelli della media annuale particolato fine (PM2.5) è di 5 µg/m3, quella del particolato inalabile (PM10) è di 15 µg/m3, mentre per il biossido di azoto (NO2) 10 µg/m3 e per il monossido di carbonio (CO) si suggerisce il limite giornaliero di 4 µg/m3.

Rispetto al documento precedente del 2005 c’è stato un aumento elevato delle prove scientifiche che mostrano inequivocabilmente che l’inquinamento atmosferico influenza in modo evidente la salute umana, sono state accumulte numerosissime informazioni sulle fonti di emissioni e sul contributo degli inquinanti atmosferici sull’amontare globale delle mallattie.

A pagina 17 del documento di cui trovate link sopra, la tabella 0.1 riporta i seguenti dati:

Non voglio con questo post fare un trattazione scientifica sull’argomento, non è ho attaulmente le competenze e mi sto formando in tal senso, ma nell’affrontare il mio studio e successivamente quello degli studenti della mia scuola sto sperimentando da tempo la realizzazione di centraline elettroniche che rilevano il particolato rischioso per la salute associati ai PM 2.5 e il PM 10 polveri il cui diametro è inferiore o uguale rispettivamente ai 2,5 micron (µm) e ai 10 micron (µm) che sono in grado di penetrare in profondità nei polmoni. Addirittura il PM2.5 è in grado di penetrare nel flusso sanguigno, provocando gravi problemi all’apparato cardiocircolatorio e respiratorio.

Non mi dilungo di più e lascio a voi lo studio del documento sopra cittato, cercherò nel prossimo futuro, durante il mio studio ed il confronto con i colleghi, di essere più preciso.

Il mio interesse attuale è quello di rilevare le polveri sottili e realizzare strumenti relativamente economici che mi possano fornire un’ordine di grandezza della qualità dell’aria che respiriamo nella zona in cui vivo e lavoro.

L’idea nasce in periodo pre-pandemico in una bozza di progettualità in cui vedeva l’installazione di una rete di sensori per la rilevazione della concentrazione delle polveri sottili in diverse zone esterne al mio istituto, un lato che volge verso la ferrovia, uno rispetto ad una strada pubblica ed una verso un giardino pubblico. Questa piccola rete doveva in qualche modo storicizzare i dati su server e renderli pubblici alla comunità scolastica.

La rete di centraline che ho immaginato ha la possibilità di trasmettere i dati via radio a distanze massime di 1Km, pertanto rilevabili dai sistemi informatici della scuola. Le frequenze utilizzabili sono libere e la comunicazione può avvenire usando apparati che hanno costi di qualche decina di Euro quindi rientrano nella filosofia che tanto mi piace: “poca spesa tanta resa” (parlo ovviamente di resa didattica).

Il progetto più ampio aveva nella mia testa la visione di riunire le tre anime dell’istituto: Meccanica, Elettronica e Biotecnologie nel costruire un network operativo tra i vari dipartimenti per mappare gli inquinanti atmosferici in modo sistematico e non solo quello delle polveri sottili, ma anche del monossido di carbonio, ossidi di zolfo, gli ossidi di azoto, l’ozono, il radon e molti altri.

Ma poi arrivò il Covid.

Ora si riparte e i vari cambiamenti lavorativi ed organizzativi che mi coinvolgono mi hanno portato a riprendere in mano il progetto che mi piacerebbe rendere operativo nel breve.

Come sapete la mia attività è prevalentemente didattica e sperimentale e mi piace studiare costruendo gli oggetti del mio studio. Ho ripreso in mano l’elettronica che avevo precedentemente usato e da un suggerimento che mi è giunto dal cognato Leo 🙂 che ringrazio, lo scorso fine settimana mi sono concentrato sul progetto opensorce sensor.community

Lo scopo del progetto è quello di monitorare in modo capillare l’inquinamento derivante da polveri sottili rendendo visibile pubblicamente il monitoraggio tramite una mappa interattiva.

Il progetto si chiama airRohr (Rohr in tedesco significa tubo) e consente di misurare l’inquinamento in piena autonomia. Viene utilizzato software libero con licenza GNU GPL 3.0 e i dati vengono caricati su un DB con licenza Database Contents License (DbCL) v1.0.

dal sito:

Sensor.Community è una rete di sensori globale guidata dai collaboratori che crea Dati Ambientali Aperti.

La missione della comunità è ispirare e arricchire la vita delle persone offrendo una piattaforma per la curiosità collettiva nella natura che sia genuina, gioiosa e positiva.

Nel momento in cui scrivo questo post i sensori attivi a livello globale sono 13.571 distribuiti in 74 nazioni (tra privati ed enti di ricerca) e tra qualche giorno se ne aggiungerà un’altro, il mio sul balcone di casa mia 🙂 e poi nel prossimo futuro forse anche nella mia scuola.

Ma come si costruisce una centralina per rilevare la concentrazione dei PM10 e PM2.5?

Sul sito di sensor.community nella sezione airRohr trovate il dettaglio preciso sulla costruzione dello strumento ed online tantissimi siti di privati e scuole che propongono varianti ed migliorie.

La costruzione base della centralina, con tutti gli strumenti a disposizione non mi ha richiesto più di un’ora di lavoro per l’assemblaggio e la configurazione.

Vi farò sorridere, ma la difficoltà maggiore è stata reperire i tubi in PVC del diametro consigliato, ho poi optato per una diversa dimensione (perchè è l’unica che ho trovato nel brico vicino casa) progettando i supporti dell’elettronica che potete vedere nelle immagini allegate (condividerò nel breve le mie varianti).

Quindi non rifarò un tutorial di costruzione dell’airRohr, in questa fase di studio non ha senso, è ottima la guida che trovate sul sito di riferimento, sicuramente però realizzerò articoli che aggiungono funzionalità ad airRohr.

Per ora ho solo voglia di sperimentare.

Spero con questo breve post di aver dato spunto ai colleghi che numerosi nelle scorse settimane mi hanno contattato per avere idee per implementare progetti “green” che non siano basati su proposte commerciali preconfezionate ma open a basso costo.

Non è l’unico progetto, ne esistono altri di complessità diversa, ma ve ne parlerò più avanti, perchè complesso è trovare il tempo per scrivere 🙂

Per i colleghi non di materie tecniche, che lavorano nella scuola elementare o media o licei, il mio suggerimento è quello di fare rete e chiedere il supporto di ITIS o Istituti Professionali ad indirizzo Elettronico che si trova nella vostra zona. Il progetto airRohr potrebbe rientrare tranquillamente in un progetto PCTO sviluppato da studenti anche del 3′ anno delle superiori.

… ma se siete miei vicini di scuola, non esitate chiedete.

Buon Making a tutti 🙂

Modular jumper wire holder

 

Quanti di voi perdono tempo nel cercare il filo giusto, del colore giusto per svolgere le sperimentazioni di elettronica? Mantenere ordine in laboratorio è fondamentale, gran parte del mio tempo di lavoro viene perso nel cercare e nel sistemare i jumper 🙂 pertanto in questa settimana, nelle pause tra uno scrutinio e l’altro ho realizzato una struttura modulare espandibile quanto si vuole per ospitare ogni tipo di jumper. Ho pensato di aggiungere alcuni fori sulla base dei supporti in modo che il tutto possa essere fissato su una base trasportabile.

P.S. fate attenzione alla modalità con cui inserite i dadi M3 (guardate le fotografie).

Vi condivido su Thingiverse i file sorgenti, spero che questo lavoro possa essere utile anche ad altri.

Di seguito alcune immagini e video che mostrano la struttura modulare.

Buon Making a tutti.

CoolTerm – Alternative alla Serial Monitor di Arduino

La comunicazione seriale viene usata in moltissimi dispositivi elettronici che utilizziamo ogni giorno. Rispetto alla comunicazione parallela (4, 8 o 64-bit), la comunicazione seriale è utilizzata spesso nei sistemi embedded a causa del basso costo e della trasmissione efficace nelle lunghe distanze.
Per chi opera con Arduino, sa che l’uso della Serial Monitor è necessario per la lettura di dati inviati serialemente tra Arduino ed il computer con altri dispositivi elettronici, ad esempio l’invio sulla Serial Monitor dei valori di temperatura rilevata da un sensore di temperatura connesso ad Arduino.

La comunicazione seriale è inoltre uno strumento utilissimo per effettuare il debug, ovvero inviare dei messaggi sulla seriale per l’utente al fine di rilevare errori o mettere in evidenza i passi di esecuzione di un programma o lo stato di un sistema.

I dati inviati da Arduino al Computer o viceversa possono essere visualizzati sul monitor del computer (attraverso la finestra della Serial Monitor) o su altri dispositivi come ad esempio un display LCD connesso ad Arduino.

Ho mostrato più volte in precedenti lezioni l’uso dei comandi seriali: Serial.begin(), Serial.print(), Serial.read() e l’utilizzo della Serial Plotter che permette di visualizzare il grafico su piano cartesiano dei dati seriali trasmessi da Arduino.

Sicuramente anche voi, nell’uso costante della Serial Monitor, avrete notato i limiti dello strumento, come esempio l’impossibilità del salvataggio dei dati inviati ad un file di log.
E’ utile quindi considerare l’uso di un terminale alternativo che offra maggiori funzionalità rispetto alla Serial Monitor, come ad esempio visualizzare:

  • i caratteri di controllo;
  • i dati in formato testo o binario o entrambi;
  • salvare i dati rilevati in un file di log.

Tra i molti software disponibili il mio consiglio va a CoolTerM, un terminale user-friendly estremamente utile.
CoolTerM viene distribuito con licenza freeware / donationware sviluppato da Roger Meier ed è disponibile per dispositivi Windows, Mac, Linux.

Come si usa CoolTerM per rilevare dati che provengono da Arduino.

A titolo di esempio sfruttiamo quanto già svolto in passato, visualizzimo su CoolTerM la distanza di un ostacolo rilevato da un sensore ad ultrasuoni.
Prendiamo come riferimento lo sketch che segue, tratto da una mia lezione sull’uso del sensore ad ultrasuoni per un kit robotico, nello stesso post trovate la teoria di funzionamento del sensore HC-SR04.

1/* Prof. Maffucci Michele
2    
3   Utilizzo del sensore ultrasuoni HC-SR04
4   Misura della distanza di un ostacolo
5 
6*/
7 
8long durata;          // durata dell'impulso
9long distanza;        // distanza dell'oggetto
10int pin_echo = 7;     // pin Arduino a cui è collegato il sensore SR04
11int pin_trig = 9;     // pin Arduino a cui è collegato il sensore SR04
12 
13void setup()
14{
15    Serial.begin(9600);
16    pinMode(pin_trig, OUTPUT);
17    pinMode(pin_echo, INPUT);
18    Serial.println("Sensore ad ultrasuini");
19}
20 
21void loop()
22{
23  Serial.print("Distanza ostacolo: ");
24  Serial.println(distanzaOstacolo());
25  delay(100);
26}
27 
28// rilevazione distanza ostacolo
29 
30// misura la distanza dell'ostacolo
31long distanzaOstacolo()
32{
33  digitalWrite(pin_trig, LOW);
34  delayMicroseconds(2);
35  digitalWrite(pin_trig, HIGH);
36  delayMicroseconds(10);
37  digitalWrite(pin_trig, LOW);
38  durata = pulseIn(pin_echo, HIGH);
39  distanza = (durata / 2.0) / 29.1;
40  delay(100);
41  return distanza;
42}

Con Arduino connesso al computer aprire CoolTerM e selezionare “Options”, da quì impostare la porta a cui è connessa la scheda e la velocità di connessione a 9600, una velocità diversa non permetterà una lettura corretta dei dati.

Torna alla schermata principale fate clic su “Connect”, ciò permetterà di avviare la trasmissione dei dati tra Arduino e il computer e i dati inizieranno ad apparire.
Quando desiderate interrompere la trasmissione ovviamente farete clic su “Disconnetti”.

E’ spesso utile analizzare i dati raccolti, in tal caso selezionate: Connection > Capture to Text/Binary File > Start ciò permetterà di salvare i vostri dati in un file TXT che potrà poi essere analizzato ad esempio con un foglio di calcolo.

CoolTerM offre ulteriori funzionalità molto utili:

  • se disponibile è possibile connettere più porte seriali concorrenti;
  • visualizzazione dei dati in formato semplice o esadecimale (HEX);
  • salvataggio e caricamento delle opzioni di connessione;
  • gestione dei caratteri speciali;
  • scripting;
  • eco locale di dati trasmessi / ricevuti;

Buon Making a tutti 🙂

Esercitazioni di base di Arduino – visualizzazione luminosità LED mediante una barra di avanzamento su display 16×2


Continuo nell’aggiornamento delle esercitazioni di base per gli studenti di 3′ dell’ITIS (Elettronica ed Automazione) e per gli utenti che iniziano con Arduino.
Utilizzeremo un display LCD 16×2 di tipo I2C su cui visualizzeremo mediante una barra di avanzamento, la quantità di luminosità impostata per il LED, mediante un potenziometro.

Per la gestione di un display LCD di tipo I2C rimando alla mia lezione: Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T.

Per la creazione di caratteri personalizzati rimando alla mia lezione: Disegnare caratteri personalizzati con Arduino per un LCD 16×2.

Lista componenti

  • N.1 Arduino UNO
  • N.1 Breadboard
  • N.1 LCD 16×2 I2C
  • N.1 Potenziometri da 10 KOhm
  • N.1 LED da 5 mm
  • N.1 Resistore da 220 Ohm
  • jumper

Schema di collegamento

Scketch

Di seguito viene indicato il codice i base, all’interno i commenti che ne dettagliano il funzionamento di ogni parte:

1/*
2   Prof. Maffucci Michele
4   Ver.1 - 27.12.21
5   Controllo di luminosità LED con
6   visualizzazione intensità mediante una
7   barra di avanzamento su display 16x2
8*/
9 
10#include <Wire.h>
11#include <LiquidCrystal_I2C.h>
12 
13byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
14byte pinLed = 3;            // pin PWM a cui connettere il LED
15int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
16int  luminosita = 0;        // variabile in cui memorizzare la luminosità
17byte barraAvanzamento = 0;  // indice barra avanzamento
18 
19// Per maggiori informazioni sulla realizzazione di caratteri speciali:
21 
22// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
23byte iconaBarra[8] = {
24  B11111,
25  B11111,
26  B11111,
27  B11111,
28  B11111,
29  B11111,
30  B11111,
31};
32 
33// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
34// impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
35LiquidCrystal_I2C lcd(0x27, 16, 2);
36//-----------------------------
37 
38void setup()
39{
40  lcd.begin();      // inizializzazione dell'LCD
41  lcd.backlight();  // attivazione della retroilluminazione
42 
43  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
44  pinMode(pinLed, OUTPUT);
45 
46  // Cancella il display
47  lcd.clear();
48 
49  // Stampa il messaggio sulla prima riga del display
50  lcd.print("Luminosita' LED");
51 
52  //Creazione del carattere per la barra di avanzamento
53  lcd.createChar(0, iconaBarra);
54}
55 
56// Per maggiori informazioni sull'uso del display 16x2 I2C:
58//-----------------------------
59 
60void loop() {
61  // Cancella il display
62  lcd.clear();
63   
64  // Stampa il messsaggio sulla prima riga
65  lcd.print("Luminosita' LED");
66   
67  //Posiziona il cursore nella seconda riga, prima colonna
68  lcd.setCursor(0,1);
69   
70  // Lettura del valore impostato dal potenziometro
71  analogVal = analogRead(pinPot);
72           
73  // Conversione del valore analogico impostato con il potenziometro
74  // in Duty Cicle per impostare la luminosità del LED
75  luminosita=map(analogVal, 0, 1024, 0, 255);
76   
77  // Impostazione della luminosità del LED
78  analogWrite(pinLed, luminosita);
79   
80  // Conversione della luminosità in quantità di caratteri della barra da stampare
81  barraAvanzamento=map(luminosita, 0, 255, 0, 15);
82   
83  // Stampa la barra di avanzamento
84  for (byte i = 0; i < barraAvanzamento; i++)
85  {
86    lcd.setCursor(i, 1);  
87    lcd.write(byte(0)); 
88  }
89  // leggero ritardo di 500 ms per visualizzare la barra
90  delay(500);       
91}

Proposta esercizi

Esercizio 1
Nell’esempio proposto viene utilizzato un delay() finale per permettere la visualizzazione dei caratteri sul display. Sostituire il delay() ed utilizzare l’istruzione millis() per valutare il tempo trascorso e controllare la stampa dei caratteri sul display.

Esercizio 2
Modificare il programma precedente raddoppiando il numero di caratteri che rappresenta la barra di avanzamento.

Esercizio 3
Modificare l’esercizio proposto variando la barra di avanzamento in funzione dell’approssimarsi al valore massimo o minimo della luminosità.

Esercizio 4
Modificare l’esercizio proposte inserendo un buzzer che emette un suono la cui frequenza varia in funzione dell’intensità luminosa del LED.

Buon Making a tutti 🙂

Esercitazione di Sistemi Elettronici – Arduino – impianto semaforico ad 1 via

Questa esercitazione è dedicata ai miei studenti di 3′ (Automazione ed Elettronica Biomedicale) che come compito per le vacanze natalizie dovranno, partendo dall’esempio svolto, realizzare le 4 varianti richieste al fondo di questa lezione.

Introduzione

  • In questo progetto bisognerà realizzare l’impianto semaforico per automobili e modificarlo secondo le specifiche indicate al fondo di questo post
  • vengono utilizzati 3 LED: verde, giallo e rosso per simulare un semaforo reale
  • vengono utilizzati 2 LED : verde e rosso per simulare il semaforo per i pedoni
  • è presente un pulsante di richiesta attraversamento per i pedoni

Lista componenti

  • 1 Breadboard
  • 1 Arduino UNO
  • 3 LED da 5mm (rosso, giallo, verde)
  • 2 LEd da 5mm LED (rosso, verde)
  • 5 resistori da 220 Ohm
  • 1 resistore da 10 kOhm
  • 1 pulsante normalmente aperto
  • jumper

Collegamenti

Sketch

Per la realizzazione di questo progetto non avrete necessità di nessuna libreria da aggiungere all’IDE di Arduino.

L’automazione del semaforo sarà la seguente:

  • Il semaforo per le automobili è sempre verde e la luce pedonale risulta sempre rossa a meno che qualcuno preme il pulsante.
  • Quando viene premuto il pulsante dal pedone:
    • il semaforo auto cambia da giallo e successivamente si spegne il giallo e si accende il rosso;
    • sul semaforo pedonale si spegne il rosso e si accende il verde;
    • le luci del semaforo pedonale rimangono in questo stato per un tempo pari a tempoAttraversamento
    • successivamente il verde del semaforo pedonale lampeggia, terminata la sequenza di lampeggio si spegne e si accende il rosso;
  • il semaforo delle auto passa da rosso a verde

Tutte queste funzioni sono svolte dalla funzione cambiabentoLuci().

1/*
2   Prof. Maffucci Michele
3   Ver.1 - 22.12.21
4   Impianto semaforico con attraversamento
5   pedonale a richiesta
6*/
7 
8// pin a cui sono connessi i LED
9byte rossoAuto = 13;
10byte gialloAuto = 12;
11byte verdeAuto = 11;
12byte rossoPedone = 10;
13byte verdePedone = 9;
14 
15// pin a cui è connesso il pulsante di richiesta
16byte pulsante = 8;
17 
18// tempo massimo di attraversamento del pedone
19int tempoAttraversamento = 10000;
20 
21// definizione della variabile per l'impostazione
22// del cambio stato del semaforo auto
23unsigned long tempoCambio;
24 
25void setup() {
26  // inizializzazione timer
27  tempoCambio = millis();
28 
29  // inizializzazione dei pin come OUTPUT
30 
31  pinMode(rossoAuto, OUTPUT);
32  pinMode(gialloAuto, OUTPUT);
33  pinMode(verdeAuto, OUTPUT);
34  pinMode(rossoPedone, OUTPUT);
35  pinMode(verdePedone, OUTPUT);
36 
37  // inizializzazione pin come INPUT
38  pinMode(pulsante, INPUT);
39 
40  // accensione luci verdi
41  // all'avvio le auto hanno il verde e i pedoni il rosso
42  digitalWrite(verdeAuto, HIGH);
43  digitalWrite(rossoPedone, HIGH);
44  digitalWrite(rossoAuto, LOW);
45  digitalWrite(gialloAuto, LOW);
46  digitalWrite(verdePedone, LOW);
47 
48  // inizializzazione della Serial Monitor
49  Serial.begin(9600);
50}
51 
52void loop() {
53  // la variabile state viene utilizzata per sapere se il
54  // pulsante di attraversamento viene premuto
55  int stato = digitalRead(pulsante);
56 
57  // lo stato del pulsante viene visualizzato sulla Serial Monitor
58  Serial.println(stato);
59 
60  // Se viene premuto il pulsante e se sono
61  // passati 5 secondi dall'ultima pressione del pulsante
62 
63  if (stato == HIGH && (millis() - tempoCambio) > 5000) {
64    // chiama la funzione per il cambio luci
65    cambioLuci();
66  }
67}
68 
69void cambioLuci() {
70  digitalWrite(verdeAuto, LOW);      // il LED verde viene spento
71  digitalWrite(gialloAuto, HIGH);    // il LED giallo viene acceso per 2 secondi
72  delay(2000);
73 
74  digitalWrite(gialloAuto, LOW);    // il LED giallo viene spento
75  digitalWrite(rossoAuto, HIGH);    // il LED rosso viene acceso per 5 secondi
76 
77  digitalWrite(rossoPedone, LOW);   // il LED rosso del pedone viene spento
78  digitalWrite(verdePedone, HIGH);  // il LED verde del pedone viene acceso
79  delay(tempoAttraversamento);
80 
81  // lampeggio del LED verde dei pedoni
82  for (int x = 0; x < 10; x++) {
83    digitalWrite(verdePedone, LOW);
84    delay(100);
85    digitalWrite(verdePedone, HIGH);
86    delay(100);
87  }
88  digitalWrite(verdePedone, LOW);
89  digitalWrite(rossoAuto, LOW);
90  digitalWrite(rossoPedone, HIGH);
91  digitalWrite(verdeAuto, HIGH);
92 
93  tempoCambio = millis();
94}

Esercizio 1
Aggiungere un sensore ad ultrasuoni che rileva la presenza del pedone in fase di attraversamento, fino a quando viene rilevato il pedone viene mantenuto il verde per il pedone ed il rosso per le auto. E’ presente sempre il pulsante di richiesta attraversamento.

Esercizio 2
Ampliare l’esercizio 1 aggiungendo un display a 7 segmenti utilizzato come conto alla rovescia (da 9 a 0) per i pedoni quando attraversano.

Esercizio 3
Ampliare l’esercizio 1 aggiungendo un buzzer che con un segnale pulsante variabile, indica l’approssimarsi del rosso.

Esercizio 4
Ampliare l’esercizio proposto in questa lezione trasformando l’impianto semaforico da 1 via a 4 vie con rispettivi attraversamenti pedonali sulle 4 strade.

Per coloro che non sono miei studenti, sul mio Patreon nei prossimi giorni verrà proposta:

  • La soluzione a tutti gli esercizi proposti con schemi di collegamento e codice
  • Video di spiegazione
  • Sorgenti STL per la stampa 3D di un semaforo da poter essere inseriti all’interno di un plastico
  • Proposta progettuale per la realizzazione di un kit didattico per lo sviluppo di questa tipologia di esercizi.

Buon Making a tutti.