From @cmaglie on November 15, 2012 18:55

This is Issue 898 moved from a Google Code project.
Added by 2012-04-24T14:01:19.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium

Original description

What change would like to see?
Replace the current ethernet shield w5100.h and w5100.cpp files with the files attached.

Why? By removing the comment slashes on "#define W5200" in w5100.h will compile for a w5200 shield.

Would this cause any incompatibilities with previous versions? If so, how
can these be mitigated?

None detected so far.

Copied from original issue: arduino/Arduino#898

Moved from arduino/Arduino#6414 by @corymayer

Line 141 in Dns.cpp has a hardcoded 5 second timeout for DNS lookups. It causes a hang intermittently in my code. Can this be a configurable value?

ret = ProcessResponse(5000, aResult);

does this library work with the esp32?

From @cmaglie on November 15, 2012 19:3

This is Issue 1068 moved from a Google Code project.
Added by 2012-10-09T22:18:15.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium

Original description

What steps will reproduce the problem?

1. Opening frequently a Ethernet connection (Once a minute)
2. After a while, the wiznet is no longer able to open connection.

What is the expected output? What do you see instead?
Running forever.

What version of the Arduino software are you using? On what operating
system? Which Arduino board are you using?
Arduino Mega2560, Ethernet shield. (Official Arduino), Arduino 1.0.1, Win7

Please provide any additional information below.
It is hard to reproduce. Sometimes the cliet.connect() keeps returning a false after a few hours, Sometimes after a few days.
I think (but i not sure) the problem occures more often if the WizNet is exposed to externel attempts to make a connection after opening ports on my router.

The problem and (possible) solution is discribes here:

http://forum.freetronics.com/viewtopic.php?t=176

I not sure if there is a relation to issue 1049.

Copied from original issue: arduino/Arduino#1068

From @josephlm on March 11, 2015 22:52

The code in recvfrom() in libraries/Ethernet/src/utility/socket.cpp does not check the length of the buffer (buf) passed before copying data from Wiznet shield buffer into the application's passed buffer.

If 'data_len' is bigger than 'len' then the only 'len' bytes should be copied to the application's passed buffer, otherwise 'data_len' bytes should be copied to the application's passed buffer.

Copied from original issue: arduino/Arduino#2756

From @cmaglie on November 15, 2012 18:48

This is Issue 734 moved from a Google Code project.
Added by 2011-12-02T15:31:08.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium

Original description

I know you perhaps should not get a response from more than 1 machine on the same network but if you do, and it's more common than one might think of, the code will end up in a never ending loop.

I have downloaded Arduino-1.0 (the proposed release that were announced on the dev mailing list, later than rc2) and have some issues.
How I detected this was by trying to use the DhcpChatClient example.
In my network I will get (working on removing but still) 2 replies to a DHCP request.
I think this messes up the EthernetUDP / DHCP implementation.

This is somewhat related to issue #669 as well and it doesn't work even if I implement the proposed changes there.
This specific issue is about DHCP but I think it's an issue that might turn up elsewhere as well.

In the beginning of DhcpClass::parseDHCPResponse there is a _dhcpUdpSocekt.parsePacket() which updates the private EthernetUDP._remaining counter. So far everything is well and the packet starts to be parsed.

A while loop begins to parse the packet until .available() is 0 on the udp socket.
While parsing, another packet arrives to the buffer in the w5100.
This will add to the count that .available() returns which is correct but I will not be allowed to read them after the _remaining counter in EthernetUDP goes down to 0.
This will make the while(_dhcpUdpSocket.available()) run forever since there is correctly bytes available but I'm not allowed to read them, unless I would do another .parsePacket() on the UDP socket since all read methods look at the _remaining counter which is already 0.

You simply can not trust to .read() the socket until .available() turns 0 since you can not be sure that the _remaining counter and the buffer in w5100 match.

My HACKY workaround was to make EthernetUDP._remaining public instead of private and do
while(_dhcpUdpSocket._remaining>0)
instead of
while(_dhcpUdpSocket.available())
and simply throw away the second response.
This is NOT the correct way to solve and I'm not good enough at c/c++ to do a correct solution but it shows the issue

Anything BUT ending up in a never ending loop would be fine, I could live with not getting an IP even though the first response would give me one. The best would be do deal with the situation in a proper way and use the first valid response (or perhaps only the first response, period) and ignore everything else.

Copied from original issue: arduino/Arduino#734

This library does not support the official shield I just bought. Is that surprising to anyone else?

From @mji83 on May 14, 2013 17:58

There's a hardcoded assumption in the following code in dhcp.cpp:

    printByte((char*)&(buffer[24]), _dhcpMacAddr[3]);
    printByte((char*)&(buffer[26]), _dhcpMacAddr[4]);
    printByte((char*)&(buffer[28]), _dhcpMacAddr[5]);

This causes various failures with the DHCP server if you define HOST_NAME to be a string that isn't exactly 6-characters long that will at best cause the DHCP server to not issue you an IP, and at worst cause a memory leak in the code. I fixed this portion of the code as follows:

 int hostNameLen = strlen(HOST_NAME); 
 buffer[17] = hostNameLen + 6; // length of hostname + last 3 bytes of mac address
 strcpy((char*)&(buffer[18]), HOST_NAME);
 printByte((char*)&(buffer[hostNameLen+18]), _dhcpMacAddr[3]);
 printByte((char*)&(buffer[hostNameLen+20]), _dhcpMacAddr[4]);
 printByte((char*)&(buffer[hostNameLen+22]), _dhcpMacAddr[5]);

Copied from original issue: arduino/Arduino#1416

today i found a several bug on the update system

• installed the IDE 1.6.7 in "portable" version
• Library Manager - Type Updatable
• appear: Ethernet - SD - Servo libraries to update

if you try to update the version become the "Second Last" not the "Last"

If you try to re-update the version become your "Old" version, not the "Last"

There is no way to update to the last version on this three libraries (i do not know if this bug affect other libraries also)

From @PaulStoffregen on December 1, 2014 1:19

The Arduino Ethernet shield should be revised, to add pullup resistors on the 2 chip select signals.

Without resistors to keep the CS signals high (inactive), the SD card can "hear" communication when only the Ethernet library is used. The card can even output data on the MISO line while the W5100 ethernet chip running, causing corruption. See this issue for confirmation this problem does indeed happen in the wild.

arduino/Arduino#2168

Shields should be designed with pullup resistors, to make them easy to use for novice Arduino users. These problems are very difficult for Arduino users to resolve, but very easy to prevent by adding inexpensive resistors. Here's an article I wrote recently with more detail.

http://www.dorkbotpdx.org/blog/paul/better_spi_bus_design_in_3_steps

Please consider revising the ethernet shield to add two pullup resistors on the chip select lines.

Copied from original issue: arduino/Arduino#2478

From @jonface on November 7, 2014 23:31

Arduino v1.5.8

