domenica 30 giugno 2013

Arduino Tutorial 15: Sensore a Forcella

I sensori a forcella appartengono al gruppo dei sensori di posizione.   
Possono essere utilizzati per esempio come encoder per rilevare quante rotazione compie una ruota e risalendo tramite il suo diametro alla lunghezza del percorso compiuto.
Quando il fascio luminoso emesso dal LED IR è bloccato a causa di alternanza slot del livello logico disco encoder dei cambiamenti fotodiodo. Questo cambiamento nel livello di logica può essere percepito dal microcontrollore.

Questo tipo di sensore si compone di LED IR e un fototransistor montato uno di fronte all'altro racchiusi in un contenitore plastico, viene usato un fascio di raggi infrarossi, in quanto questa radiazione difficilmente si confonde con i disturbi generati da fonti luminose ambientali.
Il LED IR è un diodo ad emissione luminosa (acronimo inglese di Light Emitting Diode) in pratica è un dispositivo optoelettronico che sfrutta le proprietà ottiche di alcuni materiali semiconduttori per produrre fotoni attraverso il fenomeno dell'emissione spontanea ovvero a partire dalla ricombinazione di coppie elettrone-lacuna.   In questo caso l'emissione avviene nel campo delle radiazioni infrarosse.   Nel sensore EE-SX129 il picco è a 920 nm.
Un fototransistor in sostanza è un transistor a giunzione bipolare realizzato in modo che la luce possa raggiungere la giunzione del collettore di base.
l fototransistor hanno prestazioni simili a quelle di un fotodiodo, ma con una sensibilità alla luce molto maggiore, grazie al fatto che gli elettroni che sono generati dai fotoni nella giunzione del collettore di base sono iniettati nella base e la corrente così prodotta viene successivamente amplificata dalle funzioni del transistor. Per contro un fototransistor ha una risposta nel tempo molto meno rapida del fotodiodo.


Elenco dei componenti

R1 330Ώ ¼W
R2 47kΏ ¼W
Sensore a forcella
JP1
Jumper
Connettore maschio 4 pin polarizzato




Schema


Realizzazione

Per la costruzione della scheda si procederà alla realizzazione del circuito stampato con il metodo della fotoincisione o del trasferimento termico.



Si passerà quindi alla foratura e al successivo posizionamento e saldatura dei componenti seguendo il layout visibile sotto.


Adesso che il circuito è pronto non ci resta che caricare lo sketch.

Sketch

/*
 Test_sensore_forcella.pde
 Il programma permette il test di un sensore a forcella
 composto da un'emettitore IR e un ricevitore IR montati
 nello stesso involucro.In questo esempio l'emettitore
 e sempre attivo. 
 Il funzionamento è mostrato con l'accensione del led montato
 sulla scheda quando il raggio è interrotto.    Viene anche trasmesso
 al PC lo stato del sensore visibile nella finestra monitor.
 
 Vengono utilizzati i seguenti pin
 Pin +5V         -> Alimentazione
 Pin GND         -> Alimentazione
 Pin Digital 2   -> Connesso al ricevitore IR
 Pin Digital 13  -> Led su scheda
 */

//Definizione dei pin utilizzati
#define SENSORE_PIN 2
#define LED_PIN 13 

//Tipo di sensore utilizzato?
//#define INVERTED 1
#define INVERTED 0

void setup()
{
  pinMode(SENSORE_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);  
  Serial.begin(9600);
  Serial.println("Inizio lettura sensore.");
}

void loop()
{
  if (digitalRead(SENSORE_PIN))
  {
    if (INVERTED)
    {
      Serial.println("Aperto.");
      digitalWrite(LED_PIN, LOW);
    }
    else
      Serial.println("Chiuso");
    digitalWrite(LED_PIN, HIGH); //Accensione led
  }
  else
  {
    if (INVERTED)
    {
      Serial.println("Chiuso");
      digitalWrite(LED_PIN, HIGH); //Accensione led
    }
    else
      Serial.println("Aperto");
    digitalWrite(LED_PIN, LOW);
  }
  delay(200);
}

Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.

lunedì 17 giugno 2013

Arduino Tutorial 14: Web Server Led on/off



