BASI ARDUINO

LIB: Esempio ETHERNET SHIELD

Per costurire gli esempi seguenti è necessario dotarsi di un Ethernet Shield e un led

Ecco l'immagine del circuito

Nei progetti seguenti utilizzeremo la libreria Ethernet:

Ethernet.begin()

Ethernet è la classe che Inizializza la libreria Ethernet ed imposta le configurazioni di rete (ip, mac address, dns, gateway e subnetmask).

Ha i seguenti metodi:

begin() : la rete ed imposta le configurazioni di rete di arduino

Sintassi ammesse:

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

Quando scrivo Ethernet.begin(mac) deve esistere sulla rete un server DHCP ovvero un servizio che abbina in automatico l'indirizzo IP. Questa impostazione aumenta notevolmente l'utilizzo della memoria di arduino da parte dello sketch poichè il micro deve saper gestire l'ip dinamico. Anche la presenza del parametro dns aumenta la dimensione dello sketch poichè è necessario aggiungere la gestione relativa alla comunicazione con il dns. Il mac address è un array di 6 byte e corrisponde all'indirizzo HW della scheda eth di arduino. Ip, dns, gateway e il subnet mask sono invece array di 4 bytes

Esempi:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, 1, 177 };
Ethernet.begin(mac, ip);
localIP() :Restituisce l'indirizzo IP dello shield ETH. Utile quando l'indirizzo è stato assegnato dinamicamente attraverso un server DHCP.

Esempi:

Serial.println(Ethernet.localIP());

IPAddress()

Consente la definizione di un indirizzo IP. Può essere usato sia per dichiarare indirizzi remoti che locali.

Esempi:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress dnServer(8, 8, 8, 8);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
IPAddress ip(192, 168, 1, 177);
Ethernet.begin(mac, ip, dnServer, gateway, subnet);

In alternativa possiamo usare:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte dnServer = { 8, 8, 8, 8 };
byte gateway = { 192, 168, 1, 1 };
byte subnet = { 255, 255, 255, 0 };
byte ip = { 192, 168, 1, 177 };
Ethernet.begin(mac, ip, dnServer, gateway, subnet);

EthernetServer

Crea un oggetto server che resta in ascolto per connessioni in ingresso sulla porta specificata.

Sintassi:

EthernetServer(port);

Il parametro è la porta di ascolto che è di tipo int. Ha i seguenti metodi:

begin() :inizializza il server e lo mette in ascolto delle connessioni in entrata.
available() :acquisisce un client che si è connesso al server abbinato all'oggetto associato ed ha dati disponibili per la lettura.

Esempio:

EthernetServer server = EthernetServer(23);
server.begin()

EthernetClient

Crea un cliente che può connettersi ad uno specifico indirizzo IP e porta.

Sintassi:

EthernetClient client;
client=server.available();

Ha i seguenti metodi:

connect() :Connette il client associato ad una specifica porta ed indirizzo IP. Valori di ritorno negativi indicano una situazione di errore. Se restituisce 1 la connessione ha avuto successo (SUCCESS: 1 - TIMED_OUT: -1 - INVALID_SERVER: -2 - TRUNCATED: -3 - INVALID_RESPONSE: -4). Supporta anche l'uso del DNS per cui possiamo utilizzare il nome mnemonico di dominio al posto dell'indirizzo IP. Esempi di utilizzo sono: client.connect() - client.connect(ip, port) - client.connect(URL, port).
connected() :Indica se il client è connesso o meno. Si osservi che il client è considerato connesso anche se la connessione è stata chiusa ma ci sono ancora dei dati non letti. Restituisce TRUE se il client risulta connesso, false altrimenti.
available() :Restituisce il numero di byte disponibili per la lettura (in altre parole i dati che sono stati scritti per il client da parte del server connesso).
read() : legge il prossimo byte ricevuto dal client e spedito dal server a cui è connesso. Restituisce -1 se non ci sono byte disponibili.

