ESP8266 WiFi Shield Library for Proteus: ESP-12E UART Shield for UNO

Hello friends, I hope you all are doing great. Today, I am going to share the ESP8266 WiFi Shield Library for Proteus. It brings the popular ESP8266 ESP-12E UART WiFi Shield to Proteus: the black shield that plugs on an Arduino UNO and gives it Wi-Fi through AT commands. Your UNO sketch sends AT+CWJAP, AT+CIPSERVER or AT+CIPSTART over its serial port, and the shield joins a router, serves web pages, uploads to the cloud and talks UDP with other boards, right inside the simulation.

This is the sixth library of our Wi-Fi series and the first shield of it, after five ESP32 boards. The shield runs the same AT firmware model as our ESP-01 Library for Proteus, so everything you know from the ESP-01 works here too - but on a real shield board with its DIP switches, the ESP RST button and four status LEDs. As always, the demos end with a project that links this module with the previous one: our TTGO T-Display.

NOTICE: real ESP8266 shields differ between makers: the number of switches, which switch does what, the LEDs and the buttons. Ours follows the common 4-switch version with PWR, DFU, AP and STA LEDs. Check the silkscreen of your board before you copy a switch setting. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the ESP8266 WiFi Shield board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the ESP8266 WiFi Shield Library for Proteus:

What is the ESP8266 ESP-12E UART WiFi Shield?

The ESP8266 ESP-12E UART WiFi Shield is an Arduino UNO shield built around an ESP-12E module - the ESP8266 Wi-Fi chip with its flash, crystal and PCB antenna under a metal can. The shield adds a 3.3 V regulator for the module, a level shifter between its 3.3 V serial lines and the UNO's 5 V pins, a 4-way DIP switch that decides where the module's serial port goes, a reset button for the ESP-12E and a few LEDs. It ships with the Espressif AT firmware, so the UNO does not need any Wi-Fi library: it simply writes text commands to the serial port and reads the answers.

The DIP Switches

The four switches are the heart of this shield. The ESP-12E has one serial port, and the switches route it:

Why would you ever switch 1 and 2 off? Because D0 / D1 are also the UNO's USB serial port. On the bench you turn them off to upload a new sketch, and on again to run it. And while the shield owns D0 / D1, the serial monitor cannot be used for your own messages - the shield would read them as commands. That is what switch 3 is for: with 1 and 2 off and 3 on, you can wire the DEBUG header to two other pins and keep D0 / D1 for the monitor. Our second demo does exactly that.

AT Commands in One Minute

Every command starts with AT and ends with a carriage return and a line feed; the shield 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.

Features of the ESP8266 WiFi Shield Library for Proteus

• The ESP-12E UART WiFi Shield at the UNO's size: the stacking headers with the UNO's labels, the ESP-12E module with its metal can and meander antenna, the DIP switch, ESP RST and the LEDs.
• Working DIP switches: click them on the board or in the panel - D0 / D1, the DEBUG header and DFU act at once.
• Working LEDs: PWR, DFU, AP (soft AP mode) and STA (blinks while joining, on with an IP address); the module's blue LED flashes at boot.
• A live antenna: orange while the shield sends, green while it receives.
• The AT firmware 1.7.4 of our ESP-01 model: 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, 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 shield's cards with the switches, a Test page with four measuring tools, Settings and Help.
• Three demo projects with our Arduino UNO V4.0: a web server on D0 / D1, a cloud logger on the DEBUG header, and a UDP temperature node with the TTGO T-Display.
• A compact package: about 2.61 MB, without the C++ source code of the models.

The ESP8266 WiFi Shield Part in Proteus

Search WIFI SHIELD in Pick Devices; the device is ESP-12E WIFI SHIELD in TEPESP12ESHIELD.LIB. A shield cannot sit on top of the UNO in Proteus, so the part has the same outline and headers but stands next to the UNO, and only the pins the shield really uses are Proteus pins: D0 and D1, 5V and GND, and the TX / RX of the DEBUG header. The other header holes are drawn only. Click the PANEL pad or the ESP-12E module to open the panel.

Every State of the Shield

We ran the web server demo and paused the simulation for each picture. At Run the shield powers up and the ESP-12E boots:

While data flows, the antenna shows its direction:

The Switches and ESP RST at Work

