Didattica laboratoriale a distanza: controllare la postura con BBC micro:bit quando siamo seduti al computer


Durante il recente incontro online con il FabLab di Belluno abbiamo parlato di didattica laboratoriale a distanza realizzata con diversi dispositivi elettronici e kit di sperimentazioni che ho realizzato. Siamo entrati anche nello specifico dell’utilizzo di alcune tecnologie come BBC micro:bit ed ho mostrato alcune esercitazioni realizzabili online in didattica a distanza.

Come spesso accade mi piace realizzare con gli studenti sperimentazioni che hanno attinenza con il loro vivere quotidiano in modo da fornire un senso fisico al loro studio teorico. Lavorare continuamente per molte ore davanti al computer è un’azione che molte persone stanno vivendo e gli effetti negativi di questo continuo lavorare online si riflettono sulla nostra salute, occhi e schiena doloranti sono ormai la norma. Ovviamente ginnastica e tempi precisi di lavoro aiutano tantissimo, ma occupandomi di didattica analizzare questo aspetto può rendere la lezione online interessante.

Una semplicissima esercitazione che si può condurre a distanza è quella che consente di controllare l’esatta postura di una persona seduta alla scrivania, viene controllato se si inarca in avanti la schiena.

Per poter realizzare questo sistema si utilizza il sensore di luce del micro:bit, sensore realizzato con la matrice di LED disposti sulla scheda.

Ponendo il micro:bit sullo schienale della sedia, quando siamo seduti correttamente, copriremo con la schiena il micro:bit, non permettendo di rilevare fonti di luce, non appena ci si flette in avanti il sensore rileverà la luce e quindi verrà emesso un un segnale di allarme.

Questo stessa sperimentazione è stata realizzata anche con Arduino ed una fotoresistenza, in un prossimo post pubblicherà l’esercitazione.

Di seguito due esempi, il primo semplice, visualizza un messaggio che indica l’avvio del sistema, ed emette un segnale sonoro nel caso in cui si inarchi la schiena. Il secondo esempio aggiunge un pulsante di avvio sistema, l’impostazione della sensibilità del sistema (da realizzare manualmente) ed ed aggiunge l’utilizzo di funzioni esterne, motivo che mi aiuta a spiegare la chiamata di funzioni.

Ovviamente in questa situazione si utilizza il suono emesso dal computer, ma con alcune piccole modifiche è possibile aggiungere un buzzer esterno.

Versione 1 (link al codice sorgente)

Versione 2 (link al codice sorgente)

Buon Making a tutti 🙂

Pubblicato in i miei allievi, micro:bit | Contrassegnato , , , , | Lascia un commento

Node.js e Typescript: corso base online

Più volte vi ho segnalato le iniziative dell’amico Ludovico Russo, con lui ho condiviso avventure di making in ambiti diversi: robotica, informatica e molto altro. Ludovico è un esperto nello sviluppo di applicazioni cloud, si occupa sia dello sviluppo fullstack che della parte architetturale. Anche lui formatore nel settore informatico e recentemente, in collaborazione con lacerba.io, ha realizzato il corso: Node.js e Typescript: corso base online, in cui potrete apprendere le basi di Node.js e Typescript, sviluppando una semplice app lato Back End e Front End. Con questo corso potrete approcciarvi allo sviluppo di applicazioni web moderne.
Durante l’attività formativa vi verranno fornite competenze nella programmazione in Typescript, un linguaggio derivato da Javascript e sarete introdotti al concetto di programmazione Fullstack grazie a NodeJS.
Il corso richiede una buona conoscenza delle logiche fondamentali della programmazione, in particolare HTML, CSS e Javascript.

Per maggiori informazioni sulle modalità di iscrizione e sul programma del corso vi rimando alla pagina di riferimento dove potrete vedere il video di presentazione.

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

Amore a prima vista: Excalidraw

Insegnando e facendo video lezioni uso spesso lavagne online, tra le applicazioni che uso di più Janboard di Google, ma in questi giorni non posso fare a meno di utilizzare Excalidraw, che ho conosciuto guardando le lezioni settimanali di Ludovico e Jaga su Kubernetes e molto altro.

