WeMos D1 Mini Library for Proteus: ESP8266 Wi-Fi Simulation

Hello friends, I hope you all are doing great. Today, I am going to share the WeMos D1 Mini Library for Proteus. The D1 Mini is the smallest of the popular ESP8266 boards: an ESP-12F module on a board of 34 x 26 mm, 16 pins in two rows, a micro-USB socket and a RESET button, and a whole family of stackable shields - relay, sensors, displays - that plug on top. With this library it runs your ESP8266 sketch in Proteus - ESP8266WiFi, ESP8266WebServer, ESP8266mDNS, the D0 to D8 names, A0, EEPROM - and joins a Wi-Fi network inside the simulation.

This is the twenty-first library of our Wi-Fi series and the third ESP8266 board, after our NodeMCU ESP8266 V3 Library for Proteus V2.0 and NodeMCU ESP8266 V2 Library for Proteus. Its demo is a Wi-Fi smart switch: a lamp on D1 (the pin of the D1 Mini relay shield) that our Mobile WiFi Monitor switches from a web page at switch.local, that our Laptop WiFi Monitor controls through a Telnet-style console on port 23, with an auto-off timer, the time of every change from NTP, and the lamp's state kept in EEPROM so that a reset brings it back.

NOTICE: Proteus has no ESP8266 processor, so this is not a real ESP8266 chip: your sketch is compiled for a hidden ATmega2560 inside the board (16 MHz, 8 KB of RAM). The ESP8266 Arduino API and the Wi-Fi are our model. The antenna colours, the red PWR LED, the PANEL pad and the panel are TEP additions. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the WeMos D1 Mini board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the WeMos D1 Mini Library for Proteus:

What is WeMos D1 Mini?

The WeMos D1 Mini (today sold as the LOLIN D1 Mini) puts an ESP-12F module - the ESP8266EX chip with 4 MB of flash and a PCB antenna - on a tiny board with a USB chip on the back, a 3.3 V regulator and a RESET button. It has only 16 pins, but they carry every useful GPIO of the ESP8266 under the same names as the NodeMCU: D0 to D8, RX, TX and A0. A sketch for the NodeMCU runs on the D1 Mini without a change, unless it uses SD2 and SD3, which the D1 Mini does not bring out. For the chip itself, read our ESP8266 Pinout, Datasheet, Features and Applications.

A Board Without a FLASH Button

The NodeMCU boards have a FLASH button on GPIO0; the D1 Mini has none. Its USB chip pulls GPIO0 low by itself when the Arduino IDE uploads. So on the D1 Mini, D3 (GPIO0) is a plain pin with its 10k pull-up, and RESET is the only button - our model does the same, and the board's monitor shows only the RST button.

How Your ESP8266 Sketch Runs in Proteus

Proteus 8 simulates many processors, but not the ESP8266. So, as for our NodeMCU boards, the D1 Mini in Proteus has a hidden ATmega2560 inside, and our board package for the Arduino IDE compiles your ESP8266 sketch for it. The package gives the sketch the ESP8266 names - D1 is GPIO5, D4 is GPIO2, A0 answers 0 to 1023 - and the ESP8266 libraries, which talk to our model in TEPNET.DLL. The model is the radio: it joins the router, hands out the address, keeps the sockets, answers mDNS names and reaches the virtual internet.

Know the price before you start: the sketch runs at 16 MHz with 8 KB of RAM, an int is 16 bits (use long above 32767), and there is no SPIFFS or LittleFS, no OTA and no real TLS. For web pages, sockets, consoles, relays, sensors and LEDs it is plenty, and the same sketch compiles for a real D1 Mini without a change.

Features of the WeMos D1 Mini Library for Proteus

• The D1 Mini as it looks: the small blue board turned on its side, the micro-USB on the left with RST beside it, the ME6211 regulator, the ESP-12F with its blue LED and its meander antenna on the right, 8 + 8 header pins with the D1 Mini's labels (3V3, 5V, G, D0 to D8, RX, TX, A0, RST).
• The ESP8266 Arduino API: digitalWrite, analogRead(A0), analogWrite, attachInterrupt, LED_BUILTIN, EEPROM.begin and EEPROM.commit, configTime and time(), ESP.getChipId() and more.
• Wi-Fi: a virtual router (TEP-WiFi) with DHCP, mDNS names, NTP time, TCP clients and servers, UDP, and an internet host - every TEP Wi-Fi part in the design is on the same network.
• The blue LED on GPIO2 (lit when LOW), the RST button, a red PWR LED and an antenna that changes colour with the traffic.
• A0 as on the D1 Mini: 0 to 1023 for 0 to 3.2 V.
• A built-in serial monitor at 115200 baud with Monitor, Plotter and Board tabs.
• Our pop-up panel: a phone with a browser, the router list and the cloud requests, the board, Wi-Fi and traffic cards, every pin live, a Test page, Settings and Help.
• Our Laptop and Mobile WiFi Monitors in the package: a browser, TCP and UDP terminals and ping on the same network.
• A compact package: about 2.17 MB with the board package for the Arduino IDE, without the C++ source code of the models.

