Project Files of W5500 Ethernet Module Library for Proteus: Arduino Cloud Logger

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

FILE STRUCTURE
W5500-Ethernet-Module-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                                                    201.9 KB   our UNO V4.0, to LIBRARY
|   |-- TEPLAPTOP.LIB                                                        39.5 KB   the laptop, to LIBRARY
|   |-- TEPMOBILE.LIB                                                        13.1 KB   the phone, to LIBRARY
|   |-- TEPW5500MOD.LIB                                                      22.8 KB   the W5500 module, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                                      883.5 KB   the UNO V4.0, to MODELS
|   |-- TEPNET.DLL                                                           2.00 MB   module + monitors, to MODELS
|-- Proteus Simulation/
|   |-- TEPARDUINO.DLL                                                      883.5 KB   copy of the model
|   |-- TEPNET.DLL                                                           2.00 MB   copy of the model
|   |-- W5500_Cloud_Logger.hex                                               56.5 KB   the UNO of the demo
|   |-- W5500-Cloud-Logger-with-Laptop-and-Mobile.pdsprj                     27.9 KB   the demo + PC + phone
|-- Arduino Code/
|   |-- W5500_Cloud_Logger/W5500_Cloud_Logger.ino                             8.1 KB   UNO sketch (Ethernet)
|-- README.txt                                                              ~17.8 KB   this file
Total: 6.09 MB (unzipped). The C++ source code of the models is not included.

WHAT IS IT?
The small blue W5500 Ethernet module 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, a 25 MHz crystal, an AMS1117 3.3 V regulator, a
red PWR LED and a 2x5 header - your microcontroller 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 module: SCLK, MOSI and MISO (SPI - D13 / D11 / D12 on an UNO), SCS (the W5500's chip
    select; the Ethernet library uses D10 unless the sketch calls Ethernet.init(pin)), RST (LOW holds the W5500 in
    reset; the module pulls it up, so it may stay free), INT (the W5500's interrupt output: HIGH - the Ethernet library
    never enables the interrupts), 5V or 3V3 (either one powers the module) 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) and Ethernet.linkStatus() follows the
    cable (LinkON / LinkOFF).
  * A fixed address or DHCP: Ethernet.begin(mac, ip, dns, gateway, subnet) takes the address at once (the demo uses
    192.168.1.177); Ethernet.begin(mac) asks the virtual router's DHCP (U1 gets 192.168.1.101). The router answers DNS
    (name.local of the network, any other name = the virtual internet host 203.0.113.10) and NTP.
  * TCP client (EthernetClient.connect, by name or address), 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, our Ethernet shields, and our Laptop WiFi Monitor and Mobile
    WiFi Monitor, the tools of the demo. A ping from the laptop is answered.
  * The virtual internet host takes ThingSpeak-style updates: GET /update?api_key=...&field1=... is answered with the
    new entry's number, or 0 when the same key sent one less than 15 s before (the panel's CLOUD tab lists them).
  * 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: the red PWR LED (power), and on the RJ45 jack the green LINK (the cable in) and the yellow ACT (it flashes
    with each packet); 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; after 20 s without a link they are dropped. In: the link is up at once with the same address.
The part is drawn our way at the module's size (the blue board, the RJ45 jack at its left end, the 2x5 header at its
right end); its pins leave the right edge, each named beside its end. Modules from different makers order the 2x5
header differently - wire by the names.

ONE DEVICE (search "W5500" in Pick Devices):
  W5500 ETHERNET MODULE  "W5500 Ethernet Module (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 MODULE PAGE: the phone opens the page the Arduino serves on
              PAGEPORT, tap its links), ROUTER (the router's clients - the module is listed as LAN) and CLOUD (the
              internet host's requests: stored / refused); ETHERNET CABLE IN / OUT; the cards MODULE (the chip, MAC,
              the host link with its command rate, the LEDs), ETHERNET (router, status, address with gateway and mask,
              the link, DHCP or a static address) 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), RST and INT
    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, DNS, client and server)
