Arduino monitor temperatura con display lcd

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 hello world 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.

Realizzare una scheda con due relè

In questo articolo vi illustro un circuito semplicissimo e molto banale: una scheda con due relè.  Un circuito dai mille usi, semplice da realizzare e alla portata di tutti. Si tratta di una scheda direi indispensabile: capita spesso che durante i nostri lavoretti di domotica con  Arduino abbiamo bisogno di qualche relè per controllare una lampada, un motore o altro e avere una scheda già pronta a portata di mano può semplificare di molto il lavoro.

Da una MCU (un picmicro, Arduino o quello che volete voi) arriva l’impulso positivo alla resistenza R2, il transistor Q1 viene mandato in saturazione e permette il flusso di corrente attraverso la bobina del relè K1 che si eccita e chiude tra X1-2 e X1-1 (contatto NO). D1 serve come sempre a scaricare a massa la corrente inversa generata dalla bobina del relè. L’accensione del relè viene segnalata mediante un led da 3mm.

La basetta è abbastanza piccola, misura circa 6×5 cm:

 

Il software utilizzato per  realizzare il circuito è EAGLE.

Arduino comandi vocali

Il modulo per il riconoscimento vocale da interfacciare con arduino è "EasyVR", e ne esistono vari modelli.
Il sito di supporto è www.veear.eu
Il modulo EasyVR permette la ricezione e l'interpretazione di comandi vocali da parte di arduino.

Attraverso il software EasyVR Commander e la libreria per arduino è possibile definire i comandi da ricevere ed eseguire, poi, tramite arduino.

Collegamento Arduino EasyVR.

  Il collegamento come si può ben vedere, è semplice, l'altoparlante non è spiegato, il filo nero o gnd va collegato nella parte interna del circuito e il rosso vcc in quella esterna.

Arduino RGB con potenziometro

In questo esempio vediamo come controllare sfumature e colori di un led RGB, con un potenziometro e un pulsante.

Il potenziometro regolerà l'intensità di colore, e il pulsante cambierà i colori.

Codice ARDUINO:

int sensorPin = A1; / / selezionare il pin di ingresso per il potenziometro
int buttonPin = 8; / / pulsante Digitale pin
basePin int = 9;

buttonState int = 0;
selectedColor int = 0;
currentColor int [3];


void setColor ()
{
  Serial.println ("- Imposta colore");
  for (int i = 0; i <3, + + i)
  {
    Serial.println (currentColor [i]);
    analogWrite (basePin + i, mappa (currentColor [i], 0, 255, 255, 0));
    / / AnalogWrite (basePin + i, currentColor [i]);
  }  
}

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

  currentColor [0] = 0;
  currentColor [1] = 0;
  currentColor [2] = 0;

  pinMode (buttonPin, INPUT);

  pinMode (basePin, OUTPUT);
  pinMode (basePin + 1, OUTPUT);
  pinMode (basePin + 2, OUTPUT);

  setColor ();
}

void loop () 
{
  / / Legge il valore di colore dal sensore e remap al valore gamma rgb
  int actualColor = map (analogRead (sensorPin), 0,1023,1,255);


  buttonState = digitalRead (buttonPin);
  if (buttonState == HIGH)
  {    
    delay (300); / / attendere per ritornare alla sua posizione iniziale
    currentColor [selectedColor] = actualColor;
    setColor ();
    selectedColor = (selectedColor + 1)% 3;
  }


}

Arduino e Gmail

Cassetta della posta gmail, il cartoncino avanzato nel primo notificatore non può essere sprecato.

Realizzeremo un notificatore per gmail, quando arriverà un nuovo messaggio sul nostro account di gmail, il nostro arduino lo segnalerà.

Guarda il video

Codice PYTHON:


import serial, sys, feedparser
#Settings - Change these to match your account details
USERNAME="XXXXXXX@gmail.com"
PASSWORD="PASSWORDXXWD"
PROTO="https://"
SERVER="mail.google.com"
PATH="/gmail/feed/atom"
SERIALPORT = "/dev/tty.usbserial-FTE3RS4J" # Change this to your serial port!
# Set up serial port
try:
ser = serial.Serial(SERIALPORT, 9600)
except serial.SerialException:
print "no device connected - exiting"
sys.exit()

newmails = int(feedparser.parse(PROTO + USERNAME + ":" + PASSWORD + "@" + SERVER + PATH)["feed"]["fullcount"])
 
# Output data to serial port
if newmails > 0:
ser.write("m")
print "some mail"
else:
ser.write("n")
print "no mail"
#print data to terminal


