Arduino Ethernet Rev3 Library for Proteus: Web File Server on SD

Hello friends, I hope you all are doing great. Today, I am going to share the Arduino Ethernet Rev3 Library for Proteus. The Arduino Ethernet Rev3 is an Arduino UNO and an Ethernet shield on one board: the same ATmega328P, a WIZnet W5100 Ethernet chip, a micro SD socket and an RJ45 jack where the UNO has its USB socket. With this library it is one part in Proteus: Proteus's own ATmega328P model runs your HEX file, and the W5100 and the card sit on the board's own SPI wiring, as on the real board.

This is the thirty-fourth library of our Wi-Fi / Ethernet series and the seventh of its Ethernet group. Its demo is a web file server: the pages and files live on the micro SD card, the sketch serves them to our Laptop WiFi Monitor and Mobile WiFi Monitor, lists the card, switches the board's own L9 LED and writes every request to an access log on the card.

NOTICE: the PANEL pad, the panel and the virtual router are TEP additions; the optional PoE module is not simulated (see the limits at the end). The board works with the Ethernet and SD libraries of the Arduino IDE. 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 Rev3 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 Rev3 Library for Proteus:

What is the Arduino Ethernet Rev3?

The Arduino Ethernet Rev3 is an official Arduino board with the shape and the pins of the UNO, built around the ATmega328P at 16 MHz. Instead of the UNO's USB chip it carries the WIZnet W5100 (the chip of the Ethernet shield), a micro SD socket and an RJ45 MagJack. There is no USB socket: you program it through a 6-pin FTDI header with a USB-to-serial cable. Arduino has retired the board, but many are still in use, and it is still the neatest way to see an Arduino and Ethernet on one PCB.

The Pins It Keeps for Itself

The board has the UNO's 31 pins in the same places, but five of them are already wired on the board. D10 is the W5100's chip select, D11, D12 and D13 are the SPI bus, and D4 is the micro SD card's chip select. Leave them to the libraries. Because D13 is the SPI clock, the user LED moved: on this board it is L9, on D9 - and LED_BUILTIN is 9 when the sketch is built for "Arduino Ethernet". D0 and D1 are the serial port of the FTDI header.

The Same W5100 as the Ethernet Shield

Inside, this is the W5100 of our Arduino Ethernet Shield Library for Proteus - the same model, tested with the same Ethernet library. The difference is the board around it. On the shield the W5100 sits on top of a separate UNO and its pins are wired between two parts; here the processor and the network chip are one part, so a demo needs no wires at all. The processor is the ATmega328P model of our Arduino UNO Library for Proteus V4.0, so everything you know from the UNO - the HEX file, the clock, the RESET button, the built-in serial monitor - works the same way.

Features of the Arduino Ethernet Rev3 Library for Proteus

• The board as it looks: the blue UNO outline, the silver RJ45 jack with the RESET button above it, the W5100 in the middle with its 25 MHz crystal, the small ATmega328P, the FTDI and ICSP headers on the right edge and the micro SD socket over the analog pins.
• A real ATmega328P: Proteus's own AVR model runs your HEX file - PROGRAM and CLOCK as on any Proteus AVR.
• The real Ethernet library: the chip test, DHCP or a fixed address, DNS, TCP client and server, UDP and NTP; Ethernet.hardwareStatus() reports EthernetW5100. We ran the demo against the model on the PC (17 checks), plus the 66 checks of our other WIZnet libraries, and in Proteus.
• The real SD library: a 64 MB card with demo files on D4; click the socket to take the card out or put it back.
• Working LEDs: ON, L9 on D9, and the W5100's LINK, RX and TX.
• RESET with the bootloader: the button resets the ATmega328P and the W5100 together; L9 flashes three times and the sketch starts 1 s later.
• The FTDI header: a click opens the built-in serial monitor with its Board and Plotter pages.
• The cable: pull it with a click on the jack, the CABLE property or the panel.
• Our Laptop and Mobile WiFi Monitors: a laptop and a phone with browsers on the same network - included in the package.
• Our pop-up panel: the phone, the BOARD card, an ETHERNET card, an SPI page with the library's socket commands and the card, a Test page, Settings and Help - with our TEP header, not a Windows title bar.
• A compact package: about 2.18 MB, without the C++ source code of the models.

The Arduino Ethernet Rev3 in Proteus

Search ETHERNET in Pick Devices; the device ARDUINO ETHERNET REV3 is in TEPETHREV3.LIB. Click the PANEL pad or the W5100 to open the panel, the FTDI header to open the serial monitor, the RJ45 jack to pull or plug the cable and the socket to take out the card.

