FabLearn Conference 2019

Ci siamo, da oggi io e superTutor Leo siamo ad Ancona, a partecipare alla conferenza FabLearn Italy 2019 presentando due poster sulle attività sperimentate nel nostro istituto.

I due poster accettati, che condividiamo con tutta la comunità dell’Einstein, sono:

Al ritorno impressioni e notizie sulla conferenza.

Pubblicato in didattica digitale, laboratori, Make, MakerSpace | Contrassegnato , , , , , , | Lascia un commento

Avvisatore acustico di sicurezza (parte 2)

Si può fare qualcosa mentre la nota suona ?
Stabilito che una volta lanciato il comando tone() il nostro codice prosegue nasce un problema, dobbiamo stabilire se questo è un bene o è un male.

Se dovessimo semplicemente eseguire delle sequenze di suoni, il fatto che il codice non si fermi ad aspettare che il suono termini è un problema ma, se guardiamo l’elenco delle cose che dobbiamo assolvere con il nostro programma scopriamo che la possibilità di fare altre cose mentre “suona” è una cosa ottima.
Ottima ma non senza qualche problemino, vediamo di capire quela potrebbe essere e come affrontarlo.

Per realizzare il nostro avvisatore acustico stabiliremo dei toni (frequenze) e la loro durata. Fra un tono e l’altro potremmo avere delle pause oppure no ma, per quanto ci riguarda, anche le pause sono dei toni o meglio, dei non toni e anche loro avranno delle lunghezze ben definite.
Per essere sicuri di non avere errori nell’esecuzione della nostra sequenza sonora una delle soluzioni è portare il conto del tempo che passa dopo che abbiamo lanciato un tono e, mentre gestiamo le altre funzionalità richieste dal nostro programma, controlliamo se è il momento di passare al prossimo suono.
Questa soluzione non è l’unica soluzione ne è la migliore dal punto di vista dell’ottimizzazione del codice però, è una di quelle che possiamo attuare usando pochi comandi di base e che comunque ci da buone possibilità di ottenere un risultato accettabile.

Per misurare il tempo che è passato dobbiamo utilizzare una funzione di base che viene fornita dalle funzioni di base di Arduino, questa funzione è la millis() e ogni volta che la utiliziamo, ci dice quanti millisecondi sono passati dall’ultima volta che il microcontrollore è stato resettato.
In effetti le librerie Arduino ci metteno a disposizione anche un’altra funzione che indica il tempo trascorso ed è la micros() la quale ci fornisce il tempo trascorso dall’ultimo reset ma espresso in microsecondi. Questa informazione nel nostro caso è meno comoda da gestire di quella fornita dalla millis() per cui questa volta non la useremo.

Approfondimenti:
1) Arduino reference millis()
2) Arduino reference micros()

Pubblicato in didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , | Lascia un commento

Avvisatore acustico di sicurezza (parte 1)

Verifichiamo l’usabilità del comando tone()
Il comando tone() (già utilizzato quando abbiamo fatto suonare la Maker Uno) ci permette di impostare con grande semplicità il piedio di uscita, la frequenza e la durata del tono ma, cosa succede mentre il tono viene emesso?
Per scoprirlo (in maniera sperimentale) basta caricare il seguente codice

// Test del comado tone()
//Il codice esegue un tono di frequenza Tono1 e durata TTono1
//sul piedino Sirena (pin 8 dove la Maker Uno ha collegato il buzzer)
//Il programma ci fornisce la lettura del timer intero della scheda
//espresso in millisecondi rispettivamente:
// quando inizia il prgramma
// ogni volta che fa il ciclo della loop()
//La velocità di comunicazione della seriale è VelocitaSeriale

#define VelocitaSeriale 9600

#define Sirena 8

#define Tono1 1000

#define TTono1 5000

void setup()
{
Serial.begin(VelocitaSeriale);
Serial.print(“Inizio a “);
Serial.println(millis());
}

void loop()
{
tone(Sirena,Tono1, TTono1);
Serial.print(“Ciclo “);
Serial.println(millis());
}

che trovate pronto per l’ide al link.
Una volta compilato e caricato sulla nostra scheda Maker Uno o altra Arduino Uno compatiile, possiamo lanciare il monitor seriale e osservare che, i numeri che ci appaiono sono veramente prossimi uno all’altro ovvero, il tempo che intercorre fra un giro e l’altro della subroutines loop() è di molto inferiore alla lunghezza fissata per la nostra nota (5000 mS ovvero 5 secondi).
Cosa ne deduciamo?
Ne deduciamo che la lireria di base Arduino mette a disposizione il comado tone() come comando non bloccante per il codice o meglio, il sotto processo che provvede ad eseguire il tono sul piedino richiesto viene eseguito senza che l’esecuzione del programma (principale) venga fermata.