Problem: The source port for a client TCP connection is fixed to start from 1024. If the micro controller is connect to a NAT gateway, the gateway will store this value. When the micro controller is power cycled (so no connection tear down) and tries to make a connection, once again the source port will be 1024. The NAT gateway will be confused (by the previous connection in it's connection table) and the connection will not start until the source port is incremented.

Fix: In EthernetClient.cpp, function,

int EthernetClient::connect(IPAddress ip, uint16_t port)

Changed the source port so it is set randomly,

randomSeed(analogRead(0));
_srcport = 1024 + random(1, 60000);

I'm sure there are better ways than this, but this connects 'instantly' now however many times I power cycle the controller.

Copied from original issue: arduino/Arduino#2425

Original issue here.

This issue came up when I was using Ethernet2 library on Nucleo board, but same problems would show up while using this Library.
I described original issue in Ethernet2 repo by adafruit and also on stm32duino.

I've managed to solve problem by using manual transaction control (proposed in this PR)

Since Arduino is gaining popularity on other non-avr platforms, maybe it would be worth to start optimize libraries for other platforms without affecting original usage on AVR based bards?

From @JanosAudron on April 11, 2013 20:37

Hardware:
Arduino UNO + Ethernet Shield

Software:
IDE 1.0.4 and 1.5.2

After some test I think the problem of the crash of W5100 chip that make it unresponsive is when you use an SD card, too.
If you don't force pin 4 to HIGH, disabling the SD card, if these's a card insered the W5100 may become unresponsive. Maybe the bug is in SD library and not in Ethrnet library.

Copied from original issue: arduino/Arduino#1360

From @WildOrangutan on May 14, 2015 22:49

Hi!
Please implement something like this, to avoid w5100 buffer overflow, when constantly sending data as fast as possible:

int EthernetClient::free() {
    if (_sock != MAX_SOCK_NUM)
        return W5100.getTXFreeSize(_sock);
   return 0;
}

And then use it in examples like this:

while (file.available() > 0) {
    if (client.free() > 0) { // This was key to solving the issue
        c = file.read();
        client.print((char)c);
    } else { // No free buffer? Ok, I'll wait a couple of millis...
        delay(1);
    }
}
file.close();

Source: http://www.toptal.com/c/how-i-made-a-fully-functional-arduino-weather-station-for-300

Copied from original issue: arduino/Arduino#3144

From @cmaglie on November 15, 2012 18:36

This is Issue 502 moved from a Google Code project.
Added by 2011-03-10T02:23:23.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium, Component-Core

Original description

What change would like to see?

Currently the Ethernet (and subsystems) use parameters like uint8_t *mac, being pointers to MAC or IP addresses, as well as data packets. These parameters do not and should not modify these bytes, and this should be explicitly declared in the interfaces.

Why?

Otherwise the user is left wondering whether the function might modify the MAC or IP address bytes, and whether they are safe to be resized for successive calls.

Would this cause any incompatibilities with previous versions? If so, how can these be mitigated?

This should not cause any incompatibilities, but subsystems will need to ensure they properly use const pointer parameters or the higher level functions with const parameters will not be able to pass their data in.

Attached is a diff affecting Ethernet.{cpp,h} Udp.{cpp,h} socket.{cpp,h} w5100.{cpp,h}

Copied from original issue: arduino/Arduino#502

I have updated the library and now I don't have Ethernet connection, not even with Standard Firmata Ethernet. Also pin 10 is set to HIGH, which I can't change

How to downgrade to previous version?

System: Ethernet lib 1.1.2, ATMega 2560, Ethernet shield, arduino IDE 1.6.12
Description: client.connect() returns 0 after several successful POST requests

It seems to be exactly the same error as ISSUE-15. Unfortunately, the proposed code does not solve the problem on my side.

Detailed description: I am sending small amount data into an elasticsearch server using POST request every 2 seconds. After a while, could be 15 minutes, could be hours, Ethernet client does not manage to connect to my server ( Server up and running for sure ). At this step, The ATMega is not pingable anymore. The only way I have found to make it working again is to unplug/plug the power source.

Ive made sure I have the following line in EthernetClient.cpp as mentioned in http://forum.freetronics.com/viewtopic.php?t=176

int EthernetClient::connect(IPAddress ip, uint16_t port) {
  if (_sock != MAX_SOCK_NUM)
    return -1;

  for (int i = 0; i < MAX_SOCK_NUM; i++) {
    uint8_t s = W5100.readSnSR(i);
      if (s == SnSR::CLOSED || s == SnSR::FIN_WAIT || s == SnSR::CLOSE_WAIT) {
      _sock = i;
      break;
    }
  }

And you will find below the code:

#include <SPI.h>
#include <Ethernet.h>
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
EthernetClient client;
#include <TimeLib.h>


void setup() {
  Serial.begin(9600);
  while (!Serial) {}
  Ethernet.begin(mac);
  Serial.println(Ethernet.localIP());
}

void loop() {

 String dataES = "{\"location\": \"office\"}";
 if(!postPage("192.168.1.68",9200,"/sensors/temperature",dataES)) 
  Serial.print(F("Fail "));
 else {
  Serial.print(F("Pass "));
  Serial.println(dataES);
 } 
 delay(1000);
}  


byte postPage(char* domainBuffer,int thisPort,char* page, String thisData)
{
  int inChar;
  char outBuf[64];
  int TIMEOUT_REPLY = 5000;
  Serial.print(F("connecting..."));

  if(client.connect(domainBuffer,thisPort) == 1){
    Serial.println(F("connected"));
    sprintf(outBuf,"POST %s HTTP/1.1",page);
    client.println(outBuf);
    sprintf(outBuf,"Host: %s",domainBuffer);
    client.println(outBuf);
    client.println(F("Connection: close\r\nContent-Type: application/json"));
    sprintf(outBuf,"Content-Length: %u\r\n",thisData.length());
    client.println(outBuf);
    client.print(thisData);
  } 
  else {
    Serial.println(F("failed"));
  }

  unsigned long ctime = millis() + TIMEOUT_REPLY;
  while(client.connected()) {       
    if ( millis()>ctime ) {
       Serial.println("NO RESPONSE WITHIN PRESCRIBED TIME");
      break;
    }
    while(client.available()) {
      inChar = client.read();
      Serial.write(inChar);
      delay(1);
    }
    delay(1);
  }

  Serial.println();
  Serial.println(F("disconnecting."));
  client.stop();
  return 1;
}

Any idea ? I have been battling for months on this problem. Thanks !

From @cmaglie on November 15, 2012 18:39

This is Issue 569 moved from a Google Code project.
Added by 2011-07-07T20:57:41.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium, Component-Core

Original description

With the new Arduino 1.0 Ethernet library with the DHCP client included, if your DHCP server returns more than one DNS server address for use it fails to parse the remainder of the DHCP response correctly.

This often results in the Ethernet chip not being configured correctly (which can sometimes be spotted if the netmask and/or gateway IP address are set to 0.0.0.0) and the Arduino won't be able to communicate over Ethernet

Copied from original issue: arduino/Arduino#569

Changes to existing pages

I have also included improvement suggestions not related to the 2.0.0 release for the affected reference pages because it seems like it will be easier for the person updating the page to make all necessary changes to a page at the same time, rather than addressing multiple issue reports.

https://www.arduino.cc/en/Reference/Libraries
Change:

• Ethernet / Ethernet 2 - for connecting to the internet using the Arduino Ethernet Shield, Arduino Ethernet Shield 2 and Arduino Leonardo ETH

To:

• Ethernet - for connecting to the internet using the Arduino Ethernet Shield, Arduino Ethernet Shield 2 and Arduino Leonardo ETH

https://www.arduino.cc/en/Reference/Ethernet
Change:

Ethernet / Ethernet 2 library

These libraries are designed to work with the Arduino Ethernet Shield (Ethernet.h) or the Arduino Ethernet Shield 2 and Leonardo Ethernet (Ethernet2.h). The libraries are allow an Arduino board to connect to the internet. The board can serve as either a server accepting incoming connections or a client making outgoing ones. The libraries support up to four concurrent connection (incoming or outgoing or a combination). Ethernet library (Ethernet.h) manages the W5100 chip, while Ethernet2 library (Ethernet2.h) manages the W5500 chip; all the functions remain the same. Changing the library used allows to port the same code from Arduino Ethernet Shield to Arduino Ethernet 2 Shield or Arduino Leonardo Ethernet and vice versa.

Arduino communicates with the shield using the SPI bus. This is on digital pins 11, 12, and 13 on the Uno and pins 50, 51, and 52 on the Mega. On both boards, pin 10 is used as SS. On the Mega, the hardware SS pin, 53, is not used to select the W5100, but it must be kept as an output or the SPI interface won't work.

To:

Ethernet library

This library is designed to work with the Arduino Ethernet Shield, Arduino Ethernet Shield 2, Leonardo Ethernet, and any other W5100/W5200/W5500-based devices. The library allows an Arduino board to connect to the Internet. The board can serve as either a server accepting incoming connections or a client making outgoing ones. The library supports up to eight (W5100 and boards with <= 2 kB SRAM are limited to four) concurrent connections (incoming, outgoing, or a combination).

The Arduino board communicates with the shield using the SPI bus. This is on digital pins 11, 12, and 13 on the Uno and pins 50, 51, and 52 on the Mega. On both boards, pin 10 is used as SS. On the Mega, the hardware SS pin, 53, is not used to select the Ethernet controller chip, but it must be kept as an output or the SPI interface won't work.

https://www.arduino.cc/en/Tutorial/WebClient
Change:

The results of this search are viewable as HTML through your Arduino's serial window.

To:

The results of this search are viewable as HTML in the Serial Monitor.

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/WebClientRepeating

Change:

The conent of the page is viewable through your Arduino's serial window.

To:

The content of the page is viewable in the Serial Monitor.

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/WebServer

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/BarometricPressureWebServer

Change:

Your Barometric Pressure sensor will be attached to pins 6,7, and 11 - 13

To:

Your Barometric Pressure sensor will be attached to pins 6, 7, and the SPI pins

Change:

Your sensor's MOSI (Master Out Slave In) pin should then be connected to digital pin 11, and it's counterpart MISO (Master In Slave Out) to digital pin 12. Finally, connect the SCK pin, the SPI clock input on your sensor, to digital pin 13 on your device, and make sure that the two share a common ground.

To:

Your sensor's MOSI (Master Out Slave In), MISO (Master In Slave Out), and SCK (SPI clock input) pins should then be connected to the SPI pins on your Arduino board/shield. The SPI pin numbers differ depending on which Arduino board you're using and are listed in the SPI reference page. Make sure that the two share a common ground.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/UDPSendReceiveString

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/UdpNtpClient

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/DhcpChatServer

Change:

The Serial monitor works well for this purpose.

To:

The Serial Monitor works well for this purpose.

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/DhcpAddressPrinter

Change:

Using the localIP() function, the assigned IP address is sent out via the serial monitor.

To:

Using the localIP() function, the assigned IP address is sent out via the Serial Monitor.

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Tutorial/TelnetClient

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

Change:

The Serial monitor works well for this purpose.

To:

The Serial Monitor works well for this purpose.

Change:

The Ethernet shield allows you to connect a WizNet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

To:

The Ethernet shield allows you to connect a WIZnet Ethernet controller to the Arduino or Genuino boards via the SPI bus.

Change:

It uses pins 10, 11, 12, and 13 for the SPI connection to the WizNet.

To:

It uses the ICSP header pins and pin 10 as chip select for the SPI connection to the Ethernet controller chip.

Change:

The shield should be connected to a network with an ethernet cable.

To:

The shield should be connected to a network with an Ethernet cable.

Change:

image developed using Fritzing.

To:

Image developed using Fritzing.

Remove:

Please note: according to your hardware setup, you need to comment / uncomment the libraries at the beginning of the sketch. Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

https://www.arduino.cc/en/Guide/ArduinoEthernetShield

Change:

The Arduino Ethernet shield 2

To:

The Arduino Ethernet Shield 2

Remove:

Depending on the shield version you have, you need to use the proper library, as documented in the Ethernet library page.

Change:

Here a list of tutorials that will help you in making very cool things!

To:

Here is a list of tutorials that will help you in making very cool things!

https://store.arduino.cc/arduino-ethernet-shield-2

Change:

Learn more on the Ethernet Shield 2 in the Ethernet2 Library reference

To:

Learn more on the Ethernet Shield 2 in the Ethernet Library reference

https://www.arduino.cc/en/Reference/EthernetBegin

Change:

Initializes the ethernet library and network settings.

To:

Initializes the Ethernet library and network settings.

Change:

With version 1.0, the library supports DHCP.

To:

Version 1.0 and newer of the Ethernet library supports DHCP.

Change:

Using Ethernet.begin(mac) with the proper network setup

To:

Using Ethernet.begin(mac) with the proper network setup

Change:

For older shields, choose your own.

To:

For older shields, choose any MAC you like so long as it's unique on your network.

Change:

ip: the IP address of the device (array of 4 bytes)

To:

ip: the IP address of the device (IPAddress)

Change:

the IP address of the DNS server (array of 4 bytes).

To:

the IP address of the DNS server (IPAddress).

Change:

the IP address of the network gateway (array of 4 bytes).

To:

the IP address of the network gateway (IPAddress).

Change:

the subnet mask of the network (array of 4 bytes).

To:

the subnet mask of the network (IPAddress)

Change:

The DHCP version of this function, Ethernet.begin(mac), returns an int

To:

The DHCP version of this function, Ethernet.begin(mac), returns an int

Add:

See also

• Ethernet.init()

https://www.arduino.cc/en/Reference/EthernetLocalIP

Change:

Returns

the IP address

To:

Returns

the IP address (IPAddress)

Add:

See also

• Ethernet.MACAddress()
• Ethernet.dnsServerIP()
• Ethernet.gatewayIP()
• Ethernet.subnetMask()

https://www.arduino.cc/en/Reference/ServerAvailable

Change:

you can close it by calling client.stop().

To:

you can close it by calling client.stop().

Change:

See Also

• Stream.available()

To:

See Also

• server.accept()

New reference pages to create

Based partly on information from Paul Stoffregen's blog post: https://www.pjrc.com/arduino-ethernet-library-2-0-0/

https://www.arduino.cc/en/Reference/EthernetInit

Ethernet.init()

Description

Used to configure the CS (chip select) pin for the Ethernet controller chip. The Ethernet library has a default CS pin, which is usually correct, but with some non-standard Ethernet hardware you might need to use a different CS pin.

Syntax

Ethernet.init(sspin)

Parameters

sspin: the pin number to use for CS (byte)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Ethernet.init(53);  // use pin 53 for Ethernet CS
  Ethernet.begin(mac, ip);
}

void loop () {}

https://www.arduino.cc/en/Reference/ClientRemoteIP

remoteIP()

Description

Returns the IP address of the client.

Syntax

client.remoteIP()

Parameters

none

Returns

the client's IP address (IPAddress)

Example

#include <Ethernet.h>
#include <SPI.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

// telnet defaults to port 23
EthernetServer server = EthernetServer(23);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // initialize the Ethernet device
  Ethernet.begin(mac, ip);

  // start listening for clients
  server.begin();
}