Every State of the Board

We ran the demo and paused the simulation for each picture. The sketch starts the card first; the Ethernet library then finds the W5100 and asks the router for an address:

Download Arduino Ethernet Rev3 Library for Proteus

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

• README.txt: the device, installation, the demo, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPETHREV3.LIB (the board), TEPLAPTOP.LIB and TEPMOBILE.LIB (our Laptop and Mobile WiFi Monitors).
• Proteus Model Files: TEPNET.DLL (the board, the W5100, the card, the two monitors and the network). The ATmega328P model is Proteus's own and is already installed.
• Proteus Simulation: the demo project, its HEX file and a copy of the DLL.
• Arduino Code: the demo sketch. The Ethernet and SD libraries 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 Rev3 Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy the three 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 from Proteus Model Files into the MODELS folder - replace older copies (this TEPNET.DLL is the first one that knows the Arduino Ethernet Rev3, and it still runs our Ethernet shields, our W5100, W5500 and ENC28J60 modules, every Wi-Fi part of the series and the two monitors).
4. Delete TEPETHREV3.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for ETHERNET.

For your own sketches, choose Tools > Board > Arduino AVR Boards > Arduino Ethernet in the Arduino IDE, include Ethernet.h and SD.h, and use Sketch > Export Compiled Binary. Double-click the board in Proteus and set its Program File to the HEX (see How to get the HEX file from Arduino).

Demo: A Web File Server on the micro SD Card

Open Ethernet-Rev3-File-Server-with-Laptop-and-Mobile.pdsprj. The board (ARD1) is in the middle on its own - the W5100, the card and L9 are on it, so there is nothing to wire. On the left is the phone (MOB1), on the right the laptop (PC1); they are on the router's network like the real ones.

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 home page is http://192.168.1.101/FILES and the phone's http://192.168.1.101/ - the address the router gives ARD1. The laptop is 192.168.1.21 and the phone 192.168.1.41:

The Sketch: the Card First, Then DHCP

The sketch includes SPI and the two libraries, sets a MAC address (real boards come with a sticker that has their own) and a server on port 80. L9 and the card's chip select get names:

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

byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x34, 0x01};   // (Arduino Ethernet boards come with a MAC address sticker)

EthernetServer server(80);
const byte L9 = 9, SD_CS = 4;

Both chips share the SPI bus, so only one may be selected at a time. Before SD.begin(4) the sketch makes D10 an output and drives it HIGH, so the W5100 stays quiet while the card starts. The first time, the card gets its home page, INDEX.HTM:

  pinMode(10, OUTPUT);
  digitalWrite(10, HIGH);                                // the W5100 not selected while the card starts
  sdOk = SD.begin(SD_CS);
  Serial.println(sdOk ? F("SD: card ready") : F("SD: no card"));
  if (sdOk && !SD.exists("INDEX.HTM")) writeIndex();

Then Ethernet.begin(mac) asks the router for an address with DHCP and tries again until it gets one; Ethernet.hardwareStatus() tells a missing chip from a silent router:

  while (Ethernet.begin(mac) == 0) {
    Serial.println(Ethernet.hardwareStatus() == EthernetNoHardware ? F("no W5100 found") : F("no answer - trying again"));
    delay(2000);
    Serial.print(F("DHCP... "));
  }

Press Run and click the FTDI header. The monitor shows the card, INDEX.HTM, DHCP and the address:

Arduino Ethernet Rev3 - File Server
SD: card ready
SD: INDEX.HTM written
DHCP... OK
IP: 192.168.1.101
Files on the web: http://192.168.1.101/

The panel's SPI page shows what the Ethernet library did underneath, newest first. Read it from the bottom: the W5100's reset, the chip test, the MAC address, the DHCP exchange, the address and the gateway written to the chip, and the server socket put in LISTEN. The card is there too:

INDEX.HTM from the Card

The home page is not in the sketch - it is a file. writeIndex() writes it once with File.println(); after that you could replace it with any page of your own, written on a PC:

void writeIndex() {
  File f = SD.open("INDEX.HTM", FILE_WRITE);
  if (!f) { Serial.println(F("SD: INDEX.HTM not written")); return; }
  f.println(F("<!DOCTYPE html><html><head><title>Rev3 File Server</title></head><body>"));
  f.println(F("<h1>Arduino Ethernet Rev3</h1>"));
  f.println(F("<p>This page is INDEX.HTM on the micro SD card.</p>"));
  f.println(F("<p><a href=\"/L9ON\">L9 ON</a> <a href=\"/L9OFF\">L9 OFF</a></p>"));
  f.println(F("<p><a href=\"/FILES\">FILES</a> <a href=\"/ACCESS.LOG\">ACCESS.LOG</a></p>"));
  f.println(F("</body></html>"));
  f.close();
  Serial.println(F("SD: INDEX.HTM written"));
}

