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.

In effetti, una struttura software (e hardware) che assolva a pienoalle problematiche che stiamo per affronatre è tutt’altro che semplice e, affrontarla come prima realizzazione può essere frustrante e incoraggiare l’abbandon dell’impresa per cui, da questo punto in poi, descriverò due soluzioni completamente diverse, la prima sarà semplice con tutte le limitazioni di una cosa semplice (ma più facile da realizzare e comprendere e propedeutica per il livello successivo), la seconda sarà un buon compromesso fra quello che può fare un maker e quello che si fa a livello industriale.
Per distinguerle le chiamerò:
1) Avvisatore acustico semplificato – la versione più semplice
2) Avvisatore acustico di sicurezza – la versione più articolata e complessa
Per cui, da adesso in poi avremmo due linee di articoli che parleranno di uno e dell’altro.

AVVISATORE ACUSTICO SEMPLIFICATO
Cosa deve garantire:
a) aspettare uno stimolo su di un ingresso (START)
b1) lanciare una sequenza di avviso di durata definita (TALLARM)
b2) portare alto un pin digitale (RUN)
c1) arrestare la sequenza su timeout definito
c2) portare basso un piedino digitale (RUN)
c3) tornare ad a)

AVVISATORE ACUSTICO DI SICUREZZA
Cosa deve garantire:
a1) inizializzare tutti i piedini nello stato corretto
a2) aspettare uno stimolo su di un ingresso (START)
b1) lanciare una sequenza di preavviso di durata definita
b2) portare alto il pin digitale (ALLERT)
c1) eseguire una sequenza di segnalazione distinguibile dalla precedente
c2) portare basso il pin digitale (ALLERT)
c3) portare alto il pin digitale (RUN)
d1) arrestare la sequenza acustica su stimolo (EMERGENCY STOP)
d1a) portare basso il pin digitale (RUN)
d1b) portare alto il pin digitale (ALARM)
d1c) in caso di arresto per EMERGENCY STOP non accettare più nessuno stimolo sino al reset
d2) arrestare la sequenza acustica per timeout (TALLARM)
d2a) portare basso il pin digitale (RUN)
d2b) in caso di arresto per timeout riprendere l’esecuzione dal punto a1)

Da adesso sta a voi seguire una o l’altra linea risolutiva

AVVISTARE ACUSTICO SEMPLIFICATO
1) Inizializziamo i piedini (RUN – BASSO)
2) Aspettiamo che START diventi BASSO
3) Alziamo il pin RUN
4) Facciamo una sequanza di squilli a 600Hz ogniuno lungo 500mS con 1000mS di pausa fra uno squillo e l’altro e continuiamo per un tempo totale di (TALLARM)
5) Finito il tempo (TALLARM) concludiamo la sequenza di squilli
6) Abbassiamo il pin RUN
7) torniamo a 1)

AVVISATORE ACUSTICO DI SICUREZZA
1) Inizializziamo i piedini (RUN – BASSO; ALLERT – BASSO)
2) Aspettiamo che START diventi BASSO
3) Alziamo il pin ALLERT
4) Facciamo una sequanza di 4 squilli a 600Hz ogniuno lungo 500mS con 1000mS di pausa fra uno squillo e l’altro
5) Abbassiamo il pin ALLERT
6) Alziamo il pin (RUN)
7) Facciamo una sequanza di squilli a 800Hz ogniuno lungo 1000mS con 500mS di pausa fra uno squillo e l’altro e continuiamo per un tempo totale di (TALLARM)
7a) Controlliamo se EMERGENCY STOP è basso. Se è basso
a) Abbasiamo il pin RUN
b) Alziamo il pin ALLARM
c) Fermiamo la sequenza di squilli
d) blocchiamo il processo siano alla pressione del RESET
8) Finito il tempo (TALLARM) concludiamo la sequenza di squilli
9) Abbassiamo il pin RUN

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

E’ giorno o è notte? Valutiamo la luce con Arduino