in questo post vi mostrerò come comandare un led da una pagina web.





//ARDUINO 1.0+ ONLY
String readString;
#include <Ethernet.h>
#include <SPI.h>
boolean reading = false;

////////////////////////////////////////////////////////////////////////
//CONFIGURE
////////////////////////////////////////////////////////////////////////
  byte ip[] = { 192, 168, 1, 17 };   //Manual setup only
  byte gateway[] = { 192, 168, 1, 1 }; //Manual setup only
  byte subnet[] = { 255, 255, 255, 255 }; //Manual setup only

  // if need to change the MAC address (Very Rare)
  byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

  EthernetServer server = EthernetServer(80); //port 80
////////////////////////////////////////////////////////////////////////

void setup(){
  Serial.begin(9600);

  //Pins 10,11,12 & 13 are used by the ethernet shield

  pinMode(2, OUTPUT);//led
  

  Ethernet.begin(mac, ip, gateway, subnet);
  //Ethernet.begin(mac, ip, gateway, subnet); //for manual setup

  server.begin();
  Serial.println(Ethernet.localIP());

}

void loop(){


  // listen for incoming clients, and process qequest.
  checkForClient();

}

void checkForClient(){

  EthernetClient client = server.available();

  if (client) {

    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    boolean sentHeader = false;

    while (client.connected()) {
      if (client.available()) {

        if(!sentHeader){
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          client.println("<html>");
          client.println("<head><title>Arduino accendere e spegnere LED</title>");
          client.println("<center><h1>Accendere e spegnere LED</h1></center> </head>");
          client.println("<body>");
          
  client.println("<center>");   
  client.println("<table width=100>");
  client.println("<form METHOD=get action=\"\">");
  client.println("<input type=hidden name=\"c\" value=\"2\">");
  client.println("<input type=submit value=\"LED On\">");
  client.println("</form>");
  client.println();
  
  client.println("<form METHOD=get action=\"\">");
  client.println("<input type=hidden name=\"c\" value=\"3\">");
  client.println("<input type=submit value=\"LED Off\">");
  client.println("</form>");
  client.println();
  
  client.println("</table>");
  client.println("</center>");  
  
  client.println("</body>");
  client.println("</html>");
  
          sentHeader = true;
        }

        char c = client.read();

        if(reading && c == ' ') reading = false;
        if(c == '?') reading = true; //found the ?, begin reading the info

        if(reading){
          Serial.print(c);

           switch (c) {
            case '2':
              //add code here to trigger on 2
              digitalWrite(2, HIGH);
              break;
            case '3':
            //add code here to trigger on 3
              digitalWrite(2, LOW);
              break;
            
          }

        }

        if (c == '\n' && currentLineIsBlank)  break;

        if (c == '\n') {
          currentLineIsBlank = true;
        }else if (c != '\r') {
          currentLineIsBlank = false;
        }
if (c == '\n' && currentLineIsBlank)  break;

        if (c == '\n') {
          currentLineIsBlank = true;
        }else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }


    delay(1); // give the web browser time to receive the data
    client.stop(); // close the connection:

  } 

}


Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.

giovedì 13 giugno 2013

Arduino Tutorial 13: Ethernet shield

Eccoci di nuovo per un altro progetto con Arduino, oggi cercheremo di utilizzare la nostra bella schedina di sviluppo per creare, grazie all'unione di una ulteriore schedina, un server web direttamente a casa nostra!

La Ethernet Shield


Esistono migliaia di shield interfacciabili con l'Arduino, ognuna di queste è infatti studiata per diversi scopi. Una delle più interessanti è la Ethernet Shield, una schedina che si innesta direttamente sulla principale e permette di collegare Arduino ad una porta Ethernet, in modo da poterlo controllare via rete locale o via Internet.
La Ethernet Shield è provvista di un connettore RJ45 per la connessione diretta al modem di casa ed inoltre offre la possibilità di utilizzare uno slot microSD per lo scambio diretto di dati con un supporto di memorizzazione dedicato.
Attraverso questa shield è possibile creare oltre ad un piccolo server web (come vedremo tra poco), chatroom, webclient e chi più ne ha più ne metta!
La Ethernet Shield è dotata di un chip, il W5100 che non svolge solamente il ruolo di controller Ethernet, bensì ci permette anche di utilizzare la libreria Ethernet.h che ad oggi rimane la più intuitiva tra le librerie utilizzabili con i moduli Ethernet.



Sketch:

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
byte ip[] = { 192, 168, 1, 177 }; // indirizzo IP della shield
byte gateway[] = { 192, 168, 1, 1 }; // indirizzo ip del router
byte subnet[] = { 255, 255, 255, 0 }; //subnet mask
EthernetServer server(80); 

void setup(){
Ethernet.begin(mac, ip, gateway, subnet);
Serial.begin(9600);
}

void loop(){
EthernetClient client = server.available();
if (client) {
 boolean currentLineIsBlank = true;
 while (client.connected()) {
 if (client.available()) {
 char c = client.read();
 readString.concat(c); 

 if (c == '\n' && currentLineIsBlank) {

 Serial.print(readString);

 client.println("HTTP/1.1 200 OK");
 client.println("Content-Type: text/html");
 client.println();
 client.print("<html><head><title>Hello World</head><body>");
 client.println("</body></html>");
 readString="";
 client.stop();

 } 
 } 
 } 

}
Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.

domenica 9 giugno 2013

Arduino Tutorial 12: Display LCD Fotoresistenza e Termistore

Misureremo,  la quantità di luce attorno al nostro Arduino facendo uso di un fotoresistore e faremo lo stesso per la temperatura utilizzando un termistore.

MATERIALE UTILIZZATO:
  1. Arduino Uno
  2. Breadboard
  3. 1 Fotoresistore
  4. 1 Termistore
  5. 2 Resistori (10 Ohm)
  6. Cavetteria
  7. LCD I2C (OPZIONALE)

Per prima cosa,vediamo come collegare opportunamente i vari componenti fra loro con delle immagini:


Abbiamo utilizzato i cavi di colore rosso per identificare la tensione di 5V mentre i cavi neri per identificare la Terra (GND).
I cavi di colore giallo,invece,sono stati usati per identificare gli Output analogici provenienti dai sensori,che andranno inseriti appunto nei Pin analogici sulla nostra scheda Arduino.
Fatto ciò,passiamo al codice.
Per quanto riguarda il "void setup()",andremo a definire i due pin nei quali arrivano gli output dei sensori,come pin di INPUT e inizializzeremo il Seriale a 9600 baud:
  • void setup()
  • {
  •   Serial.begin(9600);
  •   pinMode(A0,INPUT);//pin di INPUT per il fotoresistore
  •   pinMode(A1,INPUT);//pin di INPUT per il termistore
  • }
     
Nel nostro "void loop()" invece,dobbiamo prima dutto leggere i valori che ci vengono forniti dai due sensori posti sulla Breadboard e successivamente stamparli.
Implementiamo prima una versione per chi fosse sprovvisto di LCD
 
  • void loop()
  • {   
  •     ValoreLuce=analogRead(A0); //ValoreLuce è una variabile di tipo INT dichiarata in precedenza(il fotoresistore fornisce valori interi da 0 a 1023)
  •     ValoreTemp=analogRead(A1);//ValoreTemp è una variabile di tipo INT dichiarata in precedenza
Fatto ciò,possiamo passare alla stampa :
  • Serial.print("Fotoresistore = ");
  • Serial.print(ValoreLuce);
  • Serial.print(" Temperatura = ");
  • Serial.println(ValoreTemp);
Possiamo infire definire un intervallo di Delay che permetterà al nostro Arduino di Trasmettere dati ogni TOT millisecondi:
delay(1000);//Esempio: Intervallo di 1 secondo
Per chi invece fosse provvisto di LCD,una possibile soluzione potrebbe essere la seguente(NB: Alcuni comandi potrebbero non funzionare in base alla libreria del proprio LCD.Si raccomanda,pertanto,di consultare il proprio file library.h per documentarsi sulle funzioni implementabili sul proprio LCD):
  • lcd.setCursor(0,0);
  • lcd.print("Sensore = ");
  • lcd.setCursor(11,0);
  • lcd.print(ValoreLuce);
Stesso meccanismo per il Termistore.
 Infine,"giocando" un pò col codice,possiamo riuscire a tirar fuori dal nostro Arduino qualcosa di molto divertente e funzionale come mostra la seguente foto.

Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.

Arduino tutorial 11: Display LCD

Per poter pilotare il display avete necessità di utilizzare la libreria LiquidCrystal.h che vi permette di comunicare in modalità 4 bit o 8 bit, questo vuol dire che per la trasmissione dati possono essere utilizzate 4 o 8 linee di controllo a queste si aggiungono le due linee di controllo: Register Select (RS) e Enable (E) e alla linea opzionale Read/Write (RW).
In classe ho utilizzato la modalità a 4 bit, la stessa del tutorial sul sito Arduino, ciò comporta l’utilizzo di 6 uscite digitali sulla scheda Arduino.

Nella tabella allegata trovate le funzioni di ogni piedino.

Ricordate che la piedinatura di questi display è comune alla maggior parte degli LCD 16 x 2 standard Hitachi HD44780, ma potreste trovare qualche variazione tipicamente accade per i pin 15 e 16 che potrebbero essere al posto dei pin 1 e 2 (non è il caso di questo display).
In ogni caso come potete vedere dalle fotografie (sopra) il display reca sul lato piste, una legenda con il riferimento piedino -> funzione quindi, non potete sbagliarvi.
Funzione dei piedini
  • Pin 1: Vss – collegato al GND
  • Pin 2: VDD – collegato a +5V
  • Pin 3: V0 – controllo del contrasto dei caratteri. In genere viene collegato ad un potenziometro o trimmer in configurazione partitore di tensione in modo che possiate applicare sul Pin 3 una tensione che varia da 0 a +5V e al variare della tensione varia il contrasto.
  • Pin 4: RS segnale di selezione registro – per selezionare il registro nel quale registrare ciò che appare sul display oppure selezionare il registro di funzionamento in cui viene memorizzata di volta in volta l’istruzione da eseguire per il funzionamento dell’LCD
  • Pin 5: segnale Read/Write – per selezionare la modalità di funzionamento: lettura/scrittura – collegato a GND
  • Pin 6: segnale Enable (E) – per abilitare la scrittura nei registri
  • Pin 7 al Pin 14: linee dati che si inviano o si ricebono dai registri del display. Un valore HIGH (H) indica scrittura (WRITE) del bit nel registro del display, un valore LOW (L) indica un valore letto (READ) da un registro.
  • Pin 15: A (Anodo) – piedino a cui collegare una tensione positiva (nel caso del display descritto +4,2V) che serve per la retroilluminazione del display.
  • Pin 16: K (Catodo) – piedino da collegare a GND per consentire la retroilluminazione.
I collegamenti realizzati sono identici a quelli che trovate sul tutorial: LiquidCrystal – “Hello World!” dove al posto del potenziometro abbiamo utilizzato un trimmer:

Codice:
/* uso del display LCD 16x2 standard Hitachi HD44780

  Circuito:
 * pin RS collegato al pin digitale 12
 * pin E (Enable) collegato al pin digitale 11
 * pin D4 collegato al pin digitale 5
 * pin D5 collegato al pin digitale 4
 * pin D6 collegato al pin digitale 3
 * pin D7 collegato al pin digitale 2
 * pin R/W collegato al GND
 * pin 1 e pin 4 collegati a GND
 * pin 2 collegato a +Vcc
 * centrale del potenziometro/trimmer da 10 KOhm collegato al pin 3 del'LCD
 * pin SX potenziometro/trimmer collegato a +Vcc
 * pin DX potenziometro/trimmer collegato a GND
 * i pin SX e DX del potenziometro/trimmer possono essere interscambiati
*/

// includere la libreria:
#include < LiquidCrystal.h >

/*
   Viene creata l'istanza dell'oggetto LiquidCrystal chiamata lcd in cui
   sono indicati i pin dell'LCD collegati alle uscite digitali di Arduino
*/
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {
   //impostiamo il numero di colonne ed il numero di righe di lcd
  lcd.begin(16, 2);
  // Visualizzo il messaggio sul display
  lcd.print("Salve mondo!");
}

void loop() {
  // posiziona il cursore in colonna 0 e linea 1
  // (nota: la linea 1 e la seconda linea, poichè si conta incominciando da 0):
  lcd.setCursor(0, 1);
  // stampa il numero di secondi dall'ultimo reset
  lcd.print(millis()/1000);
}



 Nel caso in cui colleghiamo il Pin 15 a +5V e il Pin 16 a GND abbiamo la retroilluminazione:


Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.

venerdì 7 giugno 2013

Arduino Tutorial 10: Controllare due servo motore

In questo esempio vedremo come pilotare due servo motore con arduino dal monitor seriale tramite  la tastiera del pc.

In questo schema i pin che comandano i servo sono collegati ai pin PWM 10 e 9, ma si possono usare qualsiasi pin PWM, non tutti i pin di arduino sono PWM si possono individuare mediante la sigla davanti ai pin.
Circuito elettrico:


il codice arduino:


#include <Servo.h>//include la libreria del servo
int minPulse1     =  0;   // posizione minima o°
int maxPulse1     =  180; // posizione massima 180°
int turnRate1     =  10;  // ruota di 10° alla volta
int minPulse2     =  0;  // posizione minima o°
int maxPulse2     =  180; // posizione massima 180°
int turnRate2     =  10;  // ruota di 10° alla volta
int buttonPin     = 13;    // pin that the trigger will be connected to
/** The Arduino will calculate these values for you **/
int centerServo1;
int centerServo2;
int pulseWidth1;     // servo pulse width
int pulseWidth2;     // servo pulse width

Servo servo1;
Servo servo2;

void setup() {
  pinMode(buttonPin, OUTPUT);
  servo1.attach(10);//dichiara il servo nel pin 10 PWM
  servo2.attach(9);//dichiara il servo nel pin 9 PWM
  centerServo1 = maxPulse1 - ((maxPulse1 - minPulse1)/2);
  centerServo2 = maxPulse2 - ((maxPulse2 - minPulse2)/2);
  pulseWidth1 =  centerServo1;
  pulseWidth2 =  centerServo2;
  Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
  Serial.println(" Arduino Serial Servo Control");
  Serial.println("Press a, s, d, or w to move, spacebar to center, and f to fire");
  Serial.println();
}

void loop() {

  // check for serial input
  if (Serial.available() > 0) {

    int data = Serial.read();  // read the incoming byte:
    digitalWrite(buttonPin, LOW);  // turn the pin off on any incoming data
    switch(data)
    {
case 'a' :  pulseWidth1 = pulseWidth1 - turnRate1;  break;
case 'd' :  pulseWidth1 = pulseWidth1 + turnRate1;  break ;
case ' ' :  pulseWidth1 = pulseWidth2 = centerServo1;  break;
case 's' :  pulseWidth2 = pulseWidth2 - turnRate1;  break;
case 'w' :  pulseWidth2 = pulseWidth2 + turnRate1;  break ;
case 'f' :  digitalWrite(buttonPin, HIGH); delay (1000); digitalWrite(buttonPin, LOW); break;

    }
    // stop servo pulse at min and max
    if (pulseWidth1 > maxPulse1) { pulseWidth1 = maxPulse1; }
    if (pulseWidth1 < minPulse1) { pulseWidth1 = minPulse1; }

// stop servo pulse at min and max
    if (pulseWidth2 > maxPulse2) { pulseWidth2 = maxPulse2; }
    if (pulseWidth2 < minPulse2) { pulseWidth2 = minPulse2; }

     servo1.write(pulseWidth1);
     servo2.write(pulseWidth2);

    // print pulseWidth back to the Serial Monitor (uncomment to debug)
    Serial.print("Servo 1: ");
    Serial.print(pulseWidth1);
    Serial.print(" Servo 2: ");
    Serial.print(pulseWidth2);
    Serial.println("degrees");
  }
}

Adesso aprendo il monitor seriale visualizzerete il seguente testo:

Arduino Serial Servo Control
Press a, s, d, or w to move, spacebar to center, and f to fire

digitando uno dei tasti indicati sopra e premendo invio, vedrete il vostro servo muoversi


Se avete dei problemi a far funzionare il circuito commentate o scrivete sul forum.