Arduino Ethernet (ENC28J60)

Arduino en de ENC28J60 Ethernet Controller

Het nummer “ENC28J60” staat voor het chip nummer, ontwikkeld door Microchip.  Het betreft een 28 pins chip waarin we een complete stand-alone Ethernet controller vinden voor gebruik met een 10BASE-T netwerk. De chip heeft een SPI interface zodat microcontrollers zoals de Arduino er makkelijk mee kunnen communiceren.

10BASE-T is dezelfde connector die jouw PC gebruikt, als je de PC met een draadje aan jouw netwekr hangt. Hierbij geeft de “10” aan dat de maximale snelheid 10 Mbit/sec is. Dat mag dan langzaam klinken (de meeste netwerken gebruiken 100 Mbit/sec of sneller). Bedenk echter dat je met de Arduino geen enorme ladingen aan data zult verwerken, en na een paar dagen spelen met deze module, kan ik met gerust hart zeggen dat het vlot is.

  Voor het zelf maken van netwerk kabeltjes, lees het “Hoe maak ik zelf een netwerk-kabel” artikel.

10BASE-T RJ45 Connector

Kies jouw ENC28J60 module

Als je op zoek gaat naar een ENC28J60 Ethernet module, dan zul je snel zien dat er legio varianten bestaan, welke in principe electronisch allemaal hetzelfde zijn. Allen het board en de pin locaties zullen anders zijn, uiteraard met specifieke toepassingen in gedachten. Onderstaande foto laat je slecht 2 van de vele varianten zien van de ENC28J60 Ethernet modules.

Ik vond mijn module op eBay voor slechts $18 en werd met een Arduino Nano geleverd (links in de foto – Nano niet afgebeeld), welke prima werkt met een Nano maar ook met een Arduino Uno en waarschijnlijk andere Arduino modellen. De connectors zijn natuurlijk gedacht voor een Nano.

De reden waarom ik dit model koos (totaal niet bewust van het feit dat dit dus niet hetzelfde is als de standaard Arduino Ethernet shield) waren: prijs, Arduino Nano inbegrepen en … super compact. Als je de module en een Arduino Nano combineert, dan is het geheel ongeveer 6.7 cm lang, 1.7 cm breed, en 1.7 cm hoog – waarbij het e.e.a. afhangt of je de pinnen aan de onderkant gebruik, of the connectors aan de bovenkant. In mijn test opstelling gebruik ik de pinnen aan de onderkant maar in het “eindproduct” kan ik de connectors aan de bovenkant gebruiken en de pinnen aan de onderkant afknippen.

Arduino ENC28J60 shield varianten

Omdat ik eigenlijk niet veel uitgezocht had voor ik dit model koos, moest ik helaas ondervinden dat de verkoper maar bar weinig info had en dat dit dus niet de standaard Arduino Ethernet Shield is. Maar … na wat zoeken vond ik dan uiteindelijk een aantal Libraries die prima werken … nadat ik uitgevogeld had welke pinnen ik moest gebruiken.

In de volgende paragrafen bekijk ik drie van dit soort Libraries. Alle drie werken uitstekend!

UIPEthernet is voor projecten waar je een goed werken “print” functie nodig hebt of als het een drop-in vervanging moet zijn voor de standsard “Ethernet” library.
ETHER_28j60 is geweldig omdat het simpel en compact is, maar ook wel een beetje beperkt natuurlijk.
Ethercard lijkt geweldig voor de meer ervaren Arduino/Netwerk gebruikers, maar ik denk dat UIPEthernet het zeker kan evenaren.

Voor elk van de Libraries heb ik een “Hello World!” gemaakt, misschien niet altijd even optimaal, maar het maakt her mogelijk om de “Hello World” melding in jouw webbrowser te zien.

Voor we beginen: Libraries en gebruikte Pinnen

  Je hebt altijd stroom nodig, dus iedere module gebruikt GND en +3.3V of  +5V pin.
  Voor mijn eBay module moest ik +5V gebruiken (het heeft een voltage regulator), omdat de 3.3V pin gewoon niets deed.

Hieronder een tabel die werkt voor een Arduino Uno, Arduino Nano en mijn eBay Ethernet module, met de benodigde pinnen.
Zoals je zult zien, worden de standaard SPI pinnen (10, 11, 12 en 13) gebruikt. Uitzondering is Ethercard, welke pin 8 voor SS gebruikt (i.p.v. de standaard pin 10).

De Ethernet Controller (ENC28J60) is een zogenaamd SPI device en gebruikt dus de SPI pinnen (10, 11, 12, 13) van jouw Arduino.

SS staat voor Slave Select, en wordt gebruikt om het aangesloten SPI apparaat aan of uit te zetten (de Ethernet module in dit geval).
MOSI staat voor Master Output Slave Input, in andere woorden: Arduino OUTPUT (data van de Arduino naar de Ethernet Controller).
MISO staat voor het tegenovergestelde, Master Input Slave Output, of te wel: Arduino INPUT (data van Ethernet Controller naar Arduino).
SCK is de klok voor SPI timing.

