ESP-01S Library for Proteus: ESP8266 WiFi Module for Arduino

Hello friends, I hope you all are doing great. Today, I am going to share the ESP-01S Library for Proteus. It brings the ESP-01S to Proteus: the tiny black ESP8266 Wi-Fi module with eight pins that gives any Arduino Wi-Fi through AT commands. Your sketch sends AT+CWJAP, AT+CIPSERVER or AT+CIPSTART over a serial port, and the module joins a router, serves web pages and talks TCP and UDP with other boards, right inside the simulation. And it has the one thing that makes the ESP-01S different from its older brother: the blue LED on GPIO2, which your sketch can switch with AT commands.

This is the seventh library of our Wi-Fi series. After five ESP32 boards and the ESP8266 WiFi Shield, it is the smallest member of the family. It runs the same AT firmware model as our ESP-01 Library for Proteus and the shield, with the GPIO commands added. As always, the demos end with a project that links this module with the previous one: here the ESP-01S becomes a Wi-Fi doorbell and the WiFi Shield is the bell.

NOTICE: real ESP-01S modules differ a little between makers: the antenna shape, the flash chip and the small parts. Ours follows the common black Ai-Thinker style board with the blue LED on GPIO2. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the ESP-01S 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-01S Library for Proteus:

What is the ESP-01S?

The ESP-01S is the improved version of the famous ESP-01. Both are small boards, about 25 x 14 mm, with an ESP8266EX Wi-Fi chip, its SPI flash, a 26 MHz crystal and a meander PCB antenna, and a 2 x 4 pin header. They ship with the Espressif AT firmware, so the Arduino only writes text commands to a serial port and reads the answers - no Wi-Fi library is needed on the Arduino side.

What changed from the ESP-01 to the ESP-01S? The ESP-01S has 1 MB of flash instead of 512 kB, its board is black instead of blue, the always-on red power LED is gone, and the blue LED moved from the TX line to GPIO2. The S version also has pull-up resistors on EN (CH_PD) and RST, so you can leave those two pins open. That makes the wiring simpler: power, ground, TX and RX are enough.

The Blue LED on GPIO2

The blue LED sits between 3.3 V and GPIO2, so it lights when GPIO2 is LOW. With the stock AT firmware you can drive GPIO2 from your sketch with three commands of the AT 1.7 set: AT+SYSGPIODIR=2,1 makes it an output, AT+SYSGPIOWRITE=2,0 lights the LED and AT+SYSGPIOWRITE=2,1 turns it off. AT+SYSGPIOREAD=2 tells you the direction and the level. So the module gives the Arduino a free status light, and no Arduino pin is used for it. Our model supports these commands, and GPIO2 is a real pin of the part too: as an output it drives the pin, as an input it reads it.

AT Commands in One Minute

Every command starts with AT and ends with a carriage return and a line feed; the module answers with lines and a final OK or ERROR. A web server takes five commands: ATE0 (no echo), AT+CWMODE=1 (station), AT+CWJAP="ssid","password" (join), AT+CIPMUX=1 (several connections) and AT+CIPSERVER=1,80. A request then arrives as +IPD,0,length:GET / HTTP/1.1, and the sketch answers with AT+CIPSEND=0,length, waits for the > prompt and sends the page. A client is just as short: AT+CIPSTART="TCP","address",port, AT+CIPSEND with the data, and AT+CIPCLOSE. Our two demos use both sides, so you will see each of these commands at work.

Features of the ESP-01S Library for Proteus

• The ESP-01S module drawn as the real one from above: the black board, the ESP8266EX, the 1 MB flash, the crystal, the meander antenna and the eight labelled pins.
• A working blue LED on GPIO2: it flashes at boot and follows AT+SYSGPIOWRITE (or the pin) while the simulation runs.
• A live antenna: orange while the module sends, green while it receives.
• The AT firmware 1.7.4 of our ESP-01 model with the GPIO commands: Wi-Fi join and scan, TCP and UDP, the server, +IPD, CIPSEND, UART_CUR, SNTP, PING and more.
• EN, RST and GPIO0 work as on the real module: EN LOW disables it, RST LOW holds it in reset, GPIO0 LOW at a reset starts the flash mode.
• Wi-Fi in Proteus: a virtual router with DHCP, a phone that opens your web page, an internet host for ThingSpeak-style uploads, and TCP / UDP to every TEP Wi-Fi part in the design.
• Our pop-up panel: the phone, the module's cards, a Test page with four measuring tools, Settings and Help.
• Two demo projects with our Arduino UNO V4.0: a web page that switches the blue LED, and a Wi-Fi doorbell with the ESP8266 WiFi Shield as the bell.
• A compact package: about 2.35 MB, without the C++ source code of the models.

The ESP-01S Part in Proteus

