ESP-07S Library for Proteus: Shielded ESP8266 Wi-Fi Module

Hello friends, I hope you all are doing great. Today, I am going to share the ESP-07S Library for Proteus. The ESP-07S is the shielded little brother of the ESP-07: a metal shield covers almost the whole board, there is no ceramic antenna at all, and the only way to the air is a u.FL socket for an external antenna. With this library you can place it in Proteus, wire it to an Arduino, send it AT commands and watch it join the Wi-Fi, serve a web page, switch an LED on its own GPIO pin and talk TCP with other devices - all inside the simulation.

This is the tenth library of our Wi-Fi series, and the first one tested with our two new network tools, the Laptop WiFi Monitor and the Mobile WiFi Monitor. Instead of a second Arduino with another module, the demo puts a laptop and a phone on the same Wi-Fi network as the ESP-07S: the laptop collects its reports, both open its web page and switch its LED, both send it commands from a TCP terminal, and the laptop pings it. That is how you test a real Wi-Fi module on your desk, and now you can do the same in Proteus.

NOTICE: real ESP-07S modules differ between makers and batches: many have no LED at all, and none of them works without an antenna on the u.FL socket. Check your module before you wire it. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the ESP-07S board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the ESP-07S Library for Proteus:

What is the ESP-07S?

The ESP-07S is one of the Ai-Thinker modules built around the ESP8266 Wi-Fi chip. It has the same 16 pins as the ESP-07, eight on each long side, and it ships with the same AT firmware, so an Arduino uses it through a serial port with commands such as AT+CWJAP and AT+CIPSEND. What changes is the radio side: the shield covers the chip, the flash and the crystal together, the board is shorter (about 16 x 17 mm), and the antenna is always an external one on the u.FL socket.

ESP-07 or ESP-07S?

Last time we shared the ESP-07 Library for Proteus. The two modules look alike and share the pinout, so a circuit and a sketch made for one work with the other. The ESP-07 carries a small ceramic antenna and a u.FL socket, and a tiny 0-ohm resistor decides which one is connected - our ESP-07 part has a clickable jumper for it. The ESP-07S drops the ceramic antenna and the jumper: its u.FL socket is always the antenna. So our ESP-07S part has no antenna jumper and no ANTENNA property, and its RSSI is always the strong one of an external antenna: about -38 dBm with a GOOD signal, where the ceramic antenna of the ESP-07 reads about -46 dBm.

The Boot Pins of a Bare ESP8266 Module

Like the ESP-07, the ESP-07S brings out the pins that decide whether the chip starts at all. EN (also called CH_PD) must be pulled up, or the chip stays off. RST resets it when it goes low. GPIO15 must be low when the chip starts - pulled down with a resistor - or the ESP8266 tries to boot from an SD card and the AT firmware never runs. GPIO0 low at boot selects the flash mode for loading new firmware. Our model checks all four at every boot and the panel shows them, so a missing resistor in Proteus looks the same as on the bench: no answer from the module.

GPIO Pins Through AT Commands

The AT firmware can also use the free pins of the ESP8266. AT+SYSGPIODIR=4,1 makes GPIO4 an output, AT+SYSGPIOWRITE=4,1 sets it high and AT+SYSGPIOREAD=4 reads a pin back. So the Arduino can switch an LED or a relay that hangs on the ESP-07S itself, without spending one of its own pins. Our demo does exactly that: the LED sits on the ESP-07S's GPIO4, and the laptop and the phone switch it over Wi-Fi.

Features of the ESP-07S Library for Proteus