Click a switch on the board (or in the panel's Switches row) and it flips at once. ESP RST is held while you hold the mouse button:

Two more states come from our second demo, where switch 3 is on and the sketch passes AT commands from the serial monitor:

Download ESP8266 WiFi Shield Library for Proteus

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

ESP8266 WiFi Shield Library for Proteus V1.0

• README.txt: the device, installation, the three demos, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPESP12ESHIELD.LIB (the shield), ArduinoV4TEP.LIB (our Arduino boards V4.0 - the UNO of the demos) and TEPTDISPLAY.LIB (our TTGO T-Display, for the third demo).
• Proteus Model Files: TEPNET.DLL (the shield and the Wi-Fi network) and TEPARDUINO.DLL (the Arduino boards).
• Proteus Simulation: the three demo projects, their HEX files and copies of the DLLs.
• Arduino Code: the four demo sketches and our TEP Boards for Proteus add-on, needed only to rebuild the T-Display's sketch. AltSoftSerial and the Adafruit libraries are not included - install them 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 ESP8266 WiFi Shield 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 and the ESP-01).
4. Delete TEPESP12ESHIELD.IDX, ArduinoV4TEP.IDX and TEPTDISPLAY.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for WIFI SHIELD.

The UNO sketches need nothing special: select Arduino Uno in the Arduino IDE (plus AltSoftSerial for the second demo), 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 Server on D0 / D1

Open ESP-12E-WiFi-Shield-Web-Server.pdsprj. It is wired the way the real shield is stacked: the shield's D0 to the UNO's D0 and D1 to D1, switches 1 and 2 on. The UNO is our Arduino UNO Library for Proteus V4.0, with its built-in serial monitor set to 115200 baud. The sketch, Shield_Web_Server.ino, talks to the shield on the UNO's hardware serial port at the AT firmware's factory speed:

  Serial.begin(115200);                // D0 / D1: the shield's AT firmware speed

Every command goes through one small function: print the command, wait for an expected line, then for OK:

bool command(const char* at, unsigned long ms = 2000, const char* want = NULL, char* out = NULL, byte size = 0) {
  Serial.print(at);
  Serial.print(F("\r\n"));
  if (want && !waitFor(want, ms, out, size)) return false;
  return waitFor("OK", ms);
}

At start-up the sketch waits until the shield answers AT - the UNO's LED blinks fast meanwhile, so a wrong switch setting is easy to see - and then sets it up as a station with a web server on port 80:

void setupShield(bool afterRestart) {
  command("ATE0");                     // no echo
  command("AT+CWMODE=1");              // station (joins a router)
  bool joined = command("AT+CWJAP?", 2000, "+CWJAP:");
  for (byte i = 0; i < 4 && !joined && afterRestart; ++i) {   // after a restart its auto-connect re-joins the saved network
    delay(500);
    joined = command("AT+CWJAP?", 1000, "+CWJAP:");
  }
  if (!joined) {
    char join[64];
    snprintf_P(join, sizeof(join), PSTR("AT+CWJAP=\"%s\",\"%s\""), WIFI_SSID, WIFI_PASS);
    command(join, 20000);
  }
  command("AT+CIPMUX=1");              // several connections - needed for the server
  command("AT+CIPSERVER=1,80");
}

Press Run. The UNO's monitor shows what the UNO sends to the shield, because the monitor listens on D1 - every AT command of the set-up, in order:

AT
ATE0
AT+CWMODE=1
AT+CWJAP?
AT+CWJAP="TEP-WiFi","12345678"
AT+CIPMUX=1
AT+CIPSERVER=1,80

Now open the shield's panel, tap OPEN ESP PAGE on its phone, then LED ON:

Each request reaches the sketch as +IPD data; it switches the LED and answers with AT+CIPSEND, the page and AT+CIPCLOSE:

    if (!strcmp(path, "/led/on")) digitalWrite(LED_PIN, HIGH);
    if (!strcmp(path, "/led/off")) digitalWrite(LED_PIN, LOW);

  Serial.print(F("AT+CIPSEND="));
  Serial.print(link);
  Serial.print(',');
  Serial.print(strlen(page));
  Serial.print(F("\r\n"));
  bool sent = waitFor(">", 2000);
  if (sent) { Serial.print(page); sent = waitFor("SEND OK", 5000); }

AT+CIPSERVER=1,80
AT+CIPSEND=0,333
HTTP/1.1 200 OK
Content-Type: text/html
Connection: close

Notice one thing: you cannot type commands in the UNO's monitor in this demo. The shield drives D0, the UNO's receive line, so it is the only one the UNO hears - exactly as on the real stacked shield. For the monitor, use the DEBUG header (demo 2).

The Shield's 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; the first card, ESP-12E SHIELD, ends with the Switches row: D0, D1, DEBUG and DFU (lit = on) and ESP RST. They work exactly like the parts on the board.

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

Demo 2: A Cloud Logger on the DEBUG Header

ESP-12E-WiFi-Shield-Debug-Cloud.pdsprj uses the shield the other way: switches 1 and 2 off, switch 3 on, and two jumper wires from the DEBUG header to the UNO's D8 and D9. Now D0 / D1 belong to the UNO's serial monitor again (9600 baud), and the shield talks to AltSoftSerial - the software serial port that can receive in Proteus:

AltSoftSerial esp;                     // RX = D8 (from DEBUG TX), TX = D9 (to DEBUG RX)
SoftwareSerial espFast(12, 9);         // only sends one command at 115200 on D9 (D12 unused)

A software port cannot receive at 115200 bps, so the sketch sends one command at that speed with SoftwareSerial - AT+UART_CUR=9600 - and then talks at 9600:

  esp.end();                           // D9 to SoftwareSerial for one command
  espFast.begin(115200);               // the ESP-12E'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

Every 20 seconds it uploads the pot on A0 to an IoT channel with a plain HTTP GET in the style of ThingSpeak's update API. In Proteus the virtual internet host answers with the entry number:

  snprintf_P(request, sizeof(request), PSTR("GET /update?api_key=%s&field1=%lu&field2=%d HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n"),
             API_KEY, uptime, a0, HOST);

UNO + ESP-12E WiFi Shield (DEBUG header): cloud upload
www.TheEngineeringProjects.com
Shield found on the DEBUG header, now at 9600 bps
Joining TEP-WiFi... connected
Uploading A0 to api.thingspeak.com every 20 s
Serial monitor: AT... (to the shield), STATUS, UPLOAD, HELP
Upload 1: uptime 5 s, A0 = 410, entry 1
Upload 2: uptime 26 s, A0 = 410, entry 2

Any line that starts with AT goes to the shield as it is, and its answer comes back - so the monitor is also an AT terminal:

  if ((text[0] == 'A' || text[0] == 'a') && (text[1] == 'T' || text[1] == 't')) {
    Serial.print(F("> "));
    Serial.println(text);
    esp.print(text);

We typed AT+GMR, AT+CWMODE=3 and STATUS. The AP LED lit on the shield (see above):

AT+GMR
> AT+GMR
  < AT version:1.7.4.0(May 11 2020 19:13:04)
  < SDK version:3.0.4(9532ceb)
  < compile time:May 27 2020 10:12:17
  < Bin version(Wroom 02):1.7.4
  < OK
AT+CWMODE=3
> AT+CWMODE=3
  < OK
STATUS

Demo 3: The Shield Sends Temperatures to the TTGO T-Display

Now the shield meets the previous library of the series, our TTGO T-Display ESP32 Library for Proteus. In ESP-12E-WiFi-Shield-and-T-Display-UDP.pdsprj the UNO and the shield (U2, 192.168.1.102) are a small temperature node - the pot on A0 stands for a sensor, 0 to 50.0 C - and the T-Display (U1, 192.168.1.101) is its display and remote. They talk UDP on port 4210, both ways.

The UNO opens one UDP link to the T-Display, with its own local port 4210 so that the T-Display can answer:

  snprintf_P(at, sizeof(at), PSTR("AT+CIPSTART=\"UDP\",\"%s\",%u,%u,0"), DISPLAY_IP, PORT, PORT);
  command(at, 5000);

Every second it sends the temperature, the fan (the UNO's LED on D13) and the AUTO mode. A UDP datagram with the AT firmware is AT+CIPSEND=length, the > prompt, the data and SEND OK:

bool sendText(const char* text) {
  char at[24];
  snprintf_P(at, sizeof(at), PSTR("AT+CIPSEND=%d"), (int)strlen(text));
  Serial.print(at);
  Serial.print(F("\r\n"));
  if (!waitFor(">", 1000)) return false;
  Serial.print(text);
  return waitFor("SEND OK", 2000);
}

With AUTO on, the UNO runs the fan from 30.0 C and stops it below 29.0 C; a datagram from the T-Display changes the mode:

    if (!strcmp(msg, "FAN ON")) { fan = true; autoMode = false; }
    else if (!strcmp(msg, "FAN OFF")) { fan = false; autoMode = false; }
    else if (!strcmp(msg, "AUTO ON")) autoMode = true;
    else if (!strcmp(msg, "AUTO OFF")) autoMode = false;

On the other side the T-Display listens on port 4210 with WiFiUDP, draws the temperature, a graph and the fan, and its two buttons send commands back:

void send(const char *text) {
  udp.beginPacket(node, PORT);
  udp.print(text);
  udp.endPacket();
  Serial.print("Sent to the UNO: ");
  Serial.println(text);
}

Press Run. The pot is at 70 %, so the UNO reports 35.0 C and, in AUTO, turns the fan on:

AT+CWJAP="TEP-WiFi","12345678"
AT+CIPMUX=0
AT+CIPSTART="UDP","192.168.1.101",4210,4210,0
AT+CIPSEND=20
T=35.0 FAN=ON AUTO=1AT+CIPSEND=20

Then we typed fan off in the T-Display's monitor - the same as its BOOT button:

TTGO T-Display: UNO temperature (UDP)
Connecting to TEP-WiFi.....
IP address: 192.168.1.101
Listening on UDP port 4210
From the UNO: T=35.0 FAN=ON AUTO=1
fan off
Sent to the UNO: FAN OFF
From the UNO: T=35.0 FAN=OFF AUTO=0
fan on
Sent to the UNO: FAN ON
From the UNO: T=35.0 FAN=ON AUTO=0
auto on
Sent to the UNO: AUTO ON
From the UNO: T=35.0 FAN=ON AUTO=1

The shield's panel shows the same exchange from its side - a UDP link, bytes in and out, the AT commands:

Our earlier demos linked boards with HTTP, raw TCP and UDP between ESP32 boards; this one shows the classic shield way - an UNO that only speaks AT commands, talking UDP to an ESP32 board on the same network.

Pins of the ESP8266 WiFi Shield

Properties of the Shield

Troubleshooting

• The UNO's LED blinks fast and nothing joins: switches 1 and 2 must be on, and the shield's D0 / D1 must reach the UNO's D0 / D1.
• Typing in the monitor does nothing: with switch 1 on, the shield drives D0 - use the DEBUG header for the shield.
• The shield answers ERROR to everything: the sketch printed normal text on Serial; on D0 / D1 Serial is for AT commands only.
• FLASH MODE on the panel: switch 4 was on at the last reset - turn it off and press ESP RST.
• The sketch loses the shield after ESP RST: a reset clears the server, CIPMUX and UART_CUR - set them up again, as the demos do.
• No answer on the DEBUG header: switch 3 on, DEBUG TX to D8, DEBUG RX to D9 for AltSoftSerial.
• No panel: click the PANEL pad or the ESP-12E, or turn "Open the panel at Run" back on in Settings.

Things to Know Before Using a Real Shield

• Check the switches: makers number and wire them differently - read your board's silkscreen or its seller's notes.
• Uploading: turn the switches that connect D0 / D1 off while the Arduino IDE uploads, then on again.
• The firmware: most shields ship with AT firmware at 115200 bps, some older ones at 9600; AT+GMR tells you the version.
• Power: the ESP-12E draws up to about 200 mA while sending - power the UNO from a good supply, not a weak USB port.
• Our ESP-01 sketches work with small changes: the pins and the reset line differ (the shield has its own button).

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 light the AP LED, but nothing can join it), SSL connections, the shield's level shifter voltages, the other ESP-12E GPIOs, the radio itself - the join and network times are realistic values.
• A shield cannot be stacked in Proteus: wire D0 / D1 (or the DEBUG header) to the UNO.
• The antenna colours, the PANEL pad, the panel, its phone, the router and the internet host are TEP additions.
• ESP8266 and ESP-12E are names of Espressif and Ai-Thinker; this library is not made or endorsed by Espressif, Ai-Thinker, LilyGO, Arduino, ThingSpeak or Labcenter.
• Tested in Proteus 8.5 in October 2026 (the three demos as shipped, the web server demo 89.6 s of simulation in 157 s, about 0.6 x real time; the T-Display project 27.1 s in 95 s, about 0.3 x). Proteus 7 is not supported.

So, that was all about the ESP8266 WiFi Shield Library for Proteus. I hope it helps you learn AT commands and build Wi-Fi projects with the Arduino UNO before you touch the hardware. Our series started with the ESP32 DevKit V1 Library for Proteus V2.0 - try linking the shield with any of our ESP32 boards. If you use the ESP8266 WiFi Shield 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!