Arduino Ethernet Shield 2 Library for Proteus: W5500 and SD Card

Hello friends, I hope you all are doing great. Today, I am going to share the Arduino Ethernet Shield 2 Library for Proteus. The Arduino Ethernet Shield 2 is the newer version of the classic Ethernet shield: a WIZnet W5500 chip does the TCP / IP work in hardware, an RJ45 jack with its own LINK and ACT LEDs takes the cable from your router, and a micro SD socket shares the same SPI bus. The Ethernet library of the Arduino IDE drives it with the same functions as the first shield. With this library you can place the Shield 2 beside your UNO in Proteus and run those sketches as they are - DHCP, DNS, servers, clients, UDP, the link status and the SD card included.

This is the twenty-ninth library of our Wi-Fi / Ethernet series and the second of its Ethernet group. Its demo is a telnet chat server: the UNO gets its address from the router and waits on port 23; our Laptop WiFi Monitor and Mobile WiFi Monitor join it with their TCP terminals and chat through the UNO, which also answers a few commands, keeps the chat on the card and watches the cable.

NOTICE: the PANEL pad, the panel and the virtual router are TEP additions; the W5500's MACRAW mode, its interrupt pin and the PHY's mode settings are not simulated (see the limits at the end). The shield works with the Arduino Ethernet library. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the Arduino Ethernet Shield 2 board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the Arduino Ethernet Shield 2 Library for Proteus:

What is the Arduino Ethernet Shield 2?

The Arduino Ethernet Shield 2 connects an Arduino to a wired 10/100 Mbit Ethernet network. Its heart is the WIZnet W5500, a chip with the whole TCP / IP stack inside: the Arduino writes a few registers - "open a TCP socket on port 23", "send these bytes" - and the chip handles the packets, the handshakes and the retries. The W5500 keeps eight sockets at a time, with 16 KB of send and 16 KB of receive buffer shared between them (2 KB each by default). Next to it sit the RJ45 jack with its magnetics and LEDs, a 25 MHz crystal, a 3.3 V regulator, a reset button and a micro SD socket.

The Pins the Shield Uses

The shield takes SPI from the ICSP header (D11, D12, D13 on an UNO; D51, D50, D52 on a Mega), D10 as the chip select of the W5500 and D4 as the chip select of the micro SD card. Both chips share the bus and take turns: only one chip select is LOW at a time. The shield's RESET button pulls the board's RESET line LOW, which restarts the Arduino and the W5500 together. All the other pins are free for your sketch.

W5500 or W5100?

Our Arduino Ethernet Shield Library for Proteus has the W5100 of the first shield. The W5500 does the same job with a few differences that matter to a sketch: twice the sockets and the buffer memory, a faster SPI interface with a different frame (a 16-bit address, a control byte that picks the register block, then any number of data bytes), and a link status - the PHY reports whether a cable is connected, so Ethernet.linkStatus() really tells you. The Ethernet library finds out by itself which chip is there: it tries the W5200 and the W5500 first, then the W5100, so the same sketch runs on both shields.

Features of the Arduino Ethernet Shield 2 Library for Proteus

• The shield as it looks: the Arduino shield outline with its stacking headers and labels on the teal board, the RJ45 jack with its LINK and ACT LEDs over the UNO's USB socket, the micro SD socket with a card, the W5500 and its crystal, the regulator, the ON LED, the RESET button and the ICSP socket.
• The real Ethernet library: our W5500 answers the library exactly as the chip does - we ran the Ethernet library 2.0.2 and the demo sketch unchanged against the model on the PC (17 checks), the first shield's logger on it as a W5500 (23 checks), and the demo in Proteus.
• The chip test and the link: Ethernet.hardwareStatus() is EthernetW5500, and Ethernet.linkStatus() follows the cable - LinkON or LinkOFF.
• DHCP, DNS and NTP: Ethernet.begin(mac) gets 192.168.1.101 from the router, names are looked up by DNS, and an internet time server answers - all done by the sketch over UDP, as on real hardware.
• Eight sockets: EthernetServer, EthernetClient and EthernetUDP, each visitor of a server taking one listening socket as on the real chip (on an UNO the library uses four of them).
• The LEDs: ON on the board, the jack's green LINK and yellow ACT (it flashes with the packets), and the cable's blue plug in the port.
• The cable: pull it out and put it back - a click on the jack, the CABLE property or the panel. Open TCP connections survive a short pull, as on a real network.
• The micro SD socket with our 64 MB card model - the SD library reads and writes it; click the socket to take the card out.
• One network for every part: the cable goes to the same virtual router as our Wi-Fi boards and modules, so a wired UNO and a Wi-Fi ESP32 can talk to each other.
• Our Laptop and Mobile WiFi Monitors: a laptop and a phone on the same network, with a browser, TCP and UDP terminals - included in the package.
• Our pop-up panel: the phone, the shield card, an ETHERNET card, an SPI page with every socket command and the router's answers, the eight sockets and the micro SD card, a Test page, Settings and Help - with our TEP header, not a Windows title bar.
• A compact package: about 2.92 MB, without the C++ source code of the models.

