ESP32 DevKit V1 Library for Proteus V2.0: Wi-Fi Simulation

Hello friends, I hope you all are doing great. Today, I am going to share the new ESP32 DevKit V1 Library for Proteus V2.0. Back in 2023 we shared the first ESP32 Library for Proteus: a nice ESP32 board you could place on the sheet, but it ran an Arduino UNO HEX file and had no Wi-Fi - Proteus simply has no ESP32 processor inside. Many of you asked for more: you wanted to run a real ESP32 sketch, with WiFi.begin(), a web server and a phone that opens its page. Version 2.0 does exactly that.

Let us be clear from the first line: this is not a real ESP32 chip. Proteus 8 has no model of the ESP32's Xtensa processor, so our ESP32 DevKit V1 runs your sketch on a hidden ATmega2560 - Proteus's own AVR model - and our board model wraps it with the ESP32's pins, rules and Wi-Fi. You write a normal ESP32 Arduino sketch (GPIO numbers, analogRead() from 0 to 4095, ledcWrite(), attachInterrupt() on any pin, WiFi, WebServer, HTTPClient, ESPmDNS, NTP time) and compile it with our free Arduino IDE add-on, TEP Boards for Proteus. The board joins a virtual router, gets an address, serves pages to a phone in its panel, talks to an internet host and to our ESP-01 modules on the same network. The price is the AVR inside: 16 MHz, 8 KB of RAM, no FreeRTOS tasks and no Bluetooth - we list every limit below.

NOTICE: a board that only looks like an ESP32 would have been easy. We wanted your ESP32 sketch to work as it is: the same pin numbers, the same Wi-Fi calls, a web server a phone can open, an ESP-01 on the same router. It took our team a lot of hard work - a whole board package for the Arduino IDE and a Wi-Fi network inside Proteus. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the ESP32 DevKit V1 board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the ESP32 DevKit V1 Library for Proteus V2.0:

What is the ESP32 DevKit V1?

The ESP32 from Espressif is the favourite chip of IoT projects: a dual-core processor with Wi-Fi and Bluetooth built in. The ESP32 DevKit V1 is the cheap 30-pin board most of us start with: an ESP-WROOM-32 module with its PCB antenna, a CP2102 USB-to-serial chip, an AMS1117 3.3 V regulator, the EN (reset) and BOOT buttons, a red power LED and a blue LED on GPIO2, and 15 header pins on each side.

How Can an ESP32 Sketch Run in Proteus?

The trick is the same one our Arduino boards use. The board you place is our part; inside it sits Proteus's own ATmega2560 model, which runs the HEX file of your sketch exactly as Proteus runs any AVR. The HEX comes from our Arduino IDE add-on TEP Boards for Proteus: it compiles your ESP32 sketch for that AVR, with an Arduino core that speaks the ESP32's language - GPIO numbers, 12-bit analogRead(), ledc PWM, touchRead(), temperatureRead() - and with the ESP32's WiFi, WebServer, HTTPClient, ESPmDNS and Preferences libraries.

Whatever the AVR cannot do itself - PWM and interrupts on any pin, the Wi-Fi radio, the touch pads - the core asks the board model through a small mailbox in RAM, and our model (TEPNET.DLL) answers in the same simulation step. So WiFi.begin("TEP-WiFi", "12345678") really joins a router, and server.handleClient() really answers the phone.

What's New in ESP32 DevKit V1 Library for Proteus V2.0

• Your ESP32 sketch runs: GPIO numbers, analogRead() 0 - 4095, analogWrite() and ledc PWM on every output pin, attachInterrupt() on every pin, touchRead(), dacWrite(), Serial and Serial2, Wire and SPI.
• Wi-Fi in Proteus: a virtual router with DHCP (192.168.1.101 for U1), RSSI, a scan list, mDNS names (esp32.local), TCP and UDP, NTP time and an internet host that answers HTTP.
• A phone in the panel: it opens your sketch's web page and taps its links; the ROUTER tab lists every board, the CLOUD tab the internet requests.
• ESP-01 and ESP32 on one network: our ESP-01 Library for Proteus V1.1 modules and ESP32 boards reach each other.
• A real-looking board: the DevKit V1 drawn at its real proportions, with a working PWR LED, the blue D2 LED, the EN and BOOT buttons and a PCB antenna that changes colour with the Wi-Fi.
• The panel: Wi-Fi, Pins and Test pages, Settings and Help - and two measured tests: a web request test and a Wi-Fi re-join test.
• The built-in serial monitor on TX0 / RX0 with a Board tab: the LEDs, EN, BOOT, every pin and the analog voltages.
• TEP Boards for Proteus, our free Arduino IDE add-on: select ESP32 DevKit V1 (TEP Proteus) and export the binary.
• Three demo projects: Blink and the cloud, a web server with a pot and an LED, and the ESP32 talking to an Arduino UNO with an ESP-01.
• A compact package: about 2.64 MB, without the C++ source code of the models.

