Crea sito

Avarage

By ArduinoTutorial aprile 1st, 2011, under Avarage

In questo tutorial costruiamo un circuito in cui collegare un qualsiasi sensore al pin analogico 0, leggiamo 10 valori e ne calcoliamo la media.

Il codice da scrivere è il seguente:

#define NUMREADINGS 10  //10 valori da leggere
#define inputPin 0 //Sensore collegato al pin analogico 0
int readings[NUMREADINGS];  //Letture dal input analogico
int index = 0;  //Indice della lettura corrente
int total = 0;  //Totale letture
int average = 0;  //Media

void setup()
{
     Serial.begin(9600);
     for (int i = 0; i < NUMREADINGS; i++)
         readings[i] = 0;  //Mette tutti 0 nell'array
}

void loop()
{
     total -= readings[index];  //Sottrae l'ultima lettura
     readings[index] = analogRead(inputPin);  //Legge i valori provenienti dal sensore e li salva nell'array
     total += readings[index];  //Aggiunge la lettura al totale
     index = (index + 1);  //Incrementa l'indice
 
     if (index >= NUMREADINGS)
        index = 0;  //Alla fine dell'array resetta l'indice a 0
 
     average = total / NUMREADINGS;  //Calcola la media
     Serial.println(average); //Stampa la media
}

Analisi codice:

1- i++; equivale a dire i:   i = i + 1;

2- i–; equivale a dire i: i = i -1;

3- x += y; equivale a dire x = x + y;

4- x -= y; equivale a dire x = x – y;

5- x *= y; equivale a dire x = x * y;

6- x /= y; equivale a dire x = x / y;


 
				

				
				

Serial

By ArduinoTutorial aprile 1st, 2011, under Serial()

Serial è una libreria (ossia un insieme di funzioni) usata per fare comunicare arduino e il computer attraverso specifici comandi. Sulla scheda sono presenti due led con la scritta RX e TX che lampeggiano a seconda delle istruzioni scritte nel nostro programma. Il primo indica la ricezione mentre il secondo la trasmissione di dati. E possibile vedere la ricezione e/0 la trasmissione di dati nell’IDE di arduino, per vederli bisogna scrivere un apposito programma, fare l’upload su arduino e cliccare su Serial monitor dell ide:

Ora vediamo i due comandi principali:

1-begin(): La sintassi è Serial.begin(velocità), in pratica consente di impostare la velocità di trasmissione di dati seriali in bit/s (baud). Le velocità per la comunicazione sono: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200 solitamente si usa la 9600, bisogna solo controllare come è stata impostata la porta COM in Windows.

2-print(): La sintassi è Serial.print(valore, formato), serve a stampare a video un messaggio o una variabile in un determinato formato. Vediamo un paio di esempi:

Serial.print(78) scrive “78″
Serial.print(1.23456) scrive “1.23″
Serial.print(byte(78)) scrive “N” (78 è il valore ASCII)
Serial.print(‘N’) scrive “N”
Serial.print(“Hello world.”) scrive “Hello world.”
Serial.print(78, BYTE) scrive “N”
Serial.print(78, BIN) scrive “1001110″
Serial.print(78, OCT) scrive “116″
Serial.print(78, DEC) scrive “78″
Serial.print(78, HEX) scrive “4E”
Serial.print(1.23456, 0) scrive “1″
Serial.print(1.23456, 2) scrive “1.23″
Serial.print(1.23456, 4) scrive “1.2346″

Un’altra funzione simile a print è Serial.println() serve sempre a stampare a video, la differenza tra le due e che la prima scrive sempre sulla stessa riga mentre la seconda va a capo ogni volta. Le regole di sintassi di Serial.println() sono le stesse di Serial.print().

Knock

By ArduinoTutorial aprile 1st, 2011, under Knock

In questo tutorial usiamo un componente piezoelettrico per rilevare il suono. Un componente piezoelettrico non è altro che un dispositivo elettronico che può sia essere utilizzato per riprodurre i toni sia per rilevare i toni. Un esempio é questo:

Nel nostro tutorial collegheremo il Piezo in uno dei pin di ingresso analogici. Una cosa da ricordare è la loro polarità, hanno di solito un filo rosso e uno nero che indica come collegarlo alla scheda. Colleghiamo il nero a GND e il rosso in un pin analogico, infine dovremo anche collegare una resistenza nel range dei megaohm in parallelo all’elemento piezoelettrico.

Il circuito da fare è il seguente:

La resistenza in parallelo al piezo e nel range dei megaohm mentre la resistenza in serie al led è sempre la solita. Il filo rosso della resistenza di X megaohm và collegata al pin analogico 0.

Ora dobbiamo scrivere il seguente codice:

#define ledPin 13  //Led connesso al pin 13
#define knockSensor 0  //Sensore connesso al pin analogico 0
byte val = 0;  //Variabile per salvare il valore del sensore
int statePin = LOW;  //Variabile usato per salvare l'ultimo stato del led
int THRESHOLD = 100;  //Valore di soglia per decidere quando un suono è stato rilevato da un colpo o non

void setup()
{
     pinMode(ledPin, OUTPUT);  //Dichiaro il ledPin come OUTPUT
     Serial.begin(9600);  //Uso la porta seriale
}

void loop()
{
     val = analogRead(knockSensor);  //Legge il valore del sensore e lo salva
     if (val >= THRESHOLD)
     {
         statePin = !statePin; //Inverte lo stato del pin
         digitalWrite(ledPin,statePin);  //Accende o spegne il led
         Serial.println("Knock!");  //Invia al terminale la scritta
         delay(10);
     }
}

In pratica questo programma serve a rilevare un suono, per esempio potremmo incollare il piezo alla porta e ogni volta che qualcuno bussa, il programma scriverà sul serial monitor la parola Knock! e accenderà un led.

Analisi del codice:

1-Serial(): Per questa funzione ho realizzato un tutorial a parte raggiungibile qui.

Fading

By ArduinoTutorial marzo 31st, 2011, under Fading

Ciao a tutti, in questo tutorial vedremo come creare un effetto dissolvenza su un led grazie ai pin PWM. Questa volta il led lo collegheremo (sempre con la sua resistenza in serie) al pin digitale 9. Vi starete chiedendo perchè il pin digitale se il tutorial è nella categoria dei pin analogici?

Ve lo spiego subito, in pratica la scheda Arduino UNO è dotata di 14 pin digitali di cui 5 contrassegnati con il simbolo ˜ vicino al suo corrispettivo numero.

I pin sono: 11, 10, 9, 6, 5, 3;

Questi pin sono in grado di fornire un segnale PWM(Pulse-width modulation) in italiano modulazione di larghezza di impulso, ed è un tipo di modulazione analogica in cui l’informazione è codificata sotto forma di durata nel tempo di ciascun impulso di un segnale.

Ora passiamo al circuito, colleghiamo come abbiamo sempre fatto la resistenza al led e poi al pin 9 infine non ci rimane che scrivere il nostro programma:

int value = 0;  //Variabile per tenere l'attuale valore
#define ledpin 9  //Led connesso al pin 9

void setup()
{
}
void loop()
{
     //Dissolvenza
     for (value = 0; value <= 255; value+=5)
     {
         analogWrite(ledpin, value);  //Setto il valore sul led da 0 a 255
         delay(30);
     }
 
     for (value = 255; value >= 0; value-=5)
     {
         analogWrite(ledpin, value);
         delay(30);
     }   
}

Non credo ci sia nulla da spiegare su codice tranne per il fatto che se avete notato non ho scritto nulla all’interno di setup, il motivo è che quando si tratta di pin analogici non c’è bisogno di dichiararli ne come INPUT ne come OUTPUT.

Ingresso analogico

By ArduinoTutorial marzo 31st, 2011, under Ingresso analogico

Ciao a tutti, la serie di tutorial riguardanti la categoria Digital I/O è finita, ora incominciamo a parlare degli Analog I/O.