Approfondimenti:
1) Arduino reference tone()

Pubblicato in didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , | Lascia un commento

Incontro presso il MakerSpace

Ci siamo, finalmente in calendario l’incontro di programmazione delle attività delle “Officine digitali Einstein”; ci vediamo il 30 ottobre 2019 per discutere di cosa costruire nel laboratorio, come programmare le aperture pomeridiane, se e come far nascere l’associazione per la diffusione della cultura digitale (e non) nel quartiere aprendo lo spazio al territorio.

Aspettiamo studenti, docenti, diplomati e pensionati dell’Einstein nel MakerSpace (ingresso dal cortile) il 30 ottobre ore 14,15 – 17,15.

Pubblicato in Make, MakerSpace, robotica | Contrassegnato , , | Lascia un commento

Avvisatore acustico di sicurezza

Negli ultimi anni, con la crescita della sensibilità verso la sicurezza, l’utilizzo di segnalazioni acustiche per attivare l’attenzione delle persone che potrebbero essere esposte ad una condizione di pericolo è aumentato considerevolmente.
I segnalatori acustici più diffusi si limitano ad emettere un tono intermittente o, in alcuni casi, due toni alternati. In entrambe i casi lo sforzo del progettista è quello di scegliere toni e pause che rendano la segnalazione efficace.
Sempre in merito ai segnalatori acustici nell’ambito della sicurezza, un primo livello di sofisticazione lo troviamo nei segnalatori per i semafori stradali.
Questi dispositivi, oltre all’alternanza di toni e/o pause, utilizzano diverse sequenze e velocità di esecuzione per annunciare l’approssimarsi di un cambiamento di situazione, tipicamente il passaggio dal verde al giallo negli attraversamenti pedonali.

Il nostro obiettivo è realizzare un segnalatore acustico il quale:
a) ricevuto uno stimolo (START)
b) lanci una sequenza di avviso di durata definita
c1) esegua una sequenza di segnalazione distinguibile dalla precedente
c2) cambi di stato ad un pin digitale
d1) arresti la sequenza su stimolo (diverso da quello del punto 1) (GO)
d2) arresti la sequenza su timeout definito e cambi di stato un piedino digitale (ALARM)
diverso da quello del punto a) e del punto c2)
d3) in caso di arresto per timeout non accetti più stimoli sul piedino START sino al reset

Come già per altre esperienze procederemo per passi e nel dettaglio:
1) verifichiamo l’usabilità del comando tone()
2) si può fare qualcosa mentre la nota suona?
3) aspettiamo il via

Pubblicato in didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , , , , , | Lascia un commento

E’ giorno o è notte? Valutiamo la luce con Arduino (parte 5)

Usiamo i LED della Maker Uno o collegati all’Arduino per comunicare
Se ci guardiamo intorno scopriamo che siamo circondati da indicatori che forniscono informazioni qualitative e non quantitative, cosa intendiamo esprimere con questo concetto? Vi porto un esempio:
Accendete lo scooter e la spia della benzina si accende.
a) sapete esattamente quanti litri di benzina ci sono nel serbatoio
b) sapete che state per rimanere a piedi ma non sapete esattamente fra quanto
Ecco, questa è una informazione di tipo qualitativo e non quantitativo.
La stessa cosa è la spia della macchientta per fare il caffè, si accende quando è pronta ma, a che temperatura è arrivata???? Bo! Quella giusta, forse.
Cosa vuol dire questo? In effetti stiamo verificando che, in molti, moltissimi casi quello che serve è sapere se siamo dentro o fuori anche perchè, molte delle decisioni che prendiamo quotidianamente sono basate su passa-non-passa e non su oculati calcoli assoluti e oggettivi. Sarebbe veramente complicato.
Torniamo al nostro esperimento, lo scopo è capire se è giorno o notte …… una valutazione di tipo qualitativo per cui, se assegnamo ad un LED il significato di GIORNO e ad un’altro il significato di NOTTE abbiamo già risolto il problema di come comunicare la nostra valutazione.

