Arduino

Arduino Ethernet Shield

Guida alla gestione e controllo delle schede Arduino via ethernet

La rapida evoluzione ed espansione delle schede Arduino è legata allo sviluppo e vendita di accurate shield funzionali che permettono di interfacciare un semplice microcontrollore, quale l’ATmega328PU, con il mondo esterno a seconda delle nostre esigenze. Tra le tante board disponibili troviamo la Shield Ethernet che permette di gestire il microcontrollore tramite una rete ethernet. Tale shield ha un costo ridotto e permette di interagire da remoto con la nostra scheda.

Di seguito riportiamo tre esempi pratici che possono rappresentare il punto di partenza per sviluppare i vostri progetti, tra cui data logger, gestione di relay per carichi in AC in campo domotico, web server e molto altro. Se sei agli inizi, parti dalle basi della programmazione Arduino; per mostrare l’indirizzo IP su un display vedi LCD LiquidCrystal con Arduino.

Shield W5100 e W5500

Gli esempi sono stati scritti per lo shield Ethernet basato sul chip WIZnet W5100. Oggi è più diffusa la versione con chip W5500 (Ethernet Shield 2 e molti cloni): la libreria Ethernet ufficiale, dalla versione 2.0, riconosce automaticamente W5100, W5200 e W5500, per cui gli sketch funzionano con entrambi senza modifiche. In entrambi gli shield il chip Ethernet usa il pin 10 come chip select e il lettore microSD il pin 4.

Librerie utilizzate

Volendo fare un minimo di chiarezza sul codice utilizzato per gli sketch possiamo individuare generalmente l’utilizzo delle seguenti librerie:

  • SPI: Serial Peripheral Interface, è un protocollo seriale utilizzato dai microcontrollori per comunicare con uno o più dispositivi in modo rapido. Con una connessione SPI vi è sempre un dispositivo master (di solito un microcontrollore) il quale controlla i dispositivi periferici.
    Reference: https://www.arduino.cc/en/Reference/SPI

Quelle sopra elencate sono le librerie più gettonate per progetti che sfruttano la comunicazione ethernet.

Indirizzo MAC, indirizzo IP e porta

Ogni sketch presenterà due dati di estrema importanza che possono essere modificati in base alle proprie necessità. Tali parametri sono l’indirizzo mac e l’indirizzo IP della scheda. In tutti gli esempi trattati in questo articolo l’indirizzo IP è 192.168.1.177. In alternativa all’IP statico si può lasciare che sia il router ad assegnare l’indirizzo tramite DHCP, usando Ethernet.begin(mac) e leggendo l’indirizzo ottenuto con Ethernet.localIP(). Si lavora all’interno di una rete locale: tecnicamente con un port forwarding sul router il dispositivo diventerebbe raggiungibile anche da Internet, ma è fortemente sconsigliato perché questi sketch non prevedono alcuna autenticazione e chiunque potrebbe comandare la scheda. Per l’accesso remoto è preferibile una VPN verso la propria rete domestica. Un altro dato importante è la porta utilizzata, solitamente viene impostata la 80 (ovvero la porta utilizzata per i servizi web).

Esempio 1: Hello World (no scheda SD)

Con questo esempio si vuole mostrare il funzionamento dello shield ethernet senza l’utilizzo della memoria SD ausiliaria. Tale sistema è consigliato solo se la pagina web da generare è minimale. Infatti, le informazioni per la creazione della pagina sono all’interno del codice Arduino e pertanto andranno a saturare la memoria disponibile dedicata per lo sketch (vedi Arduino: gestione memorie interne).

Il seguente codice stamperà all’url indicato (nel nostro esempio 192.168.1.177) quanto segue:

Hello world Arduino Web Server
Vieni a visitare MST TUTORIAL
//Includiamo le librerie necessarie al progetto
#include <SPI.h>
#include <Ethernet.h>
 
//indirizzo mac fisico dello shield
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//indirizzo ip rete locale (inserire indirizzo valido per la propria rete)
byte ip[] = {192, 168, 1, 177};

//definiamo la porta di lavoro
EthernetServer ArduinoServer(80);

//variabile char per memorizzare i pacchetti
char Data_RX;
 

void setup()
{
    //inizializziamo la scheda con indirizzo mac e IP definiti in precedenza.
    //Attiviamo il server web
    Ethernet.begin(mac, ip);
    ArduinoServer.begin();
}
 
