
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
- Ethernet: Necessaria per la comunicazione Ethernet
Reference: https://docs.arduino.cc/libraries/ethernet/
- SD: libreria che permette la lettura e scrittura su dispositivi SD utilizzabili mediante una scheda ethernet.
Reference: https://docs.arduino.cc/libraries/sd/
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:
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");
}
}
}
}
}




