Arduino Ethernet Shield Library for Proteus: W5100 and SD Card

Hello friends, I hope you all are doing great. Today, I am going to share the Arduino Ethernet Shield Library for Proteus. The Arduino Ethernet Shield puts an Arduino on a wired network: a WIZnet W5100 chip does the TCP / IP work in hardware, an RJ45 jack takes the cable from your router, and a micro SD socket shares the same SPI bus. It is one of the most used shields ever made, and the Ethernet library that drives it is built into the Arduino IDE. With this library you can place the shield beside your UNO in Proteus and run those sketches as they are - DHCP, DNS, web servers, clients, UDP and the SD card included.

This is the twenty-eighth library of our Wi-Fi / Ethernet series and the first of its Ethernet group. Its demo is a data logger: the UNO gets its address from the router, sets its clock from an internet time server, writes a reading of the pot on A0 to the card every five seconds and serves it all on the network - a page for our Mobile WiFi Monitor, JSON for our Laptop WiFi Monitor and the whole log file for both.

NOTICE: the PANEL pad, the panel and the virtual router are TEP additions; the W5100's raw modes (IPRAW and MACRAW) and its interrupt jumper 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 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 Library for Proteus:

What is the Arduino Ethernet Shield?

The Arduino Ethernet Shield connects an Arduino to a wired 10/100 Mbit Ethernet network. Its heart is the WIZnet W5100, a chip with the whole TCP / IP stack inside: the Arduino only writes a few registers - "open a TCP socket on port 80", "send these bytes" - and the chip handles the packets, the handshakes and the retries. The W5100 keeps four sockets at a time, each with its own 2 KB send and receive buffers. Next to it sit the RJ45 jack with its magnetics, a 25 MHz crystal, a 3.3 V regulator, a buffer chip for the SPI lines, 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 W5100 and D4 as the chip select of the micro SD card. Both chips share the bus, and the two libraries 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 W5100 together. All the other pins are free for your sketch.

A TCP / IP Chip, Not a Network Card

The W5100 is different from the ENC28J60 found on cheap modules: the ENC28J60 only moves raw Ethernet frames, so the Arduino has to run the whole TCP / IP stack itself; the W5100 runs it in hardware. That is why an UNO with 2 KB of RAM can run a web server on this shield. Our model does what the chip does - the registers, the socket commands and the buffers - so the Ethernet library from the Arduino IDE runs unchanged, and its own chip test finds a W5100.

Features of the Arduino Ethernet Shield Library for Proteus

• The shield as it looks: the Arduino shield outline with its stacking headers and labels, the RJ45 jack over the UNO's USB socket, the micro SD socket with a card, the W5100 and its crystal, the 74HC125 buffer, the regulator, the seven LEDs, the RESET button and the ICSP socket.
• The real Ethernet library: our W5100 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 (22 checks) and in Proteus.
• 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.
• Four sockets: EthernetServer, EthernetClient and EthernetUDP, each visitor of a server taking one listening socket as on the real chip.
• The seven LEDs: ON, LINK (blinking with the traffic), FULLD and 100M (the link), RX and TX (packets in and out) and COLL; the RJ45 jack's own green and yellow LEDs, 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.
• 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 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 in Proteus

Search ETHERNET SHIELD or W5100 in Pick Devices; the device ARDUINO ETHERNET SHIELD W5100 is in TEPETHSHIELD.LIB. Its pins sit on the header positions the real shield uses. Click the PANEL pad or the W5100 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

We ran the demo and paused the simulation for each picture. At Run the cable is in, so the link LEDs light 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 Library for Proteus

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

Arduino Ethernet Shield Library for Proteus V1.0

• README.txt: the device, installation, the demo, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPETHSHIELD.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 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, and it still runs every Wi-Fi part of the series and the two monitors).
4. Delete TEPETHSHIELD.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.

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: An Ethernet Data Logger