Da sempre utilizzo il mio blocco appunti cartaceo per disegnare cose che sto cercando di capire e che voglio spiegare, quindi agisco all’inizio di ogni mio progetto in modo analogico 🙂

Online trovate moltissime applicazioni che potete utilizzare per creare diagrammi a blocchi, diagrammi di flusso ecc… ma nulla è così efficace come disegnare su un foglio di carta.

Ritengo che nessuna applicazione web per disegnare diagrammi, in cui si utilizza mouse o tavoletta grafica, può sostituire la libertà del disegno a mano libera su carta, ma molto spesso ho l’esigenza di condividere velocemente durante una video lezione, testo semplice e forme da collegare con frecce e per questo motivo potrebbe essere interessante utilizzare Excalidraw.

Piccola analisi sui pregi e difetti dell’uso di carta e penna.

Perché carta e penna è così efficace?

  • Tolto il costo della carta, non ci sono costi aggiuntivi;
  • completa libertà in ciò che disegnate: disegni, testo, forme, frecce e pasticci vari che ci vengono in mente;
  • non dovete collegarvi su nessun sito, prendete il foglio di carta ed iniziate, quindi immediatezza;
  • potete aggiornare il disegno, potete aggiungere note ad ogni parte del disegno anche in momenti diversi;
  • non rischiate di cancellare la pagina, una volta che avete diegnato tutto rimane in modo permanente.

Ma un’applicazione aggiunge qualcosa di più:

  • collaborazione del disegno, infatti risulta difficile condividere un disegno mentre state facendo una video lezione;
  • la carta occupa la mia scrivania e molto spesso perdo i fogli tra pagine di libro o  nascoste sotto schede elettroniche;
  • sicurezza, non molto rilevante nel mio mestiere, ma alcune volte si realizzano disegni con appunti riservati e quindi siete obbligati a strappare periodicamente in mille pezzi il foglio di carta;
  • il nostro Pianeta. Usare la carte non è molto sostenibile.

Excalidraw funziona interamente online in modo crittografato ed completamente open-source, su GitHub l’app ha più di 10.000 like. Proverò ad usarlo la prossima settimana  quando farò lezione, soprattutto quando dovrò spiegare ai miei studenti come funzionano sketch Arduino e circuiti elettronici.

Tutte le forme sono rese semplici in modo che il tutto sia veloce, potete aggiungere il testo facendo un doppio click in qualsiasi zona del foglio da disegno. Il piano di lavoro ha una dimensione infinita, ogni elemento può essere organizzato a livelli e potete assegnare un grado di trasparenza. Tutti i colori degli oggetti e dello sfondo possono essere selezionati da una tavolozza o tramite i codici esadecimali HTML standard.

Una delle caratteristiche più belle è la sicurezza e la capacità di condivisione dei disegni stessi.

Excalidraw memorizza tutti i disegni sul server come BLOB,  crittografati, questo vuol dire che anche se i dati sono conservati in remoto, nessuno sul server può vedere il contenuto. I disegni persistono tra le visite e possono essere esportati in formto PNG, SVG oppure condivisi solo come collegamento che include il riferimento al BLOB e la chiave di decrittografia.

Dal momento in cui iniziate a costruire il diagramma potete velocemente generare un link di condivisione da consegnare ai vostri studenti in modo che possano vedere e modificare il disegno. Può quindi essere resa collaborativa la produzione di un disegno e vedere in tempo reale la modifica del vostro disegno fatta da un altro utente.

Quindi se dovessi spiegare come funziona questo codice:

if (inputPin < 500)
{
   doThingA;
}
else if (inputPin >= 1000)
{
   doThingB;
}
else
{
   doThingC;
}

Il diagramma di flusso con Excalidraw sarebbe:

Attenzione però che Excalidraw non sostituisce altre applicazioni come ad esempio: Disegni Google, Lucidchart o Draw.io, tutti questi sono strumenti ottimi per diagrammi complessi in cui è richiesto un grado di precisione più elevato.