Partiamo con il dire che un segnale analogico può assumere tutti i valori compresi tra 0V e +5V (nel caso della nostra scheda Arduino), a differenza del segnale digitale che può assumere solo due valori 0V e +5V.

Questo tutorial vuole spiegare come collegare un potenziometro alla scheda arduino e a seconda del valore che il potenziometro assume, modificare la velocità di lampeggio di un led.

Ci serve un qualsiasi tipo di potenziometro e come sempre un led con la sua resistenza da mettere in serie.

Un potenziometro è una resistenza variabile dotata di tre pin esterni:

Il circuito da realizzare è il seguente:

Quindi come potete vedere colleghiamo il potenziometro nel modo seguente: il pin sinistro al +5V il pin centrale al pin analogico 2 e il pin destro al GND mentre la resistenza e il led come abbiamo sempre fatto.

Passiamo al codice sorgente:

#define potPin 2  //Pin di ingresso per il potenziometro
#define ledPin 13  //Pin per il led
int val = 0;  //Variabile per salvare lo stato proveniente dal sensore

void setup()
{
     pinMode(ledPin, OUTPUT);  //Dichiara il ledPin come OUTPUT
}

void loop()
{
     val = analogRead(potPin);  //Legge il valore dal sensore
     digitalWrite(ledPin, HIGH);  //Accende il led
     delay(val);  //Ritardo a seconda del valore del sensore
     digitalWrite(ledPin, LOW); //Spegne il led
     delay(val);  //Ritardo a seconda del valore del sensore
}

Analisi del codice sorgente:

1- analogRead(): Questa funzione restituisce un numero compreso tra 0 e 1023 che è proporzionale alla quantità di tensione applicata al  pin. Ossia varia tra 0 = 0V e 1023 = 5V. Il programma scritto prende questo valore e lo mette all’interno della funzione delay(), in questo modo si va a modificare la velocità di lampeggio del led.

Visto che la funzione analogRead() restituisce un numero compreso tra 0 e 1023 se volessimo conoscere a che valore di tensione corrisponde un dato numero basta impostare una semplice proporzione:

1023 : 5 = x : Xv   dove

x = numero restituito dalla funzione

Xv = tensione corrispondente

quindi per calcolarla: Xv = (5 * x) / 1023

Loop

By ArduinoTutorial marzo 30th, 2011, under Loop

Ciao a tutti, il titolo del tutorial si chiama Loop anche se sinceramente mi piace di più chiamarlo Supercar, la serie televisiva girata nel 1983 dove c’era la macchina Kitt dotata di un’ intelligenza artificiale (a cui ci sto lavorando per crearla ;)) e davanti al cofano aveva una serie di led rossi che si accendevano in sequenza. L’esempio che vediamo in questo tutorial fa uso di sei LED collegati ai pin da 2 a 7 in serie con sei resistenze da 220 ohm. Lo scopo del codice , da scrivere, sarà quello di far lampeggiare i LED in sequenza, uno dopo l’altro utilizzando due funzioni già conosciute: digitalWrite() e delay().

Il circuito da costruire è il seguente:

Fate attenzione come collegate i led…

Ora vediamo il codice da scrivere:

#define timer 100  //Tempo di ritardo
#define num_pins 6  //Numero dei pins
int pins[] = { 2, 3, 4, 5, 6, 7 };  //Array dei pin
int i;
void setup()
{
     //Dichiara tutti i pins come OUTPUT
     for (i = 0; i < num_pins; i++)
         pinMode(pins[i], OUTPUT);
}
void loop()
{
     int i;
     //loop per accendere e spegnere i led
     for(i = 0; i < num_pins; i++)
     {
         digitalWrite(pins[i], HIGH);
         delay(timer);
         digitalWrite(pins[i], LOW);
     }
     for (i = num_pins - 1; i >= 0; i--)
     {
         digitalWrite(pins[i], HIGH);
         delay(timer);
         digitalWrite(pins[i], LOW);
     }
}

Analisi del codice:

