Archivi tag: lilypad

Arduino LilyPad – lezione 05: sensore di luce

In questa lezione vi mostrerò come utilizzare il sensore luminoso: LilyPad Light Sensor acquistato presso SparkFun.

Passo 1

Come per le lezioni precedenti utilizziamo un cartocino di forma circolare per proteggere il circuito e per aumentare la presa dei morsetti a coccodrillo.

Passo 2

Collegate come rappresentato nell’immagine il + del sensore luminoso a al + di LilyPad, il – del sensore luminoso al – di LilyPad e il piedino S del sensore al piedino A0 di LilyPad:

Passo 3

Avviate l’IDE Arduino

Passo 4

Copiate il codice allegato all’interno di una nuova finestra dell’IDE.

/* Arduino LilyPad: lezione 05: sensore di luce
 * Uso del modulo LilyPad Light Sensor
 * Michele Maffucci
 * https://www.maffucci.it/
 * Progetto originale:
 * http://web.media.mit.edu/~leah/LilyPad/08_sensors.html
 */

int ledPin = 13;	// il LED e' collegato al pin digitale 13
int sensorPin = 0;	// il sensore di luce e connesso al piedino analogico 0
int sensorValue;	// variabile per memorizzare il valore rilevato dal sensore

void setup()
{
         pinMode(ledPin, OUTPUT);	// imposta ledPin come pin di output
         Serial.begin(9600);	//inizializza la porta seriale
         digitalWrite(ledPin, HIGH);	// accende il LED
}	 

void loop()
{
          sensorValue = analogRead(sensorPin);	// legge il valore dal sensore
          Serial.println(sensorValue);	// invia il valore al computer
          delay(100);	// ritardo di 1/10 di secondo
}

Passo 5

Chiarimenti sul codice.

Vi ricordo che con l’istruzione:

Serial.begin(9600);

apriamo la porta seriale USB e la inizializziamo a 9600 bps.

Per una spiegazione esaustiva dell’utilizzo del “Serial monitor” vi invito alla lettura della lezione: Arduino – lezione 04: realizzare un programma che identifica le variazioni di stato

Sempre nella lezione sopra indicata potete trovare dettagli sull’uso di:

Serial.println(sensorValue);

stampa sulla console di uscita il testo o il valore specificato tra parentesi:

Serial.print(78) stampa “78″
Serial.print(1.23456) stampa “1.23″
Serial.print(byte(78)) stampa “N” (il cui valore ASCII e’ 78)
Serial.print(‘N’) stampa “N”
Serial.print(“Hello world.”) stampa “Hello world.”

nel nostro caso “Serial.print(sensorValue);” stamperà sulla console di uscita il valore memorizzato nella variabile “sensorValue“.

Ricordo inoltre, come spiegato nella lezione: Arduino – lezione 02: facciamo lampeggiare un led

delay() è un’istruzione molto semplice che non fa altro che interrompere per un determinato tempo l’esecuzione del programma.
L’istruzione ha un solo argomento numerico che indica il numero di millisecondi di attesa.

Quindi “delay(100)” vuol dire 100 millisecondi,
cioè 100/1000 secondi
ovvero 1/10 di secondo.

Passo 6

Compilate il codice ed effettuate l’upload su LilyPad, aprite la console di uscita:

Non appena il LED si accende su LilyPad, si vedranno i valori del sensore comparire nella console di uscita e l’intervallo di valori oscillerà tra 0 (buio assoluto) a 1024 (luce piena):

Arduino LilyPad – lezione 04: suono

Per questa lezione ho utilizzato LilyPad Buzzer che ho acquistato su Sparkfun. Si tratta di un piccolo buzzer induttivo con due pin I/O in grado di riprodurre suoni di un livello sufficientemente alto da poter essere sentiti ad esempio se avete il buzzer in tasca, ma non aspettatevi livelli sonori elevatissimi.
Le dimensioni sono di 20 mm di diametro e 0,8 mm di spessore.

Passo 01