void loop() {
  // if an incoming client connects, there will be bytes available to read:
  EthernetClient client = server.available();
  if (client) {
    Serial.print("Remote IP address: ");
    Serial.println(client.remoteIP());
    client.stop();
  }
}

See also

• client.localPort()
• client.remotePort()

https://www.arduino.cc/en/Reference/ClientLocalPort

localPort()

Description

Returns the local port number the client is connected to.

Syntax

client.localPort()

Parameters

none

Returns

the local port number the client is connected to (uint16_t)

Example

#include <Ethernet.h>
#include <SPI.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

// telnet defaults to port 23
EthernetServer server = EthernetServer(23);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // initialize the Ethernet device
  Ethernet.begin(mac, ip);

  // start listening for clients
  server.begin();
}

void loop() {
  // if an incoming client connects, there will be bytes available to read:
  EthernetClient client = server.available();
  if (client) {
    Serial.print("Client is connected on port: ");
    Serial.println(client.localPort());
    client.stop();
  }
}

See also

• client.remotePort()
• client.remoteIP()

https://www.arduino.cc/en/Reference/ClientRemotePort

remotePort()

Description

Returns the port of the host that sent the current incoming packet.

Syntax

client.remotePort()

Parameters

none

Returns

the port of the host that sent the current incoming packet (uint16_t)