and the real demo sketch against the model (13 checks: the RST pulse, the chip test, the fixed address without DHCP,
an upload stored and one refused within 15 s, the JSON, the page and its UPLOAD NOW link, the laptop's ping, the
monitor's EVERY / STATUS / HELP). What the Proteus run showed:
  * W5500_Cloud_Logger: "Chip: W5500", "Fixed IP: 192.168.1.177", "Status page: http://192.168.1.177/", "Cloud:
    api.thingspeak.com every 20 s", then "Cloud: upload 1 (A0 358, 1.75 V)" and "Cloud: entry 1 stored". The sketch's
    RST pulse resets the W5500 (1 reset, 2 boots on the panel), the library finds it 0.70 s after Run and the fixed
    address is live at once (the panel: "static address"); PWR and the jack's green LINK lit, the yellow ACT flashes
    with the packets, the cable's blue plug in the port.
  * The laptop's browser: http://192.168.1.177/json - {"a0":358,"sent":7,"stored":4,"refused":3,"entry":4,"next":10,
    "failed":0} later in the run (HTTP 200, 143 bytes); its ping: 4 of 4 answered (9 - 15 ms, TTL 255). The phone's
    browser: the status page (Fixed IP 192.168.1.177, link ON; A0 now: 358; Uploads 1: stored 1, refused 0; Last entry:
    1; the countdown to the next upload; UPLOAD NOW / REFRESH; HTTP 200, 374 bytes).
  * UPLOAD NOW about 10 s after the first upload: "Page: /now", "Cloud: upload 2", "Cloud: refused (0) - one update
    per 15 s". EVERY 10: entry 2 stored, refused, entry 3 stored (every other upload refused); STATUS "IP 192.168.1.177,
    link ON, sent 5, stored 3, refused 2, last entry 3"; HELP "Commands: NOW, EVERY <seconds>, STATUS, HELP".
  * The panel: the CLOUD tab lists "U1 /update stored" and "U1 /update refused (15 s)"; the SPI page shows each upload -
    OPEN UDP, DNS api.thingspeak.com = 203.0.113.10, OPEN TCP, CONNECT / CONNECTED to 203.0.113.10:80, SEND 115 B, RECV,
    the host's FIN (CLOSE_WAIT), DISCON (LAST_ACK) - and each page (ACCEPT, SEND x6 in 64-byte pieces, DISCON); RST
    HIGH - running, INT HIGH.
  * Web request test: 3 of 3 pages answered (373 bytes, connect 4.0 ms, first byte 13.3 - 13.4 ms, full page 19.0 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 module + the laptop + the phone about 0.15 - 0.2 x real time on our PC (the Ethernet library
    reads the W5500's registers about 48,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). TEPW5500MOD.LIB is the W5500 module; 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 W5500 module; it still
   runs our Ethernet shields and every Wi-Fi part of the series).
4. Delete TEPW5500MOD.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 library is built into
   the IDE (or install it with the Library Manager).
6. Start Proteus. In Pick Devices (P) search "W5500".

RUN THE DEMO
Keep the .hex file, TEPNET.DLL and TEPARDUINO.DLL beside the project in "Proteus Simulation".
  W5500-Cloud-Logger-with-Laptop-and-Mobile.pdsprj - ARD1 our UNO V4.0 (W5500_Cloud_Logger.hex, its monitor at 9600 bps)
  with RV1 (POT-HG 10k) on A0, and U1 the W5500 module: SCK, MISO, MOSI, ETH_CS (D10) and ETH_RST (D9) by net labels,
  5V to VCC, GND to ground, 3V3 and INT free. 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.177/json, the phone
  http://192.168.1.177/; the laptop's ping box holds 192.168.1.177).
  Press Run. The monitor shows the chip, "Fixed IP: 192.168.1.177", the status page's address and the first upload to
  the cloud ("Cloud: entry 1 stored"); an upload every 20 s follows. The laptop's Browser > Go shows the counts as
  JSON, its Network > Ping pings the module; the phone's Browser > Go shows the status page with UPLOAD NOW and REFRESH.
  In the UNO's monitor: NOW, EVERY <seconds> (EVERY 10 makes every other upload come back refused), STATUS, HELP.

PINS (beside the module's right edge)
  5V, 3V3   power: either one (the module's AMS1117 makes 3.3 V from 5 V)
  GND       ground
  SCS       the W5500's chip select (LOW = selected)
  SCLK, MOSI, MISO   SPI (MISO is the W5500's while SCS is LOW, else it floats)
  RST       LOW holds the W5500 in reset; free or HIGH = running (the module's pull-up)
  INT       the W5500's interrupt output: HIGH (the Ethernet library does not enable interrupts)
Without power (5V or 3V3) and GND the module is off (the panel shows "no power").

THE DEMO SKETCH (Arduino Code)
  W5500_Cloud_Logger  pulses RST LOW on D9, then Ethernet.init(10) and Ethernet.begin(mac, ip, dns, gateway, subnet)
                      (192.168.1.177, no DHCP); waits while linkStatus() is LinkOFF; every 20 s reads A0 and sends
                      GET /update?api_key=TEPW5500DEMO01&field1=<A0>&field2=<volts> to api.thingspeak.com (DNS, then
                      TCP port 80), the answer is the entry number or 0; an EthernetServer on port 80: "/" the status
                      page, "/json" the counts, "/now" an upload at once; answers go out in 64-byte pieces
                      (print(F("...")) on an EthernetClient would send each character as its own packet).

PROPERTIES (double-click the W5500 module > 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
  PANEL     the phone's tab at start (BROWSER, ROUTER, CLOUD)
  PAGEPORT  the port OPEN MODULE 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. With DHCP the address follows the part's number: U1 192.168.1.101, U2 .102
... - give every network part its own number, and a fixed address that no other part uses. 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.hardwareStatus() is EthernetNoHardware: check SCLK / MISO / MOSI, SCS (and Ethernet.init(pin) when it is not
  D10), 5V or 3V3 and GND, and that RST is not held LOW.
* No answer from the cloud: the cable is out (the panel shows CABLE OUT, linkStatus() is LinkOFF), or the DNS address
  given to Ethernet.begin() is not the router (192.168.1.1).
* "Cloud: refused (0)": the cloud takes one update per key every 15 s - send less often.
* Two parts on one address: give a fixed address no other part uses (DHCP gives .101, .102 ...).
* 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: 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/w5500-ethernet-module-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 W5500 module model, the Laptop / Mobile WiFi Monitors and the network (TEPNET.DLL), the Arduino board models
  (TEPARDUINO.DLL), the symbols and artwork (TEPW5500MOD.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.
* W5500_Cloud_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) and the Arduino Ethernet library 2.0.2 (LGPL 2.1,
  https://github.com/arduino-libraries/Ethernet). The libraries are not shipped.
* 203.0.113.10 is a documentation address (no real server); api.thingspeak.com only stands for a ThingSpeak-style
  cloud here - the virtual internet host answers it, nothing leaves your PC.
* Proteus is a product of Labcenter Electronics and is not included. W5500 and WIZnet are names of WIZnet; HanRun of
  Zhongshan HanRun Electronic; ThingSpeak of The MathWorks. This library is not made or endorsed by WIZnet, The
  MathWorks 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: W5500_Cloud_Logger 20,554 / 662 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 reset and the RST pin; the router's DHCP, DNS and NTP answers; the
PWR LED, the jack's LINK / ACT LEDs and the cable; 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 (INT
stays HIGH), the PHY's mode settings and auto-negotiation (it is always 100 Mbit/s full duplex), the ping-block and
wake-on-LAN bits (a ping is always answered), 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 W5500 Ethernet Module library V1.0 (Oct 2026). Device W5500 ETHERNET MODULE (TEPW5500MOD.LIB / TEPNET.DLL, which
also runs our Ethernet shields, 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 W5500_Cloud_Logger V1.0.