Arduino UNO WiFi Rev2 Library for Proteus: WiFiNINA Simulation

Hello friends, I hope you all are doing great. Today, I am going to share the Arduino UNO WiFi Rev2 Library for Proteus. The UNO WiFi Rev2 is the Wi-Fi member of the classic UNO family: the UNO's size, shape and headers, a Microchip ATmega4809 as the main processor and a u-blox NINA-W102 module for Wi-Fi, programmed with Arduino's WiFiNINA library. With this library it runs your UNO WiFi Rev2 sketch in Proteus - WiFi.begin, WiFiServer, WiFiClient, WiFiUDP, WiFi.getTime() and WiFi.ping() - with the L LED, the RESET button and our serial monitor.

This is the twenty-fifth library of our Wi-Fi series and the third Arduino Wi-Fi board, after our Arduino UNO R4 WiFi Library for Proteus and our Arduino Nano ESP32 Library for Proteus. Its demo is a Wi-Fi message relay: our Mobile WiFi Monitor taps a message on the board's page, the board stamps it with the time from WiFi.getTime() and passes it on to the TCP server of our Laptop WiFi Monitor, and a /ping page measures the round trips to the router, the laptop, the phone and the internet.

NOTICE: Proteus has no ATmega4809 and no ESP32 (the heart of the NINA-W102), so this is not a real ATmega4809: your sketch is compiled for a hidden ATmega2560 inside the board (16 MHz, 8 KB of RAM). The WiFiNINA API, the L LED and the Wi-Fi are our model. The antenna colours, the PANEL pad and the panel are TEP additions. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the UNO WiFi Rev2 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 UNO WiFi Rev2 Library for Proteus:

What is Arduino UNO WiFi Rev2?

The UNO WiFi Rev2 keeps everything an UNO user knows - the 68.6 x 53.3 mm board, the headers D0 to D13 and A0 to A5, 5 V logic, USB-B and the DC jack - and adds Wi-Fi. The main processor is the ATmega4809 (16 MHz, 48 KB of flash, 6 KB of RAM), the same megaAVR family as the Nano Every. Wi-Fi comes from the NINA-W102, a small u-blox module with an ESP32 inside running Arduino's NINA firmware; the two talk over SPI, and the WiFiNINA library hides all of that behind WiFi.begin() and WiFiClient. The board also carries an LSM6DS3 IMU (accelerometer and gyroscope). For the classic UNO in Proteus, see our Arduino UNO Library for Proteus V4.0.

How Your UNO WiFi Rev2 Sketch Runs in Proteus

Proteus 8 simulates many processors, but not the ATmega4809 and not the ESP32 of the NINA module. So, as for our other sketch boards, the UNO WiFi Rev2 in Proteus has a hidden ATmega2560 inside, and our board package for the Arduino IDE compiles your sketch for it. The package gives the sketch the Rev2's pin numbers and a WiFiNINA library with the same names as Arduino's, which talks to our model in TEPNET.DLL. The model plays the NINA module: it joins the router, keeps the sockets, answers the time and measures the ping round trips.

The price is small here, because the real board is an 8-bit AVR too: the sketch runs at 16 MHz, an int is 16 bits on both, and there is even a little more RAM (8 KB against 6 KB). There is no Bluetooth, no IMU reading and no real TLS. The same sketch compiles for a real UNO WiFi Rev2 without a change.

Features of the Arduino UNO WiFi Rev2 Library for Proteus

• The UNO WiFi Rev2 as it looks: the teal UNO board with USB-B and the DC jack on the left, RESET, the ON, L, TX and RX LEDs, the ATmega4809, the IMU, the NINA-W102 with its antenna, the ICSP header and the UNO's pin labels.
• WiFiNINA: WiFi.begin() waits for the join as on the real module, WiFi.firmwareVersion() answers 1.5.0, WiFi.getTime() gives UTC from NTP and WiFi.ping() measures round trips.
• Sockets: WiFiServer, WiFiClient and WiFiUDP between every TEP Wi-Fi part in the design, plus an internet host that answers HTTP and ping.
• The UNO's pins: D0 to D13, A0 to A5 (0 to 1023 for 0 to 5 V), PWM on 3, 5, 6, 9 and 10, Serial1 on D0 / D1, Wire and SPI.
• The L LED on D13, the ON LED, the RESET button and an antenna that changes colour with the traffic.
• A built-in serial monitor on the USB (Serial) at 115200 baud with Monitor, Plotter and Board tabs.
• Our pop-up panel: a phone with a browser, the router list and the cloud requests, the board, Wi-Fi and traffic cards, every pin live, a Test page, Settings and Help - with our TEP header, not a Windows title bar.
• Our Laptop and Mobile WiFi Monitors in the package: a browser, TCP and UDP terminals and ping on the same network.
• A compact package: about 2.20 MB with the board package for the Arduino IDE, without the C++ source code of the models.