Quindi, come già affermato all’inizio di questo post, non è la soluzione perfetta per disegnare grafici e disegni, ma sicuramente è un modo estremamente veloce e sicuro per condividere un disegno.

Lascio a voi scoprire tutte le funzionalità dell’applicazione.

Buon lavoro 🙂

Pubblicato in produttività | Contrassegnato , , , , , , | Lascia un commento

Progettare una nuova scuola – Corso gratuito on-line – Corso n. 3 – produrre e gestire contenuti online

Ho il piacere di informarvi che da qualche giorno è on line il mio terzo corso gratuito:

produrre e gestire contenuti online
per potenziare la didattica digitale a distanza e integrata

che fa parte dell’iniziativa realizzata da Tecnica della Scuola: Progettare una nuova scuola.
Il corso illustra come creare e condividere contenuti on line (documenti e presentazioni mediante le Google Apps) e come gestire attività di progetto tramite la creazione di siti e blog didattici, la cui realizzazione e gestione prevede l’uso esclusivo di un browser internet. Nello specifico verranno mostrate le modalità di creazione di siti e blog mediante applicativi visuali appositamente studiate per il docente.
Il blog o il sito possono diventare luoghi in cui il docente inserisce i contenuti da lui mediati da offrire ai propri allievi, un luogo che può essere arricchito con contenuti multimediali per rafforzare l’efficacia dell’apprendimento, ma in un sito è possibile inserire sistemi di e-learning che offrono allo studente strumenti per verificare in autonomia le competenza raggiunte e quindi autovalutazione durante il processo di apprendimento.

Per maggiori informazioni vi rimando alla pagina del sito di Tecnica della Scuola.

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

5 minuti da Maker: lista della spesa smart

Figlia: Papà visto che sei al supermercato puoi aggiungere alla lista della pesa:

  • gocciole,
  • cerotti,
  • matite

aspetta aspetta papà ti mando la foto della lista!

Io: Basta! Da oggi si cambia, vi avevo condiviso liste con Evernote, Google Keep, ma nulla! Mannaggia!
Proviamo con Google Documenti che sapete usarlo tutti in famiglia! Un tag nfc da pochi centesimi ed un foglio Google Documenti condiviso in famiglia.

Approfondimenti

Progetti realizzati/da realizzare:

  • tag NFC su strumento di laboratorio che rimanda alla manualistica e agli appunti del Prof.
  • tag NFC su armadio aula che rimanda all’inventario
  • tag NFC su porta aula di scuola che rimanda ad orario occupazione aula
  • tag NFC sportello segreteria che rimanda alla documentazione (moduli permessi, ferie, ecc…)
  • tag NFC per realizzare una caccia al tesoro didattico a scuola
  • tag NFC per individuare oggetti da parte di un robot
  • tag NFC per controllo freschezza alimenti

😉

Pubblicato in produttività | Contrassegnato , , | Lascia un commento

Progettare una nuova scuola – Corso gratuito on-line – Corso n. 2 – videolezione e ambienti di apprendimento

Come già segnalato in un precedente post, ho collaborato con Tecnica della Scuola al progetto: Progettare una nuova scuola, corsi di formazione a cui è possibile iscriversi gratuitamente. Il mio contributo copre aspetti di carattere tecnologico ed ho il piacere di informarvi che da qualche giorno potete iscrivervi al corso:

video lezione e ambienti di apprendimento

Il corso si propone di mostrare come configurare e gestire ambienti di apprendimento integrati on line per potenziare la didattica digitale a distanza e integrata. Ciò consente di realizzare dinamiche di lavoro collaborative, altamente inclusive permettendo il monitoraggio e la valutazione a distanza sulla classe o sul singolo allievo.
Il corso contiene anche situazioni didattiche reali gestite con le tecnologie esposte, mostrando tutto il processo di lavoro: dalla creazione della classe online alla realizzazione di videolezioni in modalità sincrona o asincrona, in particolare si forniscono le nozioni tecniche e le competenze per un’operatività avanzata nell’uso di software per la produzione di videolezioni, sistemi per il montaggio audio e video, scelte tecnologiche: microfoni, webcam, luci.

