I miei corsi per Tecnica della Scuola: Didattica attiva con Makey Makey


Esistono numerose metodologie che in modi e tempi di esecuzione diversi permettono al docente di fornire agli studenti le competenze per imparare a sviluppare le proprie potenzialità in assoluta autonomia.

In molte delle attività laboratoriali una delle metodologie più efficaci è quella dell’apprendimento per scoperte guidate, metodologia che si fonda sul costruzionismo di Papert e Piaget. Proprio sul fare e costruire oggetti che interagiscono fisicamente con il mondo reale si basano le numerose schede elettroniche che vengono sempre più utilizzate nella scuola italiana, schede di facile utilizzo, in grado di tradurre una progetto logico in qualcosa di fisico e interattivo e che semplificano la realizzazione di attività di apprendimento per scoperte guidate.

Come spesso accade, però, l’aspetto tecnologico spaventa perché si ritiene complesso o perché si pensa di non avere le giuste competenze per inserire questi strumenti in un’attività di sperimentazione, soprattutto quando ci si rivolge ad allievi della primaria o della secondaria di primo grado.

L’aspetto elettronico ed informatico può essere ridotto moltissimo se si usano dispositivi specifici e tra questi vi è il Makey Makey che si distingue per la possibilità di essere utilizzato in qualsiasi disciplina consentendo la realizzazione di sperimentazioni fortemente interattive. Se quindi si pensa a una didattica del fare, Makey Makey è tra gli strumenti più apprezzati ed utilizzati, offrirà all’allievo un ausilio che gli permetterà di generare in maniera creativa apprendimento e sviluppo di capacità nel risolvere problemi complessi in modo efficiente.

Ma cos’è Makey Makey

Makey Makey è una scheda elettronica che permette di far dialogare il computer con qualsiasi oggetto conduttivo o materiale, e questo fa sì che l’oggetto conduttivo assuma nuove funzioni e significati. Ad esempio si potrà realizzare uno strumento musicale reale utilizzando frutta e verdura come oggetti che attiveranno un suono.

Se la scheda viene opportunamente connessa a una foglia di una pianta il tocco sulla foglia permetterà di attivare una luce o un motorino elettrico o qualsiasi altra azione su un dispositivo elettrico. Makey Makey quindi è in grado di trasformare oggetti di uso quotidiano in sistemi di input per il computer, in quanto emula i tasti della tastiera del computer e per questa sua caratteristica può essere utilizzato efficacemente con Scratch 3.

Il corso

Su questi argomenti il corso che svolgerò: Didattica attiva con Makey Makey nelle seguenti date:

  • Mercoledì 19 gennaio 2022 – Dalle 17.00 alle 19.00
  • Venerdì 21 gennaio 2022 – Dalle 17.00 alle 19.00
  • Venerdì 28 gennaio 2022 – Dalle 17.00 alle 19.00
  • Lunedì 31 gennaio 2022 – Dalle 17.00 alle 19.00

Per maggiori informazioni sui contenuti del corso e le modalità di iscrizione seguire il link allegato

… e restate sintonizzati sui miei social per vedere l’anteprima delle attività che verranno sviluppate durante il corso 🙂

Pubblicato in corsi | Contrassegnato , , , , , | Lascia un commento

EduRobot Frisbee – Come realizzare la versione in cartone ed usarla a scuola

E’ possibile costruirne un kit di robotico a basso costo con materiali di recupero che abbia valenza didattica?

Come sapete nel mio caso la risposta è sì 🙂

Ho più volte proposto su queste pagine soluzioni di kit robotici che potessero essere sviluppate da colleghi insegnanti che, pur non avendo competenze elevate di informatica ed elettronica, fossero in grado di realizzare con semplicità, attività di robotica con i loro studenti. Recentemente ho svolto due edizioni del corso in Webinar: “Creare un kit robotico a basso costo”, dove ho sviluppato soluzioni con diverse tecnologie. Nell’ultima edizione ho presentato EduRobot Frisbee costruito con materiali diversi per far fronte ad ogni disponibilità economica della scuola. In questi giorni ne sto espandendo le funzionalità e per chi desiderasse tutti i progetti ed una proposta didattica è possibile seguire il progetto su Patreon.

P.S. Per i colleghi che hanno in passato seguito seguito il mio corso in Webinar è sufficiente che mi contattino direttamente via mail per avere tutti gli aggiornamenti del kit.

Grazie per tutti coloro che vorranno sostenere il mio lavoro.

Buon Making a tutti 🙂

Pubblicato in automazione, corsi, Patreon, robotica | Contrassegnato , , , , , | Lascia un commento

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:

/*
   Prof. Maffucci Michele
   https://www.maffucci.it
   Ver.1 - 27.12.21
   Controllo di luminosità LED con
   visualizzazione intensità mediante una
   barra di avanzamento su display 16x2
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

byte pinPot = A0;           // pin analogico 0 a cui connettere il potenziometro per controllare la luminosità
byte pinLed = 3;            // pin PWM a cui connettere il LED
int  analogVal = 0;         // variabile in cui memorizzare il valore impostato dal potenziometro
int  luminosita = 0;        // variabile in cui memorizzare la luminosità 
byte barraAvanzamento = 0;  // indice barra avanzamento

// Per maggiori informazioni sulla realizzazione di caratteri speciali:
// https://www.maffucci.it/2020/01/18/disegnare-caratteri-personalizzati-con-arduino-per-un-lcd-16x2/

// Carattere personalizzato per disegnare la barraAvanzamento di avanzamento
byte iconaBarra[8] = {
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
  B11111,
};

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
// impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee
LiquidCrystal_I2C lcd(0x27, 16, 2);
//-----------------------------

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // Inpostazione ad OUTPUT del pin a cui connettiamo il LED
  pinMode(pinLed, OUTPUT);

  // Cancella il display
  lcd.clear();

  // Stampa il messaggio sulla prima riga del display
  lcd.print("Luminosita' LED");

  //Creazione del carattere per la barra di avanzamento
  lcd.createChar(0, iconaBarra);
}

// Per maggiori informazioni sull'uso del display 16x2 I2C:
// https://www.maffucci.it/2019/01/25/utilizzo-delllcd-16x2-hitachi-hd44780-1602-con-modulo-i2c-pcf8574t/
//-----------------------------

void loop() {
  // Cancella il display
  lcd.clear();
  
  // Stampa il messsaggio sulla prima riga
  lcd.print("Luminosita' LED");
  
  //Posiziona il cursore nella seconda riga, prima colonna
  lcd.setCursor(0,1);
  
  // Lettura del valore impostato dal potenziometro
  analogVal = analogRead(pinPot);
          
  // Conversione del valore analogico impostato con il potenziometro
  // in Duty Cicle per impostare la luminosità del LED
  luminosita=map(analogVal, 0, 1024, 0, 255); 
  
  // Impostazione della luminosità del LED
  analogWrite(pinLed, luminosita); 
  
  // Conversione della luminosità in quantità di caratteri della barra da stampare 
  barraAvanzamento=map(luminosita, 0, 255, 0, 15);
  
  // Stampa la barra di avanzamento
  for (byte i = 0; i < barraAvanzamento; i++)
  {
    lcd.setCursor(i, 1);   
    lcd.write(byte(0));  
  }
  // leggero ritardo di 500 ms per visualizzare la barra
  delay(500);        
}

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 🙂

Pubblicato in arduino, automazione, i miei allievi | Contrassegnato , , , , , , , | Lascia un commento

Buone Feste

Un sincero augurio a tutti coloro che mi conoscono nel mondo virtuale e nel mondo reale. Con la speranza che queste feste siano per voi piene di serenità e tante attività creativi elettroniche, auguro a tutti voi Buone Feste 🙂

Pubblicato in news | Contrassegnato , | 4 commenti

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().

/*
   Prof. Maffucci Michele
   Ver.1 - 22.12.21
   Impianto semaforico con attraversamento
   pedonale a richiesta
*/

// pin a cui sono connessi i LED
byte rossoAuto = 13;
byte gialloAuto = 12;
byte verdeAuto = 11;
byte rossoPedone = 10;
byte verdePedone = 9;

// pin a cui è connesso il pulsante di richiesta
byte pulsante = 8;

// tempo massimo di attraversamento del pedone
int tempoAttraversamento = 10000;

// definizione della variabile per l'impostazione
// del cambio stato del semaforo auto
unsigned long tempoCambio;

void setup() {
  // inizializzazione timer
  tempoCambio = millis();

  // inizializzazione dei pin come OUTPUT

  pinMode(rossoAuto, OUTPUT);
  pinMode(gialloAuto, OUTPUT);
  pinMode(verdeAuto, OUTPUT);
  pinMode(rossoPedone, OUTPUT);
  pinMode(verdePedone, OUTPUT);

  // inizializzazione pin come INPUT
  pinMode(pulsante, INPUT);

  // accensione luci verdi
  // all'avvio le auto hanno il verde e i pedoni il rosso
  digitalWrite(verdeAuto, HIGH);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(gialloAuto, LOW);
  digitalWrite(verdePedone, LOW);

  // inizializzazione della Serial Monitor
  Serial.begin(9600);
}

void loop() {
  // la variabile state viene utilizzata per sapere se il
  // pulsante di attraversamento viene premuto
  int stato = digitalRead(pulsante);

  // lo stato del pulsante viene visualizzato sulla Serial Monitor
  Serial.println(stato);

  // Se viene premuto il pulsante e se sono
  // passati 5 secondi dall'ultima pressione del pulsante

  if (stato == HIGH && (millis() - tempoCambio) > 5000) {
    // chiama la funzione per il cambio luci
    cambioLuci();
  }
}

void cambioLuci() {
  digitalWrite(verdeAuto, LOW);      // il LED verde viene spento
  digitalWrite(gialloAuto, HIGH);    // il LED giallo viene acceso per 2 secondi
  delay(2000);

  digitalWrite(gialloAuto, LOW);    // il LED giallo viene spento
  digitalWrite(rossoAuto, HIGH);    // il LED rosso viene acceso per 5 secondi

  digitalWrite(rossoPedone, LOW);   // il LED rosso del pedone viene spento
  digitalWrite(verdePedone, HIGH);  // il LED verde del pedone viene acceso
  delay(tempoAttraversamento);

  // lampeggio del LED verde dei pedoni
  for (int x = 0; x < 10; x++) {
    digitalWrite(verdePedone, LOW);
    delay(100);
    digitalWrite(verdePedone, HIGH);
    delay(100);
  }
  digitalWrite(verdePedone, LOW);
  digitalWrite(rossoAuto, LOW);
  digitalWrite(rossoPedone, HIGH);
  digitalWrite(verdeAuto, HIGH);

  tempoCambio = millis();
}

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.

Pubblicato in arduino, automazione, i miei allievi | Contrassegnato , , , | Lascia un commento