The Arduino UNO WiFi Rev2 in Proteus

Search WIFI REV2 in Pick Devices; the device ARDUINO UNO WIFI REV2 is in TEPUNOWIFIREV2.LIB (Microprocessor ICs, Arduino Wi-Fi Boards). Click the USB-B to open the serial monitor and the PANEL pad or the NINA module to open the panel.

Every State of the UNO WiFi Rev2

We ran the board with the demo sketch and paused the simulation for each picture. While WiFi.begin() waits for the join, the sketch keeps L off; when the board is on Wi-Fi, L lights:

Download Arduino UNO WiFi Rev2 Library for Proteus

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

Arduino UNO WiFi Rev2 Library for Proteus V1.0

• README.txt: the device, installation, the demos, the pins, WiFiNINA, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPUNOWIFIREV2.LIB (the board), TEPLAPTOP.LIB and TEPMOBILE.LIB (our Laptop and Mobile WiFi Monitors).
• Proteus Model Files: TEPNET.DLL (the board, the two monitors and the Wi-Fi network).
• Proteus Simulation: the two demo projects, the HEX file and a copy of the DLL.
• Arduino Code: the demo sketch and TEP Boards for Proteus 1.11.0, our board package for the Arduino IDE with its WiFiNINA library.

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 UNO WiFi Rev2 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 an older copy (this one is the first that knows the UNO WiFi Rev2 and WiFi.ping(), and it still runs every earlier board, the modules, the shields and the two monitors).
4. Delete TEPUNOWIFIREV2.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for WIFI REV2.

The Board Package for the Arduino IDE

The demo has its HEX file, so you need the Arduino IDE only for your own sketches. Copy the folder Arduino Code\TEP Boards for Proteus\hardware into your sketchbook folder (normally Documents\Arduino), so that Documents\Arduino\hardware\tep\avr\boards.txt exists, and restart the IDE; the Arduino AVR Boards platform must be installed. Version 1.11.0 adds the UNO WiFi Rev2 and replaces 1.10.0 (it still has every earlier board). Choose Tools > Board > TEP Boards for Proteus > Arduino UNO WiFi Rev2 (TEP Proteus), write your sketch 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). WiFiNINA is inside the package. If you also have Arduino's own WiFiNINA in Documents\Arduino\libraries and the compile fails in its SPI driver, move that folder out while you compile for Proteus.

Demo: A UNO WiFi Rev2 Wi-Fi Message Relay

Open UNO-WiFi-Rev2-Message-Relay-with-Laptop-and-Mobile.pdsprj. In the middle is the UNO WiFi Rev2 (U1), on the left our phone (MOB1) and on the right our laptop (PC1). There are no wires: the three are on the TEP-WiFi network. The package also has Arduino-UNO-WiFi-Rev2-Board.pdsprj, the board alone with the same sketch.

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. The laptop is 192.168.1.21; its property SERVERPORT is 5000, so its TCP server listens there from the start, and its browser's home page is the board's /ping page. The phone is 192.168.1.41 and opens the board's main page:

The Sketch: WiFiNINA as on the Real Board

The sketch includes WiFiNINA.h and names the router and the laptop's server:

const char *ssid = "TEP-WiFi";
const char *pass = "12345678";
const IPAddress laptop(192, 168, 1, 21);   // the Laptop WiFi Monitor's TCP server
const int laptopPort = 5000;

