Project Files of Adafruit QT Py ESP32-S3 Library for Proteus: Wi-Fi Alarm Clock

ADAFRUIT QT PY ESP32-S3 LIBRARY FOR PROTEUS - V1.0 (YOUR ESP32-S3 SKETCH ON THE TINY QT PY, WI-FI, AN ALARM CLOCK)
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/11/adafruit-qt-py-esp32-s3-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/adafruit-qt-py-esp32-s3-proteus-library
The demo's clock and display are our libraries (included) - their articles:
  https://www.theengineeringprojects.com/2026/10/ds3231-rtc-module-library-for-proteus-v1-0.html
  https://www.theengineeringprojects.com/2026/10/tm1637-7-segment-display-library-for-proteus-v1-0.html
The laptop and the phone:
  https://www.theengineeringprojects.com/2026/10/laptop-wifi-monitor-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/mobile-wifi-monitor-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Adafruit-QT-Py-ESP32-S3-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPDS3231.LIB                                    68.9 KB   the DS3231 (demo), to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPQTPYS3.LIB                                    28.7 KB   the QT Py ESP32-S3, to LIBRARY
|   |-- TEPTM1637.LIB                                    84.8 KB   the TM1637 (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPDS3231.DLL                                   321.5 KB   the DS3231, to MODELS
|   |-- TEPNET.DLL                                       2.66 MB   the board + monitors + network, to MODELS
|   |-- TEPTM1637.DLL                                   284.0 KB   the TM1637, to MODELS
|-- Arduino Code/
|   |-- QTPyS3_WiFi_Clock/QTPyS3_WiFi_Clock.ino           6.4 KB   the demo sketch
|   |-- TEP Boards for Proteus/hardware/                949.8 KB   the Arduino IDE add-on 1.42.0 (219 files)
|-- Proteus Simulation/
|   |-- QT-Py-ESP32-S3-WiFi-Clock.pdsprj                 27.2 KB   the demo: a Wi-Fi alarm clock
|   |-- QTPyS3_WiFi_Clock.hex                            78.6 KB   the demo sketch (U1)
|   |-- TEPDS3231.DLL                                   321.5 KB   copy of the model
|   |-- TEPNET.DLL                                       2.66 MB   copy of the model
|   |-- TEPTM1637.DLL                                   284.0 KB   copy of the model
|-- README.txt                                          ~13.3 KB   this file
Total: 7.77 MB (unzipped). The source code of the models is not included.

WHAT IS IT?
Proteus 8 has no ESP32-S3 processor model, so this is NOT a real ESP32-S3 chip. Our team has put a lot of effort into
building this board ourselves: it is Adafruit's QT Py ESP32-S3 - the thumb-sized 14-pin board with the ESP32-S3 chip,
its PCB
antenna, USB-C, the RST and BOOT buttons, the STEMMA QT socket and the NeoPixel - that runs YOUR ESP32-S3 Arduino
sketch in
Proteus:
  * You write a normal QT Py sketch (A0 .. A3, SDA, SCL, TX, RX, SCK, MI, MO, analogRead 0-4095, analogWrite, ledcWrite,
    attachInterrupt, Wire, SPI, Serial1 on TX / RX, rgbLedWrite on the NeoPixel, WiFi, WebServer, HTTPClient, ESPmDNS,
    configTime
    ...) and compile it in the Arduino IDE with our board package "TEP Boards for Proteus" 1.42.0 (in Arduino Code - see
    INSTALLATION).
  * The board model (TEPNET.DLL) runs the compiled sketch: the pins with their QT Py names, RST, the BOOT button on
    GPIO0, the
    NeoPixel on GPIO39 with its power switch on GPIO38, the built-in serial monitor and the Wi-Fi radio.
  * Wi-Fi: a virtual router (TEP-WiFi, password 12345678 - the WIFISSID / WIFIPASS properties) with DHCP (192.168.1.101
    for U1), a scan list, RSSI, mDNS names, NTP time, TCP and UDP between all the TEP Wi-Fi parts in the design.
The board is drawn at its real proportions (20.6 x 17.8 mm, far smaller than the UNO), seen from above and turned so
the USB-C
port is on the left: RST and BOOT next to it, the NeoPixel, the chip, the PCB antenna and the STEMMA QT socket on the
right
(top row: 5V GND 3V MO MI SCK RX; bottom row: A0 A1 A2 A3 SDA SCL TX).
TEP additions: the PWR LED, the PCB antenna's colours (gold not joined, green on Wi-Fi, orange sending, cyan
receiving), the
PANEL pad (or the chip) opens the board's panel, the USB-C port opens the serial monitor.
The real QT Py has no RESET pin, and neither has ours: its RST button resets the board. Limits (say them before you
start): your
sketch gets 8 KB of RAM in the simulation (the real board: 2 MB of PSRAM on the 4 MB version), about 256 KB of flash,
int is 16
bits in the simulation (use long / int32_t for big numbers), no FreeRTOS tasks, no second core, no Bluetooth LE, no
ESP-IDF, no
real TLS, no soft AP. See MODEL SCOPE AND LIMITS.