The WeMos D1 Mini in Proteus

Search D1 MINI in Pick Devices; the device WEMOS D1 MINI is in TEPD1MINI.LIB (Microprocessor ICs, ESP8266 Boards). Click the micro-USB to open the serial monitor and the PANEL pad or the ESP-12F to open the panel.

Every State of the D1 Mini

We ran the board with the demo sketch and paused the simulation for each picture. The sketch blinks the D4 LED while it joins the router and keeps it on when the board is on Wi-Fi:

The same in the demo, zoomed in on the board and its lamp. The small squares at the pins are Proteus's logic levels - red HIGH, blue LOW, grey not driven:

Download WeMos D1 Mini Library for Proteus

Click the button below to download WeMos-D1-Mini-Library-for-Proteus-v1.0.zip (about 2.17 MB, without the C++ source code of the models):

WeMos D1 Mini Library for Proteus V1.0

• README.txt: the device, installation, the demos, the pins, the properties, troubleshooting and the limits.
• Proteus Library Files: TEPD1MINI.LIB (the board), TEPLAPTOP.LIB and TEPMOBILE.LIB (our Laptop and Mobile WiFi Monitors).
• Proteus Model Files: TEPNET.DLL (the board, the two monitors and the Wi-Fi network).
• Proteus Simulation: the two demo projects, the HEX file and a copy of the DLL.
• Arduino Code: the demo sketch and TEP Boards for Proteus 1.7.0, our board package for the Arduino IDE with the ESP8266 libraries.

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 WeMos D1 Mini 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 from Proteus Model Files into the MODELS folder - replace an older copy (this one is the first that knows the D1 Mini, and it still runs our NodeMCU boards, the ESP32 boards, the ESP8266 modules, the shields and the two monitors).
4. Delete TEPD1MINI.IDX, TEPLAPTOP.IDX and TEPMOBILE.IDX from the LIBRARY folder if they are there.
5. Start Proteus, press P and search for D1 MINI.

The Board Package for the Arduino IDE

The demo has its HEX file, so you need the Arduino IDE only for your own sketches. 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, and restart the IDE; the Arduino AVR Boards platform must be installed. Version 1.7.0 adds the D1 Mini and replaces 1.6.0 (it still has the NodeMCU boards and the ESP32 boards); it also fixes EEPROM.h, which older copies could not compile. Choose Tools > Board > TEP Boards for Proteus > WeMos D1 Mini (TEP Proteus), write your sketch and use Sketch > Export Compiled Binary; double-click the board in Proteus and set its Program File to the HEX (see How to get the HEX file from Arduino).

Demo: A D1 Mini Wi-Fi Smart Switch

Open D1-Mini-Smart-Switch-with-Laptop-and-Mobile.pdsprj. In the middle is the D1 Mini (U1) with its lamp, on the left our phone (MOB1) and on the right our laptop (PC1) - no wires to them, they are on the TEP-WiFi network. The package also has WeMos-D1-Mini-Board.pdsprj, the board alone with the same sketch.

The lamp is a green LED with a 220 ohm resistor on D1 (GPIO5): D1 HIGH lights it. D1 is the pin of the D1 Mini relay shield, so on the bench you can swap the LED for the shield and switch a real lamp - our Relay Module Library for Proteus has the relay for your Proteus designs. That is the whole circuit:

The two tools come from our Laptop WiFi Monitor Library for Proteus and Mobile WiFi Monitor Library for Proteus. The laptop is 192.168.1.21; its terminal is set to connect to the D1 Mini, 192.168.1.101, on port 23. The phone is 192.168.1.41 and its home page is http://switch.local/:

The Sketch: Settings and Pins

The sketch is written as for a real D1 Mini. It includes the ESP8266 libraries, EEPROM for the saved state and time.h for the clock:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>
#include <EEPROM.h>
#include <time.h>