void loop()
{
   //Ascolto delle richieste
   EthernetClient pc_client = ArduinoServer.available();
 
   //Verifico se ci sono richieste tramite "pc_client" true
   if (pc_client)
   {
       //una riga vuota indica la fine degli header della richiesta HTTP
       boolean currentLineIsBlank = true;
       //con un ciclo while verifico che il client sia connesso
       while (pc_client.connected())
       {
           //Controllo se ci sono byte disponibili per la lettura
           if (pc_client.available())
           {
               //leggo i byte provenienti dal client
               Data_RX = pc_client.read();
 
               //un "\n" su una riga vuota indica che la richiesta (riga iniziale + header) è stata ricevuta per intero
               if (Data_RX == '\n' && currentLineIsBlank)
               {
                   //invio pagina HTML
                   pc_client.println("HTTP/1.1 200 OK");
                   pc_client.println("Content-Type: text/html");
                   pc_client.println("Connection: close");
                   pc_client.println();
                   pc_client.print("<html><body>");
                   pc_client.print("<h1>Hello world Arduino Web Server</h1><br /><br />Vieni a visitare <a href=\"https://www.mst-tutorial.it\">MST TUTORIAL</a></body></html>");
                   
                   //aspetto 1 ms affinche la risposta giunga al browser del client
                   delay(1);
                   
                   //esco dal ciclo
                   break;
               }
               if (Data_RX == '\n') {
                   //inizia una nuova riga
                   currentLineIsBlank = true;
               }
               else if (Data_RX != '\r') {
                   //la riga corrente contiene caratteri
                   currentLineIsBlank = false;
               }
           }
       }

       //chiudo la connessione
       pc_client.stop();
   }
}

Esempio 2: Hello World (file htm su scheda SD)

In questo esempio andremo a sfruttare lo shield ethernet con annessa memoria SD. Chip Ethernet e lettore SD condividono il bus SPI e sono selezionati rispettivamente dai pin 10 e 4; su Arduino Mega il pin 53 (SS hardware) va comunque lasciato configurato come uscita. Prima di continuare verificare che la memoria SD sia formattata con filesystem fat32 e al suo interno dev’essere presente il file htm con i contenuti da noi desiderati.

L’obiettivo è far visualizzare il contenuto della pagina web htm dal nostro server Arduino. Nel nostro caso, il server Arduino sarà raggiungibile all’indirizzo ip 192.168.1.177.

//Aggiungo le librerie necessarie
#include <SPI.h>
#include <Ethernet.h>
#include <SD.h>



//definiamo due array: il primo per definire l'indirizzo mac, il secondo per definire l'indirizzo IP.
//Per quanto riguarda l'indirizzo IP selezionate un indirizzo valido per la vostra rete locale.
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = {192, 168, 1, 177};

//definiamo la porta di ascolto
EthernetServer server(80);
File htmlFile;
//true se la microSD è stata inizializzata correttamente
boolean sdOk = false;

void setup (){
  //seriale attivata per prima, così da poter segnalare eventuali errori
  Serial.begin(9600);
  Ethernet.begin(mac, ip);
  server.begin();
  //pin 4: chip select della microSD (il pin 10 è il chip select del chip Ethernet)
  sdOk = SD.begin(4);
  if (!sdOk) {
    //il server resta attivo e risponde con una pagina di errore
    Serial.println("Errore: inizializzazione microSD fallita");
  }
}

void loop (){

  EthernetClient client = server.available();

  if (client) {
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        if (c == '\n' && currentLineIsBlank) {
          if (sdOk) {
            htmlFile = SD.open("index.htm");
          }
          if (sdOk && htmlFile) {
            client.println("HTTP/1.1 200 OK");
            client.println("Content-Type: text/html");
            client.println("Connection: close");
            client.println();
            while (htmlFile.available()) {
              client.write(htmlFile.read());
            }
            // close the file:
            htmlFile.close();
          }
          else {
            //microSD assente o file index.htm mancante: risposta di errore
            client.println("HTTP/1.1 500 Internal Server Error");
            client.println("Content-Type: text/html");
            client.println("Connection: close");
            client.println();
            client.println("<html><body><h1>Errore: microSD o file index.htm non disponibile</h1></body></html>");
          }
          break;
        }
        if (c == '\n') {
          currentLineIsBlank = true;
        }
        else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }
    delay(1);
    client.stop();
  }
}

Esempio 3: Gestione output da remoto