De meeste modules hebben de genoemde “Pin naam” op het printje staan. Mijn eBay module echter is gericht op de Nano en heeft alleen maar de Nano pin nummers en dus helemaal geen Ethernet Module pin-namen. Vandaar dus de extra kolom in de tabel voor mijn eBay Ethernet Module.

Illustratie van mijn eBay module, de “Nano Ethernet Shield” van “Deek-Robot“, laat zien wat ik bedoel.

Deek Robot Nano Ethernet Shield

Mijn ENC28J60 test opstelling

Ander voorbeelden

In dit artikel, laat ik je “Hello World!” voorbeelden zien van de besproken libraries. Uiteindelijk werd “UIPEthernet” mijn favoriet, en heb ik een aantal voorbeelden hiervoor geschreven (ik vul de lijst aan zodra ze gepubliceerd zijn):

  Data ophalen (Data Pull) via het netwerk
  Data versturen (Data Push) via het netwerk

Arduino Library: ETHER_28J60 en EtherShield

Dit was de eerste Library die ik vond en getest heb. Het werkt meteen, met name omdat het super simpel in gebruik is.

Al snel, toen ik wat complexere dingen wilde proberen, liep ik tegen de erg beperkte print functie van deze Library. Na wat rondsnuffelen op het Internet bleek dat de ontwikkelaar al lang niets meer veranderd had aan de Library en ik vermoed dat verder ontwikkeling geheel gestopt is, wat erg jammer is.

  Je hebt beide bibliotheken nodig!

Voordelen:

In onderstaande code zie je hoe eenvoudig ETHER_28J60 is … werkelijk, het kan niet eenvoudiger!

De library is ook erg compact, wat geheugen op de Arduino bespaart, iets wat we niet kunnen zeggen van de ander twee libraries.

Nadelen:

Een van de grootste nadelen is dat het geen zogenaamde drop-in vervanging is van de standaard Ethernet Library die bij de Arduino IDE geleverd wordt. Voorbeelden voor de standaard library kunnen dus niet eenvoudig omgezet worden.

Een ander, groter, probleem is de beperkte functionaliteit van de ingebouwde “print” functie waar je geen gebruik kunt maken van de Arduino String klasse.
Ik zal meteen toegeven dat dit ook deels is door mijn beperkte ervaringen met C-strings, zeker als bekende functies zoals  sprintf en  printf niet bestaan of maar deels werken (Arduino standaard library beperking).

Omdat verder ontwikkeling gestopt lijk, verwacht ook geen verbetering van deze “print” functie (tenzij iemand een fork maakt op Github).

Download:

ETHER_28J60 en Ether shield kun je downloaden van Github of natuurlijk van Tweaking4All.
Zoals altijd het advies om de actuele versie van Github te halen, maar in dit geval zal dat wel niets uitmaken.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// Een simpele web server die "Hello World" zegt



#include "etherShield.h"

#include "ETHER_28J60.h"



// Definieer MAC en IP adres - beiden dienen uniek te zijn in jouw netwerk

static uint8_t mac[6] = {0x54, 0x55, 0x58, 0x10, 0x00, 0x24};  

static uint8_t ip[4] = {192, 168, 1, 15}; 

static uint16_t port = 80; // Gebruik poort 80 - standaard voor HTTP                                     



ETHER_28J60 ethernet;



void setup()

{ 

  ethernet.setup(mac, ip, port);

}



void loop()

{

  if (ethernet.serviceRequest())

  {

    ethernet.print("<H1>Hello World</H1>");

    ethernet.respond();

  }

  delay(100);

}

Arduino Library: EtherCard

Deze Library blijkt zeer gerespecteerd te zijn in de Arduino gemeenschap en met goede redenen. Het lijkt erop dat dit de meest uitgebreide implementatie is.

Onderstaande code mag er wat moeilijker uitzien maar dat is hoofdzakelijk vanwege de ingevoerde HTML.

  LET OP: Ethercard gebruikt pin 8 in plaats van pin 10!

Voordelen:

Deze library is goed wanneer het aankomt op complexe netwerk zaken zoals DHCP etc. Voor ervaren Arduino/Netwerk gebruikers zeker aan te raden.

Nadelen:

Ook hier weer het gedoe met de “print” functie om data te versturen, of beter gezegd: het ontbreken van een “print” functie.

Ik ben me bewust dat mijn gemopper omtrent de “print” functie een beperking van mijzelf is, maar ik vermoed dat er genoeg andere gebruikers zijn die tegen dezelfde beperking aanlopen. Hoe moeilijk moet het worden om een stukje tekst te versturen zonder buffers en arrays?