serve() reads the request line - "GET /PATH HTTP/1.1" - keeping the path in capitals, and reads on to the blank line that ends the headers:

void serve(EthernetClient& c) {
  // the request line "GET /PATH HTTP/1.1": the path up to its space, then the headers up to the blank line
  byte n = 0, spaces = 0;
  bool blank = true;
  const unsigned long t0 = millis();
  while (c.connected() && millis() - t0 < 2000) {
    if (!c.available()) continue;
    const char ch = c.read();
    if (spaces == 1 && ch != ' ' && n < sizeof(path) - 1) path[n++] = toupper(ch);
    if (ch == ' ' && spaces < 2) ++spaces;
    if (ch == '\n' && blank) break;
    if (ch == '\n') blank = true;
    else if (ch != '\r') blank = false;
  }
  path[n] = 0;

For "/" the sketch sends INDEX.HTM with sendFile(): it checks the file exists, writes the HTTP header (a page for .HTM, plain text for anything else) and copies the file to the client 64 bytes at a time:

bool sendFile(EthernetClient& c, const char* name) {
  if (!sdOk || !SD.exists(name)) return false;
  File f = SD.open(name);
  if (!f) return false;
  if (f.isDirectory()) { f.close(); return false; }
  const char* dot = strrchr(name, '.');
  header(c, true, dot && !strcmp(dot, ".HTM"));
  byte buf[64];
  while (f.available()) {
    const int n = f.read(buf, sizeof buf);
    c.write(buf, n);
  }
  f.close();
  return true;
}

// the card's files (not the folders): a page with links, or lines for the monitor

Press Go in the phone's Browser:

The Card's Files

/FILES lists the card. listFiles() opens the root folder and walks through it with openNextFile(), writing one link per file with its size and skipping the folders:

  while (true) {
    File e = root.openNextFile();
    if (!e) break;
    if (!e.isDirectory()) {
      if (html) {                 // one link per file: "README.TXT - 372 bytes"
        out.print(F("<p><a href=\"/")); out.print(e.name()); out.print(F("\">")); out.print(e.name());
        out.print(F(" - ")); out.print(e.size()); out.println(F(" bytes</a></p>"));
      } else {

The laptop's home page is /FILES, so its Go button shows the card - the files of the demo card, INDEX.HTM and the access log:

Any other path is taken as a file name. If the card has it, sendFile() sends it; if not, the client gets a 404 with "Not found":

  } else if (!sendFile(c, path + 1)) {
    header(c, false, false);
    c.print(F("Not found: ")); c.println(path);
  }

Click HELLO.TXT, then type DATA.CSV into the laptop's address bar - plain text, shown line by line:

L9 from the Phone

Two paths are not files: /L9ON and /L9OFF switch the LED on D9 and answer with a short page:

  } else if (!strcmp(path, "/L9ON") || !strcmp(path, "/L9OFF")) {
    setLed(path[4] == 'N');
    Serial.println(ledOn ? F("L9 ON (the web page)") : F("L9 OFF (the web page)"));
    header(c, true, true);
    c.print(F("<!DOCTYPE html><html><head><title>L9</title></head><body><h1>L9 is "));
    c.print(ledOn ? F("ON") : F("OFF"));
    c.println(F("</h1><p><a href=\"/\">BACK</a> <a href=\"/L9ON\">L9 ON</a> <a href=\"/L9OFF\">L9 OFF</a></p></body></html>"));

Tap L9 ON on the phone. The page answers "L9 is ON" and L9 lights up on the board:

The monitor logs each request with the client's address from c.remoteIP():

GET /FILES from 192.168.1.21
GET /HELLO.TXT from 192.168.1.21
GET /DATA.CSV from 192.168.1.21
GET / from 192.168.1.41
GET /L9ON from 192.168.1.41
L9 ON (the web page)

ACCESS.LOG on the Card

Every request is also written to ACCESS.LOG on the card - a number, the client's address and the path. FILE_WRITE opens the file at its end, so each line is added to the log:

void logAccess(IPAddress from) {
  if (!sdOk) return;
  File f = SD.open("ACCESS.LOG", FILE_WRITE);
  if (!f) return;
  f.print(requests); f.print(' '); f.print(from); f.print(' '); f.println(path);
  f.close();
}

ACCESS.LOG is a file like any other, so the laptop can read it:

1 192.168.1.21 /FILES
2 192.168.1.21 /HELLO.TXT
3 192.168.1.21 /DATA.CSV
4 192.168.1.41 /
5 192.168.1.41 /L9ON
6 192.168.1.21 /ACCESS.LOG

The Monitor's Commands

The monitor takes STATUS (the address, L9, the request count, the card), FILES (the card's files), LOG (ACCESS.LOG) and HELP. The loop runs Ethernet.maintain(), the server and the monitor, and never waits long:

void loop() {
  Ethernet.maintain();
  EthernetClient c = server.available();
  if (c) serve(c);
  monitor();
}

LOG
1 192.168.1.21 /FILES
2 192.168.1.21 /HELLO.TXT
3 192.168.1.21 /DATA.CSV
4 192.168.1.41 /
5 192.168.1.41 /L9ON
6 192.168.1.21 /ACCESS.LOG
HELP
Commands: STATUS, FILES, LOG, HELP

The Arduino Ethernet Rev3 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: BOARD with the W5100, the MAC address, the command count and the LEDs, ETHERNET with the router, the status, the address and how long DHCP took, and TRAFFIC:

OPEN BOARD PAGE lets the panel's own phone open the page the board serves - INDEX.HTM from the card:

The ROUTER tab lists the router's clients - the board among them as a LAN client - and the TRAFFIC card lists every request:

The Test page measures the running model: the web request test lets the panel's phone open the page three times, and the cable test pulls the cable for 3 seconds, three times:

After the tests the SPI page shows the server at work: each request takes a socket (ACCEPT), the answer goes out in SEND commands, and the socket is closed and listens again. The card's counters show the reads of every file and the writes of the log:

Pins of the Arduino Ethernet Rev3

Properties of the Arduino Ethernet Rev3

With DHCP the address follows the part's number: ARD1 gets 192.168.1.101, ARD2 .102 and so on - give every network part its own number. The laptop is always 192.168.1.21 and the phone 192.168.1.41.

Troubleshooting

• Nothing runs: double-click the board and set PROGRAM to the .hex file, as for any Proteus AVR.
• "SD: no card": the SDCARD property is NONE or the card was clicked out - click the socket.
• DHCP never answers: the cable is out - the panel shows CABLE OUT. Put it in with the panel, or click the RJ45 jack.
• D10 - D13 or D4 do strange things: they belong to the W5100 and the card on this board - use other pins.
• The page never opens: the sketch must call the library often - a long delay() in the loop keeps the server waiting.
• No monitor window: click the FTDI header, or set MONITOR and AUTOOPEN to YES.
• 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 Rev3

• Programming: there is no USB socket. Use a 5 V USB-to-serial adapter or FTDI cable on the 6-pin header, and choose the board "Arduino Ethernet" in the IDE - the auto-reset works through the header.
• The SPI pins: D10 - D13 and D4 are taken by the W5100 and the card. Before using the card, keep the W5100 deselected (D10 HIGH), as the demo does.
• The card: format it FAT16 or FAT32; the SD library uses short 8.3 names like INDEX.HTM.
• The MAC address: use the one on the board's sticker, and a different one for every board on the network.
• Flash and RAM: Ethernet and SD together are big. The demo takes 28,412 of the 32,256 bytes of flash and 1,294 of the 2,048 bytes of RAM - keep the strings in flash with F().
• PoE: one version of the board takes power from the Ethernet cable through an optional PoE module; the Proteus part is the version without it.

Limitations of the Simulation

• The ATmega328P is Proteus's own model; the W5100 is our model of the chip as the Ethernet library uses it: the socket registers, the buffers, TCP, UDP and the retry timeouts.
• Not modelled: the optional PoE module, IPRAW / MACRAW traffic, the W5100's interrupt pin, the PHY's auto-negotiation and its real timing, the supply's current.
• The router, the phone, the internet host, the PANEL pad, the panel and the two monitors are TEP additions; the LAN answers in about 2 ms.
• Arduino is a name of Arduino, W5100 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 board, the laptop and the phone together at about 0.25 to 0.3 x real time on our PC). Proteus 7 is not supported.

So, that was all about the Arduino Ethernet Rev3 Library for Proteus. I hope it helps you build Arduino web projects in Proteus before you touch the hardware - a whole web site on a micro SD card, served by an ATmega328P through a W5100, with every socket command and every file read on the panel. If you want the card on its own, our Micro SD Card Module Library for Proteus has it. If you use the Arduino Ethernet Rev3 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!