In questo esempio l’intera pagina web risiede all’interno del microcontrollore (pertanto non si necessita di memoria microSD esterna). Questo fattore ovviamente incide sullo spazio disponibile per lo sketch. Pertanto, è possibile spostare tutta la gestione della pagina web su un file htm memorizzato in una microSD.

Il seguente codice permette di pilotare tramite shield ethernet un carico posto sul pin 8 della nostra scheda (per le prove un LED con resistenza in serie da 220 – 330 Ω oppure un buzzer). L’indirizzo IP utilizzato nel seguente sketch è 192.168.1.177. Lo sketch legge la prima riga della richiesta HTTP, esegue il comando (?outputon oppure ?outputoff), invia la pagina di risposta e solo alla fine chiude la connessione. Per carichi più impegnativi, come un relè, serve uno stadio di pilotaggio: vedi Transistor BJT NPN come interruttore.

//Includo librerie necessarie
#include <SPI.h>
#include <Ethernet.h>

//Indirizzo mac shield ethernet
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

//Configurazione indirizzo IP di rete
IPAddress ip(192, 168, 1, 177);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

//Inizializzazione porta server web
EthernetServer server(80);
String readString;

// posizione fisica output (collegare led o output)
int uscita = 8;

void setup()
{
  //definisco il terminale "uscita" come output
  pinMode(uscita, OUTPUT);
  //riservo subito la memoria per la stringa: limita la frammentazione dell'heap
  readString.reserve(100);
  //attivo porta seriale per eventuale debug
  Serial.begin(9600);

  //attivo connessione eth
  Ethernet.begin(mac, ip, gateway, subnet);
  server.begin();
  Serial.print("Indirizzo ip server: ");
  Serial.println(Ethernet.localIP());
  Serial.println("Gestione OUTPUT www.mst-tutorial.it");
}

void loop()
{

  EthernetClient client = server.available();
  if (client)

  {
    Serial.println("new client");

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

      {
        char c = client.read();

        //memorizzo al massimo 100 caratteri della richiesta:
        //il controllo del fine riga avviene comunque, anche con righe più lunghe
        if (readString.length() < 100) {
          readString += c;
        }
        Serial.write(c);

        if (c == '\n') {
          Serial.println(readString); //stampa su monitor seriale per debug

          //eseguo il comando PRIMA di rispondere e di chiudere la connessione
          //USCITA ON
          if (readString.indexOf("?outputon") > 0) {
            digitalWrite(uscita, HIGH);
            Serial.println("LED/BUZZER On");
          }
          //USCITA OFF
          else if (readString.indexOf("?outputoff") > 0) {
            digitalWrite(uscita, LOW);
            Serial.println("LED/BUZZER Off");
          }

          //--------------------------------------------------------------------------------------------------------
          //creazione pagina web
          client.println("HTTP/1.1 200 OK"); //send new page
          client.println("Content-Type: text/html");
          client.println("Connection: close");
          client.println();
          client.println("<HTML>");
          client.println("<HEAD>");
          client.println("<TITLE>MST TUTORIAL controllo remoto eth shield</TITLE>");
          client.println("</HEAD>");
          client.println("<BODY>");
          client.println("<center>");
          client.println("<p><img src=\"https://www.mst-tutorial.it/wp-content/uploads/2017/11/logo2.png\" width=\"500\"></p>");
          client.println("<H1>controllo remoto eth shield</H1>");
          client.println("<hr />");
          client.println("<br />");
          client.println("<p>Posizionare il led (con resistenza in serie) o il buzzer tra il pin 8 e GND</p>");
          client.println("<br /><br />");
          client.println("<a href=\"/?outputon\">OUTPUT ON</a>");
          client.println("<br />");
          client.println("<br />");
          client.println("<a href=\"/?outputoff\">OUTPUT OFF</a><br />");
          client.println("<br /><br /><br /><br />");
          client.println("visita <a href=\"https://www.mst-tutorial.it\">www.mst-tutorial.it</a><br />");
          client.println("</center>");
          client.println("</BODY>");
          client.println("</HTML>");
          readString = "";

          delay(1);
          //chiudo la connessione una sola volta
          client.stop();
          Serial.println("client disconnected");
        }
      }
    }
  }
}

Admin | MST-Tutorial

Appassionato di elettronica, elettrotecnica e programmazione. Fondatore di MST-Tutorial, condivido con entusiasmo conoscenze, esperienze e progetti legati all’innovazione tecnologica, con l’obiettivo di rendere accessibili concetti tecnici complessi attraverso tutorial chiari e pratici.

Articoli Correlati

Pulsante per tornare all'inizio