Nel percorso di crescita dei bambini una delle (tantissime) cose che imparano a fare bene è valutare la condizione ambientale relativa alla luce, al giorno e alla notte. Questo processo di valutazione ci diventa naturale perchè lo facciamo attraverso un gran numero di elementi ambientali ed esperenziali ma, se dovessimo farlo fare ad un sistema logico le cose si complicano un bel pò.
L’attuale sviluppo tecnologico ci mette a disposizione vari modi per valutare la luce presente in una zona, alcuni di questi trasduttori sono veramente economici e semplici da usare mentre altri risultano costosi e a volte complicati da utilizzare ma, in tutti i casi, un solo trasduttore che ci dica con certezza se è giorno o notte di fatto non è disponibile.
Quello che faremo per cominciare sarà provare a fare alcune semplici valutazioni sulla luce attraverso una fotoresistenza e un Arduino (in effetti io userò una Maker Uno per praticità).

Questa esperienza, come spesso accade, ha diversi livelli di complessità per cui la dividerò in diversi passi che potrete svolgere in funzione del vostro interesse e delle vostre capacità.
1) Conosciamo la fotoresistenza
2) Colleghiamo la fotoresistenza ad Arduino
3) Leggiamo la fotoresistenza e visualiziamo il risultato sul PC
4) Valutiamo la condizione di Giorno/Notte
5) Usiamo i LED della Maker Uno o collegati all’Arduino per comunicare

Approfondimenti:
1) Alcune esperienze e considerazioni sui fotoresistori e Arduino
2) Un pò di teoria dei fotosensori e dei fotoemettitori
3) Cenni teoricopratici sulle fotoresistenze
4) Fotoresistenze e fotodiodi, Appunti

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

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

La fotoresistenza in breve
La fotoresistenza è un trasduttore basato su di un materiale resistivo il quale varia il suo valore in funzione della luce che lo colpisce.
Ad esempio, se noi inseriamo una fotoresistenza in un partitore resistivo, possiamo fare delle valutazioni sulla luce che colpisce la fotoresistenza in base a come si comporta il nostro partitore.

Il partitore
Realizzeremo un semplice circuito che sarà alla base delle prossime esperienze e per l’esattezza realizzeremo un partitore del tipo

Leggere Una Fotoresistenza 01-Partitore Semplice

Il materiale di supporto lo potete trovare al seguente link.

Vcc per comodità la fissiamo in 5V. Questa scelta ci permetterà di leggere tutti i valori prodotti dal nostro partitore con un Arduino Uno senza rischiare di danneggiarlo.
R1 Per R1 non c’è un solo valore giusto, le considerazioni da fare sono molte ma, per il momento, partiamo da una considerazione cautelativa, se mettiamo R1 troppo piccola di valore la corrente massima che potrà passare in R2 potrebbe essere eccessiva e creare problemi. Per il momento fissiamo il valore di R1 in 470Ohm. Questa scelta ci garantisce che, anche in caso di corto circuito su R2 la corrente massima sarà
I = V/R -> I = 5V / 470Ohm -> ~ = 0,01A = 10 mA
R2 è una resistenza di qualsiasi valore compreso fra 0 e 100KOhm. Questi valori sono presi in maniera arbitraria per permettervi di provare il circuito.
Se a questo punto mettiamo un voltmetro (mutimetro) fra il TP1 e GND misureremo una tensione che è funzione del rapporto fra R1 e R2 ma, se noi lasciamo fissa la R1 (470Ohm) e proviamo ad inserire diversi valori di R2 vedremo che la tensione fra TP1 e GND cresce al crescere di R2 e diminuisce al diminuire di R2.

Leggiamo una fotoresistenza
Ora sostituiamo la R2 con una fotoresistenza per cui, il circuito che ne deriverà sarà il seguente

Leggere Una Fotoresistenza 01-Partitore Con Fotoresistenza

Se ora collegiamo il nostro volmetro al TP1 e variamo la luce che colpisce la nostra fotoresistenza vedremo variare la tensione al variare della luce che colpisce il trasduttore (sensore).