-int pins[] = { 2, 3, 4, 5, 6, 7 };: In questo modo definiamo un array di numeri interi, ossia possiamo immaginarlo come una cassettiera che contiene n cassetti contente un numero per ogni cassetto. Come vedete ci sono dei cicli for nel codice che “aprono un cassetto” alla volta estraendo il numero dell i-esimo cassetto, in questo modo vengono richiamati i numeri dell’array. Non sò se sono stato chiaro e semplice, ad ogni modo vi faccio un piccolo schemino che vi può essere utile in questo esempio e in altri.

Costruiamo un array di 6 numeri contente i numeri da 2 a 7:

Da scrivere nel codice:  int pins[] = { 2, 3, 4, 5, 6, 7 }

Rappresentazione: Cassetti                      1      2      3      4    | 5|    6

N° nei cassetti                                        2      3      4      5    |6 |    7

Richiamiamo il numero nel cassetto N° 5:

da scrivere nel codice:  int n = pins[5];   //n diventa uguale a 6

Come vedete un numero dentro un array lo possiamo richiamare con  un ciclo for oppure nel modo detto sopra.

Debounce

By ArduinoTutorial marzo 30th, 2011, under Debounce

Ciao a tutti, oggi parliamo del debounce ossia in italiano anti-rimbalzo. Nel terzo tutorial abbiamo visto come è possibile far accendere e spegnere un led tramite un pulsante, se noi quel pulsante lo premiamo e lo rilasciamo molto velocemente possiamo notare delle cose strane, ad esempio il led rimane sempre acceso o viceversa. Questo fenomeno capita a causa della velocita di lettura del pulsante. In parole semplici per brevi tempi arduino non capisce se abbiamo effettivamente premuto il pulsante oppure no. La cosa migliore da fare, per risolvere il problema, è fare uso della funzione millis() per tenere traccia del tempo in cui si preme il pulsante. Il circuito da fare rimane lo stesso del tutorial 3. Vediamo ora il codice da scrivere sull’IDE:

#define inPin 2  //INPUT PULSANTE
#define outPin 13  //OUTPUT LED
#define debounce 200  //Tempo di rimbalzo
int state = HIGH;  //Stato del pin OUTPUT LED
int reading;  //Lettura corrente del pin INPUT PULSANTE
int previous = LOW;  //Lettura precedente del pin INPUT PULSANTE
long time = 0;  //Ultimo tempo in cui il pin di OUTPUT è stato attivato

void setup()
{
     pinMode(inPin, INPUT);  //Imposto il pulsante come INPUT
     pinMode(outPin, OUTPUT);  //Imposto il LED come OUTPUT
}

void loop()
{
     reading = digitalRead(inPin);  //Leggo il valore in ingresso dato dal pulsante

     //Se abbiamo premuto in pulsante (HIGH) e la volta prima il suo stato
     //era LOW ed è trascorso il tempo necessario
     if (reading == HIGH && previous == LOW && millis() - time > debounce) {
         //Inverte l'OUTPUT
         if (state == HIGH)
             state = LOW;
         else
             state = HIGH;

         //Ricorda quando l'ultima volta è stato premuto il pulsante  
         time = millis();
     }

 digitalWrite(outPin, state);  //Scrivo lo stato sul LED

 previous = reading;
}

In pratica il programma legge il valore del pulsante poi passa dentro l’IF  e controlla lo stato della lettura e guarda se è trascorso il tempo necessario, se la condizione è vera allora esegue le azioni al suo interno invertendo lo stato di uscita per il led, altrimenti esce e registra lo stato corrente nelle stato passato, è un pò difficile da spiegare ma spero si sia capito ;)

Ora per chi non sa cosa sia questo simbolo && integro qui dentro la spiegazione degli operatori booleani:

&&  = (and) in italiano e

|| = (or) in italiano o

! = (not) in italiano no

E’ piu semplice spiegarli con degli esempi:

&&:     if ( a == 2 && b == 3)     Se a è uguale a 2 e b è uguale a 3

||:     if ( a == 2 || b == 3)     Se a è uguale a 2 o b è uguale a 3