ONE DEVICE (search "QT PY" in Pick Devices):
  QT PY ESP32-S3  "QT Py ESP32-S3" V1.0 (Microprocessor ICs > ESP32 Boards), prefix U, model TEPNET.DLL. The panel
  (a
  TEP pop-up window; the PANEL pad opens it): Wi-Fi (a phone: OPEN ESP32 PAGE, the router's list), Pins (every pin
  live),
  Test, Settings, Help. The serial monitor (115200 baud) has Monitor, Plotter and Board tabs (the Board tab: the LED,
  RST, BOOT, every pin). Like every TEP window it has no Windows title bar. One QT Py ESP32-S3 per design.
The same TEPNET.DLL also runs our other Wi-Fi boards and the Laptop / Mobile WiFi Monitors; it replaces any older
TEPNET.DLL (keep only this newest one in MODELS).

TEST STATUS
V1.0: verified in Proteus 8.5 on 30 Oct 2026 with the demo project as shipped. What the Proteus run showed:
* QT-Py-ESP32-S3-WiFi-Clock: the monitor printed "DS3231 ready", "Connecting to TEP-WiFi", "NTP time written to the
  DS3231: 06:59:22", "Clock page: http://192.168.1.101/" and "Time 06:59:22  25.0 C  alarm 07:00 armed"; the TM1637
  showed 06:59 with its colon blinking, the NeoPixel green, the antenna green on Wi-Fi.
* The laptop (192.168.1.21) opened http://192.168.1.101/json and the phone (192.168.1.41) http://192.168.1.101/ (HTTP
  200).
* 07:00: ">> ALARM 07:00:00", the display flashing, the NeoPixel flashing red, the page: RINGING.
* STOP on the phone: "Alarm stopped (the web page)"; +5 MIN: "Alarm now 07:05"; ARM: "Alarm off (the web page)", the
  NeoPixel blue; "Time 07:00:12  25.0 C  alarm 07:05 off".
* About 55 s of simulation, no errors, with the pop-ups, the panel, the monitor and both tools open.