# Close serial port
ser.close()


Codice ARDUINO:


#include <MsTimer2.h>
#include <Servo.h>
Servo myservo;
int val;
int pos;
void flash() {
static boolean output = HIGH;
digitalWrite(9, output);
output = !output;
}
void setup()
{
Serial.begin(9600);
Serial.flush();
myservo.attach(10);
}
void loop()
{
if (Serial.available())
{
val = Serial.read();
Serial.println(val, BYTE);
if (val == 110) // n = 110 in dec
{
pinMode(9,0);
pos = 0;
}
else if (val == 109) //109 = m in dec
{
pinMode(9, OUTPUT);

MsTimer2::set(150, flash); // 150ms periodo
MsTimer2::start();
pos =140;
}  
}
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15);
}

Fonte

Arduino controllo IR 2° Parte

Adesso, arriva la parte interessante, vediamo come accendere e spegnere un led, tramite il telecomando.
Avete salvato il codice esadecimale del telecomando, spiegato nella 1°parte?
Bene.

In questa immagine si vede il circuito, il sensore IR è collegato al Pin2 e il lede che lampeggia ad ogni tasto premuto sul pin 13.

i PIN di arduino che ci serviranno sono: Pin 4 led, Pin 2 uscita sensore IR, Pin 5 led, Pin13 led.
veniamo al codice adesso

#include <IRremote.h>

int RECV_PIN = 2;//uscita IR
int RELAY_PIN = 4;//Led

IRrecv irrecv(RECV_PIN);
decode_results results;

// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
//  decode_results *results = (decode_results *)v
void dump(decode_results *results) {
  int count = results->rawlen;
  if (results->decode_type == UNKNOWN) {
    Serial.println("Could not decode message");//non riesce a codificare
  }

    else if (results->decode_type == NEC) {
      Serial.print("Orion: ");
    }
 
    Serial.print(results->value, HEX);//visualizza il codice esadecimale
    Serial.print(" (");
    Serial.print(results->bits, DEC);
    Serial.println(" bits)");
  }

void setup()
{
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(13, OUTPUT);//Led che lampeggia ad ogni segnale ricevuto
  pinMode(5, OUTPUT);//Led
    Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

int on = 0;
unsigned long last = millis();

void loop() {
  if (irrecv.decode(&results)) {
    // If it's been at least 1/4 second since the last
    // Led IR lampeggia ad ogni tasto premuto
    if (millis() - last > 250) {
      on = !on;
   
      digitalWrite(13,  HIGH );
      delay(200);
      digitalWrite(13,  LOW );
      delay(200);
      dump(&results);
    }
    last = millis();    
    irrecv.resume(); // Receive the next value
  }
  if (results.value==0x1){Serial.println("Amstrad 1");//tasto 1 blink led Pin5
  digitalWrite(5, HIGH);
  delay(100);
  digitalWrite(5, LOW);
  delay(100);
};
  if (results.value==0x2){Serial.println("Amstrad 2");//tasto 2 Led on/of
  digitalWrite(RELAY_PIN, on ? HIGH : LOW);

};

}


Il led sul Pin13 lampeggia ad ogni tasto premuto, segno che il sensore funziona ma bisogna specificare il codice ad arduino affinchè esegua il comando desiderato.

if (results.value==0x1): 0x1 è il codice esadecimale del tasto 1 del mio telecomando, sostituitelo con il vostro codice.

f (results.value==0x2): 0x2 è il codice esadecimale del tasto 2 del mio telecomando, sostituitelo con il vostro codice.

Sbizzarritevi e divertitevi con questo esempio, e al prossimo Tutorial.

Arduino controllo IR 1°Parte

In questo tutorial, vedremo come controllare le uscite di arduino con il telecomando della tv.

Per prima cosa scaricate la libreria Arduino-IRremote per arduino 1.0.
Scompattatela rinominatela: IRremote e fate copia/incolla nella cartella: arduino-1.0/libraries, poi aprite l'ide di arduino e cercate tra gli esempi, la voce IRremote, per trovare alcuni esempi.

Per poter permettere la comunicazione tra il telecomando e arduino,per prima cosa davrete caricare lo sketch che vi permetterà di associare un tasto al relativo codice esadecimale.

Sketch: IRrecvdemo


#include <IRremote.h>

int RECV_PIN = 11;//uscita del sensore collegato al pin 11

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);//visualizza nel monitor seriale il codice esadecimale*
    irrecv.resume(); // Receive the next value
  }
}