Before anything else it checks that there is a Wi-Fi module and compares its firmware with the version the library expects, as Arduino's WiFiNINA examples do:

  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("No Wi-Fi module!");
    while (true) {}
  }

  String fv = WiFi.firmwareVersion();
  Serial.println("NINA firmware " + fv + (fv < WIFI_FIRMWARE_LATEST_VERSION ? " - please upgrade" : " (latest)"));

Joining and the Time

With WiFiNINA, WiFi.begin() does not return at once: it waits until the module has joined or given up, and returns the status. So the sketch simply calls it in a loop, with L off while it waits:

void joinWiFi() {
  Serial.print("Connecting to ");
  Serial.println(ssid);
  digitalWrite(LED_BUILTIN, LOW);
  while (WiFi.begin(ssid, pass) != WL_CONNECTED) {
    Serial.println("Not joined yet - trying again");
    delay(2000);
  }
  digitalWrite(LED_BUILTIN, HIGH);     // L on: joined
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
}

Once the board is on Wi-Fi, the NINA firmware fetches the time by NTP on its own; WiFi.getTime() answers 0 until it has it, then the Unix time in UTC. The sketch waits for it once in setup():

  unsigned long t = 0;
  while ((t = WiFi.getTime()) == 0) delay(500);   // the NINA module's NTP
  Serial.println("Time " + clockText(t) + " UTC");

Press Run and watch the monitor (115200 baud):

UNO WiFi Rev2 Message Relay - The Engineering Projects
NINA firmware 1.5.0 (latest)
Connecting to TEP-WiFi
IP address: 192.168.1.101
Time 00:10:35 UTC
Page on port 80 - messages go to the laptop 192.168.1.21:5000

The time is printed as hours, minutes and seconds with a small helper:

String clockText(unsigned long t) {
  char text[9];
  snprintf(text, sizeof text, "%02u:%02u:%02u", (unsigned)((t / 3600UL) % 24), (unsigned)((t / 60UL) % 60), (unsigned)(t % 60));
  return String(text);
}

Round Trips with WiFi.ping(): the Laptop

WiFi.ping() sends an echo request and returns the round trip in milliseconds, or a negative error such as WL_PING_TIMEOUT. It accepts an address or a name. The sketch wraps it in one line of text:

String pingText(const char *name, const char *host) {
  int ms = WiFi.ping(host);
  if (ms >= 0) return String(name) + " " + host + ": " + ms + " ms";
  return String(name) + " " + host + ": no answer (" + ms + ")";
}

The /ping page pings four places, one after the other - the router, the laptop, the phone and an internet name:

  client.print("<p>" + pingText("router", "192.168.1.1") + "</p>");
  client.print("<p>" + pingText("laptop", "192.168.1.21") + "</p>");
  client.print("<p>" + pingText("phone", "192.168.1.41") + "</p>");
  client.print("<p>" + pingText("internet", "www.google.com") + "</p>");

In the laptop, open the Browser and press Go - its home page is http://192.168.1.101/ping:

router 192.168.1.1: 4 ms
laptop 192.168.1.21: 11 ms
phone 192.168.1.41: 6 ms
internet www.google.com: 84 ms

The devices on the TEP network answer in a few milliseconds, the internet host in tens of milliseconds - realistic values, not a radio simulation. A device that is not on the network gives WL_PING_TIMEOUT after 5 seconds, as a real ping does.

Messages from the Phone to the Laptop

The WiFiNINA library has no WebServer class, so the sketch reads the HTTP request itself: a WiFiServer on port 80 hands over each connection, and the first line of the request - GET /send?m=DOOR+OPEN HTTP/1.1 - is all it needs:

void serveClients() {
  WiFiClient client = server.available();
  if (!client) return;
  String line;
  unsigned long start = millis();
  while (client.connected() && millis() - start < 2000) {
    if (!client.available()) continue;
    char c = client.read();
    if (c == '\n') {
      if (line.length() == 0) break;                 // the empty line: the end of the request
      if (line.startsWith("GET ")) handle(line.substring(4, line.indexOf(' ', 4)), client);
      line = "";
    } else if (c != '\r' && line.length() < 80) {
      line += c;
    }
  }
  delay(5);
  client.stop();
}

The path decides what happens: /send?m= passes a message on, /ping answers the round trips, anything else gets the main page. The address of the browser that asked is the message's sender:

void handle(String path, WiFiClient &client) {
  String from = client.remoteIP().toString();
  Serial.println("Page " + path + " for " + from);
  if (path.startsWith("/send?m=")) {
    relay(decode(path.substring(8)), from);
    sendPage(client);
  } else if (path == "/ping") {
    sendPings(client);
  } else {
    sendPage(client);
  }
}

A link cannot hold a space, so the buttons use + and the sketch turns + and %20 back into spaces:

String decode(String text) {
  text.replace("+", " ");
  text.replace("%20", " ");
  return text;
}

The heart of the demo is relay(). It stamps the message with the time, opens a WiFiClient to the laptop's server on port 5000, sends one line and closes the connection, keeps the last four messages for the page, and turns L off for 400 ms so you can see a message going out:

void relay(String text, String from) {
  String line = clockText(WiFi.getTime()) + " UTC " + text + " (from " + from + ")";
  digitalWrite(LED_BUILTIN, LOW);
  ledOnAt = millis() + 400;
  WiFiClient link;
  bool sent = link.connect(laptop, laptopPort);
  if (sent) {
    link.println(line);
    link.stop();
    passedOn++;
  }
  for (int i = KEEP - 1; i > 0; i--) lastMessages[i] = lastMessages[i - 1];
  lastMessages[0] = line;
  Serial.println(String(sent ? "Passed on: " : "Laptop not reachable: ") + line);
}

In the phone, open the Browser and press Go - http://192.168.1.101/:

We tapped DOOR OPEN and paused the simulation at once - L is off while the message goes to the laptop, and the antenna is orange (sending):

On the laptop, the Terminal tab and its TCP Server show each connection from the board and the line it sent - the phone's DOOR OPEN and a message we typed in the monitor:

The Serial Monitor Commands

The same things work from the serial monitor: SEND passes a message on, PING pings any address or name, TIME shows the time and the Unix time, STATUS the Wi-Fi and the count:

void command(String cmd) {
  cmd.trim();
  if (cmd.startsWith("SEND ") || cmd.startsWith("send ")) relay(cmd.substring(5), "monitor");
  else if (cmd.startsWith("PING ") || cmd.startsWith("ping ")) Serial.println(pingText("ping", cmd.substring(5).c_str()));
  else if (cmd.equalsIgnoreCase("TIME")) Serial.println(clockText(WiFi.getTime()) + " UTC (Unix time " + WiFi.getTime() + ")");
  else if (cmd.equalsIgnoreCase("STATUS")) Serial.println(status());
  else Serial.println("Commands: SEND <text>, PING <host>, TIME, STATUS, HELP");
}

We typed SEND Lunch at one, PING www.google.com, TIME, STATUS and HELP:

SEND Lunch at one
Passed on: 00:10:41 UTC Lunch at one (from monitor)
PING www.google.com
ping www.google.com: 78 ms
TIME
00:10:45 UTC (Unix time 1792714245)
STATUS
Wi-Fi 192.168.1.101 RSSI -47 dBm, 2 messages passed on, time 00:10:46 UTC
HELP
Commands: SEND <text>, PING <host>, TIME, STATUS, HELP

loop() serves the page, reads the monitor, turns L back on after a message, and joins again if the Wi-Fi is lost:

void loop() {
  serveClients();
  readMonitor();
  if (ledOnAt && (long)(millis() - ledOnAt) >= 0) {
    ledOnAt = 0;
    digitalWrite(LED_BUILTIN, HIGH);
  }
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi lost - joining again");
    joinWiFi();
  }
}

And the whole demo after the run:

The UNO WiFi Rev2 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 Wi-Fi page has a small phone and three cards: BOARD, WI-FI and TRAFFIC. OPEN REV2 PAGE opens the sketch's page on the panel's phone:

The Pins page shows every pin live:

The monitor's Board tab shows the ON and L LEDs, the RESET button you can click there too, and every pin:

Pins of the Arduino UNO WiFi Rev2

Serial is the USB - the board's monitor - and Serial1 is on D0 / D1, as on the real UNO WiFi Rev2. All pins are 5 V logic.

WiFiNINA in the Simulation

Properties of the Arduino UNO WiFi Rev2