Example

#include <Ethernet.h>
#include <SPI.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

// telnet defaults to port 23
EthernetServer server = EthernetServer(23);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // initialize the Ethernet device
  Ethernet.begin(mac, ip);

  // start listening for clients
  server.begin();
}

void loop() {
  // if an incoming client connects, there will be bytes available to read:
  EthernetClient client = server.available();
  if (client) {
    Serial.print("Remote port: ");
    Serial.println(client.remotePort());
    client.stop();
  }
}

See also

• client.localPort()
• client.remoteIP()

https://www.arduino.cc/en/Reference/EthernetSetRetransmissionTimeout

Ethernet.setRetransmissionTimeout()

Description

Set the Ethernet controller's timeout. The initial value is 200 ms. A 200 ms timeout times the default of 8 attempts equals a blocking delay of 1600 ms during a communications failure. You might prefer to set a shorter timeout to make your program more responsive in the event something goes wrong with communications. You will need to do some experimentation to determine an appropriate value for your specific application.

Syntax

Ethernet.setRetransmissionTimeout(milliseconds)

Parameters

milliseconds: the timeout duration (uint16_t)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Ethernet.begin(mac, ip);
  Ethernet.setRetransmissionTimeout(50);  // set the Ethernet controller's timeout to 50 ms
}

void loop () {}

See also

• Ethernet.setRetransmissionCount()
• client.setConnectionTimeout()
• Stream.setTimeout()

https://www.arduino.cc/en/Reference/EthernetSetRetransmissionCount

Ethernet.setRetransmissionCount()

Description

Set the number of transmission attempts the Ethernet controller will make before giving up. The initial value is 8. 8 transmission attempts times the 200 ms default timeout equals a blocking delay of 1600 ms during a communications failure. You might prefer to set a lower number to make your program more responsive in the event something goes wrong with communications. Despite the name, this sets the total number of transmission attempts (not the number of retries after the first attempt fails) so the minimum value you would ever want to set is 1.

Syntax

Ethernet.setRetransmissionCount(number)

Parameters

number: number of transmission attempts the Ethernet controller should make before giving up (byte)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Ethernet.begin(mac, ip);
  Ethernet.setRetransmissionCount(1);  // configure the Ethernet controller to only attempt one transmission before giving up
}

void loop () {}

See also

• Ethernet.setRetransmissionTimeout()
• client.setConnectionTimeout()
• Stream.setTimeout()

https://www.arduino.cc/en/Reference/EthernetClientSetConnectionTimeout

setConnectionTimeout()

Description

Set the timeout for client.connect() and client.stop(). The initial value is 1000 ms. You might prefer to set a lower timeout value to make your program more responsive in the event something goes wrong.

Syntax

client.setConnectionTimeout(milliseconds)

Parameters

milliseconds: the timeout duration for client.connect() and client.stop() (uint16_t)

Returns

Nothing

Example

#include <Ethernet.h>
#include <SPI.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

// telnet defaults to port 23
EthernetServer server = EthernetServer(23);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // initialize the Ethernet device
  Ethernet.begin(mac, ip);

  // start listening for clients
  server.begin();
}

void loop() {
  // if an incoming client connects, there will be bytes available to read:
  EthernetClient client = server.available();
  if (client) {
    client.setConnectionTimeout(100);  // set the timeout duration for client.connect() and client.stop()
  }
}

See also

• Ethernet.setRetransmissionCount()
• Ethernet.setRetransmissionTimeout()
• Stream.setTimeout()

https://www.arduino.cc/en/Reference/EthernetServerAccept

accept()

Description

The traditional server.available() function would only tell you of a new client after it sent data, which makes some protocols like FTP impossible to properly implement.

The intention is programs will use either available() or accept(), but not both. With available(), the client connection continues to be managed by EthernetServer. You don’t need to keep a client object, since calling available() will give you whatever client has sent data. Simple servers can be written with very little code using available().

With accept(), EthernetServer gives you the client only once, regardless of whether it has sent any data. You must keep track of the connected clients. This requires more code, but you gain more control.

Syntax

server.accept()

Parameters

none

Returns

a Client object. If no client has data available for reading, this object will evaluate to false in an if-statement. (EthernetClient)

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 69, 104);

// telnet defaults to port 23
EthernetServer server(23);

EthernetClient clients[8];

void setup() {
  Ethernet.begin(mac, ip);

  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // start listening for clients
  server.begin();
}

void loop() {
  // check for any new client connecting, and say hello (before any incoming data)
  EthernetClient newClient = server.accept();
  if (newClient) {
    for (byte i = 0; i < 8; i++) {
      if (!clients[i]) {
        newClient.print("Hello, client number: ");
        newClient.println(i);
        // Once we "accept", the client is no longer tracked by EthernetServer
        // so we must store it into our list of clients
        clients[i] = newClient;
        break;
      }
    }
  }

  // check for incoming data from all clients
  for (byte i = 0; i < 8; i++) {
    while (clients[i] && clients[i].available() > 0) {
      // read incoming data from the client
      Serial.write(clients[i].read());
    }
  }

  // stop any clients which disconnect
  for (byte i = 0; i < 8; i++) {
    if (clients[i] && !clients[i].connected()) {
      clients[i].stop();
    }
  }
}

See also

• server.available()

https://www.arduino.cc/en/Reference/IfEthernetServer

Description

Indicates whether the server is listening for new clients. You can use this to detect whether server.begin() was successful. It can also tell you when no more sockets are available to listen for more clients, because the maximum number have connected.

Syntax

if (server)

Parameters

none

Returns

whether the server is listening for new clients (bool)

Example

#include <Ethernet.h>
#include <SPI.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

// telnet defaults to port 23
EthernetServer server = EthernetServer(23);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // initialize the Ethernet device
  Ethernet.begin(mac, ip);

  // start listening for clients
  server.begin();
}

void loop() {
  if (server) {
    Serial.println("Server is listening");
  }
  else {
    Serial.println("Server is not listening");
  }
}

https://www.arduino.cc/en/Reference/EthernetHardwareStatus

Ethernet.hardwareStatus()

Description

Ethernet.hardwareStatus() tells you which WIZnet Ethernet controller chip was detected during Ethernet.begin(), if any. This can be used for troubleshooting. If no Ethernet controller was detected then there is likely a hardware problem.

Syntax

Ethernet.hardwareStatus()

Parameters

none

Returns

which WIZnet Ethernet controller chip was detected during Ethernet.begin() (EthernetHardwareStatus):