The Arduino Ethernet Shield 2 in Proteus

Search ETHERNET SHIELD 2 or W5500 in Pick Devices; the device ARDUINO ETHERNET SHIELD 2 W5500 is in TEPETHSHIELD2.LIB. Its pins sit on the header positions the real shield uses. Click the PANEL pad or the W5500 to open the panel, the RJ45 jack to pull or plug the cable, and the micro SD socket to take the card out.

Every State of the Arduino Ethernet Shield 2

We ran the demo and paused the simulation for each picture. At Run the cable is in, so the jack's LINK LED lights at once; the UNO first opens the card, then the Ethernet library tests the chip and asks the router for an address:

Download Arduino Ethernet Shield 2 Library for Proteus

Click the button below to download Arduino-Ethernet-Shield-2-Library-for-Proteus-v1.0.zip (about 2.92 MB, without the C++ source code of the models):

Arduino Ethernet Shield 2 Library for Proteus V1.0

• README.txt: the device, installation, the demo, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPETHSHIELD2.LIB (the shield), ArduinoV4TEP.LIB (our Arduino boards V4.0 - the UNO of the demo), TEPLAPTOP.LIB and TEPMOBILE.LIB (our Laptop and Mobile WiFi Monitors).
• Proteus Model Files: TEPNET.DLL (the shield, its micro SD card, the two monitors and the network) and TEPARDUINO.DLL (the Arduino boards).
• Proteus Simulation: the demo project, its HEX file and copies of the DLLs.
• Arduino Code: the demo sketch. The Ethernet and SD libraries are not included - they come with the Arduino IDE.

No Proteus yet? Read How to Download and Install Proteus 7 and 8. New to libraries? Follow How to Install a New Library in Proteus.

How to Install Arduino Ethernet Shield 2 Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy the four files from Proteus Library Files into the LIBRARY folder of Proteus (usually C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY).
3. Copy TEPNET.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder - replace older copies (this TEPNET.DLL is the first one that knows the Ethernet Shield 2, and it still runs the first Ethernet shield, every Wi-Fi part of the series and the two monitors).
4. Delete TEPETHSHIELD2.IDX, ArduinoV4TEP.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for ETHERNET SHIELD 2.

The sketch is a normal UNO sketch: the Ethernet and SD libraries are built into the Arduino IDE, so write your sketch and use Sketch > Export Compiled Binary; then double-click the UNO in Proteus and set its Program File to the HEX (see How to get the HEX file from Arduino).

Demo: A Telnet Chat Server on Port 23

Open Ethernet-Shield-2-Telnet-Chat-with-Laptop-and-Mobile.pdsprj. On the left is our UNO V4.0 (ARD1, from our Arduino UNO Library for Proteus V4.0) with its built-in serial monitor and a pot on A0, in the middle the Ethernet Shield 2 (U1), and on the right the laptop (PC1) and the phone (MOB1) - no wires to them, they are on the router's network like the real ones.

In Proteus we place the shield beside the UNO, so net labels do the stacking. SCK, MISO and MOSI come from the UNO's D13, D12 and D11 to the shield's right edge (its ICSP side); ETH_CS (D10) and SD_CS (D4) go to the pins of the same names, and a RESET label below each board joins the shield's button to the UNO's reset. 5V goes to VCC. RV1 (10k, at 35 %) on A0 gives the value of the /a0 command:

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. In this project both terminals are preset to 192.168.1.101 port 23, and both browsers to http://192.168.1.101:23/. The laptop is 192.168.1.21 and the phone 192.168.1.41:

The Sketch: a Server for Three Clients

The sketch includes the SPI, Ethernet and SD libraries, gives the shield a MAC address - the real shields come with one printed on a sticker - and creates a server on port 23, the telnet port:

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