Come consigliato nella lezione n. 3 procedete anche per questa piccola scheda alla realizzazione del supporto protettivo in cartocino al fine di evitare scivolamenti dei morsetti a coccodrillo.

Passo 02

Collegate il “+” del buzzer al piedino 9 di LilyPad e il “-” del buzzer al “-” di LiLyPad come rappresentato nell’immagine:

Passo 03

Avviate l’IDE di Arduino e copiate ed incollate il codice che trovate di seguito:

/* Arduino LilyPad: lezione 04: suono
 * Uso del modulo buzzer
 * Michele Maffucci LilyPad Buzzer per realizzare semplici note musicali
 * https://www.maffucci.it/2011/06/30/arduino-lilypa-zione-04-suono/
 * Progetto originale:
 * http://web.media.mit.edu/~leah/LilyPad/07_sound.html
 * per un grafico sulle differenti frequenze delle note:
 * http://www.phy.mtu.edu/~suits/notefreqs.html
 */
 
int ledPin = 13;	// il LED  connesso al pin digitale 13
int speakerPin = 9;	// il buzzer  connesso al pin digitale 9 (uscita di tipo PWM)
 	 
void setup()	 
{	 
         pinMode(ledPin, OUTPUT);		// si imposta ledPin come pin di output
         pinMode(speakerPin, OUTPUT);	// si imposta speakerPin come pin di output
}	 
 	 
void loop()	// inizio del loop
{	 
          scale();		// chiamata della funzione scale()
          delay(1000);	// attesa di 1 secondo
}	 
 	 
void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds)		// funzione che produce il suono
{	 
          int x;
          
          // converte il periodo della nota in un intero lungo
          long delayAmount = (long)(1000000/frequencyInHertz);
          
          long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));
          
			for (x=0;x<loopTime;x++)
				{
					digitalWrite(speakerPin,HIGH);
					delayMicroseconds(delayAmount);
					digitalWrite(speakerPin,LOW);
					delayMicroseconds(delayAmount);
				}
}	 
 	 
void scale ()
{	 
			// speakerPin: piedino LilyPad; numero da: 2093 a 4186: frequenza della nota; 500: durata della nota

			digitalWrite(ledPin,HIGH);	//accende il LED
			beep(speakerPin,2093,500);	//C: suona le note C (C7 come da tabella linkata sopra) per 500ms
			beep(speakerPin,2349,500);	//D
			beep(speakerPin,2637,500);	//E
			beep(speakerPin,2793,500);	//F
			beep(speakerPin,3136,500);	//G
			beep(speakerPin,3520,500);	//A
			beep(speakerPin,3951,500);	//B
			beep(speakerPin,4186,500);	//C
			digitalWrite(ledPin,LOW);	//spegne il LED
}

Un long un tipo intero lungo che pu contenere un numero intero positivo o negativo (quindi senza punto decimale) di 32 bit con valori compresi tra 2.147.483.647 a – 2.147.483.648

Analizziamo con molta attenzione la funzione beep.

long delayAmount = (long)(1000000/frequencyInHertz); ?

Domanda: cosa vuol dire 1000000/frequencyInHertz:

Vi ricordo che il periodo di una forma d’onda :

T =1/f

dove f la frequenza espressa in Hertz. L’unit di misura del periodo T il secondo.

quindi la formula:

1000000/frequencyInHertz

pu essere scritta come:

1000000 * (1/frequencyInHertz)

ovvero:

1000000 * T

Domanda: perch moltiplichiamo per 1000000?

Perch la variabile delayAmount verr passata a delayMicroseconds() che una funzione che mette in pausa il programma per un tempo, espresso in microsecondi, specificato dal parametro.

Domanda: ma in un secondo quanti microsecondi ci sono?

1 milione di microsecondi

Ecco spiegato l’arcano, poich delayMicroseconds() accetta un parametro in microsecondi bisogna moltiplicare 1/frequencyInHertz per 1000000.

Domanda: cosa vuol dire (long) nell’istruzione:

long delayAmount = (long)(1000000/frequencyInHertz);