• EthernetNoHardware
• EthernetW5100
• EthernetW5200
• EthernetW5500

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Ethernet.begin(mac, ip);

  if (Ethernet.hardwareStatus() == EthernetNoHardware) {
    Serial.println("Ethernet shield was not found.");
  }
  else if (Ethernet.hardwareStatus() == EthernetW5100) {
    Serial.println("W5100 Ethernet controller detected.");
  }
  else if (Ethernet.hardwareStatus() == EthernetW5200) {
    Serial.println("W5200 Ethernet controller detected.");
  }
  else if (Ethernet.hardwareStatus() == EthernetW5500) {
    Serial.println("W5500 Ethernet controller detected.");
  }
}

void loop () {}

See also

• Ethernet.linkStatus()

https://www.arduino.cc/en/Reference/EthernetLinkStatus

Ethernet.linkStatus()

Description

Tells you whether the link is active. LinkOFF could indicate the Ethernet cable is unplugged or defective. This feature is only available when using the W5200 and W5500 Ethernet controller chips.

Syntax

Ethernet.linkStatus()

Parameters

none

Returns

the link status (EthernetLinkStatus):

• Unknown
• LinkON
• LinkOFF

Example

#include <SPI.h>
#include <Ethernet.h>

void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
}

void loop () {
  if (Ethernet.linkStatus() == Unknown) {
    Serial.println("Link status unknown. Link status detection is only available with W5200 and W5500.");
  }
  else if (Ethernet.linkStatus() == LinkON) {
    Serial.println("Link status: On");
  }
  else if (Ethernet.linkStatus() == LinkOFF) {
    Serial.println("Link status: Off");
  }
}

See also

• Ethernet.hardwareStatus()

https://www.arduino.cc/en/Reference/EthernetSetMACAddress

Ethernet.setMACAddress()

Description

Set the MAC address. Not for use with DHCP.

Syntax

Ethernet.setMACAddress(mac)

Parameters

mac: the MAC address to use (array of 6 bytes)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Ethernet.begin(mac, ip);
  byte newMac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x02};
  Ethernet.setMACAddress(newMac);  // change the MAC address
}

void loop () {}

See also

• Ethernet.setLocalIP()
• Ethernet.setDnsServerIP()
• Ethernet.setGatewayIP()
• Ethernet.setSubnetMask()
• Ethernet.begin()

https://www.arduino.cc/en/Reference/EthernetSetLocalIP

Ethernet.setLocalIP()

Description

Set the IP address of the device. Not for use with DHCP.

Syntax

Ethernet.setLocalIP(local_ip)

Parameters

local_ip: the IP address to use (IPAddress)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Ethernet.begin(mac, ip);
  IPAddress newIp(10, 0, 0, 178);
  Ethernet.setLocalIP(newIp);  // change the IP address
}

void loop () {}

See also

• Ethernet.setMACAddress()
• Ethernet.setDnsServerIP()
• Ethernet.setGatewayIP()
• Ethernet.setSubnetMask()
• Ethernet.begin()

https://www.arduino.cc/en/Reference/EthernetSetDnsServerIP

Ethernet.setDnsServerIP()

Description

Set the IP address of the DNS server. Not for use with DHCP.

Syntax

Ethernet.setDnsServerIP(dns_server)

Parameters

dns_server: the IP address of the DNS server (IPAddress)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);
IPAddress myDns(192, 168, 1, 1);

void setup() {
  Ethernet.begin(mac, ip, myDns);
  IPAddress newDns(192, 168, 1, 1);
  Ethernet.setDnsServerIP(newDns);  // change the DNS server IP address
}

void loop () {}

See also

• Ethernet.setMACAddress()
• Ethernet.setLocalIP()
• Ethernet.setGatewayIP()
• Ethernet.setSubnetMask()
• Ethernet.begin()

https://www.arduino.cc/en/Reference/EthernetSetGatewayIP

Ethernet.setGatewayIP()

Description

Set the IP address of the network gateway. Not for use with DHCP.

Syntax

Ethernet.setGatewayIP(gateway)

Parameters

gateway: the IP address of the network gateway (IPAddress)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);
IPAddress myDns(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);

void setup() {
  Ethernet.begin(mac, ip, myDns, gateway);
  IPAddress newGateway(192, 168, 100, 1);
  Ethernet.setGatewayIP(newGateway);  // change the gateway IP address
}

void loop () {}

See also

• Ethernet.setMACAddress()
• Ethernet.setLocalIP()
• Ethernet.setDnsServerIP()
• Ethernet.setSubnetMask()
• Ethernet.begin()

https://www.arduino.cc/en/Reference/EthernetSetSubnetMask

Ethernet.setSubnetMask()

Description

Set the subnet mask of the network. Not for use with DHCP.

Syntax

Ethernet.setSubnetMask(subnet)

Parameters

subnet: the subnet mask of the network (IPAddress)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);
IPAddress myDns(192, 168, 1, 1);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 0, 0);

void setup() {
  Ethernet.begin(mac, ip, myDns, gateway, subnet);
  IPAddress newSubnet(255, 255, 255, 0);
  Ethernet.setSubnetMask(newSubnet);  // change the subnet mask
}

void loop () {}

See also

• Ethernet.setMACAddress()
• Ethernet.setLocalIP()
• Ethernet.setDnsServerIP()
• Ethernet.setGatewayIP()
• Ethernet.begin()

https://www.arduino.cc/en/Reference/EthernetMACAddress

Ethernet.MACAddress()

Description

Fills the supplied buffer with the MAC address of the device.

Syntax

Ethernet.MACAddress(mac_address)

Parameters

mac_address: buffer to receive the MAC address (array of 6 bytes)

Returns

Nothing

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Ethernet.begin(mac, ip);

  byte macBuffer[6];  // create a buffer to hold the MAC address
  Ethernet.MACAddress(macBuffer); // fill the buffer
  Serial.print("The MAC address is: ");
  for (byte octet = 0; octet < 6; octet++) {
    Serial.print(macBuffer[octet], HEX);
    if (octet < 5) {
      Serial.print('-');
    }
  }
}

void loop () {}

See also

• Ethernet.localIP()
• Ethernet.dnsServerIP()
• Ethernet.gatewayIP()
• Ethernet.subnetMask()

https://www.arduino.cc/en/Reference/EthernetDnsServerIP

Ethernet.dnsServerIP()

Description

Returns the DNS server IP address for the device.

Syntax

Ethernet.dnsServerIP()

Parameters

none

Returns

the DNS server IP address for the device (IPAddress)

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Ethernet.begin(mac, ip);

  Serial.print("The DNS server IP address is: ");
  Serial.println(Ethernet.dnsServerIP());
}

void loop () {}

See also

• Ethernet.MACAddress()
• Ethernet.localIP()
• Ethernet.gatewayIP()
• Ethernet.subnetMask()

https://www.arduino.cc/en/Reference/EthernetGatewayIP

Ethernet.gatewayIP()

Description

Returns the gateway IP address for the device.

Syntax

Ethernet.gatewayIP()

Parameters

none

Returns

the gateway IP address for the device (IPAddress)

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Ethernet.begin(mac, ip);

  Serial.print("The gateway IP address is: ");
  Serial.println(Ethernet.gatewayIP());
}

void loop () {}

See also

• Ethernet.MACAddress()
• Ethernet.localIP()
• Ethernet.dnsServerIP()
• Ethernet.subnetMask()

https://www.arduino.cc/en/Reference/EthernetSubnetMask

Ethernet.subnetMask()

Description

Returns the subnet mask of the device.

Syntax

Ethernet.subnetMask()

Parameters

none

Returns

the subnet mask of the device (IPAddress)

Example

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(10, 0, 0, 177);