*siccome il telecomando invia 2 codici dello stesso tasto,una volta uno e una volta l'altro segnateli entrambi, che potranno tornare utili.

arduino Blink led rgb

In questo esempio vedremo come effettuare un blink con un led RGB e arduino, un intervallo di colori di 1 secondo ciascuno, rosso, verde, blu.

int red=9,
    green=10,
    blue=11,
    i=0,
    j=0,
    color[]={red, green, blue},  // since array counts start a 0, color[0]=9, color[1]=10, color[2]=11
    intensity[]={0, 0,0}; // one intensity level for each color

void setup()
{
  // set pins as outputs
  pinMode(red,OUTPUT);
  pinMode(green,OUTPUT);
  pinMode(blue,OUTPUT);

  // turn off all colors
  analogWrite(red,0);
  analogWrite(green,0);
  analogWrite(blue,0);
}
void loop()
{

  analogWrite(red,255); // turn on red
  delay(1000); // wait a sec
  analogWrite(red,0); // turn off red

  analogWrite(green,255); // turn on green
  delay(1000); // wait a sec
  analogWrite(green,0); // turn off green

  analogWrite(blue,255); // turn on blue
  delay(1000); // wait a sec
  analogWrite(blue,0); // turn off blue

}

Comandare 2 servo motore con arduino

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

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(3);//dichiara il servo nel pin 3 PWM
  servo2.attach(2);//dichiara il servo nel pin 2 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

Arduino Web Server GUI

Adesso, dopo aver visto come realizzare un web server con arduino e visualizzare l'output su un browser, vediamo come realizzare un'interfaccia grafica per interagire con il nostro arduino.
In questo esempio accenderemo un led collegato ad arduino tramite un pulsante sul nostro browser.



//ARDUINO 1.0
//include tutti i pacchetti necessari
String readString;
#include <Ethernet.h>
#include <SPI.h>
boolean reading = false;

////////////////////////////////////////////////////////////////////////
//configurazione della rete
////////////////////////////////////////////////////////////////////////
  byte ip[] = { 192, 168, 1, 17 };   //ip:modificabile, da digitare nel browser
  byte gateway[] = { 192, 168, 1, 1 }; //non modificare
  byte subnet[] = { 255, 255, 255, 255 }; //non modificare

  //  MAC address
  byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

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

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

 

  pinMode(2, OUTPUT);//Pin 2 led

  Ethernet.begin(mac, ip, gateway, subnet);
 

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

}

void loop(){


 
  checkForClient();

}

void checkForClient(){

  EthernetClient client = server.available();

  if (client) {

   
    boolean currentLineIsBlank = true;
    boolean sentHeader = false;

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

        if(!sentHeader){
       
          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;

        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);
    client.stop(); // chiude la connessione

  }

}

Arduino Web Server

Questo sketch mette le basi all'interazione di arduino e il linguaggio del web(html, php, etc...)

L'ide utilizzato è 1.0 lo specifico perchè c'è una piccola differenza con le precedenti versioni, e non funziona, l'esempio è quello che si trova in examples/ethernet/web server e non esegue alcunchè se non visualizzare sul browser lo stato delle porte analogiche.




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

// Enter a MAC address and IP address for your controller below.
// The IP address will be dependent on your local network:
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };//lasciare invariato
IPAddress ip(192,168,1, 177); //ip da digitare nel browser

// Initialize the Ethernet server library
// with the IP address and port you want to use
// (port 80 is default for HTTP):
EthernetServer server(80);

void setup()
{
  // start the Ethernet connection and the server:
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop()
{
  // listen for incoming clients
  EthernetClient client = server.available();
  if (client) {
    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        // if you've gotten to the end of the line (received a newline
        // character) and the line is blank, the http request has ended,
        // so you can send a reply
        if (c == '\n' && currentLineIsBlank) {
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();

          // output the value of each analog input pin
          for (int analogChannel = 0; analogChannel < 6; analogChannel++) {
            client.print("analog input ");
            client.print(analogChannel);
            client.print(" is ");
            client.print(analogRead(analogChannel));
            client.println("<br />");
          }
          break;
        }
        if (c == '\n') {
          // you're starting a new line
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          // you've gotten a character on the current line
          currentLineIsBlank = false;
        }
      }
    }
    // give the web browser time to receive the data
    delay(1);
    // close the connection:
    client.stop();
  }
}

Cos'è il ponte ad H e come si costruisce