!:     if (!x){Azioni}   La condizione è vera se x è falsa, ossia vengono eseguite le azioni tra le parentesi {} solo le x è falsa

Resistenza di pull-up/down

By ArduinoTutorial marzo 29th, 2011, under Elettronica

Le resistenze di pull-up e pull-down sono usate nei circuiti elettronici per forzare un determinato stato logico in un punto, per eliminare fluttuazioni di corrente o ancora per evitare cortocircuiti quando si usano i pulsanti.

Ad esempio vediamo il caso più comune di applicazione di queste resistenze:

RESISTENZA DI PULL-UP: In uscita avremo lo stato logico HIGH senza premere il pulsante, premendo il pulsante avremo lo stato logico LOW.

RESISTENZA DI PULL-DOWN: In uscita avremo lo stato logico LOW senza premere il pulsante, premendo il pulsante avremo lo stato logico HIGH

Micro pulsante

By ArduinoTutorial marzo 29th, 2011, under Elettronica

Il pulsante è un’apparecchiatura elettromeccanica simile all’interruttore, ma con una molla che lo riporta alla posizione di partenza appena viene rilasciato.

Si suddividono in due tipi:

  • Normally open (NO): Pulsante normalmente aperto dove i piedini A e C, B e D sono connessi tra loro, appena premiamo il pulsante tutti i piedini sono connessi tra loro.

  • Normally closed (NC): Pulsante normalmente chiuso dove tutti i piedini sono connessi tra loro, appena premiamo il pulsante tutti piedini non saranno connessi tra di loro ma solo A e C, B e D.

Pulsante

By ArduinoTutorial marzo 28th, 2011, under Pulsante

Il pulsante è un componente che collega due punti in un circuito quando viene premuto. Il circuito e il programma che faremo consentirà di accendere un LED quando si preme il pulsante. Dobbiamo collegare tre cavi alla scheda Arduino:

Il primo va da un piedino del pulsante attraverso una resistenza di pull-down di 2,2 KOhm al GND. Il secondo va dall’altro piedino corrispondente del pulsante al +5V. Il terzo si connette al pin digitale 2 che legge lo stato del pulsante. Poi bisogna ancora connettere il led con una resistenza da 330 Ohm al pin digitale 13.

Quando il pulsante è aperto (ossia non premiamo) non vi è alcuna connessione tra i due piedini del pulsante e leggeremo un valore HIGH. Quando il pulsante viene chiuso (ossia premiamo), leggeremo un valore LOW. È inoltre possibile collegare questo circuito in senso opposto, con una resistenza di pull-down in modo da avere l’effetto controria ossia quando viene premuto il pulsante avremo un valore HIGH e viceversa.

Il circuito da realizzare è il seguente:

Dove la resistenza in serie al led è di 330 Ohm mentre la resistenza di pull-down è di 2,2 KOhm.

Passiamo al codice, apriamo il IDE e scriviamo il seguente codice:

 #define ledPin 13  //Pin digitale 13 per il led
 #define buttonPin 2  //Pin digitale 2 per il bottone
 int buttonState = 0;  //Variabile per la lettura dello stato del pin

 void setup()
 {
     pinMode(ledPin, OUTPUT);  //Dichiaro il pin 13 come output
     pinMode(buttonPin, INPUT);  //Dichiaro il pin 2 come input
 }

 void loop()
 {
     buttonState = digitalRead(buttonPin);  //Legge il valore del pulsante, ossia il valore del pin 2
     //Controllo lo stato del pulsante
     if (buttonState == HIGH)
         digitalWrite(ledPin, LOW);  //Spengo il led
     else
         digitalWrite(ledPin,HIGH);  //Accendo il led
 }

1-digitalRead(): Legge il valore proveniente da un pin digitale. Trattandosi di un pin digitale può leggere solo due valori: HIGH o LOW. La sintassi è la seguente: digitalRead(pin);

2-buttonState == HIGH: Faccio notare la differenza tra scrivere buttonState == HIGH e buttonState = HIGH: il primo confronta se buttonState è uguale al valore HIGH mentre il secondo assegna a buttonState il valore HIGH.