void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Ethernet.begin(mac, ip);

  Serial.print("The subnet mask is: ");
  Serial.println(Ethernet.subnetMask());
}

void loop () {}

See also

• Ethernet.MACAddress()
• Ethernet.localIP()
• Ethernet.dnsServerIP()
• Ethernet.gatewayIP()

From @cmaglie on November 15, 2012 18:39

This is Issue 563 moved from a Google Code project.
Added by 2011-06-23T18:16:38.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium, Component-Core

Original description

What change would like to see?
Using the standard TCP Client library with the standard Ethernet Shield, every single call to client.write(single_byte) results in an entire frame being constructed and sent. This is terribly inefficient. The underlying socket.cpp library already provides support for starting a packet, adding data, and finally sending the packet, but only for UDP. This should absolutely be available for TCP as well. I would argue that it's even more important for TCP than for UDP.

The problem can be worked around by constructing the entire desired TCP packet in ram first, but this imposes serious restrictions on possible packet size, and completely ignores the 16k of packet buffer memory on the w5100 chip.

While this lack of efficiency is not really a huge problem on a local network, it can dramatically change the network bandwidth required for a sensor node connected over the internet for example.

Would this cause any incompatibilities with previous versions? If so, how
can these be mitigated?

I believe they should be extra options. I believe the simplistic existing code is suitable for simplistic use cases, and should be kept, so I do not see any incompatibilities with previous versions.

Copied from original issue: arduino/Arduino#563

From @5a2v0 on June 22, 2016 14:53

Before this mofication:

EthernetServer server(80);
void setup() {
//some stuff here
server.begin(); //User can't change initial port value
//other stuff here
}

Now:

EthernetServer server; //without port declaration but still working old declaration system...
void setup() {
//some stuff here
unsigned int tcp = EEPROM.read(x)
server.begin(tcp); //User can now use a different port, maybe saved in eprom directly from the sketch in a configuration page that permise to choice a value for the tcp port...
//other stuff here
}

Many thanks to Arduino's forum user: SukkoPera

Copied from original issue: arduino/Arduino/pull/5062

From @vprheli on June 8, 2016 11:22

Hi, Why the function EthernetServer.begin(port|null) returns void? It calls function socket() which return uint8_t as result, same as EtherentUdp.If sock counter > MAX_SOCK_NUM it fails also.Or add some function like isListening() to know if it socket is in listening state.

Copied from original issue: arduino/Arduino#5023

The reason: now there's no official Ethernet Shield, so for doing this library more compatible/generic with the wild, I think this functionality could be another nice step to it (in addition to #37).

A suggestion of implementation is here: http://forum.arduino.cc/index.php?topic=217423.msg1601862#msg1601862

Thanks

From @cmaglie on November 15, 2012 19:3

This is Issue 1049 moved from a Google Code project.
Added by 2012-09-25T02:13:55.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium

Original description

What steps will reproduce the problem?
Difficult to catch the problem since it depends on timing of sending data from the shield while incoming data. Appears to be a coincidence issue on the exact timing. I'm getting it to happen by continually sending data at the fastest rate possible on a TCP socket while the arduino program sends back replies using a sliding window. Even at that, the problem takes several hours to hit, but when it does it is catastrophic.

What version of the Arduino software are you using? On what operating
system? Which Arduino board are you using?
Arduino 1.01 with a Mega 2560 and ethernet shield (W5100).

Please provide any additional information below.
I've traced the problem to socket.cpp:send() by putting debug outputs to the serial port if it gets stuck in a loop there. Here's the instrumented code:

uint16_t send(SOCKET s, const uint8_t * buf, uint16_t len)
{
uint8_t status=0;
uint16_t ret=0;
uint16_t freesize=0;

if (len > W5100.SSIZE)
ret = W5100.SSIZE; // check size not to exceed MAX size.
else
ret = len;

Serial.print('$');

// if freebuf is available, start.
int loopcnt=0;
do
{
freesize = W5100.getTXFreeSize(s);
status = W5100.readSnSR(s);
if ((status != SnSR::ESTABLISHED) && (status != SnSR::CLOSE_WAIT))
{
ret = 0;
break;
}
loopcnt++;
if (loopcnt==10)
Serial.println("send.1");
}
while (freesize < ret);

// copy data
W5100.send_data_processing(s, (uint8_t *)buf, ret);
W5100.execCmdSn(s, Sock_SEND);

/* +2008.01 bj /
loopcnt=0;
while ( (W5100.readSnIR(s) & SnIR::SEND_OK) != SnIR::SEND_OK )
{
/ m2008.01 [bj] : reduce code /
if ( W5100.readSnSR(s) == SnSR::CLOSED )
{
close(s);
return 0;
}
loopcnt++;
if (loopcnt==1000) {
Serial.print("send.2, SnSR=0x");
Serial.print(W5100.readSnSR(s),HEX);
Serial.print(", SnIR=0x");
Serial.print(W5100.readSnIR(s),HEX);
Serial.print(", TX_WR=0x");
Serial.print(W5100.readSnTX_WR(s),HEX);
Serial.print(", TX_RD=0x");
Serial.print(W5100.readSnTX_RD(s),HEX);
Serial.println(".");
close(s);
return 0;
}
}
/ +2008.01 bj */
W5100.writeSnIR(s, SnIR::SEND_OK);
return ret;
}

The addition to the code is the loop counter in the second loop that detects the condition. It then prints out the values of various status registers which results in:

send.2, SnSR=0x17, SnIR=0x5, TX_WR=0x92A5, TX_RD=0x92A5.

Thus, it looks like everything is OK, except that the SEND bit is never signalled in the SnIR register:
SnSR 0x17 = ESTABLISHED
SnIR 0x5 = RECV|CON
TX_WR==TX_RD indicates all data sent (I think??)