Con questo tutorial vorrei chiarire come pilotare un motore DC in modo bi-direazionale con 4 porte digitali di arduino (che possono essere ridotte a 2 con l'aggiunta di 2 ulteriori transistor), con un circuito composto da 4 transistor (di cui 2 NPN e 2 PNP) e 4 diodi. Come ben sapete i motori elettrici hanno bisogno di una "centralina" per essere comandati. Questo componente spesso è composto (se si parla di motori dc) da 4 transistor e 4 diodi (molto spesso sono presenti anche dei condensatori e resistenze), quindi una cosa realizzabile senza problemi in casa in pochi minuti. 

Lista dei componenti

1. 2x BD177 transistor
2. 2x BD178 transistor
3. 4x IN4007 diodo

I transistor sono i componenti fondamentali e attivi del sistema. Ci sono due tipologie di transistor quelli NPN e quelli PNP. La differenza tra i due è che gli NPN funzionano permettendo alla corrente positiva di attraversarli (cioè corrente in arrivo da + e in uscita dal transistor verso motore) solo se il polo base è connesso al +, invece PNP permettono alla corrente in arrivo dal motore di attraversali e andare verso la massa, solo se la base è connessa al -.

 PNP NPN

In cosa consiste

Il ponte ad H è cosi' chiamato per la forma dello schema, è formato da 4 transistor e 4 diodi che hanno il ruolo di permettere o no il flusso di corrente in un dato senso all'interno del sistema. Questi verranno accesi a coppie per ruotare il motore in un senso o nell'altro, gli altri due saranno opportunamente chiusi per evitare corti circuiti. In poche parole grazie a 4 switch è possibile decidere la direzione della corrente all'interno del motore e quindi trasformarla in movimento in un dato senso di rotazione. Ecco uno schema semplice di cosa si ottiene:

transistor1	transistor2	transistor3	transistor4	Risultato sperimentale
1	0	0	1	Rotazione in senso orario
0	1	1	0	Rotazione in senso antiorario
0	0	0	0	Motore libero
0	1	0	1	Frenata elettromagnetica
1	0	1	0	Frenata elettromagnetica

Tutto ciò consiste in un Ponte ad H davvero minimale.

E' pensato per pilotare motori DC da 3 a 36v con un assorbimento massimo di 3A continui e 7A pulsati. L'architettura del sistema è pensata per ridurre il più possibile le possibilità di baking di componenti (bruciare tutto per errore di wiring). I Transistor consigliati sono enormi ed è impossibile bruciarli con una batteria da 6 volt in qualsiasi combinazione proviate.

Come potete vedere il circuito è molto semplice. Fate molta attenzione al wiring dei transistor, controllate sui datasheet linkati sopra la referenza dei pin e connettetela come spiegato. Testate prima il funzionamento di un singolo transistor delle due tipologie. Dopo aver chiarito i collegamenti di entrambi, iniziate con metodo a duplicare e specularizzare lo schema ; ). Dopo aver fatto il wiring come mostrato qui sopra, collegate le basi dei 4 transistor alle porte digitali  2 3 4 5 di Arduino e caricate lo sketch seguente:

view sourceprint?

01	int motorPin1 =  2;

02	int motorPin2 =  3;

03	int motorPin3 =  4;

04	int motorPin4 =  5;

05

06	void setup()   {

07	pinMode(motorPin1, OUTPUT);

08	pinMode(motorPin2, OUTPUT);

09	pinMode(motorPin3, OUTPUT);

10	pinMode(motorPin4, OUTPUT);

11

}

12

13	void loop()                     {

14	digitalWrite(motorPin1, HIGH);  //gira in senso orario per 1 sec

15	digitalWrite(motorPin2, LOW);

16	digitalWrite(motorPin3, LOW);

17	digitalWrite(motorPin4, HIGH);

18	delay(1000);

19	digitalWrite(motorPin1, LOW);   //gira in senso antiorario per 1 sec

20	digitalWrite(motorPin2,HIGH);

21	digitalWrite(motorPin3, HIGH);

22	digitalWrite(motorPin4, LOW);

23	delay(1000);                  //l'uso di delay è deprecato, è solo un esempio ;)

24

}

Dopo aver alimentato il motore e caricato lo sketch dovreste ottenere 1 secondo di rotazione in un senso e 1 secondo di rotazione nel senso opposto. Questo è solo un piccolo esempio delle incredibili funzionalità di questo sistema, che permette di pilotare qualsiasi motore dc applicato alla robotica amatoriale senza avere problemi.

In questo caso per l'esempio ho utilizzato un motore delle amate MINI4WD e un alimentatore da 6v 1A.