The ESP32 DevKit V1 Part in Proteus

The part is the real board turned on its side, the USB end on the left, at its real proportions - smaller than the Arduino UNO. The top row of pins is the real board's left column, the bottom row its right column, with the same labels: D34 is GPIO34, VP GPIO36, TX2 GPIO17 and so on. Search ESP32 in Pick Devices; the device is ESP32 DEVKIT V1 in TEPESP32V1.LIB.

Three parts of the board are made to click. The USB port opens the serial monitor, the PANEL pad (or the ESP-WROOM-32 module) opens the board's panel, and EN and BOOT are buttons: EN holds the ESP32 in reset while you press it, BOOT pulls GPIO0 LOW - digitalRead(0) reads it, as on the real board.

The LEDs and the Antenna

The red PWR LED lights when the simulation runs. The blue D2 LED is on GPIO2, the LED_BUILTIN of the ESP32 - with PWM it glows at its duty cycle. The gold PCB antenna shows the Wi-Fi: gold while the board is not on Wi-Fi, green once it joined, orange for a moment when it sends, cyan when it receives. We caught every state with the Blink sketch of the first demo, the simulation paused for each picture:

Download ESP32 DevKit V1 Library for Proteus

Click the button below to download ESP32-DevKit-V1-Library-for-Proteus-v2.0.zip (about 2.64 MB, without the C++ source code of the models):

ESP32 DevKit V1 Library for Proteus V2.0

• README.txt: the device, installation, the three demos, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPESP32V1.LIB (the board), ArduinoV4TEP.LIB from our Arduino UNO Library for Proteus V4.0 and TEPESP01.LIB from our ESP-01 library - both used by the third demo.
• Proteus Model Files: TEPNET.DLL (the ESP32 board and the Wi-Fi network), TEPESP01.DLL V1.2 and TEPARDUINO.DLL.
• Proteus Simulation: the three demo projects, their HEX files and copies of the DLLs.
• Arduino Code: the three sketches and the TEP Boards for Proteus add-on for the Arduino IDE. The UNO sketch needs AltSoftSerial (not included; install it with the Library Manager).

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 ESP32 DevKit V1 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, TEPESP01.DLL and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder.
4. Delete TEPESP32V1.IDX from the LIBRARY folder if it is there.
5. Start Proteus, press P and search for ESP32.

Tip: TEPESP01.DLL V1.2 replaces the ESP-01 V1.1 DLL. The ESP-01 model now lives in TEPNET.DLL - the same model - so that ESP-01 modules and ESP32 boards share one Wi-Fi network; keep the two DLLs in the same folder. The library is tested in Proteus 8.5; Proteus 7 is not supported.

Install TEP Boards for Proteus in the Arduino IDE

You only need this to compile your own sketches - the demos come with their HEX files.

1. The Arduino AVR Boards platform must be installed: it comes with the Arduino IDE 1.8.x; in IDE 2.x install "Arduino AVR Boards" from the Boards Manager once. The add-on uses its compiler.
2. 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.
3. Restart the IDE and select Tools > Board > TEP Boards for Proteus > ESP32 DevKit V1 (TEP Proteus).
4. Write your sketch and use Sketch > Export Compiled Binary. Double-click the board in Proteus and set Program File to the exported HEX (see How to get the HEX file from Arduino).

The same sketch compiles for a real board with Espressif's "ESP32 Dev Module" - you only change the board in the Tools menu.

Demo 1: Blink and the Cloud

Open ESP32-DevKit-V1-Board.pdsprj: the board alone with ESP32_Blink_Cloud.hex. The sketch blinks the blue LED every half second, joins the Wi-Fi, and every 20 seconds sends its up time and the chip temperature to an IoT channel - a ThingSpeak-style HTTP GET. The Wi-Fi part is plain ESP32 code:

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

The blink uses millis() instead of delay(), so the Wi-Fi and the uploads keep working while the LED blinks:

  if (millis() - lastBlink >= BLINK_MS) {      // the blue LED: on / off every half second
    lastBlink = millis();
    ledOn = !ledOn;
    digitalWrite(LED_BUILTIN, ledOn ? HIGH : LOW);
  }

