Siamo giunti alla terza edizione del corso in cui utilizzo materiali poveri di facile reperibilità per proporre attività STEAM spero coinvolgenti. Come in ogni edizione aggiungerò nuove attività, suggerimenti e schede didattiche da utilizzare in classe.
Il corso fornisce una guida completa su come integrare progetti STEAM innovativi e a basso costo utilizzando cartone e componenti elettronici semplici. Gli insegnanti impareranno a trasformare materiali di uso quotidiano in strumenti educativi coinvolgenti. Le aule e i laboratori innovativi sono veri e propri centri di allenamento mentale, dove l’azione diventa un mezzo per comprendere e costruire conoscenza. Questi spazi si trasformano in luoghi di incontro, formazione e collaborazione, promuovendo lo sviluppo di una comprensione multisensoriale della realtà. In questi ambienti, gli studenti imparano a osservare e interagire con il mondo non solo visivamente, ma anche attraverso il tatto, stimolando la loro creatività e il pensiero progettuale. L’apprendimento in questi contesti diventa un’esperienza olistica che coinvolge tutti i sensi e nutre la mente.
Il corso valorizza la manualità e la creatività, esprimibili attraverso l’uso di materiali semplici e sostenibili come carta e cartone, combinati con elementi elettronici educativi. L’obiettivo è proporre attività laboratoriali finalizzate allo sviluppo di un pensiero critico e rispettoso della diversità, promuovendo l’etica del riutilizzo e la consapevolezza ambientale. Le attività STEAM proposte incoraggiano gli studenti a esplorare e innovare in modo economico, aprendo la strada a un apprendimento responsabile e creativo.
Per ogni attività del corso, saranno fornite guide dettagliate che descrivono i passaggi necessari per costruire diversi oggetti, oltre a istruzioni per la programmazione a blocchi e l’uso dei materiali. Questo approccio mira a stimolare l’esplorazione autonoma e la creatività degli studenti. Utilizzando strumenti come BBC micro:bit, Makey Makey, Make Code, Scratch 3 e altre tecnologie, gli studenti potranno realizzare progetti coinvolgenti come giochi interattivi, strumenti di misura e strumenti musicali, sperimentando così il potere dell’innovazione tecnologica.
Il corso prevede quattro incontri webinar di 2 ore ciascuno, per un totale di 8 ore:
Venerdì 21 giugno 2024 – Dalle 17.00 alle 19.00
Lunedì 24 giugno 2024 – Dalle 17.00 alle 19.00
Martedì 25 giugno 2024 – Dalle 17.00 alle 19.00
Venerdì 28 giugno 2024 – Dalle 17.00 alle 19.00
Per le modalità di iscrizione al corso seguire il LINK.
I docenti di tutte le materie possono creare robot educativi a basso costo, senza farsi intimorire dalle innovazioni tecnologiche. Questo metodo promuove un apprendimento pratico, stimola la creatività e rende le lezioni più interattive e coinvolgenti.
Nell’ambito didattico, l’uso della tecnologia è ormai comune e parte integrante del paradigma educativo contemporaneo. La tecnologia non deve essere vista solo come un ausilio tecnico, ma come un elemento strategico della didattica.
In altre parole, la tecnologia non deve limitarsi a supportare l’insegnamento, ma può anche costituire una strategia globale di lavoro. Esempi di questo approccio includono l’insegnamento programmato, l’apprendimento automatizzato e la didattica a distanza. La tecnologia può diventare il soggetto stesso della didattica, come avviene con la robotica. In questa prospettiva, la robotica apre nuove opportunità educative.
Il corso si articola in 3 moduli e guiderà i partecipanti nella costruzione di un robot partendo da zero.
Il primo modulo introduce l’uso di BBC micro:bit e la programmazione con Blocks Editor, uno strumento grafico che facilita l’uso della scheda elettronica che controllerà il robot.
Il secondo modulo riguarda la modellazione 3D con TinkerCAD, che permetterà di stampare in 3D le proprie creazioni o di generare i progetti necessari per realizzare i robot utilizzando compensato o cartone.
Il terzo modulo combina le competenze acquisite, consentendo la costruzione e il controllo del proprio robot didattico.
Saranno svolti 3 incontri in webinar di 2 ore ciascuno, per un totale di 6 ore
Giovedì 23 maggio 2024 – Dalle 17.00 alle 19.00
Lunedì 27 maggio 2024 – Dalle 17.00 alle 19.00
Giovedì 30 maggio 2024 – Dalle 17.00 alle 19.00
Per maggiori informazioni su contenuti e modalità di iscrizione seguire il link.
Una delle nuove caratteristiche presenti in entrambe le schede Arduino Uno R4, Minima e WiFi, è l’inclusione di un singolo DAC a 12 bit. Questo può generare tensioni di uscita discrete da 0 a 5 volt. Poiché questa funzionalità può essere di estremo interesse nelle attività di laboratorio di Elettronica ne indico di seguito il principio di funzionamento per sviluppare future esercitazioni.
Principio di funzionamento
Un DAC, o Convertitore Digitale-Analogico (in inglese: Digital-to-Analog Converter), è un dispositivo che converte un valore digitale (in binario) in un valore analogico (segnali continui che possono assumere un’infinità di valori all’interno di un intervallo).
Si tratta dell’operazione inversa di quella eseguita da un ADC, o Convertitore Analogico-Digitale, che converte un segnale analogico in una rappresentazione digitale.
Il processo di conversione avviene in tre fasi:
lettura in input dei dati digitali,
conversione in analogico
output del segnale analogico
Il DAC riceve in input un segnale digitale, che è rappresentato da una serie di valori binari (0 e 1), l’elettronica del DAC consente successivamente di convertire i valori binari in un segnale di output analogico che può essere utilizzato per pilotare dispositivi analogici come altoparlanti, motori, o altre apparecchiature che necessitano di un ingresso analogico.
Dal punto di vista pratico un DAC può essere utilizzato per creare un’uscita analogica a partire da un valore digitale utile per molte applicazioni, ad esempio per generare forme d’onda audio, per pilotare dispositivi che richiedono un input analogico, o per creare segnali di tensione variabile. Ad esempio nei sistemi audio un DAC converte i segnali audio digitali (come quelli presenti nei file MP3 o nei CD) in segnali analogici che possono essere riprodotti attraverso altoparlanti o cuffie.
Per semplificare ulteriormente nell’utilizzo con Arduino UNO R4, immaginate di avere un valore digitale che varia da 0 a 4095 (rappresentando un range di 12 bit). Un DAC potrebbe convertire questo valore in una tensione che varia, ad esempio, da 0V a 5V. Quindi, se il valore digitale fosse 512 (circa metà del range), l’uscita del DAC potrebbe essere di circa 0,6V.
Vediamo un esempio pratico.
Lo sketch che segue genera una forma d’onda sinusoidale o, meglio, una forma d’onda sinusoidale “simulata”. La frequenza della forma d’onda sinusoidale viene controllata da potenziometro.
Utilizzeremo un oscilloscopio per visualizzare l’onda sinusoidale, il collegamento è piuttosto semplice, abbiamo bisogno di un potenziometro lineare con una resistenza di 5 KOhm o superiore, io ho utilizzato un potenziometro da 10 KOhm.
La sonda dell’oscilloscopio deve essere connessa al pin A0 che viene usata come uscita del DAC. Il potenziometro ha il pin centrale connesso ad A5 (ingresso del DAC), un pin laterale connesso a 5V sulla scheda e l’altro pin laterale connesso a GND sulla scheda.
Se non possedete un oscilloscopio potete inviare l’output ad un amplificatore audio in modo che possiate ascoltare la tonalità generata, ricordate però che se procedete in questo modo bisogna assicurarsi che il controllo del volume sull’amplificatore sia al minimo, dopo di che lentamente aumentate il volume.
Il codice indicato di seguito è tratto dall’esempio di riferimento sul sito Arduino e all’interno degli esempi dell’IDE su cui ho inserito i commenti tradotti in italiano e fatto una piccola correzione.
La spiegazione del funzionamento la trovate nei commenti.
// Prof. Maffucci Michele
// Arduino UNO R4 Digital-to-Analog Converter (DAC)
// Sketch di esempio tratto da: https://docs.arduino.cc/tutorials/uno-r4-wifi/dac/
// libreria per la generazione di forme d'onda analogiche
#include "analogWave.h"
// Crea un'istanza della classe analogWave, usando il pin DAC
analogWave wave(DAC);
int frequenza = 10; // variabile intera che conterrà la frequenza rilevata
void setup() {
Serial.begin(115200);
// pinMode(A5, INPUT); // non necessaria perchè ingresso analogico
wave.sine(frequenza);
}
void loop() {
// legge un valore analogico dal pin A5 e lo mappa nell'intervallo 0 - 10000 Hz
frequenza = map(analogRead(A5), 0, 1024, 0, 10000);
// Stampa l'aggiornmento dell frequenza impostata sulla serial monitor
Serial.println("La frequenza e' " + String(frequenza) + " hz");
// Imposta la frequenza del generatore di forma d'onda sul valore aggiornato
wave.freq(frequenza);
// aspetta un secondo prima di ripetere la successiv rilevazione
delay(1000);
}
Volutamente ho lasciato commentata nel setup() la riga di codice in cui viene impostato il pinMode del pin A5 perché non è necessario inizializzare un pin Analogico, nell’esempio originale invece viene inizializzata.
A tal proposito per chi inizia con Arduino consiglio la lettura della guida: “Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali“.
Il risultato sarà il seguente:
E’ possibile quindi generare forme d’onda non solo sinusoidali, la funzione wave permette di impostare:
sine – onda sinusoidale
square – onda quadra
saw – onda a dente di sega
sarà sufficiente sostituire wave.sine(frequenza) presente nella sezione setup() rispettivamente con:
Credo che una delle problematiche più ostiche da gestire soprattutto per i neofiti è l’utilizzo degli intervalli di tempo in cui eseguire operazioni con Arduino, mi riferisco all’uso e all’abuso improprio del delay(). Infatti gli studenti scoprono che, sebbene la funzione delay() sia facile da usare, ha degli effetti collaterali importanti; il principale è che ferma l’esecuzione dello sketch Arduino fino a quando non è trascorso il periodo di delay. Quando ciò accade, di solito chi spiega indirizza lo studente sull’esempio di defaut sulla temporizzazione non bloccante che troviamo nell’IDE di Arduino: BlinkWithoutDelay.
Molto spesso però questo confonde ancora di più le idee perché in realtà non si vuole solo far lampeggiare un LED ma si vogliono eseguire più operazioni contemporaneamente, quindi è bene comprendere a fondo il principio di funzionamento del BlinkWithoutDelay prima di poterlo applicare alla propria situazione.
Ho pensato quindi di realizzare qualche post tematico sull’uso di millis(), prendendo spunto dalle spiegazioni che realizzo per gli studenti.
Per usare millis() per la temporizzazione è necessario registrare il momento in cui un’azione si è verificata (ad esempio accensione di un LED ritardata alla pressione di un pulsante) affinché possiate iniziare a contare il tempo trascorso da tale evento, dovrete quindi controllare ad intervalli regolari se il periodo richiesto è trascorso.
Se tale intervallo di tempo non è trascorso allora il vostro programma potrà fare altro fino al prossimo controllo.
Nei programmi che seguono userò i commenti all’interno dello sketch per spiegare l’utilizzo delle varie parti del programma.
Ma cos’è millis()?
La funzione millis() restituisce il numero di millisecondi trascorsi dall’avvio del programma corrente su una scheda Arduino. Questo valore è restituito come un numero di tipo unsigned long.
Come Funziona
Incremento Automatico: il conteggio inizia automaticamente quando il microcontrollore sulla scheda Arduino viene alimentato o resettato. Il conteggio continua ad aumentare fino a che la scheda rimane alimentata.
Overflow: poiché millis() utilizza una variabile di tipo unsigned long, che ha una dimensione di 32 bit su Arduino, il valore massimo che può raggiungere è 4,294,967,295, dopo aver raggiunto questo valore, si andrà in overflow (ovvero Arduino non è in grado di memorizzare un numero più grande) e il valore restituito da millis() ripartirà da zero. Questo avviene dopo circa 49 giorni e 17 ore dall’ultimo reset della scheda.
Utilizzi di millis()
Di seguito una lista non esaustiva di alcuni utilizzi della funzione millis():
Temporizzazione non bloccante: a differenza di delay(), che ferma l’esecuzione del programma per un periodo specificato, millis() può essere utilizzato per realizzare pause o attese senza bloccare altre operazioni. Questo è particolarmente utile in applicazioni multitasking dove altre attività devono continuare ad essere eseguite.
Debounce: viene spesso usata per implementare il debounce di pulsanti o switch, riducendo gli effetti dei rimbalzi meccanici che possono causare letture multiple per una singola pressione.
Esecuzione di azioni a intervalli regolari: può essere utilizzata per eseguire specifiche azioni a intervalli regolari, come leggere sensori, aggiornare display, o inviare dati.
Pratica di utilizzo
Per utilizzare millis() per la temporizzazione, il vostro sketch deve conoscere il valore attuale del tempo (valore restituito da millis()) e questa rilevazione può essere fatto quando volete, in più punti dello sketch ovviamente dovrebbe essere fatta quando serve, ma vediamo cosa vuol dire.
Tipicamente il valore di millis() conviene registrarlo in una variabile ad inizio loop() o all’interno del setup() in questo modo:
millisCorrente = millis();
Regola di utilizzo:
La variabile millisCorrente deve essere stata precedentemente dichiarata.
Deve essere di tipo unsigned long perché millis() restituisce un intero long senza segno.
Regole generali che valgono per tutti i programmi che realizzerete, lo scrivo perchè puntualmente durante le correzioni qualcuno dimentica questa due regolette:
Il nome della variabile, così come accade per tutte le variabili dovrebbe essere autoesplicativa, quindi il suo nome deve dare informazioni: “a cosa serve”
Inoltre è buona regola utilizzare la notazione Camel Case per gestire nomi di variabili composte da più parole, ciò vale anche per le funzioni.
Come spesso accade durante le attività di laboratorio, lascio come semplicissimo esercizio per lo studente il desumere i componenti utilizzati e connessioni dagli sketch di esempio, quindi fate riferimento a quanto indicato in ogni singolo programma, si tratterà semplicemente di connettere dei LED con in serie un resistore da 220 Ohm. Per quanto riguarda l’ultimo esempio fate riferimento al link indicato che rimanda ad un altro post su questo sito.
Siete ora pronti per seguire le spiegazioni successive.
Nella “Lezione 2 – Corso di Elettronica Creativa con Arduino Sensor Kit” ho promesso che avrei fornito alcuni esempi pratici sull’utilizzo dell’operatore “++” come prefisso e come suffisso nell’incremento di una variabile. Durante la correzione delle esercitazioni dei miei studenti noto che la posizione del “++” crea qualche confusione, quindi ho pensato di inserire questa spiegazione nella sezione “Errori comuni nell’uso di Arduino”.
Esempio 1: “++variabile” (incremento come prefisso)
Questo sketch dimostra come il valore della variabile viene incrementato prima di essere stampato sulla Serial Monitor.
// Prof. Maffucci Michele
// utilizzo del ++ come prefisso
void setup() {
Serial.begin(9600); // Avvia la comunicazione seriale a 9600 bps
}
void loop() {
int conteggio = 0;
Serial.println("Incremento come prefisso:");
for(int i = 0; i < 5; i++) {
Serial.print("Valore attuale di conteggio: ");
Serial.println(++conteggio); // Stampa il valore di conteggio dopo essere stato incrementato
delay(1000); // Attendi un secondo tra ogni iterazione
}
Serial.println("Fine del ciclo");
while(true); // Termina il loop per evitare ulteriori incrementi
}
Nell’Esempio 1, vedrete che i valori stampati iniziano da 1 e arrivano fino a 5, perché l’incremento avviene prima della stampa del valore di conteggio.
Esempio 2: “variabile++” (Incremento come suffisso)
Questo sketch illustra come il valore della variabile sia stampato prima di essere incrementato.
// Prof. Maffucci Michele
// utilizzo del ++ come suffisso
void setup() {
Serial.begin(9600); // Avvia la comunicazione seriale a 9600 bps
}
void loop() {
int conteggio = 0;
Serial.println("Incremento come suffisso:");
for(int i = 0; i < 5; i++) {
Serial.print("Valore attuale di conteggio: ");
Serial.println(conteggio++); // Stampa il valore corrente di conteggio, poi lo incrementa
delay(1000); // Attendi un secondo tra ogni iterazione
}
Serial.println("Fine del ciclo");
while(true); // Termina il loop per evitare ulteriori incrementi
}
Nell’Esempio 2, i valori stampati iniziano da 0 e arrivano a 4, poiché l’incremento avviene dopo la stampa del valore.
Esempio 3: alternanza tra incremento come prefisso e suffisso
L’esempio che segue utilizza un contatore che aumenta ogni secondo e un messaggio che mostra sulla Serial Monitor il valore del contatore prima e dopo l’incremento, alternando tra incremento come prefisso e suffisso.
// Prof. Maffucci Michele
// utilizzo del ++ come suffisso
int contatore = 0;
bool usaPrefisso = true; // Flag per alternare tra incremento prefisso e suffisso
void setup() {
Serial.begin(9600); // Inizia la comunicazione seriale a 9600 bps
}
void loop() {
Serial.println("Inizio del ciclo");
if (usaPrefisso) {
Serial.print("Incremento come prefisso - Valore prima dell'incremento: ");
Serial.println(contatore);
Serial.print("Valore dopo l'incremento: ");
Serial.println(++contatore); // Incremento prima della stampa
} else {
Serial.print("Incremento come suffisso - Valore prima dell'incremento: ");
Serial.println(contatore);
Serial.print("Valore dopo l'incremento: ");
Serial.println(contatore++); // Stampa prima dell'incremento
}
// Alterna tra prefisso e suffisso
usaPrefisso = !usaPrefisso;
Serial.println("Fine del ciclo\n");
delay(2000); // Attendere 2 secondi prima del prossimo ciclo
}
Si noti che nel loop() a ogni iterazione, si decide se usare l’incremento come prefisso o come suffisso, basandosi sul valore del flag “usaPrefisso”. Dopo ogni ciclo, il metodo di incremento viene alternato in questo modo vengono mostrati come i due metodi di incremento influenzano il valore della variabile contatore il cui valore viene stampato sulla Serial Monitor.