Vediamo un esempio che raccoglie i vari metodi visti (riceve una richiesta http sull'IP di Arduino e mostra una pagina letta su www.brescianet.com) NON FUNZIONA!!!

#include <SPI.h>
#include <Ethernet.h>
#define LT String("<")
#define E_UN_TEST "SI"
#define MANCA_CLIENT_ARDUINO 0
#define TERMINATO_CLIENT_ARDUINO 1
#define TERMINATO_CLIENT_BSNET 2

// I nuovi shield ETH hanno il MAC Address stampato su un'etichetta incollata
byte MAC[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress IP(192, 168 ,1 , 177);
IPAddress BrescianetWebServer(62, 149, 130, 28);  // IP www.brescianet.com (se non ho il DNS)
// char server[] = "www.brescianet.com";    // nome dominino (usabile con il DNS)
EthernetServer ArduinoWebServer(80);

int Stato;
int NrSecondi;
boolean TryToReqPageBSNet;

void setup() 
{
    Ethernet.begin(MAC,IP);   // Inizializzo la rete
    ArduinoWebServer.begin(); // avvio il server WEB
    Stato=MANCA_CLIENT_ARDUINO;
    NrSecondi=0;
    TryToReqPageBSNet = false;
#ifdef E_UN_TEST
    Serial.begin(9600);
    Serial.println("Indirizzo IP attivato e server WEB avviato ---");
#endif    
}

void loop()
{
  char c;
  EthernetClient clientToBrescianet;
  EthernetClient clientToArduino;
  boolean currentLineIsBlank = true; // Una richiesta HTTP termina con una linea vuota
  if (Stato==MANCA_CLIENT_ARDUINO)
  {
    // Il WEB server su Arduino resta in attesa di un client 
    clientToArduino = ArduinoWebServer.available();
    if (clientToArduino) 
    {  // Ho una richiesta per il Web Server su Arduino ... 
       if (clientToArduino.connected())
       {
         while (clientToArduino.available()) 
         { 
            // se ci sono caratteri  (relativi alla richiesta) disponibili ...
            c = clientToArduino.read(); // li leggo
#ifdef E_UN_TEST
            Serial.write(c);
#endif    
            if (c == '\n' && currentLineIsBlank) // Terminata la richiesta HTTP
            {
                Stato=TERMINATO_CLIENT_ARDUINO;
#ifdef E_UN_TEST
                Serial.println("Richiesta al Server WEB di Arduino terminata ---");
#endif      
                break;  
            }
            if (c == '\n') 
                currentLineIsBlank = true; // Inizia una nuova linea
            else if (c != '\r') 
                currentLineIsBlank = false; // ricevuto un nuovo carattere sulla linea corrente
         } // fine while Available()
       } // fine if Connected
    }
  }
  else if (Stato==TERMINATO_CLIENT_ARDUINO) // La richiesta al server Arduino è stata Completata
  {
    if (clientToBrescianet.connect(BrescianetWebServer, 80))
    {
#ifdef E_UN_TEST
      Serial.println("\nConnesso a: www.brescianet.com ---");
#endif
      if (!TryToReqPageBSNet)
      {
#ifdef E_UN_TEST
      Serial.println("\nInvio richiesta pagina a: www.brescianet.com ---");
#endif
          clientToBrescianet.print("GET ");
          clientToBrescianet.print("/appunti/Elettronica");
          clientToBrescianet.print("/Arduino/corso/supporto");
          clientToBrescianet.print("/WebClientArduino.htm");
          clientToBrescianet.println(" HTTP/1.1");
          clientToBrescianet.println("Host: www.brescianet.com");
          clientToBrescianet.println("Connection: close");
          clientToBrescianet.println();
          TryToReqPageBSNet=true;
          delay(1);
      }
      while (clientToBrescianet.available()) 
      {
        c = clientToBrescianet.read();
        clientToArduino.write(c);
#ifdef E_UN_TEST
        Serial.print(c);
#endif    
      }

      // Quando da connesso si disconnette
      if (!clientToBrescianet.connected()) 
        Stato=TERMINATO_CLIENT_BSNET;
    } 
    else if (NrSecondi>=10)
    {
#ifdef E_UN_TEST
      Serial.println("Connessione a www.brescianet.com fallita");            
#endif    
      // Invia l'header di risposta standard -------------
      clientToArduino.println("HTTP/1.1 200 OK");
      clientToArduino.println("Content-Type: text/html");
      clientToArduino.println("Connection: close");  // La connessione verrà chiusa al termine della trasmissione
      clientToArduino.println();
      // Invia il messaggio di errore
      clientToArduino.println("\n"+LT+"html>"+LT+"title>Arduino WEB Server"+LT+"/title>"+LT+"body>");
      clientToArduino.println(LT+"hr>"+LT+"h1>"+LT+"font color=red>Connessione a www.brescianet.com fallita"+LT+"/font>"+LT+"/h1>"+LT+"hr>");
      clientToArduino.println(LT+"/body>"+LT+"/html>");
      Stato=TERMINATO_CLIENT_BSNET;
   }
    if (Stato==TERMINATO_CLIENT_BSNET)
    {
#ifdef E_UN_TEST
   Serial.println("Disconnessione dal Server WEB Brescianet conclusa ---");
   Serial.println("Disconnessione dal Server WEB di Arduino ---");
#endif      
       delay(1);  // lascia il tempo al browser per ricevere il dato
       clientToBrescianet.stop();
       clientToArduino.stop(); // chiude la connessione con il client
    }
    else
    {
      NrSecondi++;
#ifdef E_UN_TEST
      Serial.println(String(NrSecondi)+"^ tentativo di connessione a www.brescianet.com"); 
      Serial.flush();      
#endif    
      delay(200);
    }
  }
  else
  {
    // Ripristino ad uno stato iniziale
#ifdef E_UN_TEST
    Serial.println("WEB server di Arduino messo in stato di Ascolto ---");
#endif  
    Stato=MANCA_CLIENT_ARDUINO;
    TryToReqPageBSNet=false;
    NrSecondi=0;
  }
} // Fine Loop()

Codice Sorgente A

Obiettivo progetto: Costruire un piccolo WEB Server che utilizzando l'ethernet shield visualizza la pagina HTML statica di benvenuto sottostante:

soluzione:

/*
  Semplice WEB Server - Mostra una pagina di benvenuto
  Utilizza Ethernet Shield connesso ad Arduino
  
  * L'ethernet shield comunica tramite i pin 10, 11, 12, 13
  
  creato il 18 dicembre 2009 da David A. Mellis 
  modificato il 9 aprile 2012 da Tom Igoe
  modificato il 17 ottobre 2014 da Marco Sechi
----------------------------------------------------------------------------------- */
#include <SPI.h>
#include <Ethernet.h>
#define LT String("<")

// Imposto:
// - il MAC address 
// - l'indirizzo IP per il controller ETH
// - la porta di ascolto per il server: la 80
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192,168,1,177);
EthernetServer server(80);

void setup() 
{
  // Inizializza la connessione Ethernet e il server:
  Ethernet.begin(mac, ip);
  server.begin();
}

void loop() 
{
   char c;
   // rimane in attesa di un client 
   EthernetClient client = server.available();
   if (client) // Se ho una richiesta al server ... 
   {
     // Una richiesta http termina con una linea bianca
     boolean currentLineIsBlank = true;
     while (client.connected()) 
     {
       if (client.available()) 
       {
         c = client.read();
         Serial.write(c);
         // Se si riceve la fine di una riga (indicata con il carattere '\n') 
         // e la linea è vuota allora la richiesta http si è conclusa e il 
         // server può inviare la risposta
         if (c == '\n' && currentLineIsBlank) 
         {
           // Invia l'header di risposta standard
           client.println("HTTP/1.1 200 OK");
           client.println("Content-Type: text/html");
           client.println("Connection: close");  // La connessione verrà chiusa al termine della trasmissione
           client.println("Refresh: 5");  // richiede il reinvio della pagina ogni 5 secondi
           client.println();
           // Invia la pagina vera e propria
           client.println(LT+"!DOCTYPE HTML>");
           client.println(LT+"html>");
           client.println(LT+"title>Arduino WEB Server"+LT+"/title>");
           client.println(LT+"body>"+LT+"h1>SALVE MONDO"+LT+"/H1>"+LT+"H2>WEB SERVER SU ARDUINO"+LT+"/H2>"+LT+"h3>Attivo da");
           client.print((float)millis()/1000);
           client.println(" secondi"+LT+"/h3>"+LT+"/body>"+LT+"/html>");
           break;
         }
         if (c == '\n') 
           currentLineIsBlank = true; // Inizia una nuova linea
         else if (c != '\r') 
           currentLineIsBlank = false; // ricevuto un nuovo carattere sulla linea corrente
       }
     }
     delay(1);  // lascia il tempo al browser per ricevere il dato
     client.stop(); // chiude la connessione con il client
   }
}

Codice Sorgente B

Obiettivo progetto: Costruire un piccolo WEB Server che utilizzando l'ethernet shield sia in grado di ricevere dei comandi per accendere o spegnere un led connesso al pin 3. Nella figura sottostante la pagina HTML che presenta i comandi disponibili:

soluzione: Vediamo come è possibile inviare un comando tramite il browser. Tutto quello che digitiamo sull'URL viene inviato dal browser al server e pertanto anche il testo del comando scritto subito dopo l'indirizzo IP dello shield di Arduino. Vediamo un esempio reale:

- supponiamo di digitare sulla barra degli indirizzi questo:

http://192.168.1.177/testo_comando

- dopo aver premuto il tasto invio o il pulsante vai, il browser invia alla board una stringa http che inizia con questo testo:

GET /testo_comando HTTP/1.1

- la board, tramite la funzione read(), legge i singoli byte e li concatena mediante l'operatore += nell'oggetto msg che alla fine conterrà l'intera stringa http inviata dal browser

Utilizzando il metodo indexOf() dell’oggetto msg posso controllare le posizioni delle sottostringhe "GET /" e " HTTP/1.1". Questo al fine di estrarre il "testo_comando" all'interno della stringa ricevuta GET /testo_comando HTTP/1.1. Ecco il codice

int p = msg.indexOf("GET /");
int q = msg.indexOf(" HTTP/1.1");
cmd=msg.substring(p+strlen("GET /"),q);

Per pilotare l’uscita pin3 al livello alto potremmo quindi scrivere sulla barra degli indirizzi del browser qualcosa di questo tipo:

http://192.168.1.177/LED_ON

mentre per porre il pin a LOW questo:

http://192.168.1.177/LED_OFF

Di conseguenza se cmd contiene la stringa "LED_ON" il pin 3 verrà posto a HIGH, se "LED_OFF" a LOW.

Il codice che realizza quanto esposto è il seguente:

/*
  Semplice WEB Server - Accende/spegne un led sul PIN 3
  a seconda del comando digitato sull'URL 
  Utilizza Ethernet Shield connesso ad Arduino
  
  creato il 17 ottobre 2014 partendo dall'esempio sul sito di Marco Lai:
  http://www.logicaprogrammabile.it/come-utilizzare-un-browser-per-pilotare-arduino/
----------------------------------------------------------------------------------- */
#include <SPI.h>
#include <Ethernet.h>
#define LED 3
#define LT String("<")

// Imposto le configurazioni di rete
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
IPAddress ip(192, 168, 1, 177);
IPAddress dnServer(8, 8, 8, 8); // DNS Server di Google
IPAddress gateway(192, 168, 0, 1); // IP del GATEWAY
IPAddress subnet(255, 255, 255, 0); // subnet mask

EthernetServer server(80);

void setup() 
{
  // Inizializza la connessione Ethernet e il server:
  Ethernet.begin(mac, ip, dnServer, gateway, subnet);
  // oppure solo:  Ethernet.begin(mac, ip);
  // Se uso il DHCP: 
  // if (Ethernet.begin(mac) == 0) {
  //    Serial.println("configurazione Ethernet utilizzando DHCP fallita!")
  server.begin();
  // Inizializzo il LED a spento
  pinMode(LED,OUTPUT);
  digitalWrite(LED,LOW);
}

void loop() 
{
   int p,q;
   char c;
   String msg = "";
   String cmd = "";

   // rimane in attesa di un client 
   EthernetClient client = server.available();
   if (client) // Se ho una richiesta al server ... 
   {
     // Una richiesta http termina con una linea bianca
     boolean currentLineIsBlank = true;
     while (client.connected()) 
     {
       if (client.available()) 
       {
         c = client.read();
         msg += c; //ricostruisco la stringa ricevuta concatenando i singoli byte
         // Se si riceve la fine di una riga (indicata con il carattere '\n') 
         // e la linea è vuota allora la richiesta http si è conclusa e il 
         // server può inviare la risposta
         if (c == '\n' && currentLineIsBlank) 
         {
            // Invia l'header di risposta standard -------------
            client.println("HTTP/1.1 200 OK");
            client.println("Content-Type: text/html");
            client.println("Connection: close");  // La connessione verrà chiusa al termine della trasmissione
            client.println();
            // Invia la pagina vera e propria
            client.println("");
            client.println(LT+"html>");
            client.println(LT+"title>Arduino WEB Server"+LT+"/title>");
            client.println(LT+"body>");
            client.println("Richiesta HTTP ricevuta:"+LT+"hr>"+LT+"font color=red>"+LT+"pre>");
            client.print(msg); // richiesta http del browser
            client.println(LT+"/pre>"+LT+"/font>"+LT+"hr>"+LT+"H1>");
            
            // Estraggo il comando:
            msg.toUpperCase();
            p=msg.indexOf("GET /");
            q=msg.indexOf(" HTTP/1.1");
            if ((p>=0) && (q>=0))
               cmd=msg.substring(p+strlen("GET /"),q);
            // Eseguo il comando
            if (cmd=="LED_ON")
            {
              digitalWrite(LED, HIGH);
              client.print("Comando LED_ON: accendo il LED");
            }
            else if (cmd=="LED_OFF")
            {
              digitalWrite(LED, LOW);
              client.print("Comando LED_OFF: spengo il LED");
            }
            else if (cmd=="STATUS")
            {
              client.print("Comando STATUS: il LED è ");
              if (digitalRead(LED)==HIGH)
                 client.print("acceso");
              else
                 client.print("spento");
            }
            else
            {
                if (cmd!="")
                   client.print("Comando "+cmd+": non riconosciuto!"+LT+"br>");
                // Costruzione del MENU se manca o metto un comando errato
                client.print(LT+"U>DIGITA SULLA BARRA DEGLI INDIRIZZI"+LT+"/U>:"+LT+"br>"+LT+"br>");
                client.print(LT+"A href=LED_ON>http://");
                client.print(Ethernet.localIP());
                client.print("/led_on"+LT+"/A> per accendere il LED"+LT+"br>");
                client.print(LT+"A href=LED_OFF>http://");
                client.print(Ethernet.localIP());
                client.print("/led_off"+LT+"/A> per spegnere il LED"+LT+"br>");
                client.print(LT+"A href=STATUS>http://");
                client.print(Ethernet.localIP());
                client.print("/status"+LT+"/A> per vedere lo stato del LED"+LT+"br>");
            }
            client.println(LT+"/h1>"+LT+"/body>"+LT+"/html>");
            cmd=msg="";
            break;
         }
         if (c == '\n') 
           currentLineIsBlank = true; // Inizia una nuova linea
         else if (c != '\r') 
           currentLineIsBlank = false; // ricevuto un nuovo carattere sulla linea corrente
       }
     }
     delay(1);  // lascia il tempo al browser per ricevere il dato
     client.stop(); // chiude la connessione con il client
   }
}

E' possibile inserire un'immagine (senza utilizzare la memory card!) sfruttando il servizio su www.webcodertools.com. Basta caricare un file immagine per ottenere la stringa Base64 associata con annesso il tag html img. Con questo metodo sarà possibile creare pagine html più accattivanti utilizzando codice html e immagini codificate in Base64.

Codice Sorgente C

Obiettivo progetto: Costruire un piccolo WEB Server che realizzi le seguenti funzionalità:

soluzione: Per poter utilizzare questo codice è necessario installare la libreria WEBDUINO disponibile in questo link. Per installarla basta scompattare il file e copiare la cartella prodotta (WEBDUINO) all'interno della cartella contenente le librerie di Arduino (solitamente C:\Program Files\Arduino\libraries). Terminare aggiungendo la cartella appena copiata, mediante il menu "Add Library", all'interno dell'IDE di Arduino

Agiunta libreria

al termine dell'importazione i files vengono ricopiati nella cartella C:\Users\<User>\Documents\Arduino\libraries. Se ci sono problemi nell'installazione occorre svuotare la cartella di libreria appena ricopiata. Per quanto riguarda la conversione in base64 relative alle credenziali d'accesso è possibile utilizzare il seguente form:

#include 
#include 
#include  //libreria webduino
#define LT "<"
#define LED 3

template
inline Print &operator <<(Print &obj, T arg)
{ obj.print(arg); return obj; }

// variabili statiche per il mac address e l'ip address
// al posto di byte posso usare: uint8_t
// Il valore del MAC ADDRESS deve essere unico sulla rete
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
// se non imposto l'IP questo verrà gestito, se esiste, dal DHCP.
static byte ip_Add[] = { 192, 168, 1, 177 };
WebServer webserver("", 80); //creazione oggetto Webduino

P(htmlHead) = LT "html>\n"
              LT "head>\n"
              LT "title>Arduino Web Server" LT "/title>\n"
              LT "style type=\"text/css\">\n"
              "BODY { font-family: arial }\n"
              "H1 { font-size: 14pt; }\n"
              "P  { font-size: 10pt; }\n"
              LT "/style>\n"
              LT "/head>\n"
              LT "body>\n";
P(htmlTail) = LT "/body>\n"
              LT "/html>\n";

// -----------------------------------------------------------------
// funzione relativa alla Home page
// -----------------------------------------------------------------
void CmdHomePage(WebServer &server, WebServer::ConnectionType type, char *url_param, bool param_complete)
{
   int val=digitalRead(LED);
   // Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
   P(P1) = LT "h1>Arduino Home Page" LT "/h1>" LT "h3>\n"
              LT "a href=paginastatica.html>Pagina statica" LT "/a>" LT "br>\n"
              LT "a href=privata.html>Pagina privata (user+passwd)" LT "/a>" LT "br>\n"
              "Pagina con parametro GET" LT "UL>\n"
              LT "LI>" LT "a href=parametriGET.html?LED=ON>LED=ON" LT "/a>" LT "br>\n"
              LT "LI>" LT "a href=parametriGET.html?LED=OFF>LED=OFF" LT "/a>" LT "br>\n"
              LT "LI>" LT "a href=parametriGET.html>Nessun parametro nell'URL" LT "/a>" LT "br>\n"
              LT "LI>" LT "input type=\"button\" value=\"Verifica stato del LED\" onclick=\"location.href='parametriGET.html?LED=STATUS'\">" LT "/UL>\n"
              " " LT "form action='parametriPOST.html' method='post'>\n"
              "Stato LED : ";
   P(P3) = LT "input type='submit' value='Cambia stato al LED'/>" LT "/form>" LT "br>\n"
              LT "img src='led.png' width=256 height=256>\n" LT "/h3>\n";
   server.httpSuccess(); //restituisce al browser l'intestazione http 200 OK
   if (type != WebServer::HEAD) //gestisco il tipo di richiesta HEAD
   {
      server.printP(htmlHead);
      server.printP(P1);
      server.radioButton("PIN3","1","On",val=1);
      server.print(" ");
      server.radioButton("PIN3","0","Off",val=0);
      server.printP(P3);
      server.printP(htmlTail);
   }
}

// -----------------------------------------------------------------
// funzione relativa alla spedizione della pagina
// -----------------------------------------------------------------
void SendHTMLPage(WebServer &server, WebServer::ConnectionType type, char *url_param, bool param_complete,const unsigned char *StrBody, bool privata)
{
  bool leggipagina=false;
  if (privata)
  {
    // verifico nome utente e password - il codice base64 e' 
    // relativo alla codifica di "sechi:marco"
    if (server.checkCredentials("c2VjaGk6bWFyY28="))
       leggipagina=true;
    else // creo la risposta http nel caso di un accesso non autorizzato
       server.httpUnauthorized();
  }
  else
    leggipagina=true;
  if (leggipagina)
  {
    server.httpSuccess(); //restituisce al browser l'intestazione http 200 OK
    if (type != WebServer::HEAD) //gestisco il tipo di richiesta HEAD
    {
        server.printP(htmlHead);
        server.printP(StrBody);
        server.printP(htmlTail);
    }
  }
}

// -----------------------------------------------------------------
// funzione relativa alla pagina statica
// -----------------------------------------------------------------
void CmdPaginaStatica(WebServer &server, WebServer::ConnectionType type, char *url_param, bool param_complete)
{
    P(strMsg) = LT "h1>Pagina Statica" LT "/h1>\n"
                LT "a href='\'>Home Page" LT "/a>\n";
    SendHTMLPage(server,type,url_param,param_complete,strMsg,false);
}

// -----------------------------------------------------------------
// funzione relativa alla pagina protetta da password
// -----------------------------------------------------------------
void CmdPaginaPrivata(WebServer &server, WebServer::ConnectionType type, char *url_param, bool param_complete)
{
    P(strMsg) = LT "h1>Pagina Privata" LT "/h1>"
                "Buongiorno Marco!" LT "h3>"
                LT "a href='\'>Home Page" LT "/a>";
    SendHTMLPage(server,type,url_param,param_complete,strMsg,true);
}

// -----------------------------------------------------------------
// funzione pagina con passaggio parametri GET
// -----------------------------------------------------------------
void CmdPaginaParametrica(WebServer &server, 
                          WebServer::ConnectionType type,
                          char *url_param, bool param_complete)
{
  String Stato;
  server.httpSuccess(); //restituisce al browser l'intestazione http 200 OK
  P(strHead) = LT "h1>Pagina con parametri GET" LT "/h1>"
              "Parametri letti:";
  P(strTail) = LT "h3>"
              LT "a href='\'>Home Page" LT "/a>";
  if (type == WebServer::GET)
  {
    if (param_complete == true)
    {
      String s=String(url_param);
      if (s.indexOf("LED=")>=0)
      {
        if (s.indexOf("LED=ON")>=0)
        {
          Stato=LT "BR>LED = L'HO ACCESO";
          digitalWrite(LED,HIGH);
        }
        else if (s.indexOf("LED=OFF")>=0)
        {
          Stato=LT "BR>LED = L'HO SPENTO";
          digitalWrite(LED,LOW);
        }
        else if (s.indexOf("LED=STATUS")>=0)
        {
          if (digitalRead(LED)==HIGH)
             Stato=LT "BR>STATO LED = ACCESO";
          else
             Stato=LT "BR>STATO LED = SPENTO";
        }
      }
    }
    server.printP(htmlHead);
    server.printP(strHead);
    server.print(url_param);
    server.print(Stato);
    server.printP(strTail);
    server.printP(htmlTail);
  }
  else if (type == WebServer::HEAD)
  {
      //gestisco il tipo di richiesta HEAD
    server.printP(strHead);
    server.print("Nessuno!");
    server.printP(strTail);
  }
}


void CmdPaginaForm(WebServer &server, WebServer::ConnectionType type, char *url_tail, bool tail_complete)
{
  if (type == WebServer::POST)
  {
    bool repeat;
    char name[16], value[16];
    do
    {
      repeat = server.readPOSTparam(name, 16, value, 16);
      int pin = strtoul(name +3, NULL, 10);
      int val = strtoul(value, NULL, 10);
      digitalWrite(pin, val);
    } while (repeat);

    server.httpSeeOther("/parametriPOST.html");
  }
  else
  {
      P(strMsg) = LT "h1>Pagina FORM" LT "/h1>"
                LT "a href='\'>Home Page" LT "/a>";
      server.printP(strMsg);
  }
}
//=============================================================================
void CmdImmagine(WebServer &server, WebServer::ConnectionType type, char *url_param, bool tail_complete)
{
  /* this data was taken from a PNG file that was converted to a C data structure
   * by running it through the directfb-csource application. */
  P(ledData) = {
    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10, 0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x91, 0x68,
    0x36, 0x00, 0x00, 0x00, 0x01, 0x73, 0x52, 0x47, 0x42, 0x00, 0xae, 0xce, 0x1c, 0xe9, 0x00, 0x00,
    0x00, 0x04, 0x67, 0x41, 0x4d, 0x41, 0x00, 0x00, 0xb1, 0x8f, 0x0b, 0xfc, 0x61, 0x05, 0x00, 0x00,
    0x00, 0x20, 0x63, 0x48, 0x52, 0x4d, 0x00, 0x00, 0x7a, 0x26, 0x00, 0x00, 0x80, 0x84, 0x00, 0x00,
    0xfa, 0x00, 0x00, 0x00, 0x80, 0xe8, 0x00, 0x00, 0x75, 0x30, 0x00, 0x00, 0xea, 0x60, 0x00, 0x00,
    0x3a, 0x98, 0x00, 0x00, 0x17, 0x70, 0x9c, 0xba, 0x51, 0x3c, 0x00, 0x00, 0x00, 0x18, 0x74, 0x45,
    0x58, 0x74, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x00, 0x50, 0x61, 0x69, 0x6e, 0x74,
    0x2e, 0x4e, 0x45, 0x54, 0x20, 0x76, 0x33, 0x2e, 0x33, 0x36, 0xa9, 0xe7, 0xe2, 0x25, 0x00, 0x00,
    0x00, 0x57, 0x49, 0x44, 0x41, 0x54, 0x38, 0x4f, 0x95, 0x52, 0x5b, 0x0a, 0x00, 0x30, 0x08, 0x6a,
    0xf7, 0x3f, 0xf4, 0x1e, 0x14, 0x4d, 0x6a, 0x30, 0x8d, 0x7d, 0x0d, 0x45, 0x2d, 0x87, 0xd9, 0x34,
    0x71, 0x36, 0x41, 0x7a, 0x81, 0x76, 0x95, 0xc2, 0xec, 0x3f, 0xc7, 0x8e, 0x83, 0x72, 0x90, 0x43,
    0x11, 0x10, 0xc4, 0x12, 0x50, 0xb6, 0xc7, 0xab, 0x96, 0xd0, 0xdb, 0x5b, 0x41, 0x5c, 0x6a, 0x0b,
    0xfd, 0x57, 0x28, 0x5b, 0xc2, 0xfd, 0xb2, 0xa1, 0x33, 0x28, 0x45, 0xd0, 0xee, 0x20, 0x5c, 0x9a,
    0xaf, 0x93, 0xd6, 0xbc, 0xdb, 0x25, 0x56, 0x61, 0x01, 0x17, 0x12, 0xae, 0x53, 0x3e, 0x66, 0x32,
    0xba, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
  };

  if (type == WebServer::POST)
  {
    // ignore POST data
    server.httpFail();
    return;
  }

  /* for a GET or HEAD, send the standard "it's all OK headers" but identify our data as a PNG file */
  server.httpSuccess("image/png");

  /* we don't output the body for a HEAD request */
  if (type == WebServer::GET)
  {
    server.writeP(ledData, sizeof(ledData));
  }
}

void CmdErrore400(WebServer &server, WebServer::ConnectionType type, char *url_param, bool tail_complete)
{
  P(Page_start) = LT "html>" LT "head>" LT "title>Web_Parms_1 " LT "/title>" LT "/head>" LT "body>\n";
  P(Page_end) = LT "/body>" LT "/html>";
  P(Get_head) = LT "h1>GET from ";
  P(Post_head) = LT "h1>POST to ";
  P(Unknown_head) = LT "h1>UNKNOWN request for ";
  P(Default_head) = "unidentified URL requested." LT "/h1>" LT "br>\n";
  P(Tail_end) = "'" LT "br>\n";
  P(Good_tail_begin) = "URL tail = '";
  P(Bad_tail_begin) = "INCOMPLETE URL tail = '";
  
  server.httpFail(); // invia un errore "HTTP 400 - Bad Request" al browser
  /* se si tratta di un GET o un POST possiamo mostrare qui i dati
    Se è una HEAD request dobbiamo fermarci qui. */
  if (type == WebServer::HEAD)
    return;

  server.printP(Page_start);
  switch (type)
    {
    case WebServer::GET:
        server.printP(Get_head);
        break;
    case WebServer::POST:
        server.printP(Post_head);
        break;
    default:
        server.printP(Unknown_head);
    }

    server.printP(Default_head);
    server.printP(tail_complete ? Good_tail_begin : Bad_tail_begin);
    server.print(url_param);
    server.printP(Tail_end);
    server.printP(Page_end);
}


void setup()
{
  // Inizializzo l'ethernet shield con il mac e il address
  Ethernet.begin(mac_Add, ip_Add);
  // definisco l'azione di default che verrà eseguita quando l'utente
  // naviga nella root del sito
  webserver.setDefaultCommand(&CmdHomePage);
  // definisco la pagina da mostrare quando quella richiesta non è sul server */
  webserver.setFailureCommand(&CmdErrore400);
  // aggiungi altri comandi/pagine - il 1^ argomento e' case sensitive
  webserver.addCommand("index.html", &CmdHomePage);
  webserver.addCommand("paginastatica.html", &CmdPaginaStatica);
  webserver.addCommand("privata.html", &CmdPaginaPrivata);
  webserver.addCommand("parametriGET.html", &CmdPaginaParametrica);
  webserver.addCommand("parametriPOST.html", &CmdPaginaForm);
  webserver.addCommand("led.png", &CmdImmagine);
  // avvia il web server
  webserver.begin();
  pinMode(LED,OUTPUT);
  digitalWrite(LED,LOW);
}
 
void loop()
{
  //elabora costantemente tutte le richieste provenienti dal browser
  webserver.processConnection();
}

voci	in chiaro	base64	conversione base 64
User:Password