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

ARDUINO ETHERNET SHIELD 2 LIBRARY FOR PROTEUS - V1.0 (THE W5500 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-2-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/arduino-ethernet-shield-2-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 first Ethernet shield (the W5100) - our Arduino Ethernet Shield Library for Proteus:
  https://www.theengineeringprojects.com/2026/10/arduino-ethernet-shield-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Arduino-Ethernet-Shield-2-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                                                    201.9 KB   our UNO V4.0, to LIBRARY
|   |-- TEPETHSHIELD2.LIB                                                    33.8 KB   the Ethernet Shield 2, 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/
|   |-- EthernetShield2_Telnet_Chat.hex                                      77.3 KB   the UNO of the demo
|   |-- Ethernet-Shield-2-Telnet-Chat-with-Laptop-and-Mobile.pdsprj          29.4 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/
|   |-- EthernetShield2_Telnet_Chat/EthernetShield2_Telnet_Chat.ino           7.5 KB   UNO sketch (Ethernet + SD)
|-- README.txt                                                              ~18.9 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 2 as one Proteus part: a WIZnet W5500 (a hardwired TCP / IP chip with its own 10/100
Ethernet port), an RJ45 jack with its magnetics and its LINK / ACT LEDs, and a micro SD socket for the SD library - your
Arduino keeps its own sketch, the W5500 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 W5500'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 W5500 itself, register by register, as the Arduino Ethernet library (2.0.x) drives it: the SPI
    frames (a 16-bit address, a control byte with the block - common registers, a socket's registers, its TX or RX
    buffer - and read / write, then 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 PHY's link in PHYCFGR, the version 4), eight
    sockets with their registers and their 2 KB TX / RX buffers (16 KB + 16 KB), 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 W5500 (Ethernet.hardwareStatus() is EthernetW5500).
  * Ethernet.linkStatus() works: the W5500 reports its link (LinkON with the cable in, LinkOFF with it out).
  * 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.
  * On an UNO the Ethernet library uses four of the eight sockets (its MAX_SOCK_NUM is 4 on a board with 2 KB of RAM);
    on a Mega it uses all eight.
  * The LEDs of the real Shield 2: ON on the board (power), and on the RJ45 jack the green LINK (the cable in) and the
    yellow ACT (it flashes with each packet), driven by the W5500; the cable's blue plug in the port while it is in.
  * The cable: the CABLE property (IN / OUT), a click on the RJ45 jack, or CABLE IN / CABLE OUT in the panel. Out: the
    link goes down at once (LinkOFF) and nothing gets through; the TCP connections wait - back within 20 s, they carry
    on and a line sent meanwhile arrives then; after 20 s without a link they are dropped. In: the link is up 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 W5500 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 other 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 teal board). The real shield works on an UNO and a Mega; the demo uses our
UNO V4.0.

ONE DEVICE (search "ETHERNET SHIELD 2" or "W5500" in Pick Devices):
  ARDUINO ETHERNET SHIELD 2 W5500  "Arduino Ethernet Shield 2 (W5500, 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 W5500 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-7) 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 W5500 driver, sockets, DHCP, DNS, client, server
and UDP) and the real demo sketch against the model (17 checks: the chip test, DHCP, the chat server, two clients
chatting both ways, the commands, a line from the UNO, a browser on port 23, the monitor, the cable out for 3 s with
the connections kept, a client leaving; and the 23 checks of our first Ethernet shield's logger with the model as a
W5500). What the Proteus run showed:
  * EthernetShield2_Telnet_Chat: "SD: card ready" (the real SD library on our card model), "DHCP... OK", "Chip: W5500",
    "IP address: 192.168.1.101", "Chat on telnet: 192.168.1.101 port 23" and "Link: ON". The library finds the W5500
    0.70 s after Run (its own 560 ms wait first), DHCP takes 0.11 s; the ON LED and the jack's green LINK lit, the
    jack's yellow ACT flashes with the packets, the cable's blue plug in the port.
  * The laptop's terminal (TCP Client, Connect) and the phone's (TCP, Connect): "Welcome to the UNO chat, #21 - type
    /help", "[#21] joined", "[#41] joined"; "[#21] Hello from the laptop" and "[#41] Hi laptop, the phone here" reach
    both and the UNO's monitor; /who "Online: #21 #41", /a0 "A0 = 358", /link "Link ON, IP 192.168.1.101", /help the
    list; a line typed in the UNO's monitor arrives as "[UNO] Hello from the UNO".
  * The browsers on port 23: the status page "Chip: W5500, link ON", "Clients: 3, messages: 5" (the browser is the
    third client while it asks), "Telnet: 192.168.1.101 port 23" - HTTP 200, 249 bytes in 0.13 s.
  * The UNO's monitor: STATUS ("IP 192.168.1.101, link ON, clients 2, messages 5"), LOG (CHAT.TXT from the card) and
    HELP ("Commands: STATUS, LOG, CLEAR, HELP - any other text goes to the chat").
  * The panel's SPI page: OPEN / LISTEN on port 23, ACCEPT with the client's address, RECV, one SEND per chat line, 243
    one-byte SENDs for the status page, DISCON (FIN_WAIT), the phone's FIN (CLOSE_WAIT, LAST_ACK); the sockets (0-7);
    the card: 212 commands, 19 reads, 17 writes.
  * Web request test: 3 of 3 pages answered (249 bytes, connect 4.0 ms, first byte 8.9 ms, full page 122.2 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; the
    monitor shows "Link: OFF" / "Link: ON" three times and both terminals stay connected - a line typed after the test
    reaches the phone. The phone's Disconnect: "[#41] left" on the laptop.
  * Speed: the UNO + the shield + the card + the laptop + the phone about 0.15 - 0.25 x real time on our PC (the
    Ethernet library reads the W5500's registers about 74,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). TEPETHSHIELD2.LIB is the Ethernet Shield 2; 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 2; it
   still runs the first Ethernet shield and every Wi-Fi part of the series).
4. Delete TEPETHSHIELD2.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 2".

RUN THE DEMO
Keep the .hex file, TEPNET.DLL and TEPARDUINO.DLL beside the project in "Proteus Simulation".
  Ethernet-Shield-2-Telnet-Chat-with-Laptop-and-Mobile.pdsprj - ARD1 our UNO V4.0 (EthernetShield2_Telnet_Chat.hex, its
  monitor at 9600 bps) with RV1 (POT-HG 10k) on A0, and U1 the Ethernet Shield 2: 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
  terminals are preset to 192.168.1.101 port 23, their home pages to http://192.168.1.101:23/).
  Press Run. The monitor shows the card, DHCP, "Chip: W5500", the address, "Chat on telnet: 192.168.1.101 port 23" and
  "Link: ON". In the laptop: Terminal > TCP Client > Connect; in the phone: Terminal > TCP > Connect. Each one is
  welcomed (#21 the laptop, #41 the phone - the last number of its address) and every line typed in one goes to the
  other, to the UNO's monitor and to CHAT.TXT on the card. A client can type /who, /a0, /link or /help. A line typed in
  the UNO's monitor goes to the chat as [UNO]; STATUS, LOG, CLEAR and HELP are the monitor's own commands. The
  browsers' Go opens the status page on port 23. Pull the cable (click the RJ45 jack): the monitor shows "Link: OFF",
  then "Link: ON" when it is back - the clients stay connected.

PINS (on the shield's headers)
  CS     D10    the W5500'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 W5500 in reset
  SCK, MISO, MOSI   SPI from the ICSP socket (MISO is the W5500'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 W5500's interrupt pin is not modelled: the
Ethernet library does not use it.

THE DEMO SKETCH (Arduino Code)
  EthernetShield2_Telnet_Chat  SD.begin(4); Ethernet.begin(mac) until DHCP answers; Ethernet.hardwareStatus() names
                               the chip; an EthernetServer on port 23 for up to 3 clients: each line goes to all of
                               them in one write ("[#21] text"), to the monitor and to CHAT.TXT; /who, /a0, /link,
                               /help answer the asking client only; a browser on port 23 (a first line "GET ...") gets
                               a status page; Ethernet.linkStatus() is watched every 0.5 s ("Link: ON" / "Link: OFF");
                               Ethernet.maintain() renews the lease. The status page is printed with print(F("..."))
                               on an EthernetClient, so each character goes out as its own packet (243 SENDs on the SPI
                               page, 0.12 s) - the chat lines are one write each.

PROPERTIES (double-click the Ethernet Shield 2 > 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; the demo sets 23)
  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, linkStatus() is LinkOFF) - 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).
* A client cannot connect: the UNO's four sockets are all in use (3 clients + the listening one) - the next one gets
  in when a client leaves.
* 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 W5500), 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-2-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 2 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 (TEPETHSHIELD2.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.
* EthernetShield2_Telnet_Chat.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; W5500 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: EthernetShield2_Telnet_Chat 28,124 / 1,507
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 W5500's SPI frames (variable-length data), its common and socket registers, its eight sockets with
their TX / RX buffers and the pointer rules the Ethernet library relies on, the PHY's link status, 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
ON LED, the jack's LINK / ACT 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: 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 (ICMP) answers, wake-on-LAN, 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; with the
cable out the TCP connections are kept for 20 s; the simulation runs below real time.

VERSION
TEP Arduino Ethernet Shield 2 library V1.0 (Oct 2026). Device ARDUINO ETHERNET SHIELD 2 W5500 (TEPETHSHIELD2.LIB /
TEPNET.DLL, which also runs our first Ethernet shield, 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 EthernetShield2_Telnet_Chat V1.0.