Per spiegare questa linea di codice devo parlarvi di Type-casting.
In C possibile forzare il tipo di una variabile (int, long, float, …) in un altro tipo, utilizzando l’operatore “()

Ad esempio:

int a;
int b=67;
float c=3.14;
float d;
char lettera='M';

/* assegna il valore 3 (solo la parte intera) ad a */
a=(int)c 

/* assegna il valore 77 (codice ASCII) ad a */
a=(int)lettera

/* assegna alla variabile d il valore di b, 67.0 (valore float) */
d=(float)b

In alcuni casi il Type-casting viene fatto automaticamente dal compilatore in altri casi bisogna specificarlo. Il Type-casting una richiesta al compilatore di trasformazione di tipo.

Quando siamo in dubbio buona norma eseguire il Type-casting.

Il Type-casting risulta utile ad esempio in una divisione:

int x, y;
float w;

w=(float)x/(float)y;

questa operazione assicura che la divisione sia in floating-point.

Tornando alla nostra istruzione:

long delayAmount = (long)(1000000/frequencyInHertz);

quando effettuiamo un passaggio di valore ad una funzione bisogna convertire long in (long , infatti delayAmount viene passata a delayMicroseconds.

Domanda: ma cos’ delayAmount?

il periodo T della frequenza della nota.

Domanda: a cosa serve loopTime?

loopTime definisce il numero di volte in cui la nota deve essere suonata.

Infatti nel corpo del for:

digitalWrite(speakerPin,HIGH);
delayMicroseconds(delayAmount);
digitalWrite(speakerPin,LOW);
delayMicroseconds(delayAmount);

si ha:

digitalWrite(speakerPin,HIGH);

viene messo ad alto l’uscita speakerPin (pin 9)

delayMicroseconds(delayAmount);

la nota viene suonata per un tempo delayAmount, periodo della della nota

l’uscita speakerPin (pin 9) viene portata a massa (spento)

digitalWrite(speakerPin,LOW);

per una quantit di tempo pari al periodo:

delayMicroseconds(delayAmount);

La variazione del timbro della nota avviene se utilizzate la modulazione di larghezza di impulso in inglese Pulse Width Modulation, in questo modo se il treno di impulsi sufficientemente elevato l’orecchio umano non percepir una sequenza di impulsi ma un suono costante.

Arduino LilyPad – lezione 03: controlliamo l’accensione di un led con un pulsante

Questa lezione ha lo scopo di realizzare un sistema che rilevi il cambiamento di stato e per far ciò costruiremo un rudimentale pulsante con due fili alle cui estremità vi sono delle pinzette a coccodrillo, quando i due fili saranno collegati, vorrà dire che il pulsante è chiuso, quando i due fili saranno scollegati il pulsante sarà aperto.

Per questo esperimento utilizzeremo due connettori alle cui estremità sono collegati dei morsetti a coccodrillo, prima di procedere vi consiglio di ritagliare una cartoncino di forma circolare con stesse dimensioni di LilyPad, ciò eviterà che le pinzette scivolino e che grattino la base inferiore isolata della scheda.

Passo 1

avrete bisogno di:

  • un cartoncino
  • una matita
  • un paio di forbici

tracciate una circonferenza prendendo come riferimento LilyPad

Passo 2

ritagliate lungo il bordo, fate in modo che la circonferenza tagliata sia leggermente più grande.

Passo 3

In questo modo il morsetto a coccodrillo dovrebbe avere una presa sicura senza il pericolo di scivolare e buon contatto elettrico.



Procedete allo stesso modo per i sensori e gli attuatori che collegherete a LilyPad mediante le pinzette a coccodrillo, anche per essi ritagliate dei cartoncini anti scivolamento.

Programmazione

Passo 1

Collegate un coccodrillo nero al morsetto negativo (indicato con -) ed il coccodrillo bianco al morsetto digitale 2, come indicato nell’immagine:

Quando collegate i due coccodrilli insieme vorrà dire che chiudete il circuito (interruttore chiuso) ed elettricamente vuol dire che collegate il pin digitale 2 direttamente a terra o “-“.

Vi ricordo che in Arduino “-” vuol dire “terra” e in Processing viene rappresentato con “LOW”, mentre “+” o “+5V” e in Processing  viene indicato con “HIGH”.

Passo 2

copiate il codice che segue in una finestra vuota:

int ledPin = 13;	                    // il LED e' connesso al pin digitale 13
int switchPin = 2;	                    // switch e' connesso al pin digitale 2
int switchValue;	                    // una variabile che tiene traccia quando il pulsante viene premuto

void setup()
{
  pinMode(ledPin, OUTPUT);	            // ledPin viene definito come pin di output
  pinMode(switchPin, INPUT);	            // switchPin viene definito come pin di input
  digitalWrite(switchPin, HIGH);            // poniamo di default switchPin ad HIGH (non premuto)
}	 

void loop()                                 // loop del programma
{
  switchValue = digitalRead(switchPin);	    // verifica se il pulsante e' premuto
  if (switchValue == LOW) {	            // se il pulsante e' premuto allora,
    digitalWrite(ledPin, HIGH);	            // accende il LED
  }
  else {	                            // altrimenti,
    digitalWrite(ledPin, LOW);	            // il led viene spento
  }
}

All’interno del loop:

viene memorizzato lo stato del pulsante in switchValue con

switchValue = digitalRead(switchPin);

Se il pulsante non è premuto switchValue assumerà il valore assegnato nel setup():

digitalWrite(switchPin, HIGH);

Poiché il circuito non è chiuso verso terra il LED rimarrà spento.

La condizione dell’IF:

..(switchValue == LOW)..

non risulta vera e quindi sarà eseguita la parte else dell’IF

digitalWrite(ledPin, LOW);

cioè il LED risulterà spento.

Se colleghiamo i coccodrilli, switchValue assumerà il valore “LOW” in quanto collegato direttamente alla terra (morsetto nero) e la condizione dell’IF

if (switchValue == LOW)

risulterà verà e quindi sarà eseguita la parte del codice:

digitalWrite(ledPin, HIGH);

e quindi il LED verrà acceso.

Bene! avete realizzato il vostro secondo scketch per LilyPad.

Nelle successive lezioni vedremo come collegare altri sensori ed attuatori a LilyPad.

Arduino LilyPad – lezione 02: facciamo lampeggiare un led

Installazione IDE Arduino

Per l’installazione dell’IDE prendete come sempre riferimento le guide sul sito Arduino oppure quelle che trovate su questo sito:

Installazione su Mac OS X
Installazione UBUNTU

Configurazione IDE

Di seguito trovate i passi per selezionare la porta seriale e la scheda dall’IDE Arduino per Mac OS X, per gli altri sistemi operativi il procedimento è analogo, seguite le istruzioni che trovate su questo sito facendo attenzione a selezionare la porta seriale e la scheda corretta.

Collegate il vostro LilyPad al computer ed avviate l’IDE Arduino.

Noterete, non appena collegate il cavo USB al computer i led TX e RX disposti sull’adattatore USB incominciano a lampeggiare, così come il led su LilyPad, dopo qualche secondo si spengono.

Selezionate la scheda: Tools -> Board -> LilyPad Arduino w/ ATmega328

Selezionate la porta seriale corretta: Tools -> Serial Port -> /dev/tty.usbserial-A8004wec

Esempio di programmazione: il nostro “amico” blink

La programmazione del dispositivo è identica a quella che potreste fare su qualsiasi altra scheda Arduino e quindi potete tranquillamente seguire il corso che trovate su questo sito facendo le dovute modifiche rispetto alla piedinatura.
Per questa breve introduzione userò il solito programma Blink.

Dagli esempi aprite lo sketch Blink:

File -> Example -> 1.Basic -> Blink

Lo sketch Blink:

Compilate il programma:

Se tutto va a buon fine al fondo della finestra apparirà il messaggio: “Done compiling”

Effettuate l’upload dello sketch sulla scheda, mentre viene effettuatta questa operazione lampeggiano i led RX e TX e dopo qualche istante lampeggerà il led sulla scheda:

Fate attenzione se vi compaiono messaggi di errore in fase di uloading è molto probabile che abbiate selezionato una porta seriale non corretta:

Se tutto a ha buon fine comparirà il messaggio “Done uploading”

Bene! Avete realizzato il vostro primo programma per LilyPad.

Arduino LilyPad – lezione 01: conoscere la scheda

Durante il prossimo anno scolastico continuerò il corso su Arduino e sperimenterò con i miei allievi anche l’uso di LilyPad, vorrei realizzare un progetto che sto portando avanti da qualche tempo che riguarda la realizzazione di un sistema indossabile per il rilevamento istantaneo di alcune grandezze fisiche che dovranno essere tradotte in tempo reale in grafici su computer e report su web.

Le lezioni su LilyPad che pubblicherò nei prossimi giorni su questo sito, saranno utilizzate durante il prossimo anno scolastico e potranno essere suscettibili di modifiche ed integrazioni. Tutte le lezioni su LilyPad, articoli e commenti importanti saranno accessibili direttamente dalla sezione: Impariamo ad usare Arduino dove trovate anche le lezioni che sto realizzando su Arduino UNO, dispense e link a risorse gratuite.

Queste lezioni prendono spunto dal tutorial che trovate al seguente link, a cui ho aggiunto esempi, filmati e dettagli tecnici.

I componenti utilizzati in questo tutorial sono stati acquistati sul sito SparkFun.

e per questo esempio ho utilizzato il kit: LilyPad Pro Kit in cui il microcontrollore sulla scheda LilyPad è l’ATmega328V.
La scheda LilyPad di questo kit corrisponde alla revision 4 (indicata sul sito arduino.cc come LilyPad Arduino 04)

Arduino LilyPad è una scheda studiata appositamente per applicazioni creative che possono essere indossate, infatti la scheda ha la possibilità di essere cucita su tessuti e i vari dispositivi possono essere interconnessi tra di loro mediante filo da sartoria conduttivo. Ha una forma circolare con diametro di 50 mm, spessore 0,8 mm.

LilyPad può essere programmato con il software Arduino dalla versione 10.0 o superiori.
La scheda può essere alimentata attraverso la presa USB del computer o mediante alimentazione esterna (mediante apposito adattatore). Può funzionare nel range di tensione che va da 2,7 a 5 V.
Rispetto alle altre schede Arduino, LilyPad risulta molto più fragile, inoltre fate attenzione a non superare la tensione di alimentazione di 5 V, rischiereste di romperla.
Maggiori informazioni sulle caratteristiche tecniche potete trovarle seguendo il link, se volete una prima guida seguite invece questo link, mentre per un tutorial andate qui.

Per quanto riguarda la piedinatura fate riferimento alle due immagini che vi allego:

fonte: westfw via Arduino forum

fonte: oreilly.com

Quindi l’elenco dei piedini è il seguente:

Piedino 1 – TX/D1
Piedini 2,3,4 – D2, D3, D4
Piedino 5 – GND o “-” (terra)
Piedino 6 – Vcc o “+” (alimentazione)
Piedino 7,8,9,10,11,12,13,14,15 – piedini digitali da D5 a D13
Pins 16,17,18,19,20,21 – piedini analogici da A0 a A5

Connettore superiore:

Piedino 1 – DTR
Piedino 2 – RX1
Piedino 3 – TX0
Piedino 4 – VCC
Piedino 5 – CTS (collegato a massa)
Piedino 6 – GND

Collegamento al computer

LilyPad può essere connessa al computer utilizzando i 6 pin che trovate sopra la scheda (nel mio caso):

Le modalità di collegamento sono 2:

FTDI Basic Breakout – 3.3V quella utilizzata da me.

USB FTDI TTL-232 cable – TTL-232R 3.3V

Se la vostra scheda è dotata di 4 connettori ed appartenente alla revision 2, allora per poterla collegare al computer dovete seguire il tutorial che trovate al seguente link.

Nella prossima lezione incominceremo a programmare!