Diciamolo, una delle migliori caratteristiche di Arduino è la facilità di interfacciarlo con qualsiasi dispositivo. La sua notorietà lo porta ad avere una vasta community di sviluppo che lo rende davvero un dispositivo “plug-and-play”. Inoltre il mondo dell’elettronica hobbystica si sta spostando sempre più verso quello che viene definito “l’Internet delle cose”.
Quest’oggi vedremo come collegare Arduino alla nostra rete LAN utilizzando una scheda NIC Ethernet esterna.

La scheda in questione è molto diffusa in giro ed è acquistabile ad esempio su eBay per pochi euro. E’ composta da una porta Ethernet RJ-45 con led di stato ed è pilotato da un integrato della Microchip, l’ENC28J60. Questo controller ha integrato in hardware sia il layer MAC che il layer PHY, ma bisogna implementare lo stack TCP/IP via software ed è possibile comunicare con esso tramite SPI. La scheda è la seguente:

ENC28j60 Ethernet Interface Module1


Come già accennato, il controller Ethernet non ha al suo interno uno stack TCP/IP e per questo bisogna programmarlo lato Arduino.

Ci viene in aiuto una potente e ben strutturata libreria scritta appositamente per questa scheda. La che potete scaricare da qui.

Una volta scaricata la libreria, bisogna installarla. Scompattate il contenuto dell’archivio zippato e spostate la cartella della libreria ed il suo contenuto all’interno della cartella “libraries” di Arduino.
Se siete nuovi su Arduino e non sapete dove risiede questa cartella, potete trovarla e impostarla andando nel menù File -> Preferenze ed impostarla come in questa finestra, dove è evidenziato:

Preferenze Arduino

Quindi salvate l’impostazione con OK e copiate la libreria in questa cartella.

ATTENZIONE: La cartella della libreria (in realtà qualunque libreria) va rinominata quando viene inserita nella cartella “libraries”. Quindi rinominiamola semplicemente in EtherCard.

Quindi colleghiamo la scheda del controller Ethernet all’arduino utilizzando questa tabella di riferimento:

Arduino Ethernet ENC28J60

ATTENZIONE: I pin Dxx sono da intendere quelli digitali e non i pin dell’integrato.

Fatto questo, è ora di iniziare a scrivere lo sketch.
Nell’IDE Arduino creiamo un nuovo sketch e importiamo la libreria dal menù Sketch -> Importa libreria.. ed in basso selezioniamo EtherCard.

Bene, siamo pronti a scrivere lo sketch. Iniziamo con l’impostare alcuni parametri necessari per il corretto, anzi, per il funzionamento del programma. Quindi ecco il primo pezzo di codice:

#include <EtherCard.h>
#define CS_PIN 10

// ethernet interface mac address
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
// ethernet interface ip address
static byte myip[] = { 192,168,1,60 };
// gateway ip address
static byte gwip[] = { 192,168,1,1 };

byte Ethernet::buffer[300];   // a very small tcp/ip buffer is enough here

Analizziamo quindi il codice:
Innanzitutto viene inclusa l’header della libreria EtherCard. Vengono definite successivamente alcune variabili.

La variabile mymac definisce l’indirizzo fisico a sei byte del MAC ADDRESS, ovvero l’indirizzo fisico del controller. Questo indirizzo deve essere univoco per ogni dispositivo esistente al mondo che integra un layer MAC. Per il nostro scopo è sufficiente inserire dei byte random (non credo proprio che avrete problemi di conflitti :) ).

La variabile myip è l’indirizzo IP associato al nostro dispositivo. L’indirizzo IP è quello che risiede all’interno della nostra rete locale, quindi occhio ad impostare i giusti valori. Di solito i router hanno l’indirizzo che varia da 192.168.1.x a 192.168.1.255. Impostatelo quindi a seconda della vostra rete.

La terza variabile gwip è l’indirizzo a cui fa riferimento il nostro router (gateway, che incanala le informazioni verso la linea ADSL, cioè Internet). Nella maggior parte dei casi, se siete sotto un unico router è l’indirizzo che è impostato nel codice, ma controllate sempre facendo un ipconfig /all dal vostro prompt dei comandi se siete su Windows.