byte mac[] = {0x90, 0xA2, 0xDA, 0x10, 0x00, 0x01};
EthernetServer server(23);

It keeps up to three clients, each in its own EthernetClient, with a line buffer and the last number of its address, which becomes its name in the chat:

const byte MAX_CLIENTS = 3, SD_CS = 4;
EthernetClient clients[MAX_CLIENTS];

The card starts first, with D10 HIGH so the W5500 stays off the bus. Then Ethernet.begin(mac) - with only the MAC address - runs DHCP: the library sends a DHCP DISCOVER by UDP, the router offers an address, the library requests it and the router confirms. The loop tries again if no router answers, for example while the cable is out:

  pinMode(10, OUTPUT);
  digitalWrite(10, HIGH);                              // the W5500 off the bus while the card starts
  sdOk = SD.begin(SD_CS);

  while (Ethernet.begin(mac) == 0) Serial.print(F(" no answer - is the cable in?"));

Before DHCP the library waits about half a second and tests which WIZnet chip answers. Ethernet.hardwareStatus() tells the sketch what it found, so the start-up names the chip:

  Serial.println(Ethernet.hardwareStatus() == EthernetW5500 ? F("W5500") : Ethernet.hardwareStatus() == EthernetW5100 ? F("W5100") : F("other"));

Press Run and watch the UNO's monitor: the card, DHCP, the chip, the address, the chat's address and the link:

Ethernet Shield 2 Telnet Chat - The Engineering Projects
SD: card ready
DHCP... OK
Chip: W5500
IP address: 192.168.1.101
Chat on telnet: 192.168.1.101 port 23
Link: ON

Watching the Cable with linkStatus()

The W5500 knows whether a cable is connected, and Ethernet.linkStatus() reads it. The sketch checks it every half second and prints a line only when it changes - the first check prints "Link: ON":

void watchLink() {
  if (millis() - lastLinkCheck < 500) return;
  lastLinkCheck = millis();
  EthernetLinkStatus s = Ethernet.linkStatus();
  if (s == lastLink) return;
  lastLink = s;
  Serial.print(F("Link: ")); Serial.println(linkName(s));
}

Joining the Chat from the Laptop and the Phone

In the laptop, open the Terminal, pick TCP Client and press Connect. The host and the port are already set by the project:

On the UNO, server.accept() hands the sketch every new connection once. The sketch puts it in a free place, remembers the last number of its address and the time it came:

  EthernetClient c = server.accept();
  if (!c) return;

      clients[i] = c; clen[i] = 0; who[i] = c.remoteIP()[3];
      welcomed[i] = false; joinAt[i] = millis();

Notice how the server works: when a client takes the listening socket, the library opens another socket and makes it listen, so the next one finds it. On an UNO the library uses four of the W5500's eight sockets (its MAX_SOCK_NUM is 4 on a board with 2 KB of RAM), so three clients and the listening socket fill it. A new client is welcomed 0.3 s later - or at its first line - and the others hear that it joined:

void welcome(byte i) {
  char b[6]; nameOf(i, b);
  clients[i].print(F("Welcome to the UNO chat, ")); clients[i].print(b); clients[i].println(F(" - type /help"));
  welcomed[i] = true;
  sendAll(b, "joined");
}

    if (!welcomed[i] && !clients[i].available() && millis() - joinAt[i] >= 300) welcome(i);

Then the phone: Terminal, TCP, Connect:

One Line to Everyone

Type a line in the laptop and another in the phone. Each line the UNO reads from a client goes to sendAll(), which builds "[#21] text" in one buffer and writes it to every client with a single write() - one packet per client - then to the monitor and to CHAT.TXT on the card:

void sendAll(const char *from, const char *text) {
  char out[64];
  byte n = 0;
  out[n++] = '[';
  while (*from && n < 12) out[n++] = *from++;
  out[n++] = ']'; out[n++] = ' ';
  while (*text && n < sizeof out - 2) out[n++] = *text++;
  out[n++] = '\r'; out[n++] = '\n';
  for (byte i = 0; i < MAX_CLIENTS; i++)
    if (clients[i]) clients[i].write((const uint8_t *)out, n);
  Serial.write((const uint8_t *)out, n);
  if (sdOk) {
    File f = SD.open("CHAT.TXT", FILE_WRITE);
    if (f) { f.write((const uint8_t *)out, n); f.close(); }
  }
  messages++;
}