• The ESP-07S as it looks: the black board with the big metal shield, the u.FL socket, the two LEDs and the 16 gold pins.
• The external antenna, always: the u.FL socket adds 7 dB to every signal, so the RSSI is strong and a weak signal still works.
• Real boot pins: EN low switches the module off, RST low resets it, GPIO15 must be low at boot and GPIO0 low selects the flash mode - the panel shows the state of each.
• Six GPIO pins (GPIO4, 5, 12, 13, 14 and 16) that the Arduino drives or reads with AT+SYSGPIO commands.
• Live LEDs and antenna: the red PWR LED, the blue IO2 LED, and the u.FL socket turns orange while the module sends and green while it receives.
• The AT firmware 1.7.4 of our ESP-01 Library for Proteus: Wi-Fi join and scan, TCP and UDP, the server, +IPD, CIPSEND, UART_CUR, SNTP, PING and more.
• Wi-Fi in Proteus: a virtual router with DHCP and two neighbours for scans, a phone in the panel that opens your web page, an internet host, and TCP / UDP to every TEP Wi-Fi part in the design.
• Our Laptop and Mobile WiFi Monitors: a laptop and a phone on the same network, with a browser, TCP and UDP terminals and ping - included in the package.
• Our pop-up panel: the phone, the module card with the antenna and the boot pins, a Test page with four measuring tools, Settings and Help.
• A compact package: about 2.54 MB, without the C++ source code of the models.

The ESP-07S Part in Proteus

Search ESP-07S in Pick Devices; the device ESP-07S WIFI MODULE is in TEPESP07S.LIB. The pins sit on both sides as on the real module: RST, ADC, EN, IO16, IO14, IO12, IO13, VCC on the left and TXD, RXD, IO5, IO4, IO0, IO2, IO15, GND on the right. Its pins sit on the 0.1 inch grid of Proteus while the real module uses a 2 mm pitch, so the part is drawn a little bigger than the real one; next to our UNO it is still small. Click the PANEL pad or the shield to open the panel.

Every State of the ESP-07S

We ran the demo and paused the simulation for each picture. At Run the ESP-07S powers up and prints its boot text; the blue IO2 LED flashes during the boot, as on the ESP-07:

While data flows, the u.FL socket shows the direction:

Download ESP-07S Library for Proteus

Click the button below to download ESP-07S-Library-for-Proteus-v1.0.zip (about 2.54 MB, without the C++ source code of the models):

• README.txt: the device, installation, the demo, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPESP07S.LIB (the ESP-07S), ArduinoV4TEP.LIB (our Arduino boards V4.0 - the UNO of the demo), TEPLAPTOP.LIB and TEPMOBILE.LIB (our Laptop and Mobile WiFi Monitors).
• Proteus Model Files: TEPNET.DLL (the ESP-07S, the two monitors and the Wi-Fi network) and TEPARDUINO.DLL (the Arduino boards).
• Proteus Simulation: the demo project, its HEX file and copies of the DLLs.
• Arduino Code: the demo sketch. AltSoftSerial is not included - install it from 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 ESP-07S Library for Proteus

1. Close Proteus and extract the whole zip file, for example to your Desktop.
2. Copy the four 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 and TEPARDUINO.DLL from Proteus Model Files into the MODELS folder - replace older copies (the new TEPNET.DLL still runs all our ESP32 boards, the ESP-01, the ESP-01S, the WiFi Shield, the ESP-01 adapter, the ESP-07 and the two monitors).
4. Delete TEPESP07S.IDX, ArduinoV4TEP.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for ESP-07S.

The sketch is a normal UNO sketch: select Arduino Uno in the Arduino IDE, install AltSoftSerial, write your sketch and use Sketch > Export Compiled Binary; then double-click the UNO in Proteus and set its Program File to the HEX (see How to get the HEX file from Arduino).

Demo: The ESP-07S with the Laptop and Mobile WiFi Monitors

Open ESP-07S-with-Laptop-and-Mobile.pdsprj. On the left is our Arduino UNO Library for Proteus V4.0 (ARD1) with its built-in serial monitor, in the middle the ESP-07S (U1) with its resistors and the LED, and on the right the laptop (PC1) and the phone (MOB1). The laptop and the phone have no wires at all - like the real ones, they are simply on the TEP-WiFi network.

