ESP-12F Library for Proteus: ESP8266 Wi-Fi Module, Chat Hub Demo

Hello friends, I hope you all are doing great. Today, I am going to share the ESP-12F Library for Proteus. The ESP-12F is the successor of the famous ESP-12E: the same ESP8266 module with the same 22 pins and the same AT firmware, but with a reworked PCB antenna for a better signal. 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, switch its own blue LED and run a TCP server that several clients use at the same time - all inside the simulation.

This is the twelfth library of our Wi-Fi series, and its demo is a small Wi-Fi chat hub. Our Laptop WiFi Monitor and Mobile WiFi Monitor both connect to the ESP-12F at once; every line one of them types reaches the other, the Arduino's serial monitor joins in, and commands switch the LED and read a pot. Our ESP-07S demo answered one TCP request at a time and our ESP-12E demo broadcast UDP datagrams; this one keeps several TCP connections open together and passes messages between them, the way chat servers, multiplayer games and remote consoles work.

NOTICE: real ESP-12F modules differ between makers: the antenna trace, the shield marking and the flash size vary, the red power LED of our part is a TEP addition, and the +2 dB of the reworked antenna is our model's value, not a measurement. 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-12F 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-12F Library for Proteus:

What is the ESP-12F?

The ESP-12F is one of the Ai-Thinker modules built around the ESP8266 Wi-Fi chip. A metal shield covers the chip, its flash and the crystal, and the antenna is a copper trace on the board itself. It ships with the AT firmware, so an Arduino uses it through a serial port with commands such as AT+CWJAP and AT+CIPSEND. It replaced the ESP-12E in most shops and on many NodeMCU boards: the board, the pins and the firmware stay the same, the antenna layout was reworked.

ESP-12E or ESP-12F?

Last time we shared the ESP-12E Library for Proteus. The two modules have the same size, the same 22 pins in the same places and the same AT firmware, so a circuit and a sketch made for one work with the other. The difference is the antenna: the ESP-12F's trace was redesigned for a better signal. In Proteus our two parts show it the same way - a different trace on the board and, in the model, 2 dB more signal for the ESP-12F: about -43 dBm where the ESP-12E reads about -45 dBm.

The Boot Pins and the Flash Pins

A bare ESP-12F needs a few resistors. 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. Our model checks all four at every boot and the panel shows them. The six pads on the bottom edge - CS0, MISO, GPIO9, GPIO10, MOSI and SCLK - are the lines of the module's own flash: leave them unconnected.

The Blue LED on GPIO2

The ESP-12F has one LED of its own: a small blue one on GPIO2, lit when the pin is low. With the AT firmware your Arduino uses it as a status light: AT+SYSGPIODIR=2,1 makes GPIO2 an output, AT+SYSGPIOWRITE=2,0 lights the LED and AT+SYSGPIOWRITE=2,1 puts it out. In the demo any chat member can switch it with /led on.

Features of the ESP-12F Library for Proteus

• The ESP-12F as it looks: the black board with its reworked antenna, the metal shield, the LEDs and all 22 gold pads, including the six flash pins on the bottom edge.
• A live antenna: the trace turns orange while the module sends and green while it receives.
• 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.
• The blue LED on GPIO2, as on the real module, and six more GPIO pins (GPIO4, 5, 12, 13, 14 and 16) for AT+SYSGPIO.
• The AT firmware 1.7.4 of our ESP-01 Library for Proteus: Wi-Fi join and scan, TCP and UDP, a server with up to five links at once, CIPSTATUS with the address of every link, 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-12F Part in Proteus

Search ESP-12F in Pick Devices; the device ESP-12F WIFI MODULE is in TEPESP12F.LIB. The pins sit where they are on the real module: RST, ADC, EN, IO16, IO14, IO12, IO13, VCC on the left, TXD, RXD, IO5, IO4, IO0, IO2, IO15, GND on the right, and CS0, MISO, IO9, IO10, MOSI, SCLK along the bottom. 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-12F

We ran the demo and paused the simulation for each picture. At Run the ESP-12F powers up and prints its boot text; the blue LED flashes during the boot:

While data flows, the antenna shows the direction:

Download ESP-12F Library for Proteus

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

ESP-12F Library for Proteus V1.0

• README.txt: the device, installation, the demo, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPESP12F.LIB (the ESP-12F), 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-12F, 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-12F 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 (this TEPNET.DLL is the first one that knows the ESP-12F, and it still runs all our ESP32 boards, ESP-01, ESP-01S, WiFi Shield, ESP-01 adapter, ESP-07, ESP-07S, ESP-12E and the two monitors).
4. Delete TEPESP12F.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-12F.

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: A Wi-Fi Chat Hub for the Laptop and the Phone

Open ESP-12F-Chat-Hub-with-Laptop-and-Mobile.pdsprj. On the left is our Arduino UNO Library for Proteus V4.0 (ARD1) with its built-in serial monitor and a pot on A0, in the middle the ESP-12F (U1) with its two resistors, and on the right the laptop (PC1) and the phone (MOB1) - no wires to them, they are on the TEP-WiFi network like the real ones.

The ESP-12F needs VCC on +3.3V and GND, R1 (10k) to pull EN up and R2 (10k) to pull GPIO15 down. Its TXD goes to the UNO's D8 and its RXD comes from D9 through the labels ESP_TXD and ESP_RXD. The LED is the blue one on the module, and RV1 (10k, at 35 %) on A0 gives a reading for the /pot command:

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. In this project their terminals are set to the hub (192.168.1.101, port 23) and their browsers to http://192.168.1.101:23/. The laptop is 192.168.1.21 and the phone 192.168.1.41 on the network:

One Server, Several Clients

The AT firmware's server can keep up to five links open at the same time, numbered 0 to 4. When a client connects, the firmware prints 0,CONNECT (with its link number); when it leaves, 0,CLOSED; and its data arrives as +IPD,0,<length>:. A hub only has to remember who is on which link, and to send each line to every link except the one it came from. Port 23 is the classic Telnet port, the usual home of text chat.

The firmware has only one server port, so the hub also answers browsers on port 23: a connection whose first line starts with GET is a browser and gets a small status page; any other connection that stays quiet for a second joins the chat.

The Sketch: The Chat Hub

The UNO talks to the module with AltSoftSerial on D8 / D9. The ESP-12F 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:

  espFast.begin(115200);               // the ESP-12F'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);

After the join, three commands start the hub: several connections, the server on port 23, and no timeout, because a chat client may stay quiet for a long time:

  command("AT+CIPMUX=1");              // several connections - one per client
  command("AT+CIPSERVER=1,23");        // the hub
  command("AT+CIPSTO=0");              // a quiet client stays connected

The connection events are short lines. The reader turns them into two small bit masks - one bit per link - so the main loop can handle them even when they arrived in the middle of another command:

      const char* comma = strchr(line, ',');
      if (line[0] >= '0' && line[0] <= '4' && comma == line + 1) {
        if (!strcmp(comma + 1, "CONNECT")) { connected |= 1 << (line[0] - '0'); continue; }
        if (!strcmp(comma + 1, "CLOSED")) { closed |= 1 << (line[0] - '0'); continue; }
      }

Who is on a link? AT+CIPSTATUS lists every open link with its address, so the hub asks it when a client joins:

void onStatus(const char* s) {
  if (strncmp(s, "+CIPSTATUS:", 11)) return;
  const byte link = atoi(s + 11);
  const char* q1 = strchr(s, '"'); if (!q1) return;
  q1 = strchr(q1 + 1, '"'); if (!q1) return;             // after "TCP"
  q1 = strchr(q1 + 1, '"'); if (!q1) return;             // the opening quote of the address
  const char* q2 = strchr(q1 + 1, '"'); if (!q2 || link >= LINKS) return;
  byte n = q2 - q1 - 1; if (n > 15) n = 15;
  memcpy(cip[link], q1 + 1, n); cip[link][n] = '\0';
}

Then the new member gets a welcome, and the others a notice:

void join(byte link) {
  command("AT+CIPSTATUS", 2000, onStatus);
  state[link] = MEMBER;
  snprintf_P(page, sizeof(page), PSTR("Welcome to the ESP-12F chat hub, %s - %d online. Type /help\r\n"), cip[link], online());
  sendOn(link, page, false);
  snprintf_P(page, sizeof(page), PSTR("* %s joined (%d online)\r\n"), cip[link], online());
  toMembers(link);
  Serial.print(page + 2);
}

A chat line goes to every member except its sender, marked with the sender's address:

void toMembers(int skip) {
  for (byte i = 0; i < LINKS; ++i) if (state[i] == MEMBER && i != skip) sendOn(i, page, false);
}

void fromClient(byte link, const char* text) {
  if (text[0] != '/') {
    snprintf_P(page, sizeof(page), PSTR("[%s] %s\r\n"), cip[link], text);
    toMembers(link);
    ++relayed;
    Serial.print(cip[link]);
    Serial.print(F(": "));
    Serial.println(text);
    return;
  }

Lines that start with / are commands. /led on and /led off switch the blue LED and tell everyone who did it; /who, /pot and /help are answered to the sender only:

  if (!strcasecmp(text, "/led on") || !strcasecmp(text, "/led off")) {
    setLed(!strcasecmp(text, "/led on"));
    snprintf_P(page, sizeof(page), PSTR("* %s switched the blue LED %s\r\n"), cip[link], led ? "ON" : "OFF");
    toMembers(-1);
    return;
  }

Two clients can type at the same moment, and the hub may be busy sending. So every complete line goes into a small queue first, and the main loop takes them out one by one:

      if (ipdLeft == 0 && queuedCount < QUEUE) {                 // the data is complete: into the queue
        request[requestLength] = '\0';
        strcpy(queued[queuedCount], request); queuedLink[queuedCount] = newLink; ++queuedCount;
      }

Finally the browser check: the first line of a new connection decides whether it is a page request or a chat client:

    if (link < LINKS && !strncmp(text, "GET ", 4) && state[link] != MEMBER) {   // a browser: the path is the text after "GET "
      char path[32] = "/";
      strncpy(path, text + 4, sizeof(path) - 1); path[sizeof(path) - 1] = '\0';
      char* e = strchr(path, ' '); if (e) *e = '\0';
      state[link] = FREE;
      Serial.print(F("Page: "));
      Serial.println(text);
      readRssi();
      sendPage(link, path);

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

UNO + ESP-12F: a Wi-Fi chat hub for the Laptop and Mobile WiFi Monitors
www.TheEngineeringProjects.com
ESP-12F found, now at 9600 bps
Joining TEP-WiFi... connected
Signal: RSSI -43 dBm (PCB antenna)
Chat hub ready: telnet 192.168.1.101 23 (up to 4 clients)
Monitor: a line goes to every client; /who, /led on, /led off, /pot, /status, /help, AT...

Joining the Chat from the Laptop and the Phone

On the laptop, open Terminal and choose TCP Client: the host 192.168.1.101 and port 23 are already filled in. Click Connect; a second later the hub greets the laptop:

Now the phone: its Terminal app, TCP, the same address and port, Connect. The phone gets its own welcome, and the laptop is told that the phone joined:

Type a line on the laptop and it appears on the phone with the laptop's address; the phone answers, the laptop sends /who, the phone sends /led on - the blue LED on the module lights and both are told - and the laptop asks /pot. Finally a line typed in the UNO's monitor reaches both as [UNO]:

Welcome to the ESP-12F chat hub, 192.168.1.21 - 1 online. Type /help
Hello from the laptop
* 192.168.1.41 joined (2 online)
[192.168.1.41] Hi laptop, the phone here
/who
Online (2): 192.168.1.21, 192.168.1.41
* 192.168.1.41 switched the blue LED ON
/pot
Pot (A0): 358 (1.75 V)
[UNO] Hello from the UNO

Welcome to the ESP-12F chat hub, 192.168.1.41 - 2 online. Type /help
[192.168.1.21] Hello from the laptop
Hi laptop, the phone here
/led on
* 192.168.1.41 switched the blue LED ON
[UNO] Hello from the UNO

The UNO's monitor sees everything: who joined, each chat line with its sender, and each command:

192.168.1.21 joined (1 online)
192.168.1.41 joined (2 online)
192.168.1.21: Hello from the laptop
192.168.1.41: Hi laptop, the phone here
192.168.1.21 sent /who
192.168.1.41 sent /led on
192.168.1.21 sent /pot
Hello from the UNO
UNO: Hello from the UNO

The Status Page on the Same Port

In the laptop's Browser the address bar already holds the home page http://192.168.1.101:23/ - click Go. The hub sees a GET and answers with its status page instead of a welcome:

Its OFF link switches the LED off - the same LED the chat switched on:

The laptop's Network tab can still ping the module while it serves the chat:

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

Leaving the Chat

Click Disconnect on the phone. The firmware reports the phone's link as CLOSED, the hub frees it and tells the others:

And the whole demo running, with the blue LED on:

The ESP-12F 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-12F card with the firmware, the mode, the UART speed, the antenna and the boot pins, the WI-FI card and the TRAFFIC card:

In this project the ESP-12F's PAGEPORT property is 23, so OPEN ESP PAGE asks the hub for its page on port 23:

The UNO's monitor is part of the chat and a small tool at once: a plain line goes to every client, /who, /led on, /pot and /status work locally, and any line starting with AT goes to the module as it is - here AT+CWLAP shows the raw scan:

/pot
Pot (A0): 358 (1.75 V)
/who
Online (0): nobody
AT+CWLAP
> AT+CWLAP
  < +CWLAP:(3,"TEP-WiFi",-44,"c8:3a:35:a4:26:89",6,-12,0)
  < +CWLAP:(3,"Neighbour_WiFi",-77,"c8:3a:35:d8:03:3c",1,-12,0)
  < +CWLAP:(0,"Guest_Network",-86,"c8:3a:35:1a:40:10",11,-12,0)
  < OK
/status
LED ON, pot 358 (1.75 V), RSSI -45 dBm; 0 online, 0 relayed, 2 pages; up 11 s

WEAK moves the router far away; the reworked antenna still holds the link:

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

The Test page has four tools that measure the running model: the Wi-Fi join test, 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-12F 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-12F restarted - setting it up again"));
      if (startEsp()) setupModule();
    }
    lastCheck = millis();
  }

