Mobile WiFi Monitor Library for Proteus: Control ESP32 from a Phone

Hello friends, I hope you all are doing great. Today, I am going to share the Mobile WiFi Monitor Library for Proteus. When you finish a Wi-Fi project, the first thing you do is pick up your phone: you open the board's web page, tap a button and watch the LED. The Mobile WiFi Monitor puts that phone into Proteus. It is a smartphone - the TEP SmartPhone - that joins the Wi-Fi network of your simulation, with four apps: a Browser for the pages of your ESP32 and ESP8266 sketches, a Terminal for TCP and UDP, a Wi-Fi app and a Devices app with ping.

It is the phone version of our Laptop WiFi Monitor Library for Proteus, and both work like our Serial Monitor: a tool you place next to your circuit to see and test what it does - only here the link is Wi-Fi, not a wire. In this article the phone controls our new ESP32 DevKit V1 Library for Proteus V2.0 from its browser and its terminal, while the TEP NoteBook laptop receives the ESP32's reports in the same design.

NOTICE: the TEP SmartPhone is a simulated phone for testing Wi-Fi projects: it has no calls, no mobile data and no app store, and it lives only on the TEP Wi-Fi network of the simulation. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the Mobile WiFi Monitor board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the Mobile WiFi Monitor Library for Proteus:

What is the Mobile WiFi Monitor?

Most IoT projects are made to be used from a phone. A smart switch has a web page with big ON and OFF buttons; a weather station shows its readings on a page; a robot takes commands from a TCP terminal app. To test such a project you need a phone on the same Wi-Fi - and until now there was none inside Proteus. The Mobile WiFi Monitor is that phone. It has no pins to wire; it gets its own address from the virtual router, and it can reach every TEP Wi-Fi part in your design: our ESP32 boards, our ESP8266 modules and the Laptop WiFi Monitor.

Why We Designed the WiFi Monitors First

A little background. These days we are working on our Wi-Fi libraries for Proteus: the ESP32 boards and the ESP8266 modules of our Wi-Fi series. All of them join the same network that we built inside Proteus - our own TEP Wi-Fi network, with its router, its addresses and its internet host. While we were designing those modules, we kept asking how a user would really see what they do on that network, because on a real desk there is always a laptop and a phone in the picture. So, before going on with the next Wi-Fi modules, we thought: why not first design the viewers - devices that live in our own network and show it to you, just like the Serial Monitor shows the UART? The TEP NoteBook came first, with the Laptop WiFi Monitor, and the TEP SmartPhone of this article is the second one.

Phone and Laptop Together

The two tools share the same network engine, so you can use them together: the laptop as a server that collects data, the phone as the remote control, and your ESP32 or ESP8266 in the middle. That is exactly what the demo of this article does, and it is how many real systems work - a device that reports to a computer and takes commands from a phone.

Features of the Mobile WiFi Monitor Library for Proteus

