Corso UTS-NES: Didattica a distanza con le Google Apps

Rete per l’inclusione della città di Torino – CTS: Formazione A Distanza
Come referente del CTS di Torino, nell’ambito delle attività di formazione gratuite organizzate dal centro, sarò relatore per il corso: Didattica a distanza con le Google Apps.

Il corso in FAD (formazione a distanza) si propone l’obiettivo di mostrare l’utilizzo di applicativi per la creazione di contenuti didattici e per la gestione di ambienti di apprendimento integrati on line che consentono di realizzare dinamiche di lavoro collaborative, altamente inclusive permettendo il monitoraggio e la valutazione a distanza sulla classe o sul singolo allievo.
Tra questi verrà dettagliato l’uso delle Google Apps in ambito didattico.
Il corso fornirà le nozioni tecniche e le competenze per un’operatività avanzata nell’uso delle Google Apps e di software per la creazione di risorse: audio, video, pubblicazione su web, per la ricerca delle fonti online, per la gestione della classe e la realizzazione di videolezioni.
Verranno simulate situazioni didattiche reali, mostrando il processo di lavoro: ricerca e collezione delle fonti, produzione del contenuto didattico, realizzazione della lezione in modalità sincrona o asincrona.
Per quanto riguarda le Google Apps se ne mostrerà l’utilizzo in ambito scolastico, si procederà alla scoperta di tutte le caratteristiche rivolte alla comunicazione, alla conservazione, alla produzione, alla collaborazione e alla condivisione.
Il corso avrà una declinazione prettamente pratica; per la partecipazione non sono richieste competenze informatiche particolari.

Le priorità sviluppate in questo corso saranno:

  • didattica per competenze e innovazione didattica
  • competenze digitali e nuovi ambienti di apprendimento
  • inclusione e disabilità.

Punti tematici

  • Gestire videolezioni sincrone e asincrone.
  • Realizzazione di videolezioni – produrre e modificare l’audio e il video.
  • Usare al meglio il motore di ricerca di Google.
  • Introduzione alle App e al cloud di Google; creare un account.
  • Accedere a Gmail, organizzazione dei messaggi; utilizzare i task e gestire le attività.
  • Google Meet per comunicare, per chattare, per chiamare e fare videochiamate; condividere lo schermo, condividere link e file.
  • Calendar per pianificare eventi; aggiungere inviti e notifiche; creare e condividere calendari.
  • Drive per caricare e archiviare file; aprire, modificare, eliminare file; condividere.
  • Google Classroom per gestire on-line la classe.
  • Keep per creare note ed elenchi; condividere e collaborare.
  • Documenti: creare un documento, modificare e formattare, condividere e collaborare; gestire il file, modificare il documento e cambiarne visualizzazione, inserire elementi e modificare il formato del testo; utilizzare le tabelle e gli strumenti aggiuntivi
  • Presentazioni: creare/modificare una presentazione, formattare gli elementi come testi e oggetti, condividere e collaborare; inserire elementi grafici, lavorare sulle transazioni, sugli schemi, sui temi
  • Disegni: impostare e formattare un disegno; aggiungere elementi, modificare le forme; lavorare sulle immagini; disporre gli elementi.
  • La lavagna virtuale di Google: Google Jamboard.
  • Fogli: introduzione ai fogli di calcolo, capire l’interfaccia e operazioni di base; formule e funzioni; matrici; creare e lavorare sui grafici; formattazione condizionale; tabelle pivot.
  • Moduli: creare e gestire un modulo; visualizzare e analizzare le risposte.
  • Usare le Mappe, aggiungere luoghi, linee e forme; indicazioni stradali, misurare distanze.
  • Sites: realizzare un sito; creare pagine, modificare il layout, organizzare la navigazione del sito.

DURATA DEL PERCORSO – PROGRAMMA: durata totale di 25 ore, di cui 15 ore di formazione individuale e 10 ore sincrone nelle seguenti date:

  • sabato 30.05 dalle 14,30 alle 16,30
  • mercoledì 03.06 dalle 14,30 alle 16,30
  • giovedì 04.06 dalle 16,30 alle 18,30
  • venerdì 05.06 dalle 14,30 alle 16,30
  • lunedì 08.06 dalle 14,30 alle 16,30

DESTINATARI: 50 docenti curriculari e di sostegno delle scuole di ogni ordine e grado 

ISCRIZIONI: entro il giorno 28 maggio p.v. tramite il seguente FORM

Per maggiori informazioni

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

Utilizzare il sensore di distanza VL530X con Arduino

Ho parlato di questo sensore di distanza quando qualche settimana fa mostrai come utilizzarlo con M5Stack mini: 5 min al giorno di sperimentazione con M5Stack mini – Sensore TOF seguendo il link trovate tutte le indicazioni sul principio di funzionamento ed una serie di dati tecnici che potrebbero essere utili per il vostro studio. Riprendo alcune parti del mio post in modo che le vostre sperimentazioni possano essere più agevoli:

…un sensore ToF (Time of Flight: tempo di volo) VL53L0X effettua un conteggio del tempo totale di volo dei fotoni dal momento in cui vengono emessi da un piccolissimo raggio laser al momento in cui viene rilevata la riflessione su un fotodiodo collocato sul sensore.
In generale il tempo di volo (spesso indicato con TOF, dall’inglese Time Of Flight) indica la misura del tempo impiegato da un oggetto, una particella o un’onda (elettromagnetica, acustica, elettromagnetica o di altro tipo) per percorrere una certa distanza in un mezzo determinato….
Il sensore ToF di cui dispongo è un VL53L0X che incorporato un emettitore Laser VCSEL ed un fotodiodiodo ricevitore SPAD. Il laser è in grado di emettere impulsi a 940 nm (prossimi al campo infrarosso). Il fotodiodiodo SPAD è estremamente sensibile al singolo fotone e grazie alla schermatura di cui è costituito riceve soltanto la lunghezza d’onda di 940 nm del laser.

Seguendo il link potete prelevare il datasheet del VL530X prodotto da ST.

Il sensore utilizzato con M5Stack mini è dotato di connettore GROVE, mentre la versione utilizzata per questo tutorial è una scheda breakout che potrete facilmente collegare ad Arduino.

Acquistai una serie di questi sensori per realizzare un sistema di rilevazione ostacoli di tipo laser per i kit robotici che faccio realizzare ai miei studenti, EduRobot e DotBot, ma poiché la situazione didattica di questi mesi è mutata drasticamente a causa dell’emergenza sanitaria, ho deciso di riutilizzare i sensori per un progetto semplice che iniziai qualche settimana fa: un bracciale per valutare la distanza tra le persone, sistema che per altro in diversi ambiti mi è stato chiesto di sviluppare.

  • Vin alimentazione del sensore, 3-5V. Collegate +5V di Arduino.
  • GND da connettere al GND di Arduino
  • SCL ed SDA dovranno essere connessi ai corrispondenti pin della scheda Arduino utilizzata, nel caso di un Arduino UNO R3 A5: SCL e A4: SDA

Installare la libreria Adafruit_VL53L0X Library Sketch > Include Library > Manage Libraries…:

Cercare la libreria Adafruit VL53L0X  all’interno del motore di ricerca e procedere con l’installazione:

Aprire da File->Examples->Adafruit_VL53L0X->vl53l0x ed effettuare l’upload sulla scheda Arduino

Di seguito trovate gli sketch di esempio in cui ho effettuato alcune traduzioni:

#include "Adafruit_VL53L0X.h"

Adafruit_VL53L0X lox = Adafruit_VL53L0X();

void setup() {
  Serial.begin(115200);

  // per i dispositivi USB nativi, attende fino a quando la serial port non risulta disponibile
  while (! Serial) {
    delay(1);
  }
  
  Serial.println("Test Adafruit VL53L0X");
  if (!lox.begin()) {
    Serial.println(F("Impossibile avviare VL53L0X"));
    while(1);
  }
  // power 
  Serial.println(F("VL53L0X API Esempio: misura distanza\n\n")); 
}