The lamp on D1, the Wi-Fi LED, the time zone and the one EEPROM byte that keeps the state; then the web server, the console port and the one console client:

const int LAMP_PIN = D1;               // GPIO5: the lamp (the relay shield's pin)
const int LED_WIFI = LED_BUILTIN;      // D4 = GPIO2, the ESP-12F's blue LED (lit when LOW)
const long UTC_OFFSET = 5 * 3600L;     // PKT; change it for your time zone
const int SAVE_ADDR = 0;               // one EEPROM byte: SAVE_MARK + the state (bit 0)
const uint8_t SAVE_MARK = 0xA0;

ESP8266WebServer server(80);
WiFiServer door(23);                   // the console port (the laptop's terminal)
WiFiClient console;

Joining the router: while WiFi.status() is not WL_CONNECTED, the D4 LED toggles every 250 ms; when the board is on Wi-Fi, the pin goes LOW and the LED stays on:

  while (WiFi.status() != WL_CONNECTED) {   // the Wi-Fi LED blinks while the board joins
    digitalWrite(LED_WIFI, !digitalRead(LED_WIFI));
    delay(250);
    Serial.print('.');
  }

Then the clock and the name. configTime() asks an NTP server for the time - in Proteus our model answers - and MDNS.begin() gives the board the name switch.local. The pages and the console port start after it:

  configTime(UTC_OFFSET, 0, "pool.ntp.org");
  if (MDNS.begin("switch")) Serial.println("mDNS: http://switch.local/");
  server.on("/", handleRoot);
  server.on("/on", handleOn);
  server.on("/off", handleOff);
  server.on("/toggle", handleToggle);
  server.on("/timer", handleTimer);
  server.begin();
  door.begin();

Press Run and watch the monitor (115200 baud): the first run finds no saved state, joins TEP-WiFi and lists the address, the name and the console port:

D1 Mini Smart Switch - The Engineering Projects
No saved state yet: lamp OFF
Connecting to TEP-WiFi.........
IP address: 192.168.1.101
mDNS: http://switch.local/
Console: port 23 (the laptop's terminal)

The Switch: One Function for Every Command

Every way of switching the lamp - the console, the phone, the monitor and the timer - ends in one function. It drives D1, counts the change, saves the state in EEPROM, stamps the time and tells everyone who is listening:

void setLamp(bool on, const char *by) {
  if (!on) timerOn = false;
  if (on == lampOn) {
    report(String("Lamp is already ") + (on ? "ON" : "OFF"));
    return;
  }
  lampOn = on;
  digitalWrite(LAMP_PIN, on ? HIGH : LOW);
  ++changes;
  save();
  lastChange = clockText() + " by " + by;
  String line = String("Lamp ") + (on ? "ON" : "OFF") + " at " + clockText() + " by " + by;
  report(line);
  remember(line);
}

One line goes to the monitor and, if the laptop is connected, to its console:

void report(const String &line) {
  Serial.println(line);
  if (console.connected()) {
    console.print(line);
    console.print("\r\n");
  }
}

The Laptop's Console on Port 23

A WiFiServer on port 23 takes one client at a time. When a new one arrives, the sketch greets it with the commands and the status; afterwards it reads its lines like the monitor's:

  WiFiClient fresh = door.available();  // a new client on port 23 (the laptop's terminal)
  if (fresh) {
    if (console.connected()) console.stop();
    console = fresh;
    fromConsole = "";
    Serial.print("Console: ");
    Serial.print(console.remoteIP());
    Serial.println(" connected");
    console.print("D1 Mini Smart Switch console - commands: ON, OFF, TOGGLE, TIMER <seconds>, STATUS, HELP\r\n");
    console.print(status());
    console.print("\r\n");
  }

In the laptop, open Terminal > TCP Client - the host 192.168.1.101 and the port 23 are already there - and press Connect. Type ON: the lamp lights, and the console answers with the time and who switched it:

D1 Mini Smart Switch console - commands: ON, OFF, TOGGLE, TIMER <seconds>, STATUS, HELP
Lamp OFF, time 17:02:28, 0 changes, last none yet, RSSI -46 dBm
ON
Lamp ON at 17:02:28 by laptop
STATUS
Lamp ON, time 17:02:28, 1 change, last 17:02:28 by laptop, RSSI -46 dBm

All the commands go through one function, whoever sends them:

void command(String cmd, const char *by, Print &reply) {
  cmd.trim();
  cmd.toUpperCase();
  if (cmd == "ON") setLamp(true, by);
  else if (cmd == "OFF") setLamp(false, by);
  else if (cmd == "TOGGLE") setLamp(!lampOn, by);
  else if (cmd.startsWith("TIMER")) startTimer(cmd.substring(5).toInt(), by);
  else if (cmd == "STATUS") { reply.print(status()); reply.print("\r\n"); }
  else reply.print("Commands: ON, OFF, TOGGLE, TIMER <seconds>, STATUS, HELP\r\n");
}

The Switch Page on the Phone

The web server has five addresses: / shows the lamp, the time, the last change and the last 6 changes, and /on, /off, /toggle and /timer?s=30 switch it and then show the same page. In the phone, open the Browser and press Go - its home page is http://switch.local/, which the board's mDNS answers:

void pageCommand(const char *cmd) {
  Serial.print("Page ");
  Serial.print(server.uri());
  Serial.print(" for ");
  Serial.println(server.client().remoteIP());
  if (!strcmp(cmd, "TIMER")) startTimer(server.arg("s").toInt(), "phone");
  else if (cmd[0]) command(cmd, "phone", Serial);
  sendPage();
}

Tap ON on the phone after the timer below has switched the lamp off: the lamp lights again, and the page lists the change with the others:

The Auto-Off Timer

TIMER 10 - from the monitor, the console or the phone's TIMER 30 S - switches the lamp on and remembers when to switch it off:

void startTimer(long seconds, const char *by) {
  if (seconds < 1 || seconds > 3600) seconds = 30;
  if (!lampOn) setLamp(true, by);
  timerOn = true;
  offAt = millis() + seconds * 1000UL;
  report("Timer: the lamp switches off in " + String(seconds) + " s");
}

The loop watches the time with a subtraction, so it keeps working when millis() rolls over:

  if (timerOn && (long)(millis() - offAt) >= 0) {
    timerOn = false;
    setLamp(false, "timer");
  }

We typed it in the monitor while the lamp was on. STATUS shows the seconds left, and ten seconds later the timer switches the lamp off by itself:

TIMER 10
Timer: the lamp switches off in 10 s
STATUS
Lamp ON (off in 10 s), time 17:02:34, 1 change, last 17:02:28 by laptop, RSSI -47 dBm
Lamp OFF at 17:02:44 by timer
HELP
Commands: ON, OFF, TOGGLE, TIMER <seconds>, STATUS, HELP

The laptop's console was still open, and it saw every change made elsewhere - the monitor's timer and its OFF:

The State Survives a Reset: EEPROM

A smart switch should come back as it was after a power cut. Every change writes one byte - a mark plus the state - with EEPROM.write() and EEPROM.commit(), the ESP8266 way:

void save() {                          // the state survives RESET and power cuts
  EEPROM.write(SAVE_ADDR, SAVE_MARK | (lampOn ? 1 : 0));
  EEPROM.commit();
}

At the start, setup() reads the byte back. The mark tells a saved state from an empty EEPROM:

  EEPROM.begin(16);
  const uint8_t saved = EEPROM.read(SAVE_ADDR);
  lampOn = (saved & 0xF0) == SAVE_MARK && (saved & 1);
  digitalWrite(LAMP_PIN, lampOn ? HIGH : LOW);
  if ((saved & 0xF0) == SAVE_MARK) Serial.println(String("Restored from EEPROM: lamp ") + (lampOn ? "ON" : "OFF"));
  else Serial.println("No saved state yet: lamp OFF");

We switched the lamp on from the phone and clicked RST on the board. The D1 Mini restarted, found the lamp ON in its EEPROM and lit it before it joined the router again:

Lamp ON at 17:02:50 by phone

D1 Mini Smart Switch - The Engineering Projects
Restored from EEPROM: lamp ON
Connecting to TEP-WiFi.........
IP address: 192.168.1.101
mDNS: http://switch.local/
Console: port 23 (the laptop's terminal)

The laptop saw the old connection close; Connect again and STATUS shows the lamp ON with the change counter back at zero:

And the whole demo after the run:

The WeMos D1 Mini 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 and three cards: BOARD, WI-FI and TRAFFIC. OPEN D1 MINI PAGE opens the sketch's page on the panel's phone:

The Pins page shows the 12 GPIOs live and A0 with its voltage and reading. WI-FI SIGNAL on the phone can take the router away (OUT OF RANGE) to test what your sketch does without Wi-Fi - this one blinks D4 again and joins once the router is back:

  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi lost - joining again");
    digitalWrite(LED_WIFI, HIGH);
    joinWiFi();
  }

The monitor's Board tab shows the board as a whole - the PWR and D4 LEDs, the RST button you can click there too, and every pin with its state:

Pins of the WeMos D1 Mini

analogWrite works on every output pin but D0, with a range of 255 and 1 kHz by default. All pins are 3.3 V logic. The pin names are the NodeMCU's - see ESP8266: Knowing the NodeMCU GPIOs for more on them.

Properties of the WeMos D1 Mini

The IP address follows the part's number: U1 gets 192.168.1.101, U2 .102 and so on. The laptop is always 192.168.1.21 and the phone 192.168.1.41. Every run starts with an empty EEPROM; within a run, it keeps its bytes through RST.

Troubleshooting

• Nothing happens at Run: the HEX was not built with our board package - choose WeMos D1 Mini (TEP Proteus) and export it again.
• "EEPROM.h ... cannot be overloaded": an older copy of the board package is installed - 1.7.0 fixes it.
• The laptop does not connect: Terminal, TCP Client, host 192.168.1.101 (U1), port 23. The console takes one client; a new connection replaces the old one.
• The lamp does not light: D1 to the 220 ohm resistor, the resistor to the LED's anode, the cathode to ground.
• The time shows --:--:--: NTP has not answered yet, or configTime() was not called.
• The board stays on "Connecting to TEP-WiFi": the network name or password differs from WIFISSID / WIFIPASS, or the phone's WI-FI SIGNAL is OUT OF RANGE.
• A number goes wrong above 32767: an int is 16 bits on the hidden AVR - use long.

Things to Know Before Using a Real D1 Mini

• The boot pins: D3 (GPIO0) and D4 (GPIO2) must be HIGH and D8 (GPIO15) LOW when the board starts - the board's resistors take care of that, so do not pull them the other way with your circuit. The simulation does not check this.
• Shields: the relay shield uses D1, the DHT shield D4, the OLED shield D1 and D2 (I2C) - plan your pins before you stack them.
• A0: the ESP8266's own ADC takes 0 to 1 V; the D1 Mini's divider stretches that to about 3.2 V. A bare ESP-12F module (our ESP-12F Library for Proteus) has no divider.
• EEPROM: the ESP8266 keeps its EEPROM in a sector of the flash, and every commit() erases and writes it - save the state when it changes, as the demo does, not in every loop.
• The USB driver: most D1 Minis use the CH340 (WCH driver); the upload resets the board by itself.
• The same sketch: choose "LOLIN(WEMOS) D1 R2 & mini" of the ESP8266 core and upload - nothing to change.

Limitations of the Simulation

• The board runs your sketch on a hidden ATmega2560 at 16 MHz with 8 KB of RAM - not on an ESP8266. Long strings and big buffers that fit in the ESP8266's 80 KB may not fit here.
• Not modelled: the CH340 and its auto-reset, SPIFFS and LittleFS, OTA updates, the soft AP and Wi-Fi events, real TLS, deep sleep timing (the board restarts), the radio itself - the join and network times are realistic values, not a radio simulation.
• The EEPROM is the hidden ATmega2560's: it keeps its bytes through RST within a run and starts empty in every run.
• The antenna colours, the red PWR LED, the PANEL pad, the panel, its phone, the router, the internet host and the two monitors are TEP additions; the MAC address is a TEP address.
• WeMos and LOLIN are names of WEMOS Electronics, ESP8266 and ESP-12F of Espressif Systems and Ai-Thinker, CH340 of WCH; this library is not made or endorsed by them or by Labcenter.
• Tested in Proteus 8.5 in October 2026 (the demos as shipped, the D1 Mini, the laptop and the phone together at about 0.33 x real time on our PC). Proteus 7 is not supported.

So, that was all about the WeMos D1 Mini Library for Proteus. I hope it lets you build your ESP8266 projects in Proteus - a smart switch with a web page, a console and a saved state, sensors, displays - before the real D1 Mini is on your desk, and watch every connection on the panel while you do. Its bigger brothers are in our NodeMCU ESP8266 V3 Library for Proteus V2.0 and NodeMCU ESP8266 V2 Library for Proteus. If you use the WeMos D1 Mini 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!