• The TEP SmartPhone: a modern phone seen from the front, with a thin bezel, the earpiece, the front camera and a large screen.
• A real start-up: our logo on the first screen, TEP OS starting with its technical data, the join to TEP-WiFi, "Welcome to TEP Wi-Fi Network", then the Browser app.
• Browser app: opens the pages of your sketches over HTTP; links become big buttons that are easy to tap; Back, Reload and Source; a start page lists the devices with a web server.
• Terminal app: TCP (connect to a board's port), Server (boards connect to the phone) and UDP, with TX / RX on every line; long lines wrap.
• Wi-Fi app: the Wi-Fi switch, the network with the address and the signal, the networks in range, a password and Join.
• Devices app: every device on the network with Ping and Open, and ping with its times.
• A phone status bar: the clock, the Wi-Fi signal bars and the battery, as on a real phone.
• A live screen on the sheet: the phone's screen in Proteus shows the app in use while the simulation runs.
• Our pop-up window that is the phone itself, in the look of the Serial Monitor, with Settings and Help.
• A demo with our ESP32 DevKit V1 and the Laptop WiFi Monitor: the phone switches the LED from the page and from the terminal while the laptop collects the reports.
• A compact package: about 1.88 MB, without the C++ source code of the models.

The Mobile WiFi Monitor Part in Proteus

Press P in Proteus and search for WiFi Monitor or Mobile; the device MOBILE WIFI MONITOR is in TEPMOBILE.LIB, with the prefix MOB. It has one hidden pin and nothing to wire. Its number sets its address: MOB1 is 192.168.1.41, MOB2 is 192.168.1.42, and so on. Before Run the screen shows our logo, the clock and the name of the phone:

The Start-Up of the TEP SmartPhone

Press Run and the phone boots. We paused the simulation at every step; on the sheet you see the phone's screen, and the pop-up window shows the same screen in a bigger size:

Then the Browser app opens on its start page with a button for every device that has a web page. The four apps are on the bar at the bottom, as on any phone:

Download Mobile WiFi Monitor Library for Proteus

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

• README.txt: the device, installation, the demo, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPMOBILE.LIB (the Mobile WiFi Monitor), TEPLAPTOP.LIB (the Laptop WiFi Monitor) and TEPESP32V1.LIB (our ESP32 DevKit V1) - all three are in the demo.
• Proteus Model Files: TEPNET.DLL - the phone, the laptop, the ESP32 boards and the Wi-Fi network.
• Proteus Simulation: the demo project, its HEX file and a copy of the DLL.
• Arduino Code: the demo sketch and TEP Boards for Proteus, the Arduino IDE add-on for our ESP32 boards.

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 Mobile WiFi Monitor 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 and replace the older copy - it runs all our Wi-Fi parts.
4. Delete TEPMOBILE.IDX, TEPLAPTOP.IDX and TEPESP32V1.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for WiFi Monitor.

To compile your own ESP32 sketches, copy Arduino Code\TEP Boards for Proteus\hardware into your sketchbook folder (normally Documents\Arduino), restart the Arduino IDE and select ESP32 DevKit V1 (TEP Proteus) under Tools > Board > TEP Boards for Proteus. Then use Sketch > Export Compiled Binary and set the board's Program File to the HEX (see How to get the HEX file from Arduino).

Demo: The Phone Controls the ESP32 DevKit V1

Open Mobile-WiFi-Monitor-with-ESP32.pdsprj. On the left is our ESP32 DevKit V1 Library for Proteus V2.0 with a 10k pot on D34 and a green LED with a 220R resistor on D18. In the middle is the TEP NoteBook from the previous library, PC1, with its TCP server on port 5000. On the right is the phone, MOB1; its properties set the home page to the ESP32 and the Terminal app's host and port to 192.168.1.101:23.

The ESP32 runs the same sketch as in the laptop article, ESP32_Laptop_Link. For the phone, two parts of it matter. The web server answers the page and the two LED links:

  server.on("/", handleRoot);
  server.on("/led", handleLed);
  server.begin();
  door.begin();

And a second TCP server on port 23 waits for a terminal. When the phone connects, the ESP32 greets it and from then on reads its lines as commands:

  WiFiClient fresh = door.available();  // a new device on port 23 (the phone's terminal)
  if (fresh) {
    if (phone.connected()) phone.stop();
    phone = fresh;
    fromPhone = "";
    Serial.print("Port 23: ");
    Serial.print(phone.remoteIP());
    Serial.println(" connected");
    phone.print("Hello - ESP32 DevKit V1 here. Commands: LED ON, LED OFF, STATUS, HELP\r\n");
  }

The commands are answered by one function that the laptop link, port 23 and the serial monitor all share:

  if (up == "LED ON" || up == "ON") { setLed(true); return "OK - the LED on D18 is ON"; }
  if (up == "LED OFF" || up == "OFF") { setLed(false); return "OK - the LED on D18 is OFF"; }

  if (up == "HELP") return "Commands: LED ON, LED OFF, STATUS, HELP";

Tapping ON in the Browser App

Press Run. The phone boots, joins TEP-WiFi and opens its start page; tap the ESP32. The phone sends a real HTTP GET to 192.168.1.101 and shows the page. The links of the page become three big buttons - ON, OFF and READ - because nobody wants to hit a tiny text link with a finger:

Tap ON. The phone requests /led?state=on, the ESP32 switches D18 high and sends the page again - now it says LED on D18 is ON, and the LED in the circuit lights:

void handleLed() {
  String state = server.arg("state");
  if (state == "on") setLed(true);
  else if (state == "off") setLed(false);
  else { server.send(400, "text/plain", "state must be on or off"); return; }
  blink();
  Serial.print(ledOn ? "LED ON" : "LED OFF");
  Serial.print(" from ");
  Serial.println(server.client().remoteIP());
  sendPage();
}

Commands from the Terminal App

Now the same LED from a terminal, the way many phone apps talk to IoT devices. Tap Terminal: the TCP segment is selected, the host and the port are already 192.168.1.101 and 23 from the properties. Tap Connect - the ESP32 greets the phone with its list of commands:

Type a command in the field at the bottom and tap Send. We sent STATUS and then LED OFF; every answer comes back on the same link, and long answers wrap to the next line:

Back in the Browser app, tap READ to load the page again and see the new state:

The Laptop Collects the Reports

While you play with the phone, the ESP32 keeps sending a report to the laptop every 3 seconds. Open the laptop's window: its TCP server shows the reports with the LED state that the phone just changed. This is the Laptop WiFi Monitor Library for Proteus in action - the previous library of the series - and you can type commands there too:

The ESP32's own serial monitor shows both sides - the page requests and the commands from the phone at 192.168.1.41, and the reports that go to the laptop:

ESP32 DevKit V1: web page, laptop reports, port 23 commands
Connecting to TEP-WiFi.....
IP address: 192.168.1.101
Web page: http://192.168.1.101/   commands: port 23
Connected to the laptop (192.168.1.21:5000)
GET / from 192.168.1.41
LED ON from 192.168.1.41
Report 1: LED ON, pot 2047 (1.65 V), RSSI -46 dBm, uptime 5 s
Port 23: 192.168.1.41 connected
Port 23: STATUS
  reply: LED ON, pot 2047 (1.65 V), 1 report, 2 pages, 1 command
Port 23: LED OFF
  reply: OK - the LED on D18 is OFF
Report 2: LED OFF, pot 2047 (1.65 V), RSSI -46 dBm, uptime 8 s
GET / from 192.168.1.41

The Devices and Wi-Fi Apps

The Devices app lists everything on TEP-WiFi: the laptop, this phone, the ESP32 and the small phone on the ESP32's own panel, each with its address. Ping checks a device, Open opens its web page, and the field below pings any address:

The Wi-Fi app is the phone's Wi-Fi settings: the switch, the network it is on with its address and signal, and the networks in range. Type a password and tap Join to move the phone to another network - a quick way to test what your project does when a client disappears:

The window has the theme, Settings and Help buttons of our TEP Serial Monitor Advance for Proteus in its header; Settings keeps the theme, the text size and whether the phone opens at Run, Help links the article, the forum and a bug report.

Designing a Web Page for a Phone

The demo page is tiny on purpose, and that is a good habit for any IoT page that people open on a phone. Keep the page short and put the state first ("LED on D18 is ON"), so it can be read at a glance. Use a few clear links for the actions - the TEP SmartPhone turns every link into a big button, and a real phone user will thank you for the same thing. Make every action a link with the command in its address, like /led?state=on, and give the page a link that only reads the state, like READ. That last point matters more than it looks: after you tap ON, the browser is on /led?state=on, and a Reload repeats the command. A READ link (or Back) only looks. You can try this in the simulation: tap ON, then LED OFF in the Terminal app, then Reload in the Browser app - the LED comes on again, exactly as it would with a real phone.

The Server and UDP Modes of the Terminal App

In the demo the phone is a TCP client, but the Terminal app has two more modes. In Server mode the phone listens on a port (the SERVERPORT property, or start it in the Server segment), and your board connects to it - change LAPTOP_IP in the sketch to 192.168.1.41 and port 5000, and the reports come to the phone instead of the laptop. In UDP mode the phone sends single datagrams, without a connection: type a host and a port, or the broadcast address 192.168.1.255 to reach every device on the network at once, and it receives datagrams on its own UDP port. The laptop of this demo listens on UDP port 4210, so you can try it right away: select UDP, send a line to 192.168.1.21 port 4210, and it appears in the laptop's terminal. On the board side the same is done with WiFiUDP.

Several Phones in One Design

You can place as many phones as you like. Each one gets its own window and its own address from its number - MOB1 is 192.168.1.41, MOB2 is 192.168.1.42 - so a board can tell them apart, just as the ESP32's monitor prints the address of every request. Keep in mind what your sketch allows: the demo sketch keeps one client on port 23, so a second phone that connects replaces the first one. A real project often needs more; a small array of WiFiClient objects, one per phone, is the usual way. Laptops and phones mix freely, because they all join the same router as our ESP32 boards and ESP8266 modules.

Properties of the Mobile WiFi Monitor

Using the Same Sketch with a Real Phone

• Same network: put your phone and the ESP32 on the same Wi-Fi, with your network's name and password in the sketch.
• The page: open the ESP32's address (the serial monitor prints it) in the phone's browser and tap ON or OFF.
• The terminal: any TCP terminal app works - connect to the ESP32's address and port 23 and send LED ON.
• The reports: they need a TCP server on port 5000 at LAPTOP_IP - your PC with any TCP terminal, or leave it: the sketch simply tries again every 5 seconds.
• The board: select ESP32 Dev Module of the Espressif core - the sketch uses only WiFi, WebServer and standard Arduino functions.

Troubleshooting

• No phone window at Run: tap the phone's screen on the sheet, or turn "Open the panel at Run" back on in Settings.
• "connection refused (no server on that port)": the board's server is not up yet, or the port is wrong; the board must be on Wi-Fi first.
• Reload sends a command again: after tapping ON, the address is /led?state=on, so Reload repeats it - use READ (or Back) to just look.
• A page does not open: the board must serve HTTP on port 80, or type the port in the address; https pages are refused.
• Typing does nothing: tap the text field first - it gets a blue frame.
• Two phones: give them different numbers (MOB1, MOB2) - the number sets the address.

Limitations of the Simulation

• The Browser app shows the text, the headings and the links of a page as buttons; pictures, CSS, JavaScript and POST forms are not shown or sent.
• There is no HTTPS: the simulated network has no TLS, so https addresses are refused.
• The phone has Wi-Fi only - no mobile data, calls or SMS - and lives only on the TEP Wi-Fi network of the simulation; its battery icon is always full.
• The join, ping and network times are realistic values of our network model, not a radio simulation.
• Bluetooth is not in this version - it will come later.
• The TEP SmartPhone, its look, the TEP OS screens, the router and the internet host are TEP additions; this library is not made or endorsed by Espressif, Arduino or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the demo as shipped, the phone, the laptop and the ESP32 about 0.35 x real time). Proteus 7 is not supported.

So, that was all about the Mobile WiFi Monitor Library for Proteus. I hope the TEP SmartPhone helps you test your Wi-Fi projects the way your users will use them - from a phone. Together with the Laptop WiFi Monitor Library for Proteus you now have both tools of a real IoT desk inside Proteus, and they work with every module of our Wi-Fi series. If you use the Mobile WiFi Monitor 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!