The IP address follows the part's number: U1 gets 192.168.1.101, U2 .102 and so on. Use one UNO WiFi Rev2 per design: its USB serial lines are hidden pins, and Proteus joins hidden pins of the same name across parts.

Your Own Sketch on the UNO WiFi Rev2

Any sketch written for the real UNO WiFi Rev2 with WiFiNINA runs the same way. A first sketch of your own takes five minutes:

1. In the Arduino IDE, choose Arduino UNO WiFi Rev2 (TEP Proteus) and start a new sketch - or open one of Arduino's WiFiNINA examples, such as WiFiWebServer.
2. Keep the UNO names: D2, A0, LED_BUILTIN, Serial1. A potentiometer on A0 reads 0 to 1023, and analogWrite on 9 dims an LED.
3. Use Sketch > Export Compiled Binary; the HEX file lands in the sketch's folder.
4. In Proteus, place ARDUINO UNO WIFI REV2, wire your parts to its pins (5 V logic), double-click it and set the Program File to the HEX.
5. Press Run: the board joins TEP-WiFi, and the monitor shows what your sketch prints on Serial.

Add our Laptop or Mobile WiFi Monitor to the same design and you have a browser, TCP and UDP terminals and ping on the same network, so a page, a socket or a UDP packet of your sketch can be tested at once. For the same NINA module on a shield for the classic UNO, see our AirLift WiFi Shield Library for Proteus.

Troubleshooting

• Nothing happens at Run: the HEX was not built with our board package - choose Arduino UNO WiFi Rev2 (TEP Proteus) and export it again.
• "WiFiNINA.h: No such file" or no getTime / ping: an older copy of the board package is installed - 1.11.0 adds the UNO WiFi Rev2.
• WiFi.getTime() answers 0: the board has no time yet - call it again after a second, as the demo does.
• WiFi.ping() answers -2: nothing at that address is on TEP-WiFi - is the laptop or the phone in the design?
• The laptop gets nothing: its SERVERPORT must be the sketch's port (5000), and the laptop must be on Wi-Fi.
• The board does not join: the network name or password differs from WIFISSID / WIFIPASS, or the panel's WI-FI SIGNAL is OUT OF RANGE.
• A number goes wrong above 32767: an int is 16 bits - use long, as on the real board.

Things to Know Before Using a Real UNO WiFi Rev2

• The board package: the real board needs Arduino megaAVR Boards in the Boards Manager and Arduino's WiFiNINA library from the Library Manager.
• The firmware: the NINA module has its own firmware; the IDE's Firmware Updater brings it to the version WiFiNINA expects - the demo prints a warning if it is older.
• PWM pins: 3, 5, 6, 9 and 10 - pin 11 has no PWM on the Rev2, unlike the classic UNO.
• The IMU: the LSM6DS3 on the board is read with Arduino's Arduino_LSM6DS3 library.
• The same sketch: the demo compiles for the real board without a change.

Limitations of the Simulation

• The board runs your sketch on a hidden ATmega2560 at 16 MHz with 8 KB of RAM - not on the ATmega4809. The ATmega4809's own peripherals and registers are not there; Arduino functions are.
• Not modelled: the LSM6DS3 IMU (drawn), Bluetooth, the soft AP, WPA2 Enterprise, the NINA's own pins, its firmware updates, real TLS, the TX and RX LEDs (drawn), the radio itself - the join, network and ping times are realistic values, not a radio simulation.
• The antenna colours, the PANEL pad, the panel, its phone, the router, the internet host and the two monitors are TEP additions; the MAC address is a TEP address.
• Arduino and UNO are trademarks of Arduino SA, ATmega4809 a name of Microchip Technology, NINA-W102 of u-blox, LSM6DS3 of STMicroelectronics; this library is not made or endorsed by them or by Labcenter.
• Tested in Proteus 8.5 in October 2026 (the demos as shipped, the UNO WiFi Rev2, 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 UNO WiFi Rev2 Library for Proteus. I hope it lets you try WiFiNINA on the UNO WiFi Rev2 before the real board is on your desk - web pages, sockets, time stamps, round trips - with the same sketch that runs on the hardware. If you use the Arduino UNO WiFi Rev2 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!