Pins of the ESP-12F

Properties of the ESP-12F

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-12F": 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.
• The terminal says "Connection refused": connect to port 23, the hub, and wait for "Chat hub ready" in the UNO's monitor.
• The browser asks whether the server on port 80 is running: the hub's page is on port 23 - open http://192.168.1.101:23/ (in the demo: click Go).
• No welcome right after Connect: the hub greets a client one second after it connects, after checking that it is not a browser.
• 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-12F

• Power: the ESP-12F 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-12F 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, or use a NodeMCU board that carries it.
• Boot resistors: on a bare module pull EN, RST, GPIO0 and GPIO2 up with 10k and GPIO15 down with 10k.
• The flash pins: never connect anything to CS0, MISO, GPIO9, GPIO10, MOSI or SCLK.
• The antenna: keep metal, ground copper and other parts away from the antenna end of the board.
• A real chat server: the AT firmware allows five links; a busy hub on a small Arduino should keep its lines short, as our demo does, and drop clients that stay silent for very long.

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 flash pins (only drawn), the soft access point (CWMODE 2 / 3 are accepted, but nothing can join it), SSL connections, the supply's voltage and current, the radio itself - the join and network times and the antenna's +2 dB are realistic values, not a radio simulation.
• The PWR LED, 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-12F 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-12F, the laptop and the phone together at about 0.3 x real time on our PC). Proteus 7 is not supported.

So, that was all about the ESP-12F Library for Proteus. I hope it helps you try the newest ESP-12 module in Proteus before you solder the real one - and build servers that several devices use at once. Our recent demos showed TCP requests with the ESP-07S Library for Proteus, UDP broadcast with the ESP-12E, and now a multi-client hub; our series started with the ESP32 DevKit V1 Library for Proteus V2.0, and the Laptop and Mobile WiFi Monitors talk to every one of our Wi-Fi boards and modules. If you use the ESP-12F 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!