The ESP-07S needs a little more than four wires: VCC to +3.3V and GND to ground, R1 (10k) pulls EN up, R2 (10k) pulls GPIO15 down, and the module's TXD goes to the UNO's D8 and its RXD comes from D9 through the labels ESP_TXD and ESP_RXD. The LED with R3 hangs on GPIO4 of the ESP-07S - not on the UNO:

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. In this project their properties are already set for the ESP-07S: the laptop runs a TCP server on port 5000 for the reports, and both have the ESP-07S's address (http://192.168.1.101/, port 80) as the home page of their browser and the host of their terminal. The laptop is 192.168.1.21 and the phone 192.168.1.41 on the network:

The Sketch: a Web Page, a Command Port and Reports

The UNO talks to the module with AltSoftSerial on D8 / D9. The ESP-07S starts at 115200 bps, too fast for a software serial port to receive, so the sketch sends one AT+UART_CUR=9600 at that speed and then talks at 9600 - the same trick as in our ESP-01 demos:

  espFast.begin(115200);               // the ESP-07S's factory speed
  espFast.print(F("AT+UART_CUR=9600,8,1,0,0\r\n"));
  espFast.end();
  esp.begin(9600);                     // AltSoftSerial takes D9 over
  delay(50);

Then it makes GPIO4 an output, joins TEP-WiFi and starts the server. AT+CIPMUX=1 allows several connections at once - one for the laptop's terminal, one for the phone's, and one for the reports - and AT+CIPSTO=0 tells the firmware never to close an idle terminal:

  command("AT+CIPMUX=1");              // several connections - needed for the server and the reports
  command("AT+CIPSERVER=1,80");
  command("AT+CIPSTO=0");              // a terminal may stay connected

Switching the LED is one AT command. The sketch remembers the state, so the page, the terminal and the reports can show it:

void setLed(bool on) {
  led = on;
  command(on ? "AT+SYSGPIOWRITE=4,1" : "AT+SYSGPIOWRITE=4,0");
}

Every request arrives as +IPD,<link>,<length>: followed by the data. The number after +IPD is the link, and every answer must go back on the same link, so the sketch keeps it:

    if (c == ':' && !strncmp(line, "+IPD,", 5)) {     // "+IPD,<link>,<length>:" then the data
      line[lineLength] = '\0';
      newLink = atoi(line + 5);
      const char* comma = strchr(line + 5, ',');
      ipdLeft = comma ? atoi(comma + 1) : 0;
      requestLength = 0; requestDone = false; lineLength = 0;
    }

One port serves two kinds of clients. When the data starts with GET, it comes from a browser: the path decides what happens to the LED, and the page goes back with the new state. Anything else is a line from a TCP terminal, answered by one line:

void answerCommand(int link, const char* text) {
  if (!strcasecmp(text, "LED ON") || !strcasecmp(text, "ON")) setLed(true);
  else if (!strcasecmp(text, "LED OFF") || !strcasecmp(text, "OFF")) setLed(false);
  if (!strcasecmp(text, "RSSI")) readRssi();
  if (!strcasecmp(text, "STATUS") || !strcasecmp(text, "RSSI") || !strcasecmp(text, "LED ON") || !strcasecmp(text, "LED OFF") ||
      !strcasecmp(text, "ON") || !strcasecmp(text, "OFF")) {
    snprintf_P(page, sizeof(page), PSTR("ESP-07S: LED %s, RSSI %d dBm, %u page%s, %u report%s, up %lu s\r\n"),
               led ? "ON" : "OFF", rssi, served, served == 1 ? "" : "s", sentReports, sentReports == 1 ? "" : "s", millis() / 1000);
  } else if (!strcasecmp(text, "HELP")) {
    strcpy_P(page, PSTR("ESP-07S commands: STATUS, LED ON, LED OFF, RSSI, HELP\r\n"));
  } else {
    snprintf_P(page, sizeof(page), PSTR("Unknown: %s - type HELP\r\n"), text);
  }
  if (sendOn(link, page, false)) ++answered;
}