Alcune considerazioni:
L’andamento della luce e della tensione misurata
Come indicato nel datasheet il valore della resistenza è inversamente proporzionale alla quantità di luce che la colpisce ovvero, il valore della resistenza si riduce all’aumentare della luce. Questo comportamento fa si che, nel circuito precedente all’aumentare della luce la tensione fra TP1 e GND diminuisse.
Considerando che noi dobbiamo leggere questo valore tramite un microcontrollore può non essere un problema ma, siccome in linea generale le cose semplici tendono a creare meno problemi di quelle complicate, le cose potrebbero essere più semplici e lineari se la tensione fra TP1 e GND aumentasse all’aumentare della luce e, se noi misurassimo la tensione ai capi di una resistenza di valore noto per cui, vi suggerisco di passare dal circuito precedente a quello che segue

aLeggere Una Fotoresistenza 01-Partitore Con Fotoresistenza-r01

Questa circuitazione ci permette di avere una tensione fra TP1 e GND che aumenta all’aumentare della luce.
Il campo di tensione misurata
Se facciamo alcune misure risulta immediatamente chiaro come ad una esposizione diretta ad un sole intenso il valore della fotoresistenza è inferiore a 1000Ohm mentre, in una situazione di illuminazione domestica il suo valore tende ad essere superiore ai 5000Ohm. Il campo di valori di tensione che ne deriva in un partitore come il nostro con una R1 di 470Ohm va da circa 1,5V a circa 0,4V.

Vtp1 = (VCC / (R1 + U1)) * R1

Dovendo misurare la tensione con un ATMega328 o equivalente alimentato a 5V ovvero con il suo convertitore Analogico Digitale che misura in un campo di tensioni comprese fra circa 0V e circa 5V con una risoluzione di 1024 passi (10 bit), ne deriva che il i valori letti corrispondenti in count andranno da circa 81 a circa 306. Questo spazio di soli 214 passi è veramente ridotto rispetto ai 1024 (0-1023) passi a disposizione. Come possiamo migliorare la situazione?
Ipotiziamo di aumentare la R1 da 470Ohm a 1500Ohm, la tensione sul TP1 a questo punto andrebbe da circa 3V a circa 1,1 e i count andrebbero da circa 236 a circa 613 con un’escursione di circa 377 passi ovvero circa il 76% in più di estensione rispetto al caso precedente.
Per il momento consideriamo questo aumento di estensione nei valori letti come un vantaggio e dunque, da questo momento useremo una R1 di 1500Ohm.

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

Facciamo suonare la Maker Uno – r01 (parte 5)

Nel punto 4 abbiamo acceso il LED e adesso, dobbiamo trovare il punto dove inserire il comando che lo spegnerà a fine esecuzione della nota.

Nel corso della nostra chiaccherata abbiamo detto che ad ogni nota è abbinato un tempo di esecuzione e che, per migliorare l’effetto “musicale”, fra una nota e l’altra viene introdotta una piccola pausa bene, noi dobbiamo inserire il comando di spegnimento del LED dopo l’arresto della nota.
Mentre per suonare una nota il comando è tone(), per spegnere il generatore di suoni il comando è noTone() ed è questo comando che dobbiamo cercare per cui

……..
// stop the waveform generation before the next note.
noTone(buzzer);
………

e inserire lo spegnimento del LED subito dopo il comando noTone().
In effetti, nella versione che trovate modificata da me, ho scelto di spegnere tutti i LED senza concentrarmi solo su quello appena acceso. Questa scelta è di tipo cautelativo e non ottimizzata. Va detto che, il ciclo di di spegnimento di tutti i LED si conclude in un tempo irrilevante per l’esecuzione delle note.
Il codice modificato secondo quanto detto diventa

………
// stop the waveform generation before the next note.
noTone(buzzer);
//Shut down all LED
for (int LEDOFF = 5; LEDOFF<14; LEDOFF = LEDOFF + 1)
{
digitalWrite(LEDOFF,LOW);
}

………

A questo punto, se abbiamo svolto bene il nostro lavoro, dobbiamo salvare le modifiche e lanciare la compilazione che si dovrebbe concludere senza errori. Se il risultato è positivo, procedete al caricamento del codice nel microcontrollore e verificatene la corretta funzionalità

Approfondimenti:
Provate a modificare il codice in maniera tale che ogni volta venga spento solo il LED precedentemente acceso.

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