Per maggiori informazioni vi rimando alla pagina dedicata.

Ringrazio di cuore tutte le persone che stanno partecipando, sono tantissimi gli iscritti sia al primo che al secondo corso e preannuncio che sono in procinto di preparare nuovi corsi per i prossimi mesi, che rispondono a molte delle esigenze che negli scorsi mesi mi avete comunicato. L’ultimo corso: produrre e gestire contenuti online verrà pubblicato nel breve.

Grazie 🙂

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

Arduino: cicli infiniti ed uscita da un ciclo infinito

Per rispondere ad un quesito che mi è stato posto questa mattina a lezione da alcuni allievi condivido questo breve approfondimento sulla gestione dei cicli infiniti.

Parliamo di un ciclo infinito quando il controllo entra nel corpo del ciclo e non esce mai da esso, ciò accade quando la condizione di test del loop non è mai false.

Possiamo realizzare un ciclo infinito in C in diversi modi:

for (int i = 0; i >= 0; )
{
    // corpo del ciclo in cui la variabile i non viene mai modificata
}

Nell’esempio la variabile i viene inizializzata a 0 e la condizione di controllo i>=0 all’inizio è vera. La variabile i non viene modificato in nessun punto del codice inoltre l’espressione di aggiornamento della variabile non è presente, ciò implica che i avrà sempre come valore 0 e la condizione di controllo i>=0 non è mai falsa e quindi il corpo del for viene eseguito ad ogni ciclo.

Un modo più sintetico per realizzare un ciclo infinito è quello di utilizzare una condizione sempre vera utilizzando l’istruzione while:

while (true)
{
    // corpo del while
}

Questo comportamento può essere realizzato anche scrivendo 1 per indicare “condizione sempre vera”.

while (1)
{
    // corpo del while ripetuto per sempre
}

o ancora utilizzando un’uguaglianza sempre vera:

while (3==3)
{
    // corpo del while ripetuto per sempre
}

che nella programmazione con Arduino può essere ottenuto anche con:

while (HIGH)
{
    // corpo del while ripetuto per sempre
}

E’ possibile realizzare un ciclo infinito anche con l’istruzione for omettendo la condizione di ripetizione del ciclo, cioè che bisognerebbe inserire tra i due punti e virgola.

for (;;)
{
    // corpo del for ripetuto per sempre
}

Terminare un ciclo infinito

Negli esempi visti precedentemente la condizione sempre vera causava la ripetizione infinita del corpo dell’istruzione, però esiste il modo per terminare un ciclo infinito utilizzando l’istruzione break usata appunto per uscire da un ciclo: for, while oppure do..while, ma anche per uscire da una istruzione switch case.

Poiché nelle nostre sperimentazioni utilizziamo Arduino vediamo come realizzare l’uscita da un loop infinito.

Lo scopo è quello di far lampeggiare ripetutamente un LED e bloccare il lampeggio con la pressione di un pulsante.

Realizzimo il seguente circuito:

Utilizzando l’istruzione while.

Esempio 1

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Esempio1: Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  while (true) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Come si può notare viene utilizzata l’istruzione break per uscire dal ciclo. Fino a quando il pulsante non sarà premuto la condizione: digitalRead(pinPulsante) == HIGH sarà falsa, pertanto non verrà eseguito il corpo dell’if e quindi non potrà essere eseguito il break, in questa condizione ciò che segue l’if è la chiamata della funzione lampeggia().

Nel caso in cui il pulsante viene premuto, la condizione digitalRead(pinPulsante) == HIGH risulta vera, pertanto viene eseguito il corpo dell’if che contiene l’istruzione break che causerà l’uscita dal ciclo while.

Il codice sopra indicato funziona anche se nel while viene sostituito true con HIGH:

...
while (true) // ciclo infinito
  {
       // corpo del while
  }