Inoltre viene definito un buffer che sarà utilizzato dalla libreria per memorizzate i dati per il suo funzionamento.

Bene la prima parte riguardante la configurazione dei parametri di rete è conclusa. Ora bisogna inizializzare la libreria:


void setup () {
  Serial.begin(57600);
  Serial.println("*** Arduino in LAN - ElettroEasy ***\n\n");
  
  if (ether.begin(sizeof Ethernet::buffer, mymac,CS_PIN) == 0) 
    Serial.println( "Impossibile accedere al controller Ethernet.");

  ether.staticSetup(myip, gwip);

  ether.printIp("IP:  ", ether.myip);
  ether.printIp("GW:  ", ether.gwip);  


}

Analizziamo il codice:
Per prima cosa stabiliamo una comunicazione seriale a 57600 baud con il computer che utilizzeremo come DEBUGGER, questo ci aiuterà a capire dove sono gli errori in caso di problemi.

Quindi il metodo begin() inizializza il controller Ethernet con i parametri immessi precedentemente. Il MAC e l’IP, quindi saranno gli stessi delle rispettive variabili.
Se l’operazione di inizializzazione non va a buon fine, sul monitor seriale apparirà la scritta “Impossibile accedere al controller Ethernet.”. Il mio consiglio è quello di verificare i collegamenti con la scheda Ethernet e i parametri di connessione, quindi riprovare.

Il metodo staticSetup() imposta il controller con un indirizzo IP statico.
Se tutto va a buon fine, apparirà sul monitor seriale l’indirizzo IP del dispositivo e l’indirizzo IP del gateway a cui fa riferimento.

Nel loop dello sketch:

void loop () {
  //elaboro i pacchetti ricevuti
  ether.packetLoop(ether.packetReceive());

}

Nel loop dello sketch abbiamo il metodo packetReceive() annidato nel metodo packetLoop().
Il primo metodo riceve il pacchetto dall’esterno, come ad esempio una chiamata PING. Il metodo packetLoop invece elabora i pacchetti ricevuti e risponde al mittente a seconda della chiamata ricevuta.

Verifichiamo e carichiamo lo sketch nel nostro Arduino e lanciamo il monitor seriale.
Questo dovrebbe essere il risultato:

Monitor Arduino Ethernet

Potete effettuare la prova di funzionamento del vostro dispositivo attraverso il prompt dei comandi, effettuando un ping verso l’indirizzo IP statico che abbiamo impostato nella variabile myip, con il comando:

ping 192.168.1.60

Come in figura:

Ping Arduino ENC28J60

Se leggiamo “Risposta da xxx.xxx.xxx.xxx:” allora il nostro Arduino riceve e processa i pacchetti alla perfezione.

Il listato completo:

#include <EtherCard.h>

// ethernet interface mac address
static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };
// ethernet interface ip address
static byte myip[] = { 192,168,1,60 };
// gateway ip address
static byte gwip[] = { 192,168,1,1 };

byte Ethernet::buffer[300];   // a very small tcp/ip buffer is enough here

void setup () {
  Serial.begin(57600);
  Serial.println("*** Arduino in LAN - ElettroEasy ***\n");
  
  if (ether.begin(sizeof Ethernet::buffer, mymac,10) == 0) 
    Serial.println( "Impossibile accedere al controller Ethernet.");

  ether.staticSetup(myip, gwip);
  
  ether.printIp("IP:  ", ether.myip);
  ether.printIp("GW:  ", ether.gwip);  
  
}

void loop () {
  //elaboro i pacchetti ricevuti
  ether.packetLoop(ether.packetReceive());

  
}

Ed ecco il sistema assemblato su breadboard con Arduino in standalone:

Bene, abbiamo visto come impostare una semplice applicazione che risponde ad un semplice ping.
Nei prossimi articoli vedremo qualcosa di più avanzato. Quindi restate sintonizzati!! 😉