Open Ethernet-Shield-SD-Logger-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 (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 the log records:

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. In this project the laptop's browser opens http://192.168.1.101/json and the phone's http://192.168.1.101/. The laptop is 192.168.1.21 and the phone 192.168.1.41:

The Sketch: Ethernet and SD on One Bus

The sketch includes the Ethernet library, its UDP class and the SD library, and gives the shield a MAC address - the real shields come with one printed on a sticker:

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

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x01};
EthernetServer server(80);
EthernetUDP udp;

The card starts first, with D10 HIGH so the W5100 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 W5100 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?"));
  Serial.println(F(" OK"));

Before DHCP the library waits about half a second (a real shield's reset chip needs it) and tests which WIZnet chip answers - it tries the W5200 and the W5500 first, then the W5100. Press Run and watch the UNO's monitor: the card, DHCP, the address, the gateway, the time and the logger's address:

Ethernet Shield Data Logger - The Engineering Projects
SD: card ready
DHCP... OK
IP address: 192.168.1.101
Gateway: 192.168.1.1
NTP: the time is 02:37:05 UTC
Logger on the web: http://192.168.1.101/

The Time from the Internet

The log needs a clock, and an UNO has none. The sketch asks an NTP time server: beginPacket() with a name looks it up by DNS first (our router answers pool.ntp.org with the internet host), then a 48-byte request goes out on UDP port 123:

  if (!udp.beginPacket("pool.ntp.org", 123)) { Serial.println(F("NTP: no DNS answer")); return; }
  udp.write(packet, sizeof packet);
  udp.endPacket();

The answer holds the time in seconds since 1900 at bytes 40 to 43; the sketch turns it into seconds since 1970 and counts on from there with millis():

      unsigned long t = (unsigned long)packet[40] << 24 | (unsigned long)packet[41] << 16 | (unsigned long)packet[42] << 8 | packet[43];
      ntpSeconds = t - 2208988800UL;
      ntpAt = millis();

Logging to the Micro SD Card

Every five seconds the sketch reads A0 and adds a line to LOG.CSV: the time, the raw reading and the volts. FILE_WRITE opens the file at its end, and a new file gets the header line first:

  File f = SD.open("LOG.CSV", FILE_WRITE);
  if (!f) { Serial.println(F("SD: cannot open LOG.CSV")); return; }
  if (f.size() == 0) f.println(F("time,a0,volts"));
  f.print(t); f.print(','); f.print(a0); f.print(','); f.println(v);

The pot at 35 % gives 358, which is 1.74 V on the UNO's 5 V scale.

The JSON for the Laptop

The web server waits on port 80. server.available() gives the sketch a visitor; it reads the first line of the request - GET /json HTTP/1.1 - and takes the path out of it:

  EthernetClient client = server.available();
  if (!client) return;

  char *path = strchr(req, ' ');                       // "GET /json HTTP/1.1"
  if (path) { path++; char *end = strchr(path, ' '); if (end) *end = 0; } else path = req;

/json answers with the reading in a form a program can read:

void sendJson() {
  int a0 = analogRead(A0);
  char t[9], v[5];
  clockText(t); voltsText(a0, v);
  putHeader(F("application/json"));
  put(F("{\"a0\":")); put((long)a0); put(F(",\"volts\":")); put(v); put(F(",\"logged\":")); put((long)logged);
  put(F(",\"time\":\"")); put(t); put(F("\",\"uptime\":")); put((long)(millis() / 1000)); put('}');
}

In the laptop, open the Browser and press Go:

{"a0":358,"volts":1.74,"logged":0,"time":"02:37:09","uptime":5}

Each put() collects the answer in a 64-byte buffer, and only a full buffer goes to the W5100 - an Ethernet client's print(F("...")) would send every character as its own packet:

void flushOut() { if (outLen) { outClient->write((const uint8_t *)outBuf, outLen); outLen = 0; } }
void put(char c) { outBuf[outLen++] = c; if (outLen == sizeof outBuf) flushOut(); }

The Page and the Log for the Phone

The main page shows the time, the reading, the counts and the last lines of the log. To find them, the sketch jumps to 100 bytes before the end of the file and skips to the next line start:

  if (size > 100) { f.seek(size - 100); while (f.available() && f.read() != '\n') {} }

In the phone, open the Browser and press Go:

LOG.CSV sends the whole file, read from the card in 64-byte blocks:

  while ((n = f.read(b, sizeof b)) > 0) outClient->write(b, n);

CLEAR opens /clear, which deletes the file with SD.remove() and starts a new log. The monitor shows each page the sketch serves:

  else if (!strcmp(path, "/clear")) { SD.remove("LOG.CSV"); logged = 0; Serial.println(F("SD: LOG.CSV deleted")); sendPage(); }

Page: /json
SD: logged 02:37:10, A0 358 (1.74 V)
Page: /

A little later the laptop's JSON counts three readings:

{"a0":358,"volts":1.74,"logged":3,"time":"02:37:21","uptime":16}

The Serial Monitor Commands

The monitor takes STATUS, LOG, TIME (ask the time server again), CLEAR and HELP:

STATUS
IP 192.168.1.101, time 02:37:21, A0 358, logged 3, pages 4
LOG
time,a0,volts
02:37:10,358,1.74
02:37:15,358,1.74
02:37:20,358,1.74
TIME
NTP: the time is 02:37:25 UTC
SD: logged 02:37:25, A0 358 (1.74 V)
HELP
Commands: STATUS, LOG, TIME, CLEAR, HELP

loop() logs, serves the visitors, reads the monitor and calls Ethernet.maintain(), which renews the DHCP lease when it is due - a sketch that runs for days needs it:

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

And the whole demo running:

The Arduino Ethernet Shield 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; 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 W5100 and what the router answers, newest first: OPEN and LISTEN for the server, ACCEPT when a visitor arrives, RECV and SEND, DISCON at the end, and the DHCP, DNS and NTP exchanges:

Notice how the server works: when a visitor takes the listening socket, the library opens another socket and makes it listen, so the next visitor finds one. A W5100 has four sockets; the demo uses one for the server, one for UDP and the rest for visitors and DNS. The footer counts the register accesses - the library reads the socket status all the time, about 35,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:

With the cable out the W5100 has no link and the shield is off the network; when it goes back in, the same address works again at once - the sketch does not even notice, because the lease is still valid.

Pins of the Arduino Ethernet Shield

Properties of the Arduino Ethernet Shield

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 - 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.
• Ethernet.linkStatus() is Unknown: normal for a W5100 - the chip has no link register.
• 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 W5100, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real Arduino Ethernet Shield

• 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, DNS and SD fill most of an UNO - the demo takes 29,188 of its 32,256 bytes of flash. Keep strings in flash with F() and buffers small.
• The pins: D10 and D4 are the two chip selects; on a Mega keep D53 an output, as the SPI library needs.
• The newer shield: the Ethernet Shield 2 has a W5500 - the same Ethernet library drives both, and finds the chip by itself.
• Wi-Fi instead of a cable: see our Arduino WiFi Shield Library for Proteus and AirLift WiFi Shield Library for Proteus; the card alone is in our Micro SD Card Module Library for Proteus.

Limitations of the Simulation

• The W5100 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: IPRAW and MACRAW traffic (the modes open but carry nothing), PPPoE, the interrupt jumper (D2), the reset chip's delay, the PHY's auto-negotiation and timing, the supply's voltage and current.
• 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 W5100 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.4 x real time on our PC). Proteus 7 is not supported.

So, that was all about the Arduino Ethernet Shield Library for Proteus. I hope it helps you try the classic Ethernet library sketches in Proteus - DHCP, web servers, clients, UDP, the time from the internet 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 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!