...

con

...
while (HIGH) // ciclo infinito
  {
       // corpo del while
  }
...

Come spiegato ad inizio lezione, un ciclo infinito può essere ottenuto anche con un’istruzione for quindi si ottiene il medesimo risultato se si utilizza il codice che segue.

Esempio 2

/*
  Prof. Michele Maffucci
  Data: 16.11.2020
  Funzionamento dell'istruzione break
*/
const int pinPulsante = 8; // pin digitale 8

void setup()
{
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT); // abilita il pin a cui è connesso il LED come output
  pinMode(pinPulsante, INPUT);  // abilita il pin a cui è connesso il pulsante come input
}
void loop()
{
  for (;;) // ciclo infinito
  {
    if (digitalRead(pinPulsante) == HIGH)
    {
      break; // esce dal ciclo se si preme il pulsante
    }
    lampeggio(); // chiama la funzione che accende e spegne il LED
  }
}
void lampeggio()
{
  digitalWrite(LED_BUILTIN, HIGH);
  delay(100);
  digitalWrite(LED_BUILTIN, LOW);
  delay(100);
}

Differenze tra ciclo for e ciclo while

  • Il ciclo for ha necessità di una variabile al suo interno, mente il ciclo while può utilizzare qualsiasi variabile definita prima dell’istruzione while.
  • L’uso del ciclo do-while permette di realizzare sempre una volta il corpo delle istruzioni in esso contenuto (indipendentemente dall’espressione condizionale) e ciò non può essere fatto con un  ciclo for.

Esercizio per i miei studenti

Esercizio 1

Realizzare le stesse funzionalità dell’esempio precedente (usando un ciclo infinito nel loop()) aggiungendo la stampa sequenziale crescente di un numero n = n + 1 sulla Serial Monitor. Alla pressione del pulsante si interrompe il lampeggio del LED e si azzera il contatore.

Buon Coding a tutti 🙂

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

5 minuti da Maker: porta rasoio

Sulla mia pagina Facebook pubblico spesso alcuni brevi post che ho intitolato: 5 minuti da Maker, attività di Making familiare che risolvono qualche piccola necessità, che rispondono a piccole problemi del vivere quotidiano. E’ un esercizio che mi piace svolgere quando ho il bisogno di distrarmi un momento da un lavoro che mi stanca parecchio. L’idea nasce da una sperimentazione di qualche tempo fa che feci con alcuni allievi: una challenge di breve durata, non più di 30 minuti, in cui bisogna risolvere un problema pratico. Tipicamente si tratta di riparare o inventare un oggetto da stampare in 3D oppure riadattare oggetti per usi diversi o ancora migliorare le caratteristiche di un oggetto secondo le necessità specifiche dell’utente sia dal punto di vista meccanico che elettronico.

L’ultima challenge svolta su me stesso nasce dal seguente fatto:

Figlio: papà perché mi rubi le lamette da barba!
Io: No giovane figlio! Sei tu che rubi le MIE lamette!
Figlio: No no diversamente giovane! Sei tu tu tu tu tuuuuu!!!!
Moglie: forse essere più ordinati aiuterebbe? Visto che siete in bagno a chi tocca pulirlo oggi?
Io: Shhh Matty… pace pace pace …. ci penso io faccio due supporti per rasoio

🙂

Per prelevare i file per la stampa 3D seguire il link sulla mia pagina su Thingiverse.

Buon Making a tutti 🙂

Pubblicato in Stampa 3D | Contrassegnato , , | Lascia un commento

Arduino: strutturare il codice in blocchi funzionali

Molto spesso durante le prime fasi di realizzazione di uno sketch Arduino si tende a non strutturare il proprio programma in blocchi funzionali separati, tutto il codice viene inserito all’interno del loop(). Questo tipo di approccio, soprattutto se siamo in presenza di un codice molto lungo, rende difficoltosa la lettura del programma da parte di altre persone e non permette una facile comprensione del funzionamento o l’identificazione di possibili errori.