Search ESP-01S in Pick Devices; the device is ESP-01S WIFI MODULE in TEPESP01S.LIB. The real module has a 2 x 4 header; in Proteus the eight pins sit in one row at the bottom, on the 0.1 inch grid, so the part is drawn about 1.5 times its real size next to our UNO - still a small part on the sheet. Click the PANEL pad or the ESP8266EX chip to open the panel.

Every State of the ESP-01S

We ran the blue LED demo and paused the simulation for each picture. At Run the module boots, and like the real ESP-01S its blue LED lights while the boot loader talks on GPIO2:

While data flows, the antenna shows its direction:

Download ESP-01S Library for Proteus

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

ESP-01S Library for Proteus V1.0

• README.txt: the device, installation, the two demos, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPESP01S.LIB (the ESP-01S), ArduinoV4TEP.LIB (our Arduino boards V4.0 - the UNO of the demos) and TEPESP12ESHIELD.LIB (our ESP8266 WiFi Shield, the bell of the second demo).
• Proteus Model Files: TEPNET.DLL (the ESP-01S and the Wi-Fi network) and TEPARDUINO.DLL (the Arduino boards).
• Proteus Simulation: the two demo projects, their HEX files and copies of the DLLs.
• Arduino Code: the three demo sketches. 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-01S 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 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 and the WiFi Shield).
4. Delete TEPESP01S.IDX, ArduinoV4TEP.IDX and TEPESP12ESHIELD.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for ESP-01S.

The sketches are normal UNO sketches: 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 1: A Web Page That Switches the Blue LED

Open ESP-01S-Blue-LED-Web.pdsprj. The wiring is the classic ESP-01S one: TXD to the UNO's D8, RXD from D9, 3V3 to the supply and GND to ground. EN and RST stay open, because the ESP-01S pulls them up itself. The UNO is our Arduino UNO Library for Proteus V4.0, with its built-in serial monitor at 9600 baud - D0 / D1 stay free for the monitor, and the module talks to AltSoftSerial, the software serial port with fixed pins that can receive in Proteus:

AltSoftSerial esp;                     // RX = D8 (from ESP-01S TXD), TX = D9 (to ESP-01S RXD)
SoftwareSerial espFast(12, 9);         // only sends one command at 115200 on D9 (D12 unused)

The module starts at 115200 bps, too fast for a software port to receive. So the sketch sends one command at that speed with SoftwareSerial, AT+UART_CUR=9600, and then talks at 9600 until the next reset:

bool startEsp() {
  esp.end();
  espFast.begin(115200);               // the ESP-01S'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);
  while (esp.available()) esp.read();
  lineLength = 0; ipdLeft = 0; prompt = false;
  for (byte i = 0; i < 5; ++i) if (command("AT", 500)) { Serial.println(F("ESP-01S found, now at 9600 bps")); return true; }
  Serial.println(F("No answer from the ESP-01S - check TXD -> D8, RXD <- D9 and the supply"));
  return false;
}

Why AltSoftSerial and not the usual SoftwareSerial? SoftwareSerial receives with pin-change interrupts, and those do not reach the sketch in Proteus, so it can send but never hear the answer. AltSoftSerial uses the UNO's Timer1 input capture instead, which works both in Proteus and on the bench. Its pins are fixed (RX on D8, TX on D9), and it does not like 115200 bps - hence the switch to 9600. The reset of the module brings the factory speed back, which is why the sketch checks the module every 30 seconds and runs startEsp() again when it stops answering.

Then it sets the module up: no echo, station mode, and GPIO2 an output with the LED off. The blue LED needs only one small function:

void setupModule() {
  command("ATE0");                     // no echo
  command("AT+CWMODE=1");              // station
  command("AT+SYSGPIODIR=2,1");        // GPIO2 (the blue LED) an output
  setBlue(false);

void setBlue(bool on) {
  blue = on;
  command(on ? "AT+SYSGPIOWRITE=2,0" : "AT+SYSGPIOWRITE=2,1");
}

After the join it starts a web server on port 80. Press Run and watch the UNO's monitor:

UNO + ESP-01S: the blue LED web page
www.TheEngineeringProjects.com
ESP-01S found, now at 9600 bps
Joining TEP-WiFi... connected
Web server ready: open http://192.168.1.101/
Serial monitor: BLUE ON, BLUE OFF, BLINK, STATUS, AT..., HELP

Now open the module's panel and tap OPEN ESP PAGE on its phone. The page shows the LED, three links and the pot on A0:

    snprintf_P(page, sizeof(page), PSTR("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: close\r\n\r\n"
               "<html><head><title>ESP-01S LED</title></head><body><h1>ESP-01S Blue LED</h1>"
               "<p>Blue LED (GPIO2) is <b>%s</b></p><p><a href=\"/blue/on\">BLUE ON</a> <a href=\"/blue/off\">BLUE OFF</a> "
               "<a href=\"/blink\">BLINK</a></p><p>Pot on A0: %ld.%02ld V</p><p>Uptime %lu s, page %u</p></body></html>"),
               blue ? "ON" : "OFF", mv / 1000, (mv % 1000) / 10, millis() / 1000, served + 1);

A tap on BLUE ON sends GET /blue/on. The request reaches the sketch as +IPD data; it switches the LED, then answers with the page:

    if (!strcmp(path, "/blue/on")) setBlue(true);
    if (!strcmp(path, "/blue/off")) setBlue(false);
    if (!strcmp(path, "/blink")) blink();

The serial monitor can switch the LED too. Type BLUE ON, BLUE OFF, BLINK or STATUS - and any line that starts with AT goes to the module as it is, so the monitor is also an AT terminal:

  } else if (!strcasecmp(text, "BLUE ON") || !strcasecmp(text, "BLUE OFF")) {
    setBlue(!strcasecmp(text, "BLUE ON"));
    Serial.println(blue ? F("Blue LED ON (AT+SYSGPIOWRITE=2,0)") : F("Blue LED OFF (AT+SYSGPIOWRITE=2,1)"));

Request: GET / HTTP/1.1
Request: GET /blue/on HTTP/1.1
Request: GET /blink HTTP/1.1
BLUE OFF
Blue LED OFF (AT+SYSGPIOWRITE=2,1)
BLUE ON
Blue LED ON (AT+SYSGPIOWRITE=2,0)
AT+SYSGPIOREAD=2
> AT+SYSGPIOREAD=2
  < +SYSGPIOREAD:2,1,0
  < OK
STATUS
Blue LED ON, IP 192.168.1.101, 3 pages served, A0 = 614, up 17 s

+SYSGPIOREAD:2,1,0 means GPIO2, direction 1 (an output), level 0 - LOW, so the LED is lit.

The ESP-01S Panel

The panel opens at Run, in the look of our TEP Serial Monitor Advance for Proteus. The Wi-Fi page holds the phone and three cards: ESP-01S (firmware, mode, UART, TCP, power and the blue LED), WI-FI and TRAFFIC.

The phone has two more tabs. CLOUD shows what the virtual internet host stored (this demo uploads nothing), and WI-FI shows the router with its DHCP list:

The Test page measures the running model. The web request test opened the page three times, and the Wi-Fi join test made the module leave and re-join the router three times:

The whole first demo while it runs, with the blue LED on:

Demo 2: A Wi-Fi Doorbell with the ESP8266 WiFi Shield

Now the ESP-01S meets the previous library of the series, our ESP8266 WiFi Shield Library for Proteus. In ESP-01S-and-WiFi-Shield-Doorbell.pdsprj the first UNO and the ESP-01S (U1, 192.168.1.101) are the doorbell, and the second UNO with the shield (U2, 192.168.1.102) is the bell. They talk TCP on port 333: the doorbell connects, sends RING n, and the bell rings and answers DING n.

The shield sits on its DEBUG header (DIP switch 3 on), wired to ARD2's D8 / D9, so both UNOs use AltSoftSerial and both serial monitors are free. The bell is a TCP server:

  command("AT+CIPMUX=1");              // several connections - needed for the server
  command("AT+CIPSERVER=1,333");

Why AT+CIPMUX=1 on the bell and AT+CIPMUX=0 on the doorbell? The AT firmware runs a server only in multiple-connection mode, and then every +IPD and AT+CIPSEND carries a link number - here the bell answers on the link the ring came from. A client with one connection is simpler: +IPD,length: without a link number, and AT+CIPSEND=length. The bell's address is fixed by the router of the simulation: 192.168.1.102 for U2.

The doorbell is a TCP client with one connection. Type RING in ARD1's monitor and it connects to the bell, sends the ring and waits for the answer:

  snprintf_P(at, sizeof(at), PSTR("AT+CIPSTART=\"TCP\",\"%s\",%d"), BELL_IP, BELL_PORT);
  if (!command(at, 5000)) { Serial.println(F("The bell does not answer (no TCP connection)")); return; }

  command("AT+CIPCLOSE", 2000);
  if (answerLength) {
    ++answered;
    Serial.print(F("The bell answers: "));
    Serial.println(answer);
    blinkBlue(2);
  } else Serial.println(F("No answer from the bell"));

When the answer arrives, the ESP-01S blinks its own blue LED twice - the doorbell's "heard you" light, without any extra Arduino pin:

void blinkBlue(byte times) {           // the ESP-01S's blue LED on GPIO2: LOW = on
  for (byte i = 0; i < times; ++i) { command("AT+SYSGPIOWRITE=2,0"); delay(150); command("AT+SYSGPIOWRITE=2,1"); delay(150); }
}

On the bell's side, each RING lights the UNO's LED on D13 for 2 seconds and goes back as DING on the same link:

    if (!strncmp(msg, "RING", 4)) {
      ++rings;
      digitalWrite(BELL_PIN, HIGH);
      bellOff = millis() + 2000;
      Serial.print(F("Ding-dong! "));
      Serial.print(msg);
      Serial.print(F(" on link "));
      Serial.println(msgLink);
      char text[16];
      snprintf_P(text, sizeof(text), PSTR("DING %s"), msg + 5);
      answer(msgLink, text);
      Serial.print(F("Answered "));
      Serial.println(text);

Press Run, wait until both monitors say the boards are on Wi-Fi, and type RING:

UNO + ESP-01S: Wi-Fi doorbell (TCP client)
ESP-01S found, now at 9600 bps
Joining TEP-WiFi... connected
The bell: 192.168.1.102:333
Type RING
RING
RING 1 sent to the bell
The bell answers: DING 1
RING
RING 2 sent to the bell
The bell answers: DING 2
STATUS
Rings 2, answered 2, up 9 s

UNO + ESP-12E WiFi Shield: the doorbell's bell (TCP server)
Shield found on the DEBUG header, now at 9600 bps
Joining TEP-WiFi... connected
The bell listens on TCP port 333
Ding-dong! RING 1 on link 0
Answered DING 1
Ding-dong! RING 2 on link 0
Answered DING 2

Both panels show the exchange from their side:

Our earlier projects linked boards with HTTP, raw TCP and UDP; this one is the smallest Wi-Fi link of the series - two Arduinos that only speak AT commands, one of them with the tiniest Wi-Fi module there is.

Pins of the ESP-01S

Properties of the ESP-01S

Troubleshooting

• "No answer from the ESP-01S": TXD must reach D8 and RXD D9 (AltSoftSerial's fixed pins), and 3V3 / GND the supply - the panel says NO POWER without it.
• NOT OUTPUT! after AT+SYSGPIOWRITE: send AT+SYSGPIODIR=2,1 first.
• The blue LED is on when you expect it off: it lights at LOW - AT+SYSGPIOWRITE=2,1 turns it off.
• FLASH MODE on the panel: IO0 was LOW at the last reset - leave IO0 open and reset the module.
• EN LOW on the panel: EN is wired LOW - leave it open, the module pulls it up.
• The sketch loses the module after a reset: a reset clears the server, CIPMUX and UART_CUR - set them up again, as the demo does every 30 s.
• No panel: click the PANEL pad or the ESP8266EX chip, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real ESP-01S

• It is a 3.3 V part: do not connect it to 5 V. Use a 3.3 V regulator that gives about 300 mA (the UNO's 3.3V pin is too weak for its peaks) and a divider, for example 1k / 2k, from the UNO's TX to RXD.
• The firmware: most ESP-01S modules ship with AT firmware at 115200 bps; AT+GMR tells you the version. The SYSGPIO commands belong to the AT 1.x firmware (we model 1.7.4); if your module answers ERROR to them, check its version first.
• GPIO0 and GPIO2 at boot: both must be HIGH (or open) when the module starts, or it will not run the firmware.
• Breadboards: the 2 x 4 header does not fit a breadboard - a small adapter board helps.
• Our ESP-01 sketches work unchanged; only the LED moved from TX to GPIO2.

Limitations of the Simulation

• The ESP8266 runs our model of the AT firmware 1.7.4, not your own ESP8266 firmware: flash mode only stops the AT firmware, no upload is modelled.
• Not modelled: the soft access point (CWMODE 2 / 3 are accepted, but nothing can join it), SSL connections, the 3.3 V levels, GPIO0 as an I/O pin, the radio itself - the join and network times are realistic values.
• The eight pins sit in one row (the real module has a 2 x 4 header), so the part is drawn about 1.5 times its real size.
• The antenna colours, the PANEL pad, the panel, its phone, the router and the internet host are TEP additions.
• ESP8266 and ESP-01S are names of Espressif and Ai-Thinker; this library is not made or endorsed by Espressif, Ai-Thinker, Arduino, ThingSpeak or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the two demos as shipped, the blue LED demo 24.0 s of simulation in 46 s, about 0.5 x real time; the doorbell with its two UNOs 7.5 s in 31 s, about 0.25 x). Proteus 7 is not supported.

So, that was all about the ESP-01S Library for Proteus. I hope it helps you learn AT commands and build small Wi-Fi projects with the Arduino before you solder the first wire. Our series started with the ESP32 DevKit V1 Library for Proteus V2.0 - try linking the ESP-01S with any of our ESP32 boards too. If you use the ESP-01S 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!