INSTALLATION (about 3 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" to the LIBRARY folder of Proteus, for example:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY
   (on some PCs: C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY). TEPQTPYS3.LIB is the board;
   the
   others are the demo's parts: TEPDS3231.LIB, TEPTM1637.LIB, TEPLAPTOP.LIB and TEPMOBILE.LIB.
3. Copy the DLLs from "Proteus Model Files" (TEPNET.DLL, TEPDS3231.DLL, TEPTM1637.DLL) to the MODELS folder
   (...\Proteus 8
   Professional\MODELS) - replace an older TEPNET.DLL (this one is the first that knows the QT Py ESP32-S3).
4. Delete TEPQTPYS3.IDX from the LIBRARY folder if it is there.
5. The Arduino IDE (only to compile your own sketches - the demo has its HEX file): 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 (replace an older copy); restart the IDE. The Arduino AVR Boards
   platform must be installed (it comes with IDE 1.8.x; in IDE 2.x install "Arduino AVR Boards" from the Boards Manager
   once). Tools > Board > TEP Boards for Proteus > QT Py ESP32-S3 (TEP Proteus). The demo also needs RTClib and TM1637
   by
   Avishay Orpaz (Library Manager).
6. Start Proteus. In Pick Devices (P) search "QT PY".

RUN THE DEMO
Keep the .hex file and the DLLs beside the project in "Proteus Simulation".
QT-Py-ESP32-S3-WiFi-Clock.pdsprj - U1 the QT Py ESP32-S3 (QTPyS3_WiFi_Clock.hex) is a desk alarm clock that sets
itself over
Wi-Fi: U2 = the DS3231 clock on I2C (SDA, SCL, address 0x68) and TM1 = the TM1637 4-digit display (CLK on A0, DIO on
A1). PC1
the Laptop WiFi Monitor opens http://192.168.1.101/json, MOB1 the Mobile WiFi Monitor the page http://192.168.1.101/.
The DS3231 and
the TM1637 are the Advance versions: they open their pop-up windows at Run.
The board's TIME property is 2026-11-03 01:59:20 UTC, so that the demo starts near 06:59 in UTC + 5 and the alarm
rings during the
run. The sketch asks NTP for the time and writes it to the DS3231, which keeps it from then on. The display shows the
hours and
minutes with a colon blinking every second. At 07:00 the ALARM goes off: the display flashes and the NeoPixel flashes
red until it
is stopped. The NeoPixel at rest is green with the alarm armed and blue with the alarm off. The BOOT button (GPIO0),
STOP on the
page or STOP in the monitor stops it.
Press Run. The board joins TEP-WiFi and the DS3231 gets the time. About 40 s later the alarm rings. On the phone click
STOP, +5 MIN
and ARM.
The supply: in the demo the modules' VCC is Proteus' power rail; on a real board they sit on the QT Py's 3V.
Closed a window? The USB-C port of the board opens the monitor, the PANEL pad the panel. The monitor (115200) prints
every event
and a status line every 10 s and takes STATUS and STOP.

THE PINS (the label on the board, what it can do in the simulation)
  A0 .. A3      GPIO18, 17, 9, 8: analogRead 0 .. 4095 for 0 .. 3.3 V, GPIO, PWM, interrupt
  SDA / SCL     GPIO7 / 6: Wire
  TX / RX       GPIO5 / 16: Serial1
  SCK / MI / MO GPIO36 / 37 / 35: SPI
  3V, 5V, GND   3.3 V (the logic), 5 V, ground
  On the board: BOOT = GPIO0 (BUTTON, LOW when pressed), the NeoPixel = RGB_BUILTIN (rgbLedWrite), GPIO38 = its power,
  Serial = the USB

PROPERTIES (double-click the board > Edit Properties)
  PROGRAM   the sketch's HEX (Arduino IDE: Sketch > Export Compiled Binary with QT Py ESP32-S3 (TEP Proteus))
  WIFISSID  the router in range (default TEP-WiFi);  WIFIPASS  its password (default 12345678)
  MONITOR   YES = the built-in serial monitor on Serial;  BAUD  its speed (115200, or AUTO)
  AUTOOPEN  YES = the monitor window opens at Run (the demo: YES)
  TIME      the clock for NTP: PC (the PC's clock) or YYYY-MM-DD HH:MM:SS in UTC
The IP address follows the part's number: U1 192.168.1.101, U2 .102 ...

TROUBLESHOOTING
* Nothing happens at Run: the HEX was not built with TEP Boards for Proteus - select QT Py ESP32-S3 (TEP Proteus) and
  export
  again.
* "DS3231 NOT FOUND": SDA and SCL on the QT Py's SDA and SCL pins.
* The display stays dark: CLK on A0, DIO on A1, and display.setBrightness() before the first number.
* The time is wrong: the TIME property sets what NTP answers; PC uses your computer's clock.
* The board stays off the network: the sketch's SSID / password differ from WIFISSID / WIFIPASS.
* An integer goes wrong above 32767: int is 16 bits in the simulation - use long.
* The page shows old values: tap Reload (the monitors do not reload by themselves).

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot and the Serial Monitor text:
  https://www.theengineeringprojects.com/forum/category/adafruit-qt-py-esp32-s3-proteus-library

LICENCES AND THIRD-PARTY NOTES
* The board model and the Wi-Fi network (TEPNET.DLL), the symbols and artwork (TEPQTPYS3.LIB, TEPLAPTOP.LIB,
  TEPMOBILE.LIB) and the DS3231 and TM1637 models are made by The Engineering Projects. The source code of the models is
  not included.
* TEP Boards for Proteus (Arduino Code): its core, the variants and the EEPROM, SPI and Wire libraries are modified
  copies of the Arduino AVR core 1.8.6 - GNU Lesser General Public License 2.1 (LGPL 2.1, the text:
  LICENSE-LGPL-2.1.txt); its WiFi, WebServer and the other libraries and our core files are MIT (LICENSE-MIT.txt).
* The demo sketch uses RTClib (MIT) and TM1637 by Avishay Orpaz (LGPL 3.0) - install them in the Arduino IDE (Library
  Manager) to
  compile it; the .hex is included.
* Proteus is a product of Labcenter Electronics and is not included. QT Py is a name of Adafruit Industries, ESP32-S3 of
  Espressif Systems. This library is not made or endorsed by them or by Labcenter.

REBUILDING THE FIRMWARE (OPTIONAL)
The HEX file is supplied. Install TEP Boards for Proteus (INSTALLATION step 5), RTClib and TM1637, open Arduino
Code\QTPyS3_WiFi_Clock, select QT Py ESP32-S3 (TEP Proteus) and use Sketch > Export Compiled Binary. For a real
QT Py install "esp32" by Espressif Systems (3.x), select "Adafruit QT Py ESP32-S3" and upload - the same sketch.

MODEL SCOPE AND LIMITS
Modelled: the QT Py's 11 GPIO pins; digital I/O, analogRead 0 .. 4095, PWM (analogWrite / ledc) and attachInterrupt
through the
board model; RST, BOOT (GPIO0) and the NeoPixel; Serial (the board's monitor), Serial1 on TX / RX, Wire on SDA / SCL
and SPI on SCK /
MI / MO; WiFi station mode, DHCP, TCP, UDP, WebServer, HTTPClient, mDNS and NTP; the other TEP Wi-Fi parts on the same
network. Not
modelled: the ESP32-S3 itself (the two 240 MHz cores, the PSRAM, the flash, the vector instructions), Bluetooth LE,
the native USB, the
STEMMA QT socket as a connector (use the SDA and SCL pins), the touch pads' capacitance. The simulation runs below
real time.

VERSION
TEP QT Py ESP32-S3 library V1.0 (Nov 2026). Device QT PY ESP32-S3 (TEPQTPYS3.LIB / TEPNET.DLL), TEP Boards for
Proteus
1.42.0 (adds the QT Py ESP32-S3). Demo sketch QTPyS3_WiFi_Clock V1.0. Demo parts: DS3231ADVTEP and TM1637ADVTEP
(the
Advance versions), LAPTOP WIFI MONITOR and MOBILE WIFI MONITOR.