void loop() {
  VL53L0X_RangingMeasurementData_t measure;
    
  Serial.print("Lettura misura... ");
  lox.rangingTest(&measure, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!

  if (measure.RangeStatus != 4) {  // dati errati
    Serial.print("Distanza (mm): "); Serial.println(measure.RangeMilliMeter);
  } else {
    Serial.println(" fuori portata ");
  }
    
  delay(100);
}

Aprite serial monitor ed impostate la velocità a 115200 baud

Muovete la vostra mano sul sensore per leggere la misura della distanza tra mano e sensore, noterete che quando non viene rilevato nulla sulla serial monitor verrà visualizzato il messaggio: out of range (fuori portata).

Modificare l’indirizzo assegnato al sensore

Durante l’inizializzazione, invece di usare la funzione lox.begin(), usare lox.begin(0x30) per impostare l’indirizzo su 0x30 sul nuovo sensore aggiunto, oppure in qualsiasi parte dello sketch, quando deve essere usato il sensore usare la funzione lox.setAddress(0x30).

Connessione di più sensori

Nel caso abbiate la necessità di connettere più sensori bisognerà che ognuno di essi abbia un indirizzo I2C diverso. L’indirizzo predefinito per VL53L0X è 0x29 ma è possibile modificarlo via software. Gli indirizzi che possono essere utilizzati vanno da 0x30 a 0x3F.

  1. Reset di tutti i sensori impostando i pin XSHUT a LOW per un tempo di 10 millisecondi.
  2. Mantenere il sensore 1 attivo mantenendo a HIGH il pin XSHUT a HIGH.
  3. Disattivare tutti gli altri sensori impostando i loro pin XSHUT a LOW
  4. Inizializzare il sensore 1 con lox.begin(nuovo_i2c_address). Scegliere qualsiasi indirizzo tranne 0x29, dovete scegliere un indirizzo inferiore a 0x7F, scegliere un indirizzo nell’intervallo 0x30 a 0x3F.
  5. Mantenere attivo il sensore n. 1 e disattivate il sensore n. 2 impostando il pin XSHUT ad HIGH.
  6. Inizializzare il sensore n. 2 usando la funzione lox.begin (nuovo_i2c_address). Scegliere qualsiasi indirizzo tranne 0x29, l’indirizzo da scegliere dovrà rientrare nel range ammesso (0x30 a 0x3F).
  7. Ripetere l’operazione per ciascun sensore, attivarli e assegnare ad ognuno un indirizzo diverso.

Attenzione che l’assegnazione dell’indirizzo non è permanente, in mancanza di alimentazione viene persa memoria dell’indirizzo assegnato a tutti i sensori, quindi la procedura deve essere ripetuta ogni volta che viene alimentato il circuito.

Nel caso abbiate un solo sensore l’indirizzo assegnato in automatico di default nel momento che date alimentazione è sempre 0x29.

Se operate con due sensori, per assegnare automaticamente gli indirizzi utilizzare lo sketch presente negli esempi che troverete all’interno della cartella della libreria Adafruit_VL53L0X: vl53l0X_dual

#include "Adafruit_VL53L0X.h"

// indirizzi assegnati se sono presenti due sensori
#define LOX1_ADDRESS 0x30
#define LOX2_ADDRESS 0x31

// impostazione dei pin per lo spegnimento dei sensori
#define SHT_LOX1 7
#define SHT_LOX2 6

// creazioni degli oggetti vl53l0x
Adafruit_VL53L0X lox1 = Adafruit_VL53L0X();
Adafruit_VL53L0X lox2 = Adafruit_VL53L0X();

// per memorizzare le misure
VL53L0X_RangingMeasurementData_t measure1;
VL53L0X_RangingMeasurementData_t measure2;

/*
  - Il reset dei sensori viene fatto impostando tutti i pin XSHUT a LOW per 10 millisecondi 'delay(10)',
    successivamente, per uscire dal reset tutti gli XSHUT vemgono posti ad HIGH.
  - Mantiene il sensore 1 attivo mantenedo il pin XSHUT HIGH
  - Tutti gli altri sensori vengono disattivati ponendo a LOW i pin XSHUT
  - L'inizializzazione del sensore n.1 avviene con lox.begin(new_i2c_address). Scegliere qualsiasi diverso da 0x29 ed inferiore a 0x7F.
    Scegliere un valore compreso tra 0x30 a 0x3F.
  - Mantiene il sensore n.1 attivo e disattiva il sensore n.2 impostando il pin XSHUT ad HIGH.
  - L'inizializzazione del sensore n.2 avviene con lox.begin (new_i2c_address). Scegliere qualsiasi diverso da 0x29 o da qualsiasi indirizzo impostato per l'altro ensore.
 */
void setID() {
  // reset di tutti i sensori
  digitalWrite(SHT_LOX1, LOW);    
  digitalWrite(SHT_LOX2, LOW);
  delay(10);
  // attivazione dei sensori
  digitalWrite(SHT_LOX1, HIGH);
  digitalWrite(SHT_LOX2, HIGH);
  delay(10);

  // attivazione di LOX1 e reset di LOX2
  digitalWrite(SHT_LOX1, HIGH);
  digitalWrite(SHT_LOX2, LOW);

  // inizializzazione di LOX1
  if(!lox1.begin(LOX1_ADDRESS)) {
    Serial.println(F("Errore nell'avvio del primo VL53L0X"));
    while(1);
  }
  delay(10);

  // attivazione di LOX2
  digitalWrite(SHT_LOX2, HIGH);
  delay(10);

  //inizializzazione di LOX2
  if(!lox2.begin(LOX2_ADDRESS)) {
    Serial.println(F("Errore nell'avvio del secondo VL53L0X"));
    while(1);
  }
}

void read_dual_sensors() {
  
  lox1.rangingTest(&measure1, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!
  lox2.rangingTest(&measure2, false); // se si inserisce 'true' si avvia la stampa dei dati di debug!

  // stampa la lettura dei dati del primo sensore
  Serial.print("1: ");
  if(measure1.RangeStatus != 4) {     // se non si è fuori portata
    Serial.print(measure1.RangeMilliMeter);
  } else {
    Serial.print("Fuori portata");
  }
  
  Serial.print(" ");

  // stampa la lettura dei dati del secondo sensore
  Serial.print("2: ");
  if(measure2.RangeStatus != 4) {
    Serial.print(measure2.RangeMilliMeter);
  } else {
    Serial.print("Fuori portata");
  }
  
  Serial.println();
}

void setup() {
  Serial.begin(115200);

  // per i dispositivi USB nativi, attende fino a quando la serial port non risulta disponibile
  while (! Serial) { delay(1); }

  pinMode(SHT_LOX1, OUTPUT);
  pinMode(SHT_LOX2, OUTPUT);

  Serial.println("Inizio spegnimento...");

  digitalWrite(SHT_LOX1, LOW);
  digitalWrite(SHT_LOX2, LOW);

  Serial.println("Entrambi in modalità ripristino...(i pin sono a LOW)");
  
  
  Serial.println("Avvio...");
  setID();
 
}

void loop() {
   
  read_dual_sensors();
  delay(100);
}

Buon Making a tutti 🙂

 

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

I miei corsi per Tecnica della Scuola: Google per la didattica – 9′ edizione


Nuova edizione del sempre richiesto e seguitissimo corso sulle Google Apps. In questa ultima edizione oltre che fornire una formazione di base su tutte le applicazioni, parlerò delle ultimissime funzionalità aggiunte alle varie app negli ultimi due mesi, utili soprattutto per la DaD. Nuove proposte di attività didattiche ed organizzazione del lavoro on-line ed integrazione con altri applicativi on-line.

Saranno svolti 5 incontri di 2 ore ciascuno per un totale di 10 ore di formazione

  • Martedì 19 maggio 2020 – dalle ore 16.00 alle 18.00
  • Venerdì 22 maggio 2020 – dalle ore 17.00 alle 19.00
  • Lunedì 25 maggio 2020 – dalle ore 17.00 alle 19.00
  • Giovedì 28 maggio 2020 – dalle ore 18.30 alle 20.30
  • Venerdì 29 maggio 2020 – dalle ore 17.00 alle 19.00

Per maggiori informazioni sul programma e le modalità di iscrizione vi rimando al link sul sito di Tecnica della Scuola.

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

Gestire le stringhe con Arduino – approfondimenti


In passato ho già affrontato questo argomento e con questo post aggiungo alcuni approfondimento utili per i miei studenti.

Le stringhe sono una struttura di dati che viene utilizzata per memorizzare e gestire il testo. Le stringhe possono essere utilizzate per visualizzare del testo su un qualsiasi display connesso ad Arduino oppure più semplicemente sul monitor seriale di Arduino. Le stringhe possono essere utilizzate anche per memorizzare ad esempio i caratteri inseriti da tastiera connessa ad Arduino.

Possiamo distinguere due tipi di stringhe

  1. Array di caratteri, che sono le stesse delle stringhe utilizzate nella programmazione C.
  2. Il tipo di dato Sring di Arduino che permette di utilizzare un oggetto String in uno sketch.

Array di caratteri

Il primo tipo di stringa che impareremo ad utilizzare è la stringa costituita da una serie di caratteri memorizzati in un Array, cioè un vettore di caratteri il cui ultimo elemento è un carattere terminatore (o di fine stringa), codificato con il numero 0 e rappresentato in C dal carattere ‘\0’.

Nel programma che segue viene composta la stringa, un array di caratteri, il cui ultimo carattere è costituito dal terminatore 0, la stringa composta verrà poi stampata sulla Serial Monitor.

void setup() {
   char mia_stringa[8];    // un array di dimensione 8 costituito da 7 caratteri
   Serial.begin(9600);     // inizializzazione della Serial Monitor
   mia_stringa[0] = 'A';   // la stringa è formata da 5 caratteri più il terminatore
   mia_stringa[1] = 'r';
   mia_stringa[2] = 'd';
   mia_stringa[3] = 'u';
   mia_stringa[4] = 'i';
   mia_stringa[5] = 'n';
   mia_stringa[6] = 'o';
   mia_stringa[7] = 0;          // l'ottavo elemento dell’array è costituito dal terminatore
   Serial.println(mia_stringa); // stampa della stringa sulla Serial Monitor
}

void loop() { 
    // per ora nulla
}

Nell’esempio che segue utilizziamo un modo più comodo per creare le stringhe.
In questo caso il compilatore calcola la dimensione dell’array di caratteri ed inserisce automaticamente il terminatore di stringa costituito dal carattere 0. Un array composto da 8 elementi, 7 caratteri seguiti dal carattere 0.
Il risultato sarà il medesimo dello sketch precedente:

void setup() {
   char mio_sito[] = "Arduino";
   Serial.begin(9600);
   Serial.println(mio_sito);
}

void loop() {
    // per ora nulla
}

Manipolazione di Array di stringhe

La manipolazione di un’array di stringhe può essere effettuata nel seguente modo:

void setup() {
   char mia_stringa[] = "Salve mondo"; // creazione della stringa
   Serial.begin(9600);
   // stampa della stringa sulla Serial Monitor
   Serial.println(mia_stringa);
   // cancellazione di una parte della stringa
   mia_stringa[5] = 0;
   Serial.println(mia_stringa);
   // (3) sostituzione dei caratteri
   mia_stringa[5] = ' ';  // sostituzione con il carattere spazio
   mia_stringa[6] = 'M';  // inserimento della nuova parola
   mia_stringa[7] = 'i';
   mia_stringa[8] = 'k';
   mia_stringa[9] = 'y';
   mia_stringa[10] = '!';
   mia_stringa[11] = 0; // terminatore di stringa
   Serial.println(mia_stringa);
}

void loop() {
    // per ora nulla
}

Risultato:

Salve mondo
Salve
Salve Miky!

La stringa viene abbreviata sostituendo il 5′ carattere con il terminatore 0.
Quando la stringa viene stampata sulla Serial Monitor, tutti i caratteri dell’array vengono stampati fino al nuovo terminatore 0, quello che possiede l’indice 5 nell’array. I restanti caratteri non vengono cancellati sono ancora presenti in memoria, compreso il secondo terminatore 0 e l’array possiede ancora la stessa dimensione, però in questo caso se utilizziamo una funzione che legge l’array questa vedrà tutti i caratteri fino al nuovo terminatore (indice 5).

Successivamente viene sostituita la parola ” mondo” con la parola “Miky!” e questa operazione viene effettuato sostituendo il terminatore in posizione 5 con uno spazio in modo che la stringa venga ripristinata nel formato di origine.
L’inserimento della nuova parola viene eseguito inserendo in ogni posizione la lettera corrispondente alla nuova parola.

Funzioni per manipolare le stringhe

Lo sketch precedente permette di manipolare la stringa manualmente accedendo ai singoli caratteri memorizzati nell’array.
Per manipolare le stringhe possiamo scrivere noi delle nostre funzioni, oppure più semplicemente utilizzare le funzioni String presenti nella libreria del C.

Esempio

void setup() {
   char mia_stringa[] = "Nel mezzo del cammin di nostra vita"; // creazione della stringa
   char mia_stringa_output[80]; // l’output verrà inserito in questa stringa
   int dimensione;
   Serial.begin(9600);

   // A. stampa la stringa 
   Serial.println(mia_stringa);

   // B. lettura della lunghezza della stringa.
   // Nel conteggio viene escluso il carattere
   // terminatore
   dimensione = strlen(mia_stringa);
   Serial.print("La lunghezza della stringa è: ");
   Serial.println(dimensione);

   // C. prende la lunghezza dell’array incluso il carattere terminatore
   dimensione = sizeof(mia_stringa); // sizeof() non è una funzione specifica per gestire le stringhe
   Serial.print("Dimensione dell'array: ");
   Serial.println(dimensione);

   // D. copiare una stringa
   strcpy(mia_stringa_output, mia_stringa);
   Serial.println(mia_stringa_output);

   // E. aggiungere una stringa alla fine di un’altra (append)
   strcat(mia_stringa_output, " mi ritrovai per una selva oscura");
   Serial.println(mia_stringa_output);
   dimensione = strlen(mia_stringa_output);
   Serial.print("La lunghezza della stringa è: ");
   Serial.println(dimensione);
   dimensione = sizeof(mia_stringa_output);
   Serial.print("Dimensione dell'array mia_stringa_output[ ] è: ");
   Serial.println(dimensione);
}

void loop() {
    // per ora nulla
}

Risultato:

Nel mezzo del cammin di nostra vita
La lunghezza della stringa è: 35
Dimensione dell'array: 36
Nel mezzo del cammin di nostra vita
Nel mezzo del cammin di nostra vita mi ritrovai per una selva oscura
La lunghezza della stringa è: 68
Dimensione dell'array mia_stringa_output[ ] è: 80

Come avete avuto modo già di imparare, per stampare una stringa sarà sufficiente richiamarla come argomento all’interno della funzione println. La funzione strlen(), che restituisce la lunghezza di una stringa, prende in considerazione solamente i caratteri che possono essere stampati (visualizzati) ad esclusione del terminatore 0.

L’operatore sizeof() prende come argomento un array e di questo ne restituisce la sua lunghezza, in questo caso però la lunghezza include anche il terminatore di stringa, pertanto il sizeof() restituirà un valore più grande di una unità rispetto alla funzione strlen().

sizeof() può essere confusa con una funzione, ma tecnicamente è un operatore. Non fa parte della libreria String del C, ma è stata utilizzata in questi esempio per mostrare la differenza tra la dimensione dell’array e la dimensione della stringa.

La funzione strcpy() viene usata, nello sketch sopra indicato, per copiare mia_stringa in mia_stringa_output quindi la funzione copia la seconda stringa nella prima attenzione che in questo caso la seconda stringa viene copiata in una stringa che ha dimensione più grande, 80, mentre mia_stringa ha una dimensione di 35, questo vuol dire che ci saranno 20 caratteri liberi in memoria che potranno essere utilizzati.

Domanda

Dopo la copia di mia_stringa in mia_stringa_output sei in grado di dimostrare con uno sketch cosa è presente in memoria dal 36’ al 80’ posizione di mia_stringa_output?

La concatenazione di stringhe viene eseguita con la funzione strcat() che permette di inserire la seconda stringa indicata nella funzione strcat() alla fine delle prima stringa indicata nella strcat(). Dopo la concatenazione viene mostrata la lunghezza della nuova stringa risultante costituita da 68 caratteri copiati in un array che ha una dimensione di 80.

Si ricorda che una stringa di 68 caratteri occupano nell’array 69 caratteri in quanto bisogna considerare il terminatore 0.

Attenzione

Se l’array fosse troppo piccolo e provassimo a copiare all’interno una una stringa più grande della dimensione dell’array, la stringa verrebbe copiata anche al di fuori dell’array. La memoria oltre la fine dell’array potrebbe contenere altri dati importanti utilizzati nello sketch, questi dati verrebbero quindi sovrascritti dalla nostra stringa. In questo caso se la memoria oltre la fine della stringa viene sovrascritto potrebbe far arrestare in modo anomalo il programma o causare comportamenti strani.

Per approfondire l’argomento e verificare come evitare di scrivere al di furi dello spazio di memoria assegnato ad uno specifico array, vi rimando a questi due post:

Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne
Arduino – Concatenare la stampa di stringhe e variabili

Pubblicato in arduino, i miei allievi | Lascia un commento

MicroCon 2020


Il lockdown come ben sapete ha creato nella scuola numerose criticità che hanno mutato radicalmente il nostro modo di studiare ed insegnare. Come insegnate di materia tecnica che vive quotidianamente il laboratorio ho necessariamente bisogno di pensare e sviluppare diverse modalità di making elettronico/didattico che da settembre bisognerà adottare a scuola in una situazione in cui tempi e comportamenti del fare e costruire saranno da rimodulare.

Ma come fare tutto ciò?

Pensieri, progetti nascenti, sperimentazioni di nuove tecnologie questo ed altro il 9 maggio al MicroCon 2020, evento online in cui si parlerà di elettronica, microcontrollori e di nuove frontiere dell’apprendimento nel settore delle nuove tecnologie.

La conferenza online e organizzata da Paolo Aliverti e Pier Aisa entrambi maker che da anni svolgono in modo egregio la loro opera di divulgazione nel settore dell’elettronica.

Maggiori informazioni sul programma e i relatori che interverranno su: www.microcon.it
Per partecipare è indispensabile l’iscrizione gratuita al seguente link.

Ringrazio Paolo e Pier per l’invito 🙂

Vi aspettiamo all’evento.

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

Errori comuni nell’uso di Arduino – inserire void davanti alla funzione chiamata

Ho rilevato che alcune volte alcuni allievi nella chiamata di una funzione inseriscono il tipo restituito dalla funzione davanti alla funzione chiamata, ciò può essere fatto solamente nella dichiarazione del prototipo di funzione.
Il prototipo di una funzione costituisce una dichiarazione della funzione e fornisce al compilatore le informazioni indispensabili per gestire la funzione.
Nella definizione di una funzione, viene indicato anche ciò che deve fare la funzione quando viene invocata, specificato nel corpo della funzione.

Lo sketch che segue non chiama la funzione miSentoFortunato()

void setup() {
  Serial.begin(9600);
}

void loop() {

  // inserendo void nella chiamata di funzione
  // NON verrà chiamata la funzione miSentoFortunato() 
  void miSentoFortunato();
}

void miSentoFortunato() {
  Serial.println("Oggi mi sento fortunato :-)");
}

Attenzione che in fase di compilazione e trasferimento non verrà restituito nessuno errore da parte del compilatore quindi l’individuazione dell’errore in un codice più esteso potrebbe essere di difficile individuazione.

Codice corretto

void setup() {
  Serial.begin(9600);
}

void loop() {

  // eliminando void nella chiamata di funzione
  // verrà chiamata la funzione miSentoFortunato() 
  miSentoFortunato();
}

void miSentoFortunato() {
  Serial.println("Oggi mi sento fortunato :-)");
}

Esercizio 1

Perché il codice che segue non restituisce errore?

void setup() {
  Serial.begin(9600);
}
void loop() {
  void miSentoFortunato();
}

Esercizio 2

Perché il codice che segue non restituisce errore?

void setup() {
  Serial.begin(9600);
}
void loop() {
  // :-)
}
void miSentoFortunato();

Esercizio 3

Perché il codice che segue restituisce errore?

void setup() {
  Serial.begin(9600);
}
void loop() {

  void miSentoFortunato() {
  // :-)
  }
}

Per i miei allievi: il primo che risponde correttamente vince una scheda Arduino (non è uno scherzo) 😉

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

Microlearning con Instagram a supporto della didattica a distanza

E’ da tempo che stavo pensando di sviluppare soluzioni per realizzare del microlearning, attività che vorrei utilizzare per rafforzare competenze fornite durante videolezioni proposte in modalità sincrona ed asincrona e durante le lezioni in presenza (quando ci saranno).

Ma perché sto pensando al microlearning?
Il sistema microlearning trova largo impiego nella formazione a distanza aziendale, ma è possibile, secondo me modificarlo anche per supportare la didattica che normalmente svolgiamo con i nostri studenti a scuola o online.

In queste settimane come appunti in disordine sul mio Evernote in un blocco che ho chiamato “rinnovamento didattico” sto scrivendo una serie di frasi che spero andranno a strutturare poi un progetto più preciso:

“il prossimo anno scolastico sarà complicato, bisognerà recuperare e far fronte ai problemi legati al mantenimento della distanza sociale… quindi bisogna costruire qualcosa che affianchi la didattica online ed in presenza come la intendiamo adesso, bisogna costruire strumenti che permettano di atomizzare il progetto educativo al fine di facilitare la personalizzazione in funzione delle necessità dello studente soprattutto in questo periodo di crisi”.

Progetto che credo poi verrà strutturato applicando il metodo iterativo: “imparare facendo”

NON imparo ad usare prima lo strumento
e POI lo uso
ma lo uso SUBITO per spiegare
e usandolo IMPARO

… e quindi alla fine preso tra i mille lavori applicherò il metodo “imparare facendo” 🙂

Ma come opererò?

L’idea è quella di creare brevi contenuti, testuali o video, dedicati ad un singolo argomento.
Nel caso di contenuti testuali banalmente anche fotografie di appunti, disegni fatti a mano o video brevissimi non più lunghi di 3-5 minuti.

Quindi la parola chiave è: “atomizzare”, concetto che per altro avevo utilizzato anni fa per la progettazione della didattica laboratoriale della robotica.

Tutto ciò inoltre credo sia utile perché sfrutta di più la memoria di lavoro, faccio riferimento al “modello tripartito” di Baddeley ed Hitch.

Quando dico “atomizzare” intendo lo sviluppo di mattoncini cognitivi che si aggiungono ai mattoni che vengono “posati” durante le lezioni normali e con lo studio degli studenti a casa.

Tutto ciò però non deve, da parte dello studente, essere di difficile fruizione, non deve dipendere dal dispositivo utilizzato o dal sistema operativo. Inoltre se possibile non deve richiedere una formazione all’uso dello strumento tecnologico.

Ho analizzato per mesi la modalità ed i tempi di utilizzo da parte degli studenti di: smartphone, computer desktop e portatili, ma la cosa che ho analizzato più di tutte è il modo con cui condividono appunti e i momenti in cui leggono gli appunti che tra di loro si condividono, condivisione che in moltissimi casi avviene mediante fotografie di appunti scambiati attraverso gruppi WhatsApp.

Durante i miei corsi, quando parlo di organizzazione del lavoro didattico e della progettazione di contenuti, parlo di atteggiamento minimalista nella scelta dei metodi e degli strumenti e quindi per sviluppare un’azione didattica in cui è presente anche il microlearning, ho pensato di concentrarmi su strumenti usabili da tutti, anche se questi non presentano le funzionalità utili per coprire tutte le necessità di progetto del docente.

Cosa usare? Ho sperimentato di tutto, ma dopo tanto peregrinare sono ritornato sullo strumento che in origine avevo selezionato, Instagram, alcuni diranno: “bella scoperta!”, o ancora “ma vuoi fare didattica con Instagram?” attenzione che ciò che voglio fare non è fare didattica SOLO CON Instagram, ma utilizzare ANCHE Instagram per aggiungere qualcosa di più alla didattica che svolgo.

… e poi… sto osservando come molti colleghi che stimo e che lavorano in altre nazioni stanno operando con le loro classi e mi sono convinto che è essenziale provarci.

Quindi da cosa inizio?
Senza ansia e con i giusti tempi inizio a sintetizzare appunti cartacei sull’elettronica: Arduino, elettrotecnica, elettronica, uso di applicativi ecc… e li propongo ai miei studenti sul mio canale Instagram e pian pianino costruisco.

Inizio oggi! Funzionerà? Non so, ma voglio provarci.

Buon Making didattico a tutti.

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

Errori comuni nell’uso di Arduino – usare troppa memoria RAM

Nella collezione degli errori nell’uso di Arduino aggiungo l’uso improprio della memoria Flash (RAM) disponibile all’interno del microcontrollore. La dimensione della memoria RAM differisce sulle varie schede Arduino, nell’esempio prendo in considerazione la scheda Arduino UNO R3.

Nell’esempio che segue, un semplice Blink, viene dichiarato un array di interi che in fase di compilazione provocherà un errore di dimensione troppo grande dell’array:

// laMiaCollezione è un array di interi che ha una dimensione di:
// (20000x16)/8=40kB
// superiore alla RAM disponibile in un Arduino UNO R3 che è di 32kB 
// si faccia riferimento al seguente link:
// https://www.arduino.cc/en/tutorial/memory

int laMiaCollezione[20000];

void setup() {
  Serial.begin (9600);
  Serial.println ("Avvio programma");
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  delay(1000); 
}

Dovreste rilevare l’errore indicato nell’immagine che segue:

Se non vedete il led L (connesso al pin13) lampeggiare o rilevate un errore simile a quello indicato nell’immagine sopra, vuol dire che state utilizzando troppa memoria RAM. Fate attenzione che molte librerie utilizzano la RAM (ad es. Libreria di schede SD, librerie LCD, ecc.).

Nel link allegato nello sketch di esempio potete consultare la pagina specifica di Arduino.cc in cui viene spiegato come viene usata la memoria sull’Arduino UNO R3:

  • Flash 32k byte (di cui 0.5k usato per il bootloader)
  • SRAM 2k byte
  • EEPROM 1k byte

Nel dettaglio:

  • 32kB (1024×32=32768bit) di memoria Flash di cui 0,5 kB (equivalenti a 512 bit) sono dedicati al bootloader.
    Il microcontrollore presente sull’Arduino UNO R3 è un ATmega328P. All’interno della memoria Flash (RAM) del microcontrollore è presente una zona di memoria riservata in cui viene allocato il Bootloader, un programma che ha il compito di controllare se dopo il reset della scheda vie è la possibilità di caricare in memoria, tramite la USB, un nuovo programma creato dall’utente. Se non è presente nessun nuovo programma il controllo passa all’inizio del programma presente in memoria, quello precedentemente caricato e viene eseguito e il controllo non ritorna più al Bootloader fino a quando non si esegue un nuovo reset della scheda, reset che avviene quando viene caricato una nuovo programma dell’utente.
  • 2 KB di SRAM (2048 bit), è una RAM statica volatile utilizzata per gestire le variabili contenute nel programma (sketch) creato dall’utente e i dati che servono al microcontrollore per funzionare.
  • 1KB di EEPROM (1024 bit) memoria i cui valori vengono mantenuti anche quando la scheda viene spenta.

Esercizio

Nello sketch riportato sopra quel è il numero massimo di interi che può ospitare l’array laMiaCollezione affinché non si incorri nell’errore di memoria RAM piena?

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

5 min al giorno di sperimentazione con M5Stack mini – Sensore TOF

Buoni propositi: utilizzare 5 minuti della mia giornata di lavoro per sperimentare alcuni utilizzi di M5Stick Mini, ma anche per sollecitare la curiosità e voglia di sperimentazione da parte dei miei studenti… pillole tecnologiche 🙂
Recentemente ho acquistato un sensore ToF (Time of Flight: tempo di volo) VL53L0X con connettore GROVE per effettuare misure precise sulla della distanza di ostacoli con M5Stick mini.

Un sensore ToF effettua un conteggio del tempo totale di volo dei fotoni dal momento in cui vengono emessi da un piccolissimo raggio laser al momento in cui viene rilevata la riflessione su un fotodiodo collocato sul sensore.
In generale il tempo di volo (spesso indicato con TOF, dall’inglese Time Of Flight) indica la misura del tempo impiegato da un oggetto, una particella o un’onda (elettromagnetica, acustica, elettromagnetica o di altro tipo) per percorrere una certa distanza in un mezzo determinato. (fonte: Wikipedia)
Il sensore è in grado di fornire una misura molto precisa della distanza, indipendentemente dalla riflettanza della superficie incidente.

Il sensore ToF di cui dispongo è un VL53L0X che incorporato un emettitore Laser VCSEL ed un fotodiodiodo ricevitore SPAD. Il laser è in grado di emettere impulsi a 940 nm (prossimi al campo infrarosso). Il fotodiodiodo SPAD è estremamente sensibile al singolo fotone e grazie alla schermatura di cui è costituito riceve soltanto la lunghezza d’onda di 940 nm del laser.

Il sensore che sto utilizzando sul mio M5Stick mini connesso in I2C, è in grado di misurare la distanza di oggetti dai 30mm a 800 mm, ma in commercio è possibile trovare sensori che sono in grado di misurare con precisione distanze fino a 2m. Campi di impiego: telecamere, macchine fotografiche, smartphone e sensoristica industriale.

L’integrato elettronico VL53L0 viene prodotto dalla ST Microelettronics, seguendo il link trovate maggiori informazioni tecniche.

Durante le nostre sperimentazioni elettroniche a scuola, spesso usiamo sensori basati sull’uso di un diodo LED emettitore di infrarossi ed un fotodiodi ad infrarossi ricevente  che sono influenzati dalla luce ambiente e dall’assorbimento della luce rilevata. Stessa cosa capita nel caso si utilizzi sensori ad ultrasuoni, dove la misura della distanza è fortemente dipendente dall’angolo di incidenza dell’onda ultrasonica e dalla fonoassobenza degli ostacoli di cui si vuole misurare la distanza.

Per maggiori informazioni sulle nozioni di base sull’utilizzo dei sensori ToF vi rimando al breve articolo di digikey dove oltre a presentare la tecnologia ToF, trovate dettagli interessanti su altre tecnologie utilizzate per la rilevazione della distanza degli ostacoli.
Nell’articolo si ripercorre la storia della sensistica per la misurazione degli ostacoli:

  • sensori di prossimità delle prime macchine fotografiche della Polaroid
  • sensori ad ultrasuoni come gli SR-HC04 che utilizziamo nelle sperimentazioni con Arduino
  • sensori ad infrarossi della Sharp
  • sensori ToF

Trovate il sensore ToF VL53L0X su schede che possono essere comodamente connessi in I2C ad Arduino a costi estremamente contenuti.

L’utilizzo del sensore ToF con M5Stick mini è estremamente semplice.

E’ sufficiente aggiungere tra i sensori disponibili il ToF, così come indicato nell’immagine che segue ed utilizzare così l’istruzione che permette di misurare la distanza dell’ostacolo.

Nel programma indicato di seguito viene misurate la distanza dell’ostacolo è nel caso in cui la misura sia inferiore ai 50 mm viene acceso il LED rosso disposto sull’M5Stick mini.

Ovviamente sviluppare ora un sistema per valutare il tempo necessario per lavarsi le mani, così come indicato nell’articolo: Arduino – Esercizio: Realizzare un timer per il lavaggio delle mani risulta semplicissimo.

Buona sperimentazione a tutti 🙂

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