Ethercard is, net zoals UIPEthernet, niet echt compact en verbruikt dus best wat geheugen.

Download:

EtherCard vindt je ook op GitHub en op de Ethercard project pagina of natuurlijk op Tweaking4All.
Ook hier weer: kijk eerst op Github zodat je de meest recente versie hebt.

Note: Update voor de nieuwere Arduino IDE (dank je Permutor!). Zie regel 10: “const” toegevoegd zodat we geen compiler error krijgen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <EtherCard.h>



// Ethernet IP, default gateway en MAC adres

static byte myip[] = { 192,168,1,200 };

static byte gwip[] = { 192,168,1,1 };

static byte mymac[] = { 0x74,0x69,0x69,0x2D,0x30,0x31 };



byte Ethernet::buffer[500]; // tcp/ip send en receive buffer



const char page[] PROGMEM =

"HTTP/1.0 503 Service Unavailable\r\n"

"Content-Type: text/html\r\n"

"Retry-After: 600\r\n"

"\r\n"

"<html>"

  "<head><title>"

    "Hello World!"

  "</title></head>"

  "<body>"

    "<h3>Hello World! This is your Arduino speaking!</h3>"

  "</body>"

"</html>";



void setup(){

  Serial.begin(57600);

  Serial.println("\n[Hello World]");



  if (ether.begin(sizeof Ethernet::buffer, mymac) == 0) 

    Serial.println( "Toegang to Ethernet controller is mislukt");

  ether.staticSetup(myip, gwip);



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

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

  ether.printIp("DNS: ", ether.dnsip);  

}



void loop(){

  // wacht op inkomend TCP packet, maar negeer de inhoud van het pakket

  if (ether.packetLoop(ether.packetReceive())) {

    memcpy_P(ether.tcpOffset(), page, sizeof page);

    ether.httpServerReply(sizeof page - 1);

  }

}

Arduino Library: UIPEthernet

Na wat dagen prullen met de eerste twee libraries, liep ik tegen UIPEthernet aan, wat op dit moment mijn favoriet is.

Onderstaande code mag er misschien complex uitzien, maar dat is mijn fout. Ik wilde “even snel” voorbeeld code voor een “Hello World!” voor jullie in elkaar gooien.

Voordelen:

Een van de belangrijkste voordelen is dat het geheel compatibel is met de standaard Ethernet Library die bij de Arduino IDE zit. Je kunt het dus als een drop-in vervanging gebruiken waarbij je alleen maar de twee include regels van de voorbeelden (“#include <Ethernet.h> ” and “#include <SPI.h> “) hoeft te vervangen met “#include <UIPEthernet.h>“.

Ook een groot voordeel is dat we hier een “print” functie hebben die WEL compleet is. Deze “print” functie werkt hetzelfde als de print functie die je gebruikt in “Serial” – mooi dus!

Ook de “pro” gebruiker zal niet teleurgesteld zijn omdat er legio geavanceerde functies beschikbaar zijn.

Nadelen:

Duidelijk groter dan ETHER_28J60.

Download:

UIPEthernet is ook op GitHub beschikbaar en je kunt het ook van Tweaking4All downloaden.
Kijk eerst op Github zodat je de meest actuele versie hebt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <UIPEthernet.h> // Voor Ethernet



// **** ETHERNET INSTELLINGEN ****

byte mac[] = { 0x54, 0x34, 0x41, 0x30, 0x30, 0x31 };                                       

IPAddress ip(192, 168, 1, 179);                        

EthernetServer server(80);



void setup() {

  Serial.begin(9600);



  // start de Ethernet verbinding en de server:

  Ethernet.begin(mac, ip);

  server.begin();



  Serial.print("IP Adres: ");

  Serial.println(Ethernet.localIP());

}



void loop() {

  // listen for incoming clients

  EthernetClient client = server.available();



  if (client) 

  {  

    Serial.println("-> Nieuwe Verbinding");



    // een http request eindigt met een lege regel

    boolean currentLineIsBlank = true;



    while (client.connected()) 

    {

      if (client.available()) 

      {

        char c = client.read();



        // als je aan het einde van een regel bent (newline karakter ontvangen)

        // en de regel is leeg, dan zijn we aan het einde van een HTTP request gekomen,

        // en kunnen we een antwoord sturen

        if (c == '\n' && currentLineIsBlank) 

        {

          client.println("<html><title>Hello World!</title><body><h3>Hello World!</h3></body>");

          break;

        }



        if (c == '\n') {

          // We beginnen met een nieuwe regel

          currentLineIsBlank = true;

        }

        else if (c != '\r') 

        {

          // we ontvingen een karakter (niet einde regel)

          currentLineIsBlank = false;

        }

      } 

    }



    // geef de browser tijd om de data te ontvangen

    delay(10);



    // sluit de verbinding:

    client.stop();

    Serial.println("   Einde verbinding\n");

  }

}