The upload builds the URL and calls HTTPClient, as on a real board:

  HTTPClient http;
  String url = "http://api.thingspeak.com/update?api_key=";
  url += API_KEY;
  url += "&field1=";
  url += millis() / 1000;
  url += "&field2=";
  url += String(temperatureRead(), 1);
  http.begin(url);
  int code = http.GET();
  String body = http.getString();
  http.end();

Press Run. The serial monitor (115200 baud) and the board's panel open; move them aside. We let the board join, upload once, then took the router away with the panel's OUT OF RANGE button and gave it back with GOOD:

ESP32 DevKit V1: blink + Wi-Fi
Joining TEP-WiFi
Wi-Fi connected, IP 192.168.1.101, RSSI -45 dBm
Upload 1: HTTP 200, entry 1
Wi-Fi lost - the ESP32 joins again by itself
Wi-Fi connected, IP 192.168.1.101, RSSI -47 dBm

The internet host answers every name you use - here api.thingspeak.com - and the panel's phone shows what arrived in its CLOUD tab:

On a real board put your channel's Write API Key in API_KEY; ThingSpeak accepts one update every 15 seconds, the sketch sends every 20.

The Board's Panel

The panel opens at Run, in the look of our TEP Serial Monitor Advance for Proteus. Its header shows the board, its address and three pages - Wi-Fi, Pins and Test - with Settings and Help on the right.

The phone is a second device on the same router. OPEN ESP32 PAGE makes it ask the sketch's web server for its page and draws the answer - headings, text and links you can tap. WI-FI SIGNAL moves the router: GOOD, WEAK (a lower RSSI, slower answers) or OUT OF RANGE:

The Pins page shows the 25 GPIOs live - driven HIGH or LOW, PWM with its duty and frequency, input with a pull-up or pull-down, analog with its voltage - and a TOUCH button on every touch pin for touchRead(). The Test page has two measured tests; both appear in the web server demo below. Settings holds the theme, the text size, "open the panel at Run" and the window size; Help has the links to this article, the forum, updates and Copy diagnostics for a bug report:

Demo 2: ESP32 Web Server with a Pot and an LED

ESP32-DevKit-V1-Web-Server.pdsprj adds a 10k pot RV1 on D34 - an ADC1 pin - between the board's 3V3 pin (the "3V3" labels) and ground, and a green LED with a 220 ohm resistor on D18. The sketch, ESP32_Web_Server.ino, serves three addresses:

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

The LED handler reads the argument, switches the LED and answers with the page - or JSON for another board:

void handleLed() {
  String state = server.arg("state");
  if (state == "on") setLed(true);
  else if (state == "off") setLed(false);
  else if (state == "toggle") setLed(!ledOn);
  else { server.send(400, "text/plain", "state must be on, off or toggle"); return; }
  activity(ledOn ? "LED ON" : "LED OFF");
  if (server.arg("format") == "json") server.send(200, "application/json", json());
  else sendPage();
}

The on-board BOOT button toggles the LED too, with a short debounce:

  bool down = digitalRead(BOOT_PIN) == LOW;     // the BOOT button toggles the LED too
  if (down != bootWas && millis() - bootChangedAt > 30) {
    bootWas = down;
    bootChangedAt = millis();
    if (down) {
      ++presses;
      setLed(!ledOn);
      Serial.printf("BOOT pressed (%u): LED %s\n", presses, ledOn ? "ON" : "OFF");
    }
  }

Press Run, then OPEN ESP32 PAGE on the panel. The phone connects to 192.168.1.101 and shows the page:

Tap LED ON: the phone sends GET /led?state=on, the LED on D18 lights and the page comes back with the new state. The TRAFFIC card lists each connection and request:

ESP32 DevKit V1 web server
Connecting to TEP-WiFi.....
IP address: 192.168.1.101
RSSI -45 dBm, MAC 24:0A:C4:00:00:01
mDNS: http://esp32.local
HTTP server started: /  /data  /led?state=on|off|toggle
GET / from 192.168.1.201
LED ON from 192.168.1.201

Turn the pot with its arrows and tap RELOAD: the page shows the new reading. The Pins page shows D18 driven HIGH and D34 as an analog input with its voltage:

The Two Measured Tests

The Test page measures the running model. The web request test lets the phone open the page 3, 5 or 10 times and times the connection, the first byte and the full page. The Wi-Fi re-join test takes the router away for 3 seconds and measures when the board lost the Wi-Fi and how long it took to join again:

In our run the board lost the Wi-Fi 1.00 s after the router went away, and it was back on Wi-Fi 3.44 - 3.54 s after the router came back: the board waits 1 second before it tries again, then the join itself takes about 2.5 seconds. The page itself took 8.0 ms to connect and 55.2 ms to arrive, 340 bytes.

The Serial Monitor's Board Tab

The serial monitor is built into the board - no Virtual Terminal to wire. Besides the Monitor and the Plotter, its Board tab shows the LEDs, an EN (RESET) button, the BOOT button, every digital pin, the analog inputs with their voltages, the supply pins and the speed of the simulation:

Demo 3: ESP32 and ESP-01 - Serve on One, Read on the Other

A Wi-Fi library is more fun with a second board. In ESP32-and-ESP-01-Data-Link.pdsprj the ESP32 runs the same web server, and an Arduino UNO V4.0 from our Arduino UNO Library for Proteus V4.0 reads it through an ESP-01 from our ESP-01 Library for Proteus V1.1 - the AT-command Wi-Fi module of the previous library.

The UNO resets the ESP-01, switches it to 9600 bps, joins TEP-WiFi and then, every 3 seconds, asks the ESP32 for /data with AT commands - AT+CIPSTART, AT+CIPSEND, the request, then the answer arrives as +IPD data:

int get(const char* path) {
  char at[48];
  snprintf_P(at, sizeof(at), PSTR("AT+CIPSTART=\"TCP\",\"%s\",80"), ESP32_IP);
  if (!command(at, 5000)) return 0;
  char request[96];
  snprintf_P(request, sizeof(request), PSTR("GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n"), path, ESP32_IP);
  snprintf_P(at, sizeof(at), PSTR("AT+CIPSEND=%d"), (int)strlen(request));
  esp.print(at);
  esp.print(F("\r\n"));
  memset(tail, 0, sizeof(tail)); inBody = false; bodyLength = 0; body[0] = '\0'; statusLength = 0; status[0] = '\0';
  if (!waitFor(">", 2000)) { command("AT+CIPCLOSE"); return 0; }
  esp.print(request);
  waitFor("SEND OK", 3000);
  waitFor("CLOSED", 5000);             // the ESP32's web server answers, then closes the connection
  const char* sp = strchr(status, ' ');
  return sp ? atoi(sp + 1) : 0;
}

The UNO prints what the ESP32 sent and puts the ESP32's LED state on its own L LED. LED ON, LED OFF, TOGGLE and READ typed in the UNO's monitor go to the ESP32:

void switchLed(const char* state) {
  char path[40];
  snprintf_P(path, sizeof(path), PSTR("/led?state=%s&format=json"), state);
  Serial.print(F("LED "));
  Serial.print(state);
  Serial.print(F(": "));
  const int code = get(path);
  if (code == 200) { Serial.println(F("done")); show(); }
  else { Serial.print(F("failed, HTTP ")); Serial.println(code); }

Press Run. The ESP32 joins as 192.168.1.101, the ESP-01 as 192.168.1.102 - the address follows the part's number. We typed LED ON, then TOGGLE, then LED ON again in the UNO's monitor:

LED on: done
ESP32: pot 2049 (1.65 V), LED ON, BOOT presses 0, up 12 s
TOGGLE
ESP32: pot 2049 (1.65 V), LED ON, BOOT presses 0, up 16 s
LED toggle: done
ESP32: pot 2049 (1.65 V), LED OFF, BOOT presses 0, up 17 s
LED ON
ESP32: pot 2049 (1.65 V), LED OFF, BOOT presses 0, up 21 s
LED on: done
ESP32: pot 2049 (1.65 V), LED ON, BOOT presses 0, up 22 s
ESP32: pot 2049 (1.65 V), LED ON, BOOT presses 0, up 26 s
ESP32: pot 2049 (1.65 V), LED ON, BOOT presses 0, up 29 s

The ESP32's monitor shows the other side - every request with the address it came from:

ESP32 DevKit V1 web server
Connecting to TEP-WiFi.....
IP address: 192.168.1.101
RSSI -45 dBm, MAC 24:0A:C4:00:00:01
mDNS: http://esp32.local
HTTP server started: /  /data  /led?state=on|off|toggle
GET /data from 192.168.1.102
GET /data from 192.168.1.102
LED ON from 192.168.1.102
GET /data from 192.168.1.102
LED OFF from 192.168.1.102
GET /data from 192.168.1.102
LED ON from 192.168.1.102
GET /data from 192.168.1.102
GET /data from 192.168.1.102

The panel's ROUTER tab lists everyone on TEP-WiFi - the ESP32, the ESP-01 and the two phones of the panels - and the TRAFFIC card names the ESP-01 in every request. The ESP-01 has its own pop-up, with its AT traffic:

Serving on one board and reading on the other: the same pattern links sensors, displays and controllers in a real IoT project.

Pins of the ESP32 DevKit V1

Properties of the Board

How the Model Works

At Run our model creates Proteus's ATmega2560 model, hands it the board's pins and the HEX file, and stays between the two: every call of Proteus goes through it. When the sketch starts, the core puts a small block of data in RAM with a known signature; the model finds it and reads it every 0.2 ms of simulation time. A request in that block - join this router, open a socket, start PWM on GPIO4 - is answered in place while the sketch waits. Most things never need a request: a pin, the ADC, the UART and the timers are the AVR's own, simulated by Proteus.

The Wi-Fi network is shared by every TEP Wi-Fi part in the design. A join takes the time a real one takes - about 2 seconds to associate and get an address -, packets between boards arrive in order after a few milliseconds, and the internet host answers HTTP after a realistic delay. The panel and the monitor run in their own windows and read the model's state ten times a second, so they never slow the sketch down.

Troubleshooting

• Nothing happens at Run: the HEX was not built with TEP Boards for Proteus - a plain Arduino Mega HEX or a real ESP32 binary does not run here. Select ESP32 DevKit V1 (TEP Proteus) and export the binary again.
• Stuck at "Connecting...": the SSID or password in the sketch differ from the WIFISSID / WIFIPASS properties, or the phone's WI-FI SIGNAL is OUT OF RANGE.
• "Connection refused" on the phone: the sketch has no server.begin(), or it listens on another port.
• Two boards with the same address: they have the same part number - renumber one (U1, U2 ...).
• The ESP-01 cannot reach the ESP32: an old ESP-01 V1.1 DLL in MODELS - copy the V1.2 TEPESP01.DLL of this package next to TEPNET.DLL.
• Slow: the simulation runs below real time; use millis() instead of long delay() loops and print less.
• No monitor or no panel: click the USB port or the PANEL pad; or turn "Open the panel at Run" back on in Settings.

Things to Know Before Moving to a Real ESP32

• The board: select Espressif's "ESP32 Dev Module" - your sketch compiles unchanged.
• Memory: the real ESP32 has 520 KB of RAM - a sketch that fits in 8 KB here has room to grow there.
• ADC2 pins (D2, D4, D12, D13, D14, D15, D25, D26, D27) cannot read analog values while the Wi-Fi is on; the demo uses D34, an ADC1 pin.
• 3.3 V logic: the ESP32's pins are not 5 V tolerant - level shift signals from 5 V boards.
• Strapping pins: GPIO0, GPIO2, GPIO5, GPIO12 and GPIO15 decide the boot mode at reset - keep their pull-ups and pull-downs in mind.
• The ESP-01 needs a 3.3 V supply that can deliver 300 mA and a divider on its RXD from a 5 V UNO.

Limitations of the Simulation

• It is not a real ESP32 chip: the sketch runs on Proteus's ATmega2560 model at 16 MHz with 8 KB of RAM and 256 KB of flash; int is 16 bits.
• Not modelled: FreeRTOS tasks (xTaskCreate()), Bluetooth and BLE, ESP-IDF calls, the soft access point, real TLS (https:// reaches the internet host without encryption), OTA updates, SPIFFS / LittleFS, the ESP32's ADC details, the radio itself - the join and network times are realistic values, not a radio simulation.
• The badge, the antenna colours, the PANEL pad, the panel, its phone, the router and the internet host are TEP additions.
• TEP Boards for Proteus is based on the Arduino AVR core 1.8.6 (LGPL 2.1, the licence text is included); our libraries are MIT. The API follows Espressif's Arduino-ESP32 core - names only. This library is not made or endorsed by Espressif, Arduino or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the three demos as shipped, the web server demo 54.7 s of simulation in 112 s with the panel and the monitor open, about 0.5 x real time; the ESP32 + UNO + ESP-01 demo 30.8 s in 111 s, about 0.3 x). Proteus 7 is not supported.

So, that was all about the ESP32 DevKit V1 Library for Proteus V2.0. I hope you enjoy running your ESP32 sketches and web servers in Proteus, and that the honest list of limits saves you a surprise. If you use the ESP32 DevKit V1 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!