Project Files of Arduino Ethernet Shield Library for Proteus: W5100 and SD Card

ARDUINO ETHERNET SHIELD LIBRARY FOR PROTEUS - V1.0 (THE W5100 SHIELD, ETHERNET LIBRARY ON SPI, MICRO SD)
Designed by The Engineering Projects www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/10/arduino-ethernet-shield-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/arduino-ethernet-shield-proteus-library
The demo talks to our Laptop WiFi Monitor and Mobile WiFi Monitor (both included) - their articles:
  https://www.theengineeringprojects.com/2026/10/laptop-wifi-monitor-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/mobile-wifi-monitor-library-for-proteus.html
The demo uses our Arduino UNO V4.0 (included) - its article:
  https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.html
The Wi-Fi shields of the same series - our Arduino WiFi Shield and AirLift WiFi Shield Libraries for Proteus:
  https://www.theengineeringprojects.com/2026/10/arduino-wifi-shield-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/airlift-wifi-shield-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Arduino-Ethernet-Shield-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                                                    201.9 KB   our UNO V4.0, to LIBRARY
|   |-- TEPETHSHIELD.LIB                                                     38.0 KB   the Ethernet shield, to LIBRARY
|   |-- TEPLAPTOP.LIB                                                        39.5 KB   the laptop, to LIBRARY
|   |-- TEPMOBILE.LIB                                                        13.1 KB   the phone, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                                      883.5 KB   the UNO V4.0, to MODELS
|   |-- TEPNET.DLL                                                           1.99 MB   shield + monitors, to MODELS
|-- Proteus Simulation/
|   |-- EthernetShield_SD_Logger.hex                                         80.2 KB   the UNO of the demo
|   |-- Ethernet-Shield-SD-Logger-with-Laptop-and-Mobile.pdsprj              29.8 KB   the demo + PC + phone
|   |-- TEPARDUINO.DLL                                                      883.5 KB   copy of the model
|   |-- TEPNET.DLL                                                           1.99 MB   copy of the model
|-- Arduino Code/
|   |-- EthernetShield_SD_Logger/EthernetShield_SD_Logger.ino                 9.2 KB   UNO sketch (Ethernet + SD)
|-- README.txt                                                              ~17.4 KB   this file
Total: 6.12 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
The Arduino Ethernet Shield R3 as one Proteus part: a WIZnet W5100 (a hardwired TCP / IP chip with its own 10/100
Ethernet port), an RJ45 jack with its magnetics, and a micro SD socket for the SD library - your Arduino keeps its own
sketch, the W5100 does the TCP / IP and the sockets, a cable joins it to the router.
  * The pins work as on the real shield: SPI from the ICSP socket (SCK, MISO, MOSI - D13 / D12 / D11 on an UNO, D52 /
    D50 / D51 on a Mega), CS D10 (the W5100's chip select), SD CS D4 (the micro SD card), RESET (the shield's button
    pulls the board's RESET LOW), 5V and GND.
  * The model is the W5100 itself, register by register, as the Arduino Ethernet library (2.0.x) drives it: the 4-byte
    SPI frames (0xF0 write / 0x0F read, the address, the data), the common registers (the mode with its reset bit, the
    gateway, the subnet mask, the MAC, the IP address, the retry time and count, the buffer sizes), four sockets with
    their registers and their 2 KB TX / RX buffers, and the commands OPEN, LISTEN, CONNECT, DISCON, CLOSE, SEND, RECV.
    It runs the Ethernet library from the Arduino IDE unchanged - the library's own chip test finds a W5100.
  * The Ethernet library does DHCP and DNS itself (UDP); the virtual router answers them: Ethernet.begin(mac) gets
    192.168.1.101 for U1 (gateway and DNS 192.168.1.1, mask 255.255.255.0), a name is looked up by DNS (name.local of
    the network, any other name = the virtual internet host 203.0.113.10), and NTP to the internet host answers with
    the clock. Ethernet.begin(mac, ip) with a fixed address works too.
  * TCP client (EthernetClient.connect), TCP server (EthernetServer - each visitor takes one listening socket, as on
    the real chip, and the library opens the next) and UDP (EthernetUDP) reach every TEP part on the router's network:
    our Wi-Fi boards and modules, and our Laptop WiFi Monitor and Mobile WiFi Monitor, the tools of the demo.
  * The seven LEDs of the real shield: ON (power), LINK (the cable in; it blinks with the traffic), FULLD and 100M (the
    link: 100 Mbit/s full duplex), RX and TX (a packet in / out), COLL (collisions - never on a switched router); the
    RJ45 jack's own green LINK and yellow ACT LEDs; the cable's blue plug in the port while the cable is in.
  * The cable: the CABLE property (IN / OUT), a click on the RJ45 jack, or CABLE IN / CABLE OUT in the panel. Out: no
    link, the shield leaves the network (its sockets close); in: it is back at once with the same address.
  * RESET: a click on the shield's RESET button is a 0.25 s press - the RESET pin goes LOW, the UNO restarts (wire it to
    the UNO's RESET, as the demo does) and the W5100 is held in reset while RESET is LOW, as on the real shield.
  * The micro SD socket with a 64 MB card (our Micro SD Card model, the same as on our Wi-Fi shields): the SD library
    works on it; the DEMO card holds README.TXT, HELLO.TXT, DATA.CSV, CONFIG.INI, BIG.TXT and two folders. A click on
    the socket takes the card out / puts it back.
The part is drawn our way at the shield's size (the Arduino shield outline, the stacking headers with the pin labels,
the RJ45 jack over the UNO's USB socket). The real shield works on an UNO and a Mega; the demo uses our UNO V4.0.

ONE DEVICE (search "ETHERNET SHIELD" or "W5100" in Pick Devices):
  ARDUINO ETHERNET SHIELD W5100  "Arduino Ethernet Shield (W5100, Ethernet library)" V1.0 (category Peripherals >
                                 Ethernet), prefix U, model TEPNET.DLL
  The panel (a TEP pop-up window, the look of the TEP Serial Monitor - our own header, no Windows title bar; it opens at
  Run, the PANEL pad or the W5100 opens it again). Tabs:
    Wi-Fi     a phone with three tabs - BROWSER (OPEN SHIELD PAGE: the phone opens the page the Arduino serves on
              PAGEPORT, tap its links), ROUTER (the router's clients - the shield is listed as LAN) and CLOUD (the
              internet host's requests); ETHERNET CABLE IN / OUT; the cards SHIELD (the chip, MAC, the host link with
              its command rate, the LEDs), ETHERNET (router, status, address with gateway and mask, the link, the DHCP
              time) and TRAFFIC
    SPI       the Ethernet library's socket commands and the router's DHCP / DNS / NTP answers, newest first (repeats
              counted, x N), the link, commands and SPI bytes, the sockets (0-3) and the micro SD card
    Test      web request test (the phone opens the page n times, measured) and cable test (the cable pulled for 3 s,
              measured)
    Settings  theme, text size, open at Run, window size
    Help      report a bug, suggest a feature, article, updates, donate, forum; Copy diagnostics

TEST STATUS
V1.0: verified in Proteus 8.5 on 23 Oct 2026 (the demo project as shipped, the windows off-screen, posted clicks and
keys), and on the PC with the real Arduino Ethernet library 2.0.2 (its W5100 driver, sockets, DHCP, DNS, client, server
and UDP) and the real demo sketch against the model (22 checks: the chip test, DHCP, NTP, the log, the JSON, the page,
LOG.CSV, two visitors at once, CLEAR, the monitor, the cable pulled and put back). What the Proteus run showed:
  * EthernetShield_SD_Logger: "SD: card ready" (the real SD library on our card model), "DHCP... OK", "IP address:
    192.168.1.101", "Gateway: 192.168.1.1", "NTP: the time is 02:37:05 UTC" (the PC's clock) and "Logger on the web:
    http://192.168.1.101/". The library finds the W5100 0.75 s after Run (its own 560 ms wait first), DHCP takes 0.11 s,
    the shield is on the LAN at 2.4 s; ON, LINK, FULLD and 100M lit, RX / TX and the jack's ACT LED flash with the
    packets, the cable's blue plug in the port.
  * The laptop's browser: http://192.168.1.101/json - {"a0":358,"volts":1.74,"logged":0,"time":"02:37:09","uptime":5}
    (HTTP 200, 133 bytes). The phone's browser: the page (the time, "A0 now: 358 (1.74 V)", the readings, the last lines
    of LOG.CSV, LOG.CSV / CLEAR / REFRESH; HTTP 200, 413 bytes) and LOG.CSV (136 bytes, a line every 5 s).
  * The UNO's monitor: STATUS ("IP 192.168.1.101, time 02:37:21, A0 358, logged 3, pages 4"), LOG (the file), TIME (a
    new NTP answer: "NTP: the time is 02:37:25 UTC") and HELP ("Commands: STATUS, LOG, TIME, CLEAR, HELP").
  * The panel's SPI page: OPEN / LISTEN on port 80, ACCEPT with the visitor's address, RECV, SEND in 64-byte pieces,
    DISCON (FIN_WAIT), the next socket opened to listen; DHCP DISCOVER / OFFER, REQUEST / ACK, DNS pool.ntp.org =
    203.0.113.10, NTP; the card: 230 commands, 33 reads, 19 writes.
  * Web request test: 3 of 3 pages answered (489 bytes, connect 4.0 ms, first byte 15.9 ms, full page 31.9 - 33.9 ms);
    cable test: off the LAN at once when the cable is pulled, back 0.005 s after it goes back in, the same address.
  * Speed: the UNO + the shield + the card + the laptop + the phone about 0.4 x real time on our PC (the Ethernet
    library reads the W5100's registers about 35,000 times a second).

INSTALLATION (about 3 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY - use the folder that already holds
   Proteus's own .LIB files). TEPETHSHIELD.LIB is the Ethernet shield; ArduinoV4TEP.LIB our Arduino boards V4.0 (the UNO
   of the demo); TEPLAPTOP.LIB and TEPMOBILE.LIB our Laptop WiFi Monitor and Mobile WiFi Monitor.
3. Copy TEPNET.DLL and TEPARDUINO.DLL from "Proteus Model Files" to the MODELS folder (...\Proteus 8
   Professional\MODELS) - replace older copies (this TEPNET.DLL is the first one that knows the Ethernet shield; it
   still runs every Wi-Fi part of the series).
4. Delete TEPETHSHIELD.IDX, ArduinoV4TEP.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. The Arduino IDE (only to compile your own sketches - the demo has its HEX file): the Ethernet and SD libraries are
   built into the IDE (or install them with the Library Manager).
6. Start Proteus. In Pick Devices (P) search "ETHERNET SHIELD".

RUN THE DEMO
Keep the .hex file, TEPNET.DLL and TEPARDUINO.DLL beside the project in "Proteus Simulation".
  Ethernet-Shield-SD-Logger-with-Laptop-and-Mobile.pdsprj - ARD1 our UNO V4.0 (EthernetShield_SD_Logger.hex, its monitor
  at 9600 bps) with RV1 (POT-HG 10k) on A0, and U1 the Ethernet shield: SCK / MISO / MOSI from the UNO's D13 / D12 / D11
  to the shield's ICSP side, ETH_CS (D10), SD_CS (D4) and RESET by net labels, 5V to VCC, GND to ground. PC1 the Laptop
  WiFi Monitor and MOB1 the Mobile WiFi Monitor - no wires, they are on the router's network (their home pages are
  preset: the laptop http://192.168.1.101/json, the phone http://192.168.1.101/).
  Press Run. The monitor shows the card, DHCP, the address, the gateway, the time from NTP and the logger's address.
  Every 5 s a reading (the pot on A0, with the time) is added to LOG.CSV on the card. The laptop's Browser > Go shows
  the reading as JSON; the phone's Browser > Go the page: the time, A0, the readings, the last lines of the log and
  LOG.CSV / CLEAR / REFRESH. In the UNO's monitor: STATUS, LOG, TIME, CLEAR, HELP.

PINS (on the shield's headers)
  CS     D10    the W5100's chip select (LOW = selected)
  SDCS   D4     the micro SD card's chip select
  RESET  RESET  the shield's button (LOW while pressed); LOW also holds the W5100 in reset
  SCK, MISO, MOSI   SPI from the ICSP socket (MISO is the W5100's or the card's while its CS is LOW, else it floats)
  5V, GND           power (the shield uses the power header's second GND)
Without 5V and GND the shield is off (the panel shows "no power"). The real shield's INT jumper (D2) is not modelled:
the Ethernet library does not use it.

THE DEMO SKETCH (Arduino Code)
  EthernetShield_SD_Logger  SD.begin(4); Ethernet.begin(mac) until DHCP answers; an EthernetServer on port 80: "/" the
                            page, "/json" the reading, "/log.csv" the file, "/clear" a new log; the time from NTP
                            (pool.ntp.org by DNS, then UDP port 123, every TIME command too); LOG.CSV gets
                            "time,a0,volts" every 5 s; Ethernet.maintain() renews the lease. Answers go out in 64-byte
                            pieces (print(F("...")) on an EthernetClient would send each character as its own packet).

PROPERTIES (double-click the Ethernet shield > Edit Properties)
  ROUTER    the router the cable goes to - the network name of the Wi-Fi parts (default TEP-WiFi)
  CABLE     the Ethernet cable at Run: IN (default) or OUT
  SDCARD    the micro SD card at Run: DEMO (the files above), EMPTY (formatted, no files), RAW (not formatted), NONE
  PANEL     the phone's tab at start (BROWSER, ROUTER, CLOUD)
  PAGEPORT  the port OPEN SHIELD PAGE opens (default 80)
  CLOCK     the clock of NTP and the panel: PC (UTC), or a start time YYYY-MM-DD HH:MM:SS (UTC)
Every run starts again from the properties (the card too). The DHCP address follows the part's number: U1
192.168.1.101, U2 .102 ... - give every network part its own number. The laptop is 192.168.1.21, the phone 192.168.1.41.

LINKS.INI (OPTIONAL)
The Help page cards open web pages. To point them somewhere else without a new DLL, put a text file named links.ini next
to TEPNET.DLL with lines KEY=URL, for example:
  ARTICLE=https://www.theengineeringprojects.com/...
Keys: WEBSITE, FORUM, BUG_REPORT, FEATURE_REQUEST, ARTICLE, USER_GUIDE, UPDATE_CHECK, DONATE. Only http:// and https://
links are used; lines starting with # are comments.

TROUBLESHOOTING
* Ethernet.begin() returns 0 / Ethernet.hardwareStatus() 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 (the panel shows CABLE OUT) - put it in, or click the RJ45 jack.
* The card is not found: SD CS on D4, and D10 HIGH while SD.begin() runs (the demo sets it).
* Ethernet.linkStatus() is Unknown: normal for a W5100 - the chip has no link register (the W5200 / W5500 have one).
* A page is slow or arrives in many small pieces: write whole buffers (client.write(buf, n)), not one character at a
  time.
* A paused simulation shows the SIMULATION 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 (Settings).

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot, the serial monitor text, the simulation log and the Copy diagnostics
text of the panel:
  https://www.theengineeringprojects.com/forum/category/arduino-ethernet-shield-proteus-library

SUPPORT US
This library is free. If it saves you time, please support our work:
  https://www.theengineeringprojects.com/donate

WEBSITE
  https://www.theengineeringprojects.com/

LICENCES AND THIRD-PARTY NOTES
* The Ethernet shield model, the micro SD card model, the Laptop / Mobile WiFi Monitors and the network (TEPNET.DLL),
  the Arduino board models (TEPARDUINO.DLL), the symbols and artwork (TEPETHSHIELD.LIB, ArduinoV4TEP.LIB,
  TEPLAPTOP.LIB, TEPMOBILE.LIB) are made by The Engineering Projects. The UNO's processor is Proteus's own AVR model
  (Labcenter); RV1 is Proteus's POT-HG. The models use only standard Windows libraries; no Visual C++ redistributable
  is needed. The C++ source code of the models is not included.
* EthernetShield_SD_Logger.hex contains the Arduino AVR core 1.8.6 with its SPI library (LGPL 2.1,
  https://github.com/arduino/ArduinoCore-avr/tree/1.8.6), the Arduino Ethernet library 2.0.2 (LGPL 2.1,
  https://github.com/arduino-libraries/Ethernet) and the SD library 1.3.0 (GPL 3,
  https://github.com/arduino-libraries/SD). The libraries are not shipped.
* 203.0.113.10 is a documentation address (no real server).
* Proteus is a product of Labcenter Electronics and is not included. Arduino is a name of Arduino; W5100 and WIZnet of
  WIZnet; HanRun of Zhongshan HanRun Electronic. This library is not made or endorsed by Arduino, WIZnet or Labcenter.

REBUILDING THE FIRMWARE (OPTIONAL)
The HEX file is supplied; the Arduino IDE is not needed to run the demo. Open the sketch in Arduino Code with Tools >
Board > Arduino Uno, then Sketch > Export Compiled Binary. Flash / RAM: EthernetShield_SD_Logger 29,188 / 1,409
bytes (of the UNO's 32,256 / 2,048; the rest of the RAM is the stack). Put the exported HEX in place of the
simulation's .hex.

MODEL SCOPE AND LIMITS
Modelled: the W5100's SPI frames, its common and socket registers, its four sockets with their TX / RX buffers and the
pointer rules the Ethernet library relies on, TCP (client and server, one connection per socket), UDP (with the 8-byte
header of each packet in the RX buffer), the retry timeouts (RTR x RCR) of an address nobody answers, the soft and the
hardware reset; the router's DHCP, DNS and NTP answers; the seven LEDs, the jack's LEDs and the cable; the micro SD
socket with our card model; the router, the phone and the internet host shared with every TEP network part. Not
modelled: IPRAW / MACRAW traffic (the modes open but carry nothing), PPPoE, the interrupt pin (INT jumper, D2), the
power-on reset chip's delay, the PHY's auto-negotiation and its real timing, the supply's voltage and current.
The model's own choices: the cable goes to the same router as the Wi-Fi parts; the LAN answers in about 2 ms; the
simulation runs below real time.

VERSION
TEP Arduino Ethernet Shield library V1.0 (Oct 2026). Device ARDUINO ETHERNET SHIELD W5100 (TEPETHSHIELD.LIB /
TEPNET.DLL, which also runs our Wi-Fi shields and breakouts, our ESP32, ESP8266, Arduino and Pico W boards, the ESP-01
family, the ESP-07 / ESP-12 modules, the ESP32-WROOM-32 and the Laptop / Mobile WiFi Monitors), with our Arduino UNO
V4.0 (ArduinoV4TEP.LIB / TEPARDUINO.DLL) and the Laptop WiFi Monitor / Mobile WiFi Monitor (TEPLAPTOP.LIB /
TEPMOBILE.LIB). Demo sketch EthernetShield_SD_Logger V1.0.