Ho parlato in passato come strutturare il codice in blocchi funzionali nel post:
Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne, ma in quella lezione utilizzavo istruzioni che in questa fase dell’anno scolastico non sono ancora conosciute da alcuni allievi soprattutto del 3′ anno, che iniziano ad utilizzare Arduino, pertanto la presente lezione dovrebbe chiarire in modo più semplice l’argomento.

Le funzioni vengono utilizzate per organizzare le azioni eseguite dal vostro programma. Ogni funzione può essere identificata da un’azione specifica richiamata dal programma principale loop(), oppure richiamate da altre funzioni sempre all’interno del nostro sketch.

Senza saperlo quando avete iniziato a programmare con Arduino avete utilizzato delle funzioni: loop() e setup() le due funzioni sempre presenti in ogni sketch.

Per creare una funzione bisogna:

  • definire il tipo di valore restituito dalla funzione;
  • assegnare un nome alla funzione;
  • e opzionalmente impostare una serie di parametri che la funzione riceverà quando viene chiamata (si dice anche invocata).

Creiamo una semplice funzione che permette di fare lampeggiare un LED, non possiede parametri e non restituisce nessun valore.
Assegnare alla funzione il tipo void vuol dire che non restituisce nulla e non inserire nulla tra le parentesi tonde indica che la funzione non accetta nessun parametro.

Esempio 1

// Prof. Michele Maffucci
// Es.01 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  lampeggia();
}

// blink LED una volta
void lampeggia()
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(1000); // pausa di 1 secondo
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(1000); // pausa di 1 secondo
}

Ogni volta che il loop() chiama (invoca) la funzione esterna lampeggia() viene effettuato il blink del LED sulla scheda.

Esempio 2

Realizziamo ora un secondo esempio in cui la funzione “lampeggia” accetta come parametro un valore intero che definisce il delay da impostare all’interno del funzione.

// Prof. Michele Maffucci
// Es.02 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250);
}

// blink LED una volta
// per far si che la funzione accetti un parametro in input
// bisogna dichiarare il tipo del parametro in ingresso
// nella funzione lampeggia: int pausa

void lampeggia(int pausa)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausa); // pausa: valore inserito nella variabile "pausa"
}

Esempio 3

Realizziamo ora un terzo sketch in cui i parametri di ingresso per la funzione lampeggia() sono due, uno che definisce il tempo di accensione del LED ed uno che definisce il tempo di spegnimento del LED:

// Prof. Michele Maffucci
// Es.03 - Usare le funzioni
// Data: 15.11.2020

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  lampeggia(250, 1000);
}

// blink LED una volta
// per far si che la funzione accetti duen parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn e int pausaOff

void lampeggia(int pausaOn, int pausaOff)
{
  digitalWrite(LED_BUILTIN, HIGH); // accende il LED
  delay(pausaOn); // delay LED ON
  digitalWrite(LED_BUILTIN, LOW); // spegne il LED
  delay(pausaOff); // delay LED OFF
}

Esempio 4

Definiamo ora una funzione che ha 3 parametri di ingresso: il tempo in cui il LED rimane acceso, il tempo in cui il LED rimane spento e il numero di volte (cicli) che deve ripetersi il lampeggio, al termine del numero di cicli il LED non lampeggerà più. Come specificato nei commenti la variabile chiave verrà utilizzata per eseguire una volta sola la chiamata della funzione lampeggio:

// Prof. Michele Maffucci
// Es.04 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  for (int i = 0; i < contatore; i++) {
    digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
  }
}

All’interno dello sketch precedente la funzione lampeggio utilizza un ciclo for per ripetere, per il numero di volte specificato dalla variabile contatore, il codice di accensione e spegnimento (corpo del for).

Esempio 5

Per completezza e per richiamare il modo con cui utilizzare l’istruzione while, di seguito trovate lo sketch che realizza la medesima funzionalità dello sketch precedente in cui il ciclo for viene sostituito da un while:

// Prof. Michele Maffucci
// Es.05 - Usare le funzioni
// Data: 15.11.2020

// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  // chiamiamo la funzione lampeggia passando il valore
  // specificato all'interno delle parentesi tonde
  if (chiave == 0) {
    chiave = 1;
    lampeggia(250, 1000, 5);
  }
}

// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio

void lampeggia(int pausaOn, int pausaOff, int contatore)
{
  while (contatore > 0) {
     digitalWrite(LED_BUILTIN, HIGH); // accende il LED
    delay(pausaOn); // delay LED ON
    digitalWrite(LED_BUILTIN, LOW); // spegne il LED
    delay(pausaOff); // delay LED OFF
    contatore = contatore - 1; // decremento del contatore
  }
}

Esempio 6

Nello sketch che segue realizziamo una funzione che accetta un parametro e restituisce un valore. Il parametro che viene passato alla funzione definisce la durata dei tempi di accensione e spegnimento del LED (in millisecondi). La funzione continua a far lampeggiare un LED fino a quando non viene premuto un pulsante. Il valore restituito dalla funzione è il numero di lampeggi effettuati, questo valore verrà stampato sulla Serial Monitor:

// Prof. Michele Maffucci
// Es.06 - Usare le funzioni
// Data: 15.11.2020

const int pinPulsante = 8; // pin a cui colleghiamo il pulsante

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
  pinMode(pinPulsante, INPUT);
  Serial.begin(9600);
}

void loop() {
  Serial.println("Premere il pulsante per interrompere il lampeggio");
  int contatore = lampeggia(500); // lampeggio del LED: 500 ms ON e 500 ms OFF
  Serial.print("Il numero di volte in cui il LED ha lampeggiato è stato di: ");
  Serial.println(contatore);
  while (digitalRead(pinPulsante) == HIGH)
  {
    // non viene fatto nulla fino a quando non rilascio il pulsante
  }
}

// la funzione fa lampeggiare il LED per un periodo specificato (int periodo)
// e restituisce il numero di volte in cui il LED ha lampeggiato

int lampeggia(int periodo)
{
  int contatoreLampeggio = 0;

  while (digitalRead(pinPulsante) == LOW)
    // ripetere finché non viene premuto il pulsante
    // cicla fino a quando il pulsante non viene premuto
  {
    digitalWrite(LED_BUILTIN, HIGH);
    delay(periodo);
    digitalWrite(LED_BUILTIN, LOW);
    delay(periodo);
    contatoreLampeggio = contatoreLampeggio + 1; // incrementa il contatore
  }
  // in questo punto vuol dire che pinPulsante è HIGH
  // ciò vuol dire che il pulsante è premuto

  // contatoreLampeggio è il valore che viene restituito alla funzione chiamante
  return contatoreLampeggio;
}

Il tipo di dato che precede in nome della funzione:

int lampeggia()

indica il tipo di dato restituito dalla funzione. Ricordarsi che nella funzione chiamante, nel nostro caso il loop(), quando chiamiamo la funzione questa deve terminare con un punto e virgola:

int contatore = lampeggia(500);

Errori comuni che vengono commessi nella chiamata di funzioni

Rimando a queste due brevi note che mostrano alcuni errori tipici:

Buon Making a tutti 🙂

Esercizi per i miei studenti

Esercizio 1

Realizzare un circuito costituito da 4 pulsanti e 4 led, connessi ad Arduino.

  • Alla pressione del pulsante P1 il LED1 effettua il blink con un tempo di 200 ms
  • Alla pressione del pulsante P2 il LED2 effettua il blink con un tempo di 400 ms
  • Alla pressione del pulsante P3 il LED3 effettua il blink con un tempo di 600 ms
  • Alla pressione del pulsante P4 il LED4 effettua il blink con un tempo di 800 ms

Fare in modo tale che ci sia una funzione esterna, chiamata dal loop(), che effettui il blink dei led.

Esercizio 2

Aggiungere all’esercizio 1 un pulsante che se premuto accende in sequenza ripetuta i 4 led. L’accensione in sequenza deve avvenire chiamando una funzione esterna al loop().

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