It seems that this may be an instance of the reported errata to the 5100 (see http://www.techw.co.jp/Download/3150A_5100_errata1_Eng.pdf )

Copied from original issue: arduino/Arduino#1049

From @ibantxo on January 7, 2016 21:6

Hi,

I want that my code works in 3 cases:

1. Without ethernet shield connected to Arduino.
2. With ethernet shield, but unpluged cable
3. With ethernet shield with a working network

The third scenario works well. But the first one "hangs" in this code line (waiting forever...):
ethClient.connect(server, port);

Is there any way to detect presence of ethernet shield or to insert a timeout in connection attempt?

Many thanks

Iban

Copied from original issue: arduino/Arduino#4400

From @matthijskooijman on November 25, 2013 17:44

Before, it would return the sum of the number of bytes written to all
clients, which makes it hard for a caller to find out the length of an
object printed (e.g., for alignment purposes). On the flipside, the
return value is now slightly less useful to detect connection errors,
but if really needed, something different should probably be implemented
anyway.

This change was discussed here:
http://comments.gmane.org/gmane.comp.hardware.arduino.devel/1928
http://forum.arduino.cc/index.php?topic=185835.0

Copied from original issue: arduino/Arduino/pull/1699

From @lestofante on March 15, 2013 10:29

Copied from original issue: arduino/Arduino#1320

EthernetServer.available() returns the first socket connected (or waiting for close) with data in RX buffer.

This is bad because:

• User tends to think available() returns the NEXT connected socket (even if it has no data into RX).
• If there are multiple clients connected continually writing data to Arduino (or writing it at right moment), there can be a situation where you will never be able to read the last EthernetClient.

We have found 3 solution:

1. Add a flag into EthernetClient: when returned by available() this client will never be returned thanks to this flag. The client is returned even is RX buffer is empty.
   • Can break some code.
2. Add an EthernetServer.available(int) where user can choose what Socket to use. This should be invisible to the user, as it can overflow the array or receive non-connected EthernetClient,
   • Advantage is that this is an overloaded method, so old code will work.
3. Add a new method like EthernetServer.getNextClient() which will use the flag method as in solution (1).
   • No retro-compatibility problem.
   • An easy way to get all client connected.
   • A method to get maximum number of client connected should be provided, or the constant MAX_SOCK_NUM should be public, so user can create their own EthernetClient array

(the last is probably the best)

Additional Context

Related discussion (in Italian):

https://forum.arduino.cc/t/accettare-piu-connessioni-in-ingresso-su-server-ethernet/150498

From @cmaglie on November 15, 2012 18:52

This is Issue 840 moved from a Google Code project.
Added by 2012-03-02T22:45:01.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium

Original description

What change would like to see?
It'd be useful to be able to print MAC addresses as well as IP addresses.

Copied from original issue: arduino/Arduino#840

From @PaulStoffregen on September 15, 2013 15:13

EthernetClient.cpp in 1.5.x has old pre-1.0 flush() function that discards input. Arduino 1.0 changed flush() to complete transmission.

https://github.com/arduino/Arduino/blob/ide-1.5.x/libraries/Ethernet/src/EthernetClient.cpp#L122

void EthernetClient::flush() {
  while (available())
    read();
}

Copied from original issue: arduino/Arduino#1576

Problem: After upgrading from Ethernet lib 1.1.2 to 2.0.0 things stopped working.

Board: Arduino UNO R3
Shield: Arduino Compatible Ethernet Shield by ELECFreaks (https://www.robotshop.com/en/arduino-compatible-ethernet-shield.html)
Shield Specs: https://www.robotshop.com/media/files/zip/documentation-ef02007.zip

I ran the example sketch from https://www.arduino.cc/en/Tutorial/WebClient. It says in that example:

Use Ethernet.h with the Arduino Ethernet Shield or Ethernet2.h with the Arduino Ethernet Shield 2 and Leonardo Ethernet.

Since my Shield is V1.1 I'm using Ethernet.h.

The error I'm getting is: Ethernet shield was not found. Sorry, can't run without hardware. :( which tells me that the WIZ5100 chip isn't being recognized:

Ethernet.hardwareStatus() == EthernetNoHardware

Version 1.1.2 of the Ethernet library is working fine, so I am confident the shield is properly connected to the Arduino. Any ideas what could be going on here?

From @nmklotas on January 21, 2015 22:26

Hello,

I use Arduino uno rev3 board on windows 8.1 x64 with Arduino 1.58 beta, and after uploading the sketch, code line:

Ethernet.begin(mac);

hangs and does not return! Been waiting for like 5 - 10 mins.

Also setting pin 4 as an output and writting HIGH to it didn't help.
(I found this instruction here http://arduino.cc/en/Main/ArduinoEthernetShield)

Not working example would be in Arduino IDE > File > Examples > DhcpAddressPrinter

Thank you

Copied from original issue: arduino/Arduino#2565

From @pidloop on April 26, 2016 20:42

Hello. I greatly improved the speed of my W5100 ethernet shield by adding some buffering to the method in Print.cpp for FLASH memory strings. This wiki won't let me attach it here but you can get it from my web site at http://www.clearskyinstitute.com/ham/AST or contact me at ecdowney at clearskyinstitute.com. Cheers.

Copied from original issue: arduino/Arduino#4899

And now hopefully in the correct section

https://www.arduino.cc/en/Reference/Ethernet

I picked up the following. Note that I'm not native English speaking, so might have some things wrong.

The libraries are allow an Arduino board to connect to the internet.

'are' to be removed

The libraries support up to four concurrent connection (incoming or outgoing or a combination).

'connection' to be changed to 'connections'

From @rhbroberg on February 11, 2016 16:52

Being able to capture the amount of traffic being used on an interface would be very useful, especially in a situation where the interface is on a network which incurs cost (like GSM). A simple counter for bytes in/out, reported by the interface, much like 'netstat' shows, would be suitable. Presumably the count could be made in GSM3SoftSerial::finalWrite()?

This would allow an application using GSM data to keep track of the data it is using, and perhaps make adjustments. (Just like a mobile phone has a report showing you how much data you are using).

Copied from original issue: arduino/Arduino#4560

From @carlosdelfino on February 1, 2013 16:13

Hello

Enjoying the post of @DavyLandman, I would make a small change I made in the function:

EthernetClient EthernetServer :: available ()

EthernetServer class.

The change function gives the possibility of obtaining more than one customer when using a server. Every call this having a new customer is returned, reserving for the sock that is not used until it is released when the customer receives the signal stop (), this releases the sock is worn allowing its use again.

I am doing some tests with my fork Ethernet library and the Arduino which focuses on the use of threads based on DuinOS / FreeRTOS, and would like to invite you to test my changes together with those already made​​, so I can also their experience.

I realized that the current library does not allow more than one client concurrently, and then I made a small change that is not yet finished and well tested, but it is helping me in my tests.

The code is not yet final, but is enough for a proposal for a new approach in obtaining the clients connected to a server.

Principal function affected:
EthernetClient EthernetServer::available()
{
accept();

  for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
      if(Ethernet.isSocketFree(sock)){
          EthernetClient client(sock);
          if (EthernetClass::_server_port[sock] == _port &&
                  (client.status() == SnSR::ESTABLISHED ||
                  client.status() == SnSR::CLOSE_WAIT)) {
              if (client.available()) {
                  // XXX: don't always pick the lowest numbered socket.
                  Ethernet.useSocket(sock);
                  return client;
              }
          }
      }
  }

  return EthernetClient(MAX_SOCK_NUM);
}

File Changed:
https://github.com/carlosdelfino/Arduino/blob/ide-1.5.x/libraries/Ethernet/Ethernet.cpp
https://github.com/carlosdelfino/Arduino/blob/ide-1.5.x/libraries/Ethernet/Ethernet.h
https://github.com/carlosdelfino/Arduino/blob/ide-1.5.x/libraries/Ethernet/EthernetClient.cpp
https://github.com/carlosdelfino/Arduino/blob/ide-1.5.x/libraries/Ethernet/EthernetServer.cpp
https://github.com/carlosdelfino/Arduino/blob/ide-1.5.x/libraries/Ethernet/EthernetServer.h

ps.
@DavyLandman, I removed the previous post and created a new discussion.

Copied from original issue: arduino/Arduino#1260

From @cmaglie on November 15, 2012 19:3

This is Issue 1056 moved from a Google Code project.
Added by 2012-09-30T18:39:19.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium, Component-Ethernet

Original description

Hi I have a problem with the default dns library.

I found that the problem is in a check that the dns library does to control if the dns server address is not null (0.0.0.0). I commented the line and executed my code without this check and the library worked well.

The code that I executed is the file test_dns.ino attached.

Expected output (seen with my patch):
My IP address: 10.0.1.119
64.131.82.241
64.131.82.241
64.131.82.241
64.131.82.241

Real output (without patch):
My IP address: 10.0.1.119
0.0.0.0
0.0.0.0
0.0.0.0
0.0.0.0

I'm using Arduino 1.0.1 on Debian Sid with an Arduino Uno board.

I attached the patch that I used.

I know that this isn't the right way to correct this error but I'm waiting before changing more code. In fact the problem is related to the == operator of the IPAddress class but first of all I want to check if it is a common problem or not.

Copied from original issue: arduino/Arduino#1056

The Ethernet library has a big amount of external contributions, the list of all contributors should be put in a CONTRIBUTIONS file and the library.properties adjusted accordingly.

Moreover there are a bunch of files without a license, these files should be fixed by adding a proper license header.

See also arduino/Arduino#5272 (comment)

From @sornii on April 4, 2014 17:46

Hello,

I'm using im my project a NFC module created by elecfreaks, and it use a PN532 which can comunicate over SPI, I2C or UART.

Currenctly I had problems using this in I2C, and switched to SPI, it works when nothing but the module is used in Arduino, but when I initialize the Ethernet it won't work.

Is everything okay in the Ethernet library or is the library that I'm using to control the NFC module?

Copied from original issue: arduino/Arduino#1987

Hello there I am looking for sketch for parsing string to variable from .txt file. For instance i want to download if led is on/off when i am controlling it throught webserver. I have this solution on NodeMCU, which i use only for HTTPS requests. But for HTTP i want to use Ethernet shield. So can you please send me sketch? Thanks a lot!

From @sauerburger on January 21, 2016 18:5

I modified EthernetServer::available() such that it will not always pick the
lowest numbered socket by introducing an internal index int _sock which is incremented by one every time available() is called. (I suppose the previous comment XXX: don't always pick the lowest numbered socket. was to be understood as a TODO)

Copied from original issue: arduino/Arduino/pull/4463

From @Apollon77 on September 20, 2015 20:53

Copied from original issue: arduino/Arduino#3829

I use a library where the EthernetClient instance is created once and then reused.
This was not really working - the first call worked, then it did not connect for additional uses.

I tracked it down to the following:
The library did the following:

if (udata->client->theClient->connected())
{
  udata->client->theClient->stop();
}

And this was the reason! After all data was received the called server closed the connection. So the socket was in status CLOSE_WAIT and available returned 0 because all data was already read. That's why stop was never called.
And that's why the connect method found a still set _sock to a valid number and returned false.

I found the advice to use "if connected() then stop()" in several sources in the internet, but this brings big problems as seen here.

I think the fix should be to change the check in connected: All Sockets that are in CLOSE_WAIT are reused in any case ... so a call to connect should check also connected and call stop or simply reuse that socket also when _sock is a value < MAX_SOCK_NUM.

From @cmaglie on November 15, 2012 18:47

This is Issue 715 moved from a Google Code project.
Added by 2011-11-17T07:37:03.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Defect, Priority-Medium

Original description

parseDHCPResponse do not exit if it read the endOption. If there is more then one dhcp replay, it continue parsing the next one.

--- Dhcp.cpp.orig 2011-11-17 08:34:56.000000000 +0100
+++ Dhcp.cpp 2011-11-17 08:35:34.000000000 +0100
@@ -253,6 +253,8 @@
switch (_dhcpUdpSocket.read())
{
case endOption :

•                _dhcpUdpSocket.flush();
  

•                return type;
               break;
  
           case padOption :
  

Copied from original issue: arduino/Arduino#715

Overflow risk in Dhcp.cpp.
_dhcpLocalIp has only 4 byte.
Every variable should be filled separate with zeros.

void DhcpClass::reset_DHCP_lease(){
    // zero out _dhcpSubnetMask, _dhcpGatewayIp, _dhcpLocalIp, _dhcpDhcpServerIp, _dhcpDnsServerIp
    memset(_dhcpLocalIp, 0, 20);
}

From @cmaglie on November 15, 2012 18:42

This is Issue 642 moved from a Google Code project.
Added by 2011-09-16T15:14:44.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium

Original description

While checking the code in the ethernet library and the w5100 datasheet, I discovered a utility function that should be included in the ethernet library.

The w5100 datasheet specifies before writing to the transmit buffer, you must check the transmit buffer free space register first to insure enough space is available for the next data send.

The function is already available in the w5100.cpp file. getTXFreeSize();

It should be included in the Arduino ethernet library, since it is now possible to send large amounts of data from the SD. This would not be too apparent on a localnet, but when the internet bogs down, or bandwidth restrictions take effect, this could cause a problem.

I added this in Client.cpp below the Client::available() function and it works well.

int Client::free() {
if (_sock != MAX_SOCK_NUM)
return W5100.getTXFreeSize(_sock);
return 0;
}

I added this in Client.h below the declaration for available()

virtual int free();

To find the transmit buffer free space remaining in the w5100, it is about like the Client::available() function.

int freeSpace = client.free();

The variable freeSpace would contain the transmit buffer free space remaining in bytes.

Writing to the transmit buffer when there is insufficient room will cause errors.

Copied from original issue: arduino/Arduino#642

My main reasoning is here (arduino/Arduino#5170) but it was centered about web documentation, so I think maybe here is the right place to explain the issue. Let's go:

None of current official Arduino products has Ethernet conectivity (sadly). So...why keep maintaining this library? If the plan is to be not tied to any specific official Arduino product, then I think this library should be more generic (as it is this: https://github.com/Wiznet/WIZ_Ethernet_Library, at least). Current situation is no sustainable because W5100 is vanishing little by little and currently this library doesn't offer other alternative. It's the same case as TFT library...if it were generic, maybe someone used it (as it is used LiquidCrystal library, for instance) but being tied to an specific chip, i_f this chip is not associated to an official product,_ it's a dead-end.

Another solution would be offer a new shining product: an Ethernet shield with TLS integrated chip and SD card , (and therefore, modify this library accordingly)...but I suspect this is not the plan

From @Fede85 on September 25, 2014 19:15

Version 1.1 of the Ethernet library brings the following improvements:

• support for W5500 and W5200 Wiznet chipsets
• automatic detection of the Wiznet chipset
• SPI speed set to 14MHz, maximum allowed by the W5100 chipset
• generalized SPI_CS pin handling functions
• added getMaxSockets() method
• improved 3rd party compatibility using the SPI Extended API as a criterion of choice
• removed redundant configurations and useless variable modifiers

Copied from original issue: arduino/Arduino/pull/2325

From @cmaglie on November 15, 2012 18:52

This is Issue 838 moved from a Google Code project.
Added by 2012-03-01T17:37:17.000Z by [email protected].
Please review that bug for more context and additional comments, but update this bug.

Original labels: Type-Enhancement, Priority-Medium

Original description

I would like to point out some dangerous or at least bad code in the methods void W5100Class::read_data and void W5100Class::recv_data_processing.

The first problem is in read_data with the volatile keywords which don't make any sense since none of the methods are executed inside interrupts.

The second problem that exists regards the use of an internal W5100 memory address as an AVR one, casting the correct uint16_t value returned by readSnRX_RD(s) into a uint8_t_. This code does not fail because coincidentally uint8_t_ are 16 bit addresses but the same cannot be guaranteed for other architectures besides AVR (Leonardo?). After that casting is passed to W5100Class::read_data it is again converted to uint16_t. After that a series of (uint8_t) casts are made for no usefull reason.

That is it. If in any of my reasoning there is any need for clarification i will provide it.

Thanks
Paulo Neves

Copied from original issue: arduino/Arduino#838

This request was one of multiple ones in #37 but I've separated here to make it more visible.

I suspect that hardware design of Ethernet shield should be changed to achieve this ...but I think this is a must to be on pair with Wifi101 shield.

Thanks

From @qbahn21 on March 14, 2015 12:0

Sometimes WIZ5100 reports status ESTABLISHED without any data available. In such a case, whole socket is permanently blocked. Moreover there is no possibilities to implement time out methods on higher level of application because EthernetServer returns no client.

Copied from original issue: arduino/Arduino/pull/2771