A page is closed after it is sent, as a browser expects; a terminal's link stays open for the next command. Both go out through the same small function:

bool sendOn(int link, const char* text, bool close) {
  esp.print(F("AT+CIPSEND="));
  esp.print(link);
  esp.print(',');
  esp.print(strlen(text));
  esp.print(F("\r\n"));
  bool sent = waitFor(">", 2000);
  if (sent) { esp.print(text); sent = waitFor("SEND OK", 5000); }
  if (close) {
    esp.print(F("AT+CIPCLOSE="));
    esp.print(link);
    esp.print(F("\r\n"));
    waitFor("OK", 2000);
  }
  return sent;
}

And every 10 seconds the ESP-07S becomes a client itself: it opens link 4 to the laptop's server at 192.168.1.21:5000, sends one report line and closes it. If the laptop's server is not running, it says so once and tries again later:

void sendReport() {
  char open[64];
  snprintf_P(open, sizeof(open), PSTR("AT+CIPSTART=%d,\"TCP\",\"%s\",%d"), REPORT_LINK, LAPTOP_IP, LAPTOP_PORT);
  if (!command(open, 5000)) {
    if (laptopSeen) { Serial.println(F("Laptop not reachable (its TCP server on port 5000) - reports wait")); laptopSeen = false; }
    return;
  }
  laptopSeen = true;
  snprintf_P(page, sizeof(page), PSTR("ESP-07S report %u: LED %s, RSSI %d dBm, %u page%s, up %lu s\r\n"),
             sentReports + 1, led ? "ON" : "OFF", rssi, served, served == 1 ? "" : "s", millis() / 1000);
  if (sendOn(REPORT_LINK, page, true)) {
    ++sentReports;
    Serial.print(F("Report to the laptop: "));
    Serial.print(page);
  }
}

Press Run and watch the UNO's monitor. The module is found, joins TEP-WiFi, reports the signal of its external antenna and starts the server:

UNO + ESP-07S: a Wi-Fi node for the Laptop and Mobile WiFi Monitors
www.TheEngineeringProjects.com
ESP-07S found, now at 9600 bps
Joining TEP-WiFi... connected
Signal: RSSI -38 dBm (u.FL antenna)
Ready: open http://192.168.1.101/ on the laptop or the phone
Serial monitor: ON, OFF, RSSI, SCAN, STATUS, REPORTS, AT..., HELP

Talking to the ESP-07S from the Laptop

The Laptop WiFi Monitor opens at Run, joins TEP-WiFi in about 2.4 seconds and starts its TCP server on port 5000. Its Terminal tab, TCP Server mode, shows every report: the ESP-07S connects, sends one line and closes the connection, every 10 seconds:

Now the Browser tab. The ESP-07S is listed as a device, and its address is the home page, so one click opens the page of the sketch:

Click ON. The browser asks for /on, the UNO sends AT+SYSGPIOWRITE=4,1 to the ESP-07S, and the LED in the circuit lights before the page comes back:

View source shows what really travelled over the network - the HTTP header and the HTML the UNO built with snprintf:

The TCP Terminal on Port 80

A web page is fine for people; for another program a short command and a one-line answer is easier. In Terminal, choose TCP Client: the host 192.168.1.101 and port 80 are already filled in.

Click Connect and type STATUS, LED OFF and RSSI. Each line gets one answer, and the connection stays open. The reports keep arriving on the server side in between - the ESP-07S handles both at once:

STATUS
ESP-07S: LED ON, RSSI -40 dBm, 2 pages, 2 reports, up 32 s
LED OFF
ESP-07S: LED OFF, RSSI -40 dBm, 2 pages, 3 reports, up 34 s
RSSI
ESP-07S: LED OFF, RSSI -39 dBm, 2 pages, 3 reports, up 35 s