The UNO's monitor shows the chat too:

[#21] joined
[#41] joined
[#21] Hello from the laptop
[#41] Hi laptop, the phone here

The Commands

A line that starts with a slash is a command, and its answer goes to the asking client only. /who lists the clients, /a0 reads the pot, /link shows the link and the address, and /help the list:

  if (!strcmp(cmd, "/who")) {
    c.print(F("Online:"));
    for (byte k = 0; k < MAX_CLIENTS; k++)
      if (clients[k]) { char b[6]; nameOf(k, b); c.print(' '); c.print(b); }
    c.println();

  } else if (!strcmp(cmd, "/a0")) {
    c.print(F("A0 = ")); c.println(analogRead(A0));

The laptop's commands and their answers:

/who
Online: #21 #41
/link
Link ON, IP 192.168.1.101

And the phone's:

/a0
A0 = 358
/help
Commands: /who, /a0, /link, /help - any other line goes to everyone

The pot at 35 % gives 358. The answers are printed with print(F("...")), and the Ethernet library sends each character of such a print as its own packet - fine for a short answer, slow for a page, as we will see.

A Line from the UNO

The UNO takes part too: any line typed in its serial monitor that is not one of its commands goes to the chat as [UNO]:

      sendAll("UNO", line);

Hello from the UNO
[UNO] Hello from the UNO

A Browser on Port 23

What if a browser opens port 23? A browser sends its request at once - GET / HTTP/1.1 - before any welcome, so a first line starting with "GET " gets a small status page instead of the chat, and the connection is closed:

      if (!welcomed[i] && !strncmp(cline[i], "GET ", 4)) {        // a browser on port 23: the status page
        statusPage(clients[i]);
        delay(1);
        clients[i].stop();
        break;

  c.print(F("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: close\r\n\r\n"
            "<html><head><title>UNO Chat</title></head><body><h3>Ethernet Shield 2 Chat</h3><p>Chip: W5500, link "));

In the laptop, open the Browser and press Go - the home page is http://192.168.1.101:23/:

Ethernet Shield 2 Chat
Chip: W5500, link ON
Clients: 3, messages: 5
Telnet: 192.168.1.101 port 23

The page takes 0.13 s for 249 bytes because print(F("...")) on an EthernetClient sends each character as its own packet: the panel's SPI page shows 243 SENDs of one byte. For a real web page, collect the text in a buffer and send it with client.write(buf, n), as sendAll() does.

The Serial Monitor Commands

The monitor takes STATUS, LOG (CHAT.TXT from the card), CLEAR (delete it) and HELP:

STATUS
IP 192.168.1.101, link ON, clients 2, messages 5
LOG
[#21] joined
[#41] joined
[#21] Hello from the laptop
[#41] Hi laptop, the phone here
[UNO] Hello from the UNO
HELP
Commands: STATUS, LOG, CLEAR, HELP - any other text goes to the chat

loop() accepts, reads the clients, watches the link, reads the monitor and calls Ethernet.maintain(), which renews the DHCP lease when it is due - a server that runs for days needs it:

  Ethernet.maintain();                                 // renews the DHCP lease when it is due

Pulling the Cable

Click the RJ45 jack, or use the panel's cable test, which pulls the cable for 3 seconds three times. The link goes down at once, linkStatus() becomes LinkOFF, and the monitor shows it:

Link: OFF
Link: ON
Link: OFF
Link: ON
Link: OFF
Link: ON

The two terminals stay connected. On a real network a short pull does not close a TCP connection: the packets wait and are sent again, and the connection carries on when the cable is back. Our model does the same - a line sent while the cable is out arrives when it is back, and only after 20 s without a link are the connections dropped. After the test the laptop sends another line, and the phone gets it:

Leaving the Chat

When a client disconnects, connected() turns false; the sketch stops its socket and tells the others:

      if (welcomed[i]) sendAll(b, "left");

And the whole demo running:

The Arduino Ethernet Shield 2 Panel

The panel opens at Run, in the look of our TEP Serial Monitor Advance for Proteus - our own TEP header, no Windows title bar. Its first page has a small phone of its own with the CABLE IN and CABLE OUT buttons, and three cards: SHIELD with the chip, the MAC address, the host link and the LEDs, ETHERNET with the router, the status, the address with its gateway and mask, the link and the DHCP time, and TRAFFIC:

OPEN SHIELD PAGE opens the page the UNO serves on PAGEPORT - 23 in this demo, so the status page; the ROUTER tab lists the router's clients, the shield among them as a LAN client:

The SPI page lists what the Ethernet library asks the W5500 and what the router answers, newest first: OPEN and LISTEN for the server, ACCEPT when a client arrives, RECV and SEND, DISCON at the end, and the DHCP exchange at the start. The sockets card shows all eight places:

The footer counts the register accesses - the library reads the socket status all the time, about 74,000 register reads a second while it waits. The Test page measures the running model: the phone opens the page three times, and the cable is pulled for 3 seconds three times:

Pins of the Arduino Ethernet Shield 2

Properties of the Arduino Ethernet Shield 2

The DHCP address follows the part's number: U1 gets 192.168.1.101, U2 .102 and so on, so give every network part its own number. The laptop is always 192.168.1.21 and the phone 192.168.1.41. Ethernet.begin(mac, ip) with a fixed address works too.

Troubleshooting

• Ethernet.begin() returns 0 or the hardware status is EthernetNoHardware: check SCK, MISO, MOSI, CS (D10) and 5V / GND, and that RESET is not held LOW.
• DHCP never answers: the cable is out (linkStatus() is LinkOFF) - put it in with the panel, or click the RJ45 jack.
• The card is not found: SD CS on D4, and D10 HIGH while SD.begin() runs.
• A client cannot connect: on an UNO the four sockets are all in use (three clients and the listening one) - the next client gets in when one leaves.
• A page is slow or arrives in tiny pieces: write whole buffers with client.write(buf, n), not one character at a time.
• A paused simulation shows the log: the AVR model notes "Clock frequency changed while in the Master mode" when the SD library changes the SPI speed - harmless; click the Schematic Capture tab.
• No panel: click the PANEL pad or the W5500, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real Arduino Ethernet Shield 2

• The MAC address: use the one on the sticker under the shield (or any locally administered address), and give every shield on the network its own.
• The size of the sketch: Ethernet, DHCP and SD fill most of an UNO - the demo takes 28,124 of its 32,256 bytes of flash and 1,507 of its 2,048 bytes of RAM. Keep strings in flash with F() and buffers small.
• The sockets: the W5500 has eight, but on an UNO the library uses four; on a Mega it uses all eight.
• The pins: D10 and D4 are the two chip selects; on a Mega keep D53 an output, as the SPI library needs.
• Telnet clients: a real telnet program may send option bytes when it connects; a chat sketch for real use should skip bytes above 127.
• The first shield: the same sketch runs on the W5100 shield of our Arduino Ethernet Shield Library for Proteus, except that its linkStatus() is always Unknown. Wi-Fi instead of a cable: see our Arduino WiFi Shield Library for Proteus; the card alone is in our Micro SD Card Module Library for Proteus.

Limitations of the Simulation

• The W5500 is our model of the chip as the Ethernet library (2.0) uses it - the registers, the sockets and the buffers - not a packet-level simulation of Ethernet.
• Not modelled: MACRAW traffic (the mode opens but carries nothing), PPPoE, the socket interrupts (the INT pin), the PHY's mode settings and auto-negotiation (it is always 100 Mbit/s full duplex), ping answers, wake-on-LAN, the supply's voltage and current.
• With the cable out the TCP connections are kept for 20 s - our choice, close to what a real network does for a short pull.
• The internet host is a stand-in for the internet: every internet name is 203.0.113.10, and it answers HTTP and the time.
• The PANEL pad, the panel, its phone, the router, the internet host and the two monitors are TEP additions.
• Arduino is a name of Arduino and W5500 a name of WIZnet; this library is not made or endorsed by Arduino, WIZnet or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the demo as shipped, the UNO, the shield, the card, the laptop and the phone together at about 0.15 to 0.25 x real time on our PC). Proteus 7 is not supported.

So, that was all about the Arduino Ethernet Shield 2 Library for Proteus. I hope it helps you try the Ethernet library sketches on the newer W5500 shield in Proteus - DHCP, servers and clients, the link status and the micro SD card - and watch every socket command on the panel while you do. The cable goes to the same router as our Wi-Fi boards, so a wired UNO and a Wi-Fi ESP32 can share one design. If you use the Arduino Ethernet Shield 2 Library for Proteus in a project, please share it in the comments or in our forum, and if you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!