Archive for marzo, 2011

Fading

giovedì, marzo 31st, 2011

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

giovedì, marzo 31st, 2011

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

mercoledì, marzo 30th, 2011

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

mercoledì, marzo 30th, 2011

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

martedì, marzo 29th, 2011

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

martedì, marzo 29th, 2011

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

lunedì, marzo 28th, 2011

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.

Funzione millis()

lunedì, marzo 28th, 2011

Per far lampeggiare un led, al posto di usare la funzione delay() possiamo utilizzare anche la funzione millis(). Questa funzione restituisce il numero di millisecondi da quando la scheda Arduino ha iniziato l’esecuzione del programma. Dopo 50 giorni che la scheda non viene spenta questo numero ritorna a 0. Per usare questa funzione si può ad esempio scrivere int tempo = millis(); dove in pratica la funzione restituisce un numero in millisecondi e lo immagazina all’interno della variabile tempo.

Vediamo ora come possiamo far lampeggiare il led usando questa funzione.

Lo schema elettrico per collegare il led è lo stesso usato nel primo tutorial Hello World mentre il codice da scrivere nell’IDE cambia.

Codice:

#define ledPin 13  //LED connesso al pin digitale 13
#define interval 1000  //Intervallo di tempo per  far lampeggiare il LED(millisecondi)
int value = LOW;  //Valore precedente del LED
long previousMills = 0;  //Memorizza l'ultima volta che il led è stato aggiornato

void setup()
{
     pinMode(ledPin, OUTPUT);  //Impostiamo il led come output
}

void loop()
{
     if (millis() -  previousMills > interval ){
         previousMills = millis();  //Tiene in memoria l'ultimo lampeggio

         //Se il LED è spento lo accende e viceversa
         if (value == LOW)
             value = HIGH;
         else
             value = LOW;

         digitalWrite(ledPin, value);
     }
}

Analisi del codice:

1-Struttura IF/ELSE:

if (variabile < 500)
{
  // Azione A
}
else
{
  // Azione B
}

L’IF è un controllo, tradotto in parole povere significa che controlla se una variabile è minore, maggiore o uguale ad un numero, se la condizione è verificata esegue l’azione A altrimenti esegue l’azione B.

2- if (millis() –  previousMills > interval ): Fà la differenza tra il tempo attuale e il tempo precedente in cui stato acceso il led e controlla se è necessario accendere oppure no il led dopo un tempo (interval) di un secondo.

Hello World!

lunedì, marzo 28th, 2011

Nella maggior parte dei linguaggi di programmazione, il primo programma che  si scrive è la stampa della scritta “Hello World!” sullo schermo. Dal momento che una scheda Arduino non dispone di uno schermo, noi ci limiteremo a far lampeggiare un LED. Avremo bisogno di una scheda Arduino UNO, un led rosso o di altri colori che preferite e di una resistenza da 330 ohm  che andremo a collegare in serie al led.

Il collegamento da effettuare sulla scheda è questo:

In pratica abbiamo collegato il led in serie ad una resistenza, dove il piedino meno del led và messo al GND mentre il piedino della resistenza và collegato al pin digitale 13.

Per comodità vi allego una foto su come collegare i led:

Se il led non si dovesse accendere è perchè, probabilmente, lo avete collegato al contrario.

Ora passiamo ad aprire il nostro IDE per programmare Arduino:

Un consiglio che mi sento di darvi è quello di non fare copia e incolla ma di scrivere le varie parti del codice a mano in modo da poter imparare la sintassi delle varie funzioni.

Il codice da scrivere è il seguente:

#define ledPin 13  //LED connesso al pin digitale 13
void setup()
 {
     pinMode(ledPin, OUTPUT);  //Imposto il LED come output
 }
void loop()
 {
     digitalWrite(ledPin, HIGH);  //Accendo il LED
     delay(1000);  //Aspetto un secondo  1000ms = 1s
     digitalWrite(ledPin, LOW);  //Spengo il LED
     delay(1000);  //Aspetto un secondo
 }

Analisi codice:

1- setup (): E’ una funzione che viene chiamata quando si avvia lo sketch. Si usa per inizializzare le variabili,  i pin,  iniziare ad usare le librerie. La funzione di setup viene eseguita una sola volta, dopo ogni accensione o reset della scheda Arduino.

2-pinMode(): Dice ad un pin specifico come comportarsi,  ossia come ingresso(INPUT) o come uscita(OUTPUT). La sintassi è la seguente: pinMode(pin, mode);

3-loop(): Dopo aver creato la funzione setup (), che inizializza e imposta i valori iniziali, la funzione loop () fa esattamente quello che suggerisce il suo nome, ossia il vostro programma gira all’infinito eseguendo le operazioni che sono state scritte al suo interno.

4-digitalWrite(): Questa funzione scrive sul pin desiderato un valore alto (HIGH) oppure basso (LOW). Dove per valore alto si intende +5V mentre per valore basso si intende 0V. La sintassi è la seguente: digitalWrite(pin, valore);

5-delay(): Questa funzione imposta un ritardo in millisecondi tra una funzione è l’altra. La sintassi è la seguente: delay(ms);

6-#define: Serve a definire una costante. Si definisce sempre all’inizio del programma. La sintassi è la seguente: #define costante valore

Per definire il pin che vogliamo usare possiamo anche dichiararlo nella funzione setup() come int ledPin = 13; così facendo dichiariamo una variabile, il che non ha molto senso visto che un pin non cambia mai il proprio identificativo. Inoltre dichiarare il pin con #define ci consente di risparmiare memoria su arduino.

Cosa è Arduino

lunedì, marzo 28th, 2011

Arduino è una semplice ma potente piattaforma hardware, basata su una semplicissima scheda I/O che grazie alla libreria Wiring ci consente di programmarla.

Questa è la scheda Arduino UNO

La scheda consiste in un microcontroller della Atmel, nello specifico l’ATmega328. Offre 14 connettori per l’I/O digitale, 6 dei quali possono produrre segnali PWM, mentre 6 sono dedicati a ingressi di segnali analogici.

Il tutto è possibile collegarlo al computer tramite un cavo usb e per poterla programmare abbiamo bisogno di scaricare l’IDE di Arduino, disponibile sul sito ufficiale.