The Network tab lists every device on TEP-WiFi with its address - the laptop, the phone, the ESP-07S and the phone of the ESP-07S's own panel. Click Ping on the ESP-07S's row:

Pinging 192.168.1.101:
Reply from 192.168.1.101: bytes=32 time=14ms TTL=255
Reply from 192.168.1.101: bytes=32 time=9ms TTL=255
Reply from 192.168.1.101: bytes=32 time=9ms TTL=255
Reply from 192.168.1.101: bytes=32 time=15ms TTL=255
Packets: sent = 4, received = 4, lost = 0 (0% loss)

Back on the server side, the reports now carry the changes we made: the LED ON from the browser, the LED OFF from the terminal and the pages served to both tools:

Talking to the ESP-07S from the Phone

The Mobile WiFi Monitor is a phone on the same network, 192.168.1.41. Its Browser app opens the same page, with the links drawn as big buttons for a finger:

Its Terminal app is a TCP client too. Connect to 192.168.1.101 port 80 and send the same commands:

The Devices app shows the same network as the laptop, and the Wi-Fi app the router and the two neighbour networks:

The UNO's monitor logs everything from its side: the reports it sent, each page with its path, and each command with the link it came on - link 0 is the laptop's terminal, link 1 the phone's:

Report to the laptop: ESP-07S report 1: LED OFF, RSSI -38 dBm, 0 pages, up 13 s
Report to the laptop: ESP-07S report 2: LED OFF, RSSI -38 dBm, 0 pages, up 23 s
Page: GET / HTTP/1.1
Page: GET /on HTTP/1.1
Command on link 0: STATUS
Report to the laptop: ESP-07S report 3: LED ON, RSSI -40 dBm, 2 pages, up 33 s
Command on link 0: LED OFF
Command on link 0: RSSI
Page: GET / HTTP/1.1
Page: GET /on HTTP/1.1
Command on link 1: STATUS
Command on link 1: LED OFF
Report to the laptop: ESP-07S report 4: LED OFF, RSSI -39 dBm, 4 pages, up 43 s

And the whole demo running, with the LED on - switched over Wi-Fi, without a wire between the tools and the circuit:

The ESP-07S Panel

The panel opens at Run, in the look of our TEP Serial Monitor Advance for Proteus. Its Wi-Fi page has a small phone of its own and three cards: the ESP-07S card with the firmware, the mode, the UART speed, the antenna and the boot pins, the WI-FI card and the TRAFFIC card:

Tap OPEN ESP PAGE and the panel's phone asks the sketch for its page too - a quick check without the monitors. Tap a link on the page to send it:

The monitor is a small Wi-Fi tool too. Type ON or OFF for the LED, RSSI for the signal, SCAN for the networks in range, STATUS for a summary and REPORTS to stop or start the reports; any line starting with AT goes to the module as it is. Here STATUS was typed while the scan was still running, so its answer comes after the list:

RSSI
Signal: RSSI -39 dBm
SCAN
Scanning (AT+CWLAP)...
STATUS
  TEP-WiFi  -40 dBm
  Neighbour_WiFi  -72 dBm
  Guest_Network  -81 dBm
3 network(s) in range
LED ON, IP 192.168.1.101, RSSI -39 dBm, 2 pages, 0 commands, 0 reports, up 10 s

WEAK moves the router far away. With its external antenna the ESP-07S still reads -75 dBm and stays connected:

OUT OF RANGE takes the router away completely; the module loses its IP address and the reports wait until GOOD brings the router back and the module joins again:

The Test page has four tools that measure the running model: the Wi-Fi join test (the module really leaves and re-joins the router), the web request test, the cloud upload check and the AT check. Then Settings and Help:

One more thing the sketch does: every 30 seconds it checks that the module still answers at 9600. A reset puts the ESP-07S back to 115200 bps without its server, so the sketch finds it again and repeats the set-up:

  if (millis() - lastCheck > CHECK_EVERY) {
    if (!command("AT", 1000) && !command("AT", 1000)) {
      Serial.println(F("The ESP-07S restarted - setting it up again"));
      if (startEsp()) setupModule();
    }
    lastCheck = millis();
  }

Pins of the ESP-07S

Properties of the ESP-07S

The IP address follows the part's number: U1 gets 192.168.1.101, U2 .102 and so on, so give every Wi-Fi part its own number. The laptop is always 192.168.1.21 and the phone 192.168.1.41.

Troubleshooting

• "No answer from the ESP-07S": TXD must reach D8 and RXD D9 (AltSoftSerial's fixed pins), VCC 3.3 V and GND the supply - the panel says NO POWER without it, and "EN low - disabled" when EN is low.
• The panel says "SDIO boot (GPIO15 not low)": GPIO15 needs its pull-down; without it the AT firmware does not start. "flash mode (GPIO0 low)" means GPIO0 was low at boot.
• AT+SYSGPIOWRITE answers NOT OUTPUT!: send AT+SYSGPIODIR=4,1 first - the pins start as inputs.
• "Laptop not reachable" in the UNO's monitor: the laptop must be on Wi-Fi with its TCP server running (Terminal, TCP Server, port 5000); the sketch tries again every 10 seconds.
• The laptop or the phone shows no page: wait for "Ready: open http://192.168.1.101/" in the UNO's monitor - the module joins in about 4 seconds of simulation.
• No panel: click the PANEL pad or the shield, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real ESP-07S

• The antenna first: the ESP-07S has no antenna of its own. Plug an antenna into the u.FL socket before you power it, and never let it send without one.
• Power: the ESP-07S draws up to about 300 mA while it sends. Use a 3.3 V regulator that can deliver that - not the UNO's 3.3V pin.
• Levels: the ESP-07S is a 3.3 V part. Put a divider (for example 1k / 2k) between a 5 V Arduino's TX and the module's RXD; the module's TXD can go straight to the Arduino.
• The 2 mm pitch: the pins do not fit a breadboard. Solder the module to an adapter plate - many of them already carry the EN, RST and GPIO15 resistors.
• Boot resistors: on a bare module pull EN, RST, GPIO0 and GPIO2 up with 10k and GPIO15 down with 10k.
• The firmware: most ESP-07S modules ship with the AT firmware at 115200 bps; AT+GMR tells you the version, and the GPIO commands depend on it.

Limitations of the Simulation

• The ESP8266 runs our model of the AT firmware 1.7.4, not your own ESP8266 firmware; GPIO0 low gives the flash mode, but nothing can be flashed.
• In Proteus an open EN or a 10k pull-up to a 3.3 V terminal both count as on - only a low switches the module off. GPIO15 must really be low.
• Not modelled: the ADC pin, the soft access point (CWMODE 2 / 3 are accepted, but nothing can join it), SSL connections, the supply's voltage and current, a missing antenna, the radio itself - the join and network times and the +7 dB of the external antenna are realistic values, not a radio simulation.
• The LEDs, the antenna colours, the PANEL pad, the panel, its phone, the router, the two neighbour networks, the internet host and the two monitors are TEP additions.
• ESP8266 and ESP-07S are names of Espressif and Ai-Thinker; this library is not made or endorsed by Espressif, Ai-Thinker, Arduino or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the demo as shipped, the UNO, the ESP-07S, the laptop and the phone together at about 0.35 x real time on our PC). Proteus 7 is not supported.

So, that was all about the ESP-07S Library for Proteus. I hope it helps you try the ESP-07S with its external antenna in Proteus before you solder the real one - and test it the way you would on your desk, from a laptop and a phone. Our series started with the ESP32 DevKit V1 Library for Proteus V2.0; the Laptop and Mobile WiFi Monitors talk to every one of our Wi-Fi boards and modules, so try them with the others too. If you use the ESP-07S 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!