Come già fatto in altre esperienze, individuiamo due piedini di I/O digitale collegati ad altrettanti LED, inizializziamoli e utiliziamoli per comunicare all’utente lesito della nostra valutazione.
Lo stesso risultato si può ottenre utilizzando un solo LED bicolore o RGB, per questa soluzione comunque dovranno essere utilizzati almeno 2 piedini di I/O digitale.
Per verificare la soluzione che ho attuato potete verificare il listato del punto 4 o sul file scaricabile al link.

Pubblicato in Ambiente, didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , | Lascia un commento

E’ giorno o è notte? Valutiamo la luce con Arduino (parte 4)

Valutiamo la condizione Giorno/Notte
Dalle prove fatte in precedenza (parte 3), sappiamo che i count sono funzione della luminostà che interessa il nostro trasduttore, riguardando quei numeri possiamo individuare quattro valori:
1) il valore al di sotto del quale (secondo noi) si può parlare di oscurità o scarsa visibilità ambientale che chiameremo Notte
2) il valore oltre il quale si può parlare di luminosità sufficiente alla visione d’insieme sino al pieno sole che chiameremo Giorno
3) un valore empirco intermedio ai due estremi (Giorno Notte) che individui un punto nel percorso di oscuramento che chiameremo SogliaGiornoNotte
4) un valore empirico intermedio alla SogliaGiornoNotte e a Giorno che chiameremo SogliaNotteGiorno.

I valori Notte e Giorno al momento ci saranno utili solo per la fase in cui sceglieremo le soglie intermedie. Possiamo riportarli nel programma come commenti ma, al momento, non verranno uilizzati dal codice.

Perchè c’è la necessità di individuare due soglie distinte e separate?
Il motivo è semplice, se noi assumessimo un solo valore di soglia al di sopra del quale è Giorno e al di sotto è Notte, ogni volta che le condizioni di illuminamento danno luogo a valori prossimi alla soglia ma non stabili, il nostro processo continuerebbe a cambiare l’esito della valutazione ad ogni attraversamento della soglia da parte del valore letto. Questo continuo cambiamento di stato creerebbe una situazione di confusione per l’utente e per tutti i processi decisionali associati a questo parametro (in seguito utilizzeremo l’informazione relativa a Giorno/Notte per prendere delle decisioni).
Se al posto di una soglia, ne individuiamo due distinte, separate e dall’azione univoca, noi avremo che la zona compresa fra le due soglie agisce da “ammortizzatore”.
La grandezza compresa fra le due soglie (l’ammortizzatore) si chiama isteresi.
L’introduzione dell’isteresi elimina le indecisioni per tutte le variazioni della grandezza da valutare inferiori all’ampiezza dell’isteresi.
Il processo di scelta che adotta un’isteresi sull’ampiezza del segnale valutato simula il funzionamento del Trigger di Schmitt.

Fase operativa
Buttiamo giù un po di codice.

// Programma per la definizione della condizione di Giorno/Notte attraverso la lettura
  // di una fotoresistena collegata ad un ingresso analogico
 //La condizione iniziale è che sia Notte.
 // Il programma comprende il modulo per la comunicazione seriale dei valori letti.
  // Il modulo si attiva e disattiva con il flag Monitor che ammette i valori true e false
 define Monitor false
 //Ricordate che nella definizione delle costanti non va messo il segno uguale fra 
 //il nome simbolico e il valore e non va messo il punto e virgola a fine riga
 // Il valore assegnato alla costante Tp1 è 0
 //perchè io ho usato per le prove l’ingresso analogico 0 
 #define Tp1 0
 #define LEDNotte 13
 #define LEDGiorno 10
 //Associo ad una costante la velocità di comunicazione della porta seriale
 #define  VelocitaPortaSeriale 9600
 //Ritardo fra una lettura e la successiva espresso in millesimi di secondo
 #define ADCDelay 500
 int ADCCount = 0; //Creo e inizializzo la variabile di appoggio per la lettura dell’ADC
 #define SogliaGiornoNotte 100
 #define SogliaNotteGiorno 150
 byte GiornoNotte = 0;//0 = NOTTE - 1 = GIORNO
 void setup()
 {
    pinMode(LEDNotte, OUTPUT);
    digitalWrite(LEDNotte, HIGH);
    pinMode(LEDGiorno, OUTPUT);
    if (Monitor == true)
    {
      Serial.begin(VelocitaPortaSeriale);
    }
 //Per semplificare il programma ho scelto di omettere il controllo della seriale
 }
 void loop()
 {
    ADCCount = analogRead(Tp1); //leggo il Tp1 e metto il risultato in ADCCount
 if (GiornoNotte==1 & ADCCount < SogliaGiornoNotte)    {     GiornoNotte = 0;//è diventato NOTTE     digitalWrite(LEDNotte, HIGH);     digitalWrite(LEDGiorno, LOW);   } if (GiornoNotte==0 & ADCCount > SogliaNotteGiorno)
 {
      GiornoNotte = 1;
      digitalWrite(LEDNotte, LOW);
      digitalWrite(LEDGiorno, HIGH);
 }
 if(Monitor == true)
 {
      Serial.print("Lettura in COUNT ");//mando sulla seriale l'inizio della riga 
      Serial.println(ADCCount);//mando sulla seriale il valore letto e vado a capo
 }
 delay( ADCDelay);//aspetto prima di ripetere il ciclo
 } 

Aprendo il link trovate il codice compatibile e scaricabile

Leggendo il codice potete vedere come la versione presentata gestisce oltre alla valutazione a doppia soglia, la presentazione dei risultati tramite i LED installati sulla piastra.
Per il momento non considerate la parte relativa alla presentazione della quale parleremo nel punto successivo.

Approfondimenti:
a) Trigger di Schmitt cenni di teoria
b) Trigger di Schmitt nelle logiche TTL

Pubblicato in Ambiente, didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , , , , , , , | Lascia un commento

E’ giorno o è notte? Valutiamo la luce con Arduino (parte 3)

Leggiamo la fotoresistenza e visualiziamo il risultato sul PC
Come avrete capito, cerchiamo di procedere per passi per cui in questa fase ci limiteremo a leggere l’ingreso analogico e a mandare il risultato sulla porta seriale (che per noi diventa la porta USB con cui colleghiamo l’Arduino al PC) del nostro microntollore per poterla leggere con il monitor dell’IDE Arduino. Questa soluzione offre la possibilità di vedere dei risultati immediatamente senza dover prima collegare altro hardware e stabilire strategie di presentazione dei dati, a questo ci penseremo più avanti.
Per far dialogare la scheda Arduino compatibile con il PC useremo le istruzioni Serial.begin(), Serial.print() e Serial.println(), per chiarimenti ed esercizi sul loro uso vi rimando ad altri articoli ed altre esercitazioni.

Per leggere il nostro ingresso analogico utilizzaremo il Convertitore Analogico Digitale (ADC) interno al microcontrollore, per qualche chiarimento sommario visitate il link.
Per quanto riguarda questa fase dell’esperienza, per leggere il valore sul Tp1 ci basterà scrivere il comando “analogRead()” e mettere il risultato in una variabile di tipo “int” usata come appoggio della lettura.
Oltre alla variabile di appoggio e al comando analogRead(), per comodità associeremo ad una costante il numero dell’ingresso analogico utilizzato per collegare il Tp1 per cui alla fine avremo che
a) nella prima parte del listato dichiareremo la costante Tp1 assegnandogli il numero dell’ingresso analogico utilizzato per collegare il Tp1
b) sempre nella prima parte del listato dichiareremo la variabile ADCCount come “int” e inizializzeremo a 0
c) all’interno della loop() per effettuare la lettura scriveremo
ADCCount = analogRead(Tp1);
Di seguito il codice del nostro programma di prova.

// Programma per la lettura di una fotoresistena tramite un ingresso analogico

//Ricordate che nella definizione delle costanti non va messo il segno uguale fra
//il nome simbolico e il valore e non va messo il punto e virgola a fine riga

// Il valore assegnato alla costante Tp1 è 0
//perchè io ho usato per le prove l’ingresso analogico 0
#define Tp1 0

//Associo ad una costante la velocità di comunicazione della porta seriale
#define VelocitaPortaSeriale 9600

//Ritardo fra una lettura e la successiva espresso in millesimi di secondo
#define ADCDelay 500

int ADCCount = 0; //Creo e inizializzo la variabile di appoggio per la lettura dell’ADC

void setup()
{
Serial.begin(VelocitaPortaSeriale);
//Per semplificare il programma ho scelto di omettere il controllo della seriale
}

void loop()
{
ADCCount = analogRead(Tp1); //leggo il Tp1 e metto il risultato in ADCCount
Serial.print(“Lettura in COUNT “);//mando sulla seriale l’inizio della riga
Serial.println(ADCCount);//mando sulla seriale il valore letto e vado a capo

delay( ADCDelay);//aspetto prima di ripetere il ciclo
}

Aprendo il link trovate il codice copiabile e scaricabile.

Proviamo il programma
Dopo aver compilato e verificato che non ci siano segnalazioni di errori, carichiamo il programma nella scheda alla quale abbiamo collegato il circuito con la fotoresistena (parte 2), a questo punto procediamo aprendo il monitor seriale e verifichiamo che nella parte in basso a destra della finestra del monitor ci sia lo stesso valore che abbiamo assegnato alla ” VelocitaPortaSeriale “, nel caso sia diverso adeguiamolo. Se avete proceduto a cambiare il valore della velocità della porta seriale, potrebbe essere necessario chiudere il monitor e riaprirlo affinchè riprenda il suo funzionamento corretto.
Se tutto è andato come si deve dovremmo veder scorrere nella finestra del monitor seriale i valori dei count letti dal convertitore e, variando la luce che colpisce la fotoresistenza il valore presentato dovrebbe cambiare in maniera coerente alla variazione (parte 1).

Approfondimenti:
1) Il convertitore Analogico Digitale
2) Teoria dell’acquisizione tramite ADC
3) Arduino e la conversione Analogico Digitale
4) AVR e la Conversione Analogico Digitale

Pubblicato in Ambiente, chimica-fisica, didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , , , , , , , | Lascia un commento

Arduino Uno e il Convertitore Analogico Digitale – Brevi cenni

Il Convertitore Analogico Digitale o ADC (Analog to Digital Converter) integrato nei chip della famiglia AVR è un dispositivo con risoluzione di 10 bit con ingresso sbilanciato e se non modifichiamo nulla usa come Vref la VCC.
In altre parole (più semplici) significa che quando fa una misura, la fa rispetto massa (GND), che ammette solo valori positivi e compresi fra 0V (GND) e 5V e che tutti i valori compresi fra 0V e 5V vengono rappresentati attraverso un numero che va da 0 a 1023 (1024 count o meglio 2^10 count).
In pratica vuol dire che per far variare di 1 il valore del convertitore la tensione in ingresso deve variare di

Vstep = Vref / (Risoluzione – 1) -> 5 V / (2^10 – 1) -> 5 V / (1024 -1) -> 5 V / 1023 = 0,00488 V = 4,88 mV

Questo numerello che sembra molto piccolo ma in effetti lavorando, scopriremo che non è sempresufficiente e che in alcuni casi dovremo adoperarci per migliorarlo.
In ogni caso è opportuno ricordarlo e tenerlo presente perchè costituisce il limite teorico nelle nostre misure analogiche nella configurazione di default delle piastre Arduino Uno e compatibili.

Approfondimenti:
1) Il convertitore Analogico Digitale
2) Teoria dell’acquisizione tramite ADC
3) Arduino e la conversione Analogico Digitale
4) AVR e la Conversione Analogico Digitale

Pubblicato in didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , , | Lascia un commento

E’ giorno o è notte? Valutiamo la luce con Arduino (parte 2)

Come abbiamo visto nel pumto 1, il segnale che troviamo sul Tp1 ha un andamento analogico ovvero, assume un valore arbitrario e passa da un valore ad un altro senza soluzione di continuita ovvero, in maniera continua.
Questa tipologia di segnale non e direttamente leggibile da un ingresso digitale o almeno, un ingreso digitale non sarebbe in grado di dirci che valore abbiamo sul Tp1 ma solo di dirci se il Tp1 e al di sopra o al disotto di un certo valore. Questa modalita di lettura non va bene nel nostro caso. Noi, per leggere il valore che e presente sul Tp1 a questo punto abbiamo bisogno di un ingresso analogico cosi da leggere il valore tramite un convertitore Analogico Digitale.
Per procedere su questa strada dobbiamo collegare la VCC al +5 del nostro microcontrollore, il GND al GND e il Tp1 ad uno degli ingressi analogici della scheda. Gli ingressi anlogici sono contrassegnati sui connettori delle schedeArduino compatibili con la lettera A seguita da un numero.
Una volta realizzati i nostri 3 collegamenti, possiamo passare alla fase successiva.

Pubblicato in Ambiente, didattica digitale, Elettronica, Informatica, laboratori, Make, MakerSpace, robotica | Contrassegnato , , , , | Lascia un commento