Project Files of Arduino UNO Q Library for Proteus: Bridge, Python, LED Matrix

ARDUINO UNO Q LIBRARY FOR PROTEUS - V1.0 (QRB2210 LINUX + STM32U585 MCU, THE BRIDGE, THE 8 X 13 LED MATRIX, WI-FI)
YOUR PYTHON PROGRAM AND YOUR SKETCH RUN TOGETHER - DEMO: A SMART GREENHOUSE WITH A WEB PAGE
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/10/arduino-uno-q-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/arduino-uno-q-proteus-library
The demo's parts are our libraries (included) - their articles:
  DHT22:
    https://www.theengineeringprojects.com/2026/10/dht11-dht22-library-for-proteus-v1-0.html
  Soil probe:
    https://www.theengineeringprojects.com/2026/10/capacitive-soil-moisture-sensor-library-for-proteus-v1-0.html
  WS2812B:
    https://www.theengineeringprojects.com/2026/10/ws2812b-neopixel-library-for-proteus-v1-0.html
  Relay:
    https://www.theengineeringprojects.com/2026/10/relay-module-library-for-proteus-v1-0.html
  Laptop:
    https://www.theengineeringprojects.com/2026/10/laptop-wifi-monitor-library-for-proteus.html
  Phone:
    https://www.theengineeringprojects.com/2026/10/mobile-wifi-monitor-library-for-proteus.html
Our other boards that run Python, and our Arduino Wi-Fi boards:
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-4-model-b-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/arduino-uno-r4-wifi-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Arduino-UNO-Q-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPCAPSOIL.LIB                                   60.1 KB   the soil probe (demo), to LIBRARY
|   |-- TEPDHT.LIB                                      155.3 KB   the DHT22 (demo), to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPRELAY.LIB                                    490.4 KB   the relay (demo), to LIBRARY
|   |-- TEPUNOQ.LIB                                      50.4 KB   the Arduino UNO Q, to LIBRARY
|   |-- TEPWS2812.LIB                                    1.59 MB   the WS2812B ring (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPCAPSOIL.DLL                                  312.5 KB   the soil probe, to MODELS
|   |-- TEPDHT.DLL                                      306.5 KB   the DHT22, to MODELS
|   |-- TEPNET.DLL                                       2.44 MB   the board + monitors + network, to MODELS
|   |-- TEPRELAY.DLL                                    330.0 KB   the relay, to MODELS
|   |-- TEPWS2812.DLL                                   312.5 KB   the WS2812B ring, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  953.8 KB   TEP Pi runtime, gpiozero (72 files)
|-- Arduino Code/
|   |-- UNO-Q-Blink/python/main.py                        0.4 KB   Blink: the Python program
|   |-- UNO-Q-Blink/sketch/sketch.ino                     0.5 KB   Blink: the sketch
|   |-- UNO-Q-Greenhouse/python/main.py                   5.4 KB   the greenhouse: the Python program
|   |-- UNO-Q-Greenhouse/sketch/sketch.ino                4.0 KB   the greenhouse: the sketch
|   |-- TEP Boards for Proteus/hardware/                641.9 KB   the Arduino IDE add-on 1.16.0 (157 files)
|-- Proteus Simulation/
|   |-- blink.hex                                        20.6 KB   the Blink app's sketch
|   |-- blink.py                                          0.4 KB   the Blink app's python/main.py
|   |-- main.py                                           5.4 KB   the greenhouse's Python program
|   |-- sketch.hex                                       44.3 KB   the greenhouse's sketch
|   |-- TEPCAPSOIL.DLL                                  312.5 KB   copy of the model
|   |-- TEPDHT.DLL                                      306.5 KB   copy of the model
|   |-- TEPNET.DLL                                       2.44 MB   copy of the model
|   |-- TEPRELAY.DLL                                    330.0 KB   copy of the model
|   |-- TEPWS2812.DLL                                   312.5 KB   copy of the model
|   |-- UNO-Q-Blink.pdsprj                               17.7 KB   the board alone: blink through the Bridge
|   |-- UNO-Q-Smart-Greenhouse.pdsprj                    43.3 KB   the demo: a smart greenhouse
|-- README.txt                                          ~17.8 KB   this file
Total: 28.98 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Arduino UNO Q (2025: Arduino's board with two processors in the UNO's shape) as one Proteus part - and a way to run
UNO Q apps in Proteus 8.5. A UNO Q app has two halves, as in Arduino App Lab: a Python program on the Qualcomm QRB2210
(Debian Linux) and a sketch on the STM32U585 microcontroller, which call each other's functions through the Bridge.
Proteus cannot run Debian or an STM32, so this library does what matters for electronics:
  * The sketch (the PROGRAM property: a .hex compiled with our TEP Boards for Proteus add-on, board "Arduino UNO Q")
    runs on a hidden ATmega2560 at 16 MHz inside the part: D0 - D13, A0 - A5 and SDA / SCL are its pins, with
    digitalWrite / Read, analogRead (10 bits for 0 - 3.3 V by default), analogWrite and attachInterrupt on any pin,
    Serial1 on D0 / D1, Wire on SDA / SCL, SPI on D10 - D13, and libraries such as DHT and Adafruit NeoPixel.
  * The Python program (the MAINPY property, App Lab's python/main.py) runs in Python 3.11 (included: the TEPPi folder)
    with our TEP runtime, in lockstep with Proteus: while it runs, Proteus waits; while it sleeps or waits for the
    network or the Bridge, Proteus runs. time.sleep(1) is 1 s of simulation; threads work.
  * The Bridge - arduino.app_utils on Linux, Arduino_RouterBridge in the sketch, with the names of Arduino's libraries:
      Python:  Bridge.call("name", args..., timeout=10)   Bridge.notify("name", args...)   Bridge.provide("name", fn)
               App.run(user_loop=loop)   Leds.set_led1_color(r, g, b) / set_led2_color(r, g, b)
      sketch:  Bridge.begin();  Bridge.provide("name", fn) / provide_safe;  Bridge.call("name", args...).result(x);
               Bridge.notify("name", args...);  Monitor.begin(115200); Monitor.println(...)
    Arguments and answers: bool, int, float, str / String / const char* (None from a void function). Errors as on the
    board: Python raises ValueError (the sketch does not provide it) or TimeoutError; in the sketch result() returns
    false and getErrorCode() / getErrorMessage() tell why.
  * Wi-Fi on Linux: wlan0 joins the router of the WIFISSID property ("TEP-WiFi", the router of our Wi-Fi parts and the
    Laptop / Mobile WiFi Monitors); the board is 192.168.1.51 (192.168.1.(50 + the part's number)), uno-q.local.
    Python's socket, http.server and urllib work on it.
  * The LEDs: the 8 x 13 blue LED matrix (Arduino_LED_Matrix: begin, draw with setGrayscaleBits, loadFrame,
    renderBitmap, loadSequence and playSequence), RGB LED 3 and 4 on the sketch's pins LED3_R, LED3_G, LED3_B and
    LED4_R, LED4_G, LED4_B (lit when LOW; LED_BUILTIN = LED 3's red), RGB LED 1 and 2 on Linux
    (/sys/class/leds/red:user, green:user, blue:user, red:panic, green:wlan, blue:bt or Leds.set_led1_color; LED 2's
    green shows Wi-Fi until a program takes it), and the green power LED.
  * Two windows (our TEP windows, no Windows title bar): the Linux terminal (arduino@uno-q:~$ python3 main.py, the
    program's output and errors, a line for input(), a Board tab with LED 1 / 2 and RESTART PROGRAM) - click the QRB2210
    to open it - and the sketch's serial monitor (Monitor / Serial, a Board tab with every pin and LED 3 / 4) - click
    the USB-C port. The power button restarts the Python program (on the real board a long press reboots Linux).
The board is drawn our way at its real size (68.58 x 53.34 mm, the UNO outline) from Arduino's own top-view drawing: the
USB-C port on the left, the digital header along the top, the power and analog headers along the bottom, the power
button, the WCBN3536A Wi-Fi / Bluetooth module and its PCB antenna, the QRB2210 and its LPDDR4X + eMMC, the STM32U585,
the JCTL and JSPI headers, the Qwiic connector, the matrix and the four RGB LEDs. We keep the UNO's vertical pin labels
next to the headers.

ONE DEVICE (search "UNO Q" in Pick Devices):
  ARDUINO UNO Q  "Arduino UNO Q" V1.0 (category Microprocessor ICs > Arduino UNO Q), prefix UQ, model TEPNET.DLL (with
                 the TEPPi folder)
The same TEPNET.DLL also runs our Raspberry Pi boards, the Jetson Nano, the BeagleBone Black, our ESP32 / Arduino Wi-Fi
boards, our Ethernet and Wi-Fi shields and modules and the Laptop / Mobile WiFi Monitors; it replaces any older
TEPNET.DLL (keep only this newest one).

TEST STATUS
V1.0: verified in Proteus 8.5 on 24 Oct 2026 with the demo projects as shipped. What the Proteus runs showed:
* UNO-Q-Smart-Greenhouse: the Linux terminal shows "arduino@uno-q:~$ python3 main.py"; wlan0 joins TEP-WiFi and about
  2.5 s after Run the program prints "serving on http://192.168.1.51:7000/". The sketch's monitor: "greenhouse sketch:
  DHT22 on D2, soil on A0, ring on D6, pump relay on D7", then "T 26.0 C  RH 58 %  soil 54 % (1854 mV)" every 2 s (the
  DHT22 at 26.0 C / 58 %, the soil probe's MOIST preset); LED1 cyan (AUTO), LED2 green (Wi-Fi), LED3 green (moist), the
  matrix shows the readings.
* The laptop and the phone opened the page; LIGHT 100 from the laptop: Python called the sketch's set_light and all 12
  LEDs of the WS2812B ring lit.
* DRY on the soil probe's pop-up: AUTO printed "pump ON - soil 31 % < 35 %" and the sketch's set_pump switched the relay
  on; then "soil 18 % (2300 mV)" - LED3 red, LED4 blue: the power LED, all four RGB LEDs and the matrix lit at once.
* WET: "pump OFF - soil 63 %", then "soil 67 % (1680 mV)". PUMP ON from the phone: MANUAL, LED1 magenta, "pump ON - by
  hand"; AUTO: "pump OFF - soil 67 %"; DRY 40 from the laptop: "dry below 40 %" (the sketch's set_dry_limit). The pages
  followed every step after REFRESH ("waterings: 1").
* The Board tabs: the sketch's D2 / D6 / D7 and LED3R ... LED4B, A0 1.68 V (520 of 1023), 3V3 3.30 V; the Linux side's
  LED1 / LED2 and main.py. About 35 s of simulation, no errors.
* UNO-Q-Blink: "arduino@uno-q:~$ python3 blink.py", then "LED on" / "LED off" every second; RGB LED 3's red blinks.
* Speed on our test PC: about 10 - 14 % of real time for the greenhouse with the four pop-ups, the two windows and both
  monitors open; about 28 % for Blink.

INSTALLATION (about 5 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 - use the folder that already holds
   Proteus's own .LIB files). TEPUNOQ.LIB is the UNO Q; TEPDHT.LIB, TEPCAPSOIL.LIB, TEPWS2812.LIB, TEPRELAY.LIB,
   TEPLAPTOP.LIB and TEPMOBILE.LIB are the demo's parts.
3. Copy everything in "Proteus Model Files" - the DLLs AND the TEPPi folder - to the MODELS folder:
     C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\MODELS
   TEPPi holds Python 3.11 and the TEP runtime; the board finds it next to TEPNET.DLL, in MODELS or next to your
   project. Replace an older TEPNET.DLL and TEPPi folder (these are the newest).
4. Delete TEPUNOQ.IDX (and the .IDX of a part library you replaced) from the LIBRARY folder if it is there.
5. For your own sketches: copy the folder "Arduino Code\TEP Boards for Proteus\hardware" into your Arduino sketchbook
   (Documents\Arduino - the result: Documents\Arduino\hardware\tep\avr\boards.txt), restart the Arduino IDE and choose
   Tools > Board > TEP Boards for Proteus > Arduino UNO Q (TEP Proteus). The add-on 1.16.0 needs the "Arduino AVR
   Boards" platform installed (its compiler); its own README tells more.
6. Start Proteus. In Pick Devices (P) search "UNO Q".
Nothing else to install: Python is in TEPPi (no Python on the PC needed, none is changed).

RUN THE DEMOS
Keep the .hex, the .py files and the DLLs beside the projects in "Proteus Simulation" (the TEPPi folder in MODELS).
  UNO-Q-Smart-Greenhouse.pdsprj - UQ1 runs sketch.hex (the sketch) and main.py (the Python program) on Wi-Fi:
  DHT1 = a DHT22 (VCC 3V3, DATA on D2), U1 = a capacitive soil moisture probe (VCC 5V, AOUT on A0), NEO1 = a 12-LED
  WS2812B ring, the grow light (5V, DIN on D6), RLY1 = a relay module for the pump (VCC 5V, IN on D7, active LOW);
  PC1 = the Laptop WiFi Monitor and MOB1 = the Mobile WiFi Monitor on the same router. The four parts are the Advance
  parts: their pop-up windows open at Run.
  The sketch reads the DHT22 and the soil every 2 s, shows the soil's last 13 readings as bars on the matrix, lights
  LED 3 green (moist) or red (drier than the limit) and LED 4 blue while the pump runs, and sends each reading to
  Python with Bridge.notify("readings", ...). It provides set_pump, set_light and set_dry_limit.
  The Python program waters in AUTO: the pump on (Bridge.call("set_pump", True)) when the soil is drier than the limit
  (35 %), off again 15 points above it. It serves http://192.168.1.51:7000/ with http.server: the temperature, the
  humidity, the soil, the pump and the grow light, with REFRESH, PUMP ON, PUMP OFF, AUTO, DRY 30, DRY 40,
  LIGHT OFF, LIGHT 50 and LIGHT 100. LED 1 is cyan in AUTO, magenta when you drive the pump by hand.
  Press Run, then change the soil with the probe's pop-up (DRY, DAMP, MOIST, WET, SOAKED, or WATER IT / DRY OUT) and the
  air with the DHT22's; on the laptop or the phone open the page (Browser, the address, Go).
  UNO-Q-Blink.pdsprj - UQ1 alone: blink.py (the Blink app's python/main.py) calls the sketch's set_led_state every
  second through the Bridge (blink.hex): RGB LED 3's red blinks.

YOUR OWN APPS
An app is a sketch and a Python program, as in App Lab ("Arduino Code\UNO-Q-Greenhouse" and "Arduino Code\UNO-Q-Blink":
sketch\sketch.ino and python\main.py). Compile the sketch in the Arduino IDE for "Arduino UNO Q (TEP Proteus)" (Sketch >
Export Compiled Binary) and set the board's PROGRAM to the .hex; put the Python program next to your project and set
MAINPY to its name (or a full path). Python's standard library is there; other pure-Python packages work when you copy
them next to your program. The same two files run on a real UNO Q in App Lab.

THE HEADERS (the modelled pins)
  Top (JDIGITAL): SCL (D21), SDA (D20), AREF, GND, 13, 12, ~11, ~10, ~9, 8, 7, ~6, ~5, 4, ~3, 2, TX>1, RX<0
  Bottom (JANALOG): BOOT, IOREF (3.3 V), RESET (the sketch), 3.3V, 5V, GND, GND, VIN, A0 - A5 (D14 - D19)
3.3 V logic: A0 and A1 (and D3) are not 5 V tolerant on the real board; an analog input takes 0 - 3.3 V.

PROPERTIES (double-click the board > Edit Properties)
  PROGRAM        the sketch: a .hex from TEP Boards for Proteus (board "Arduino UNO Q")
  MAINPY         the Python program (default main.py; a name next to the project or a full path)
  WIFISSID       the Wi-Fi network wlan0 joins (default TEP-WiFi); WIFIPASS its password
  LINUXAUTOOPEN  the Linux terminal at Run: YES (default) or NO
  MONITOR        the sketch's serial monitor (Monitor / Serial): YES (default) or NO; BAUD its baud rate (115200)
  AUTOOPEN       the sketch's monitor at Run: YES or NO (default)
  PYTHON         a python.exe of your own (empty: TEPPi's)
  RUNTIME        the TEP runtime folder (empty: TEPPi's)

TROUBLESHOOTING
* "TEP Pi: the TEPPi folder ... was not found": copy the TEPPi folder from "Proteus Model Files" into MODELS (or next
  to the project).
* "python3: can't open file 'main.py'": the MAINPY file is not next to the project - put it there or give a full path.
* ValueError: Request set_pump failed: method not available: the sketch does not provide that name - check the sketch's
  Bridge.provide and that Bridge.begin() runs in setup().
* TimeoutError: the sketch did not answer in time - it must call Bridge.begin() and spend time in loop() or delay()
  (a provided function runs between two loop()s or while the sketch waits in delay()).
* RuntimeError: Bridge.call() inside a provided handler: set a flag in the handler and call from your loop (as on the
  real board: it can deadlock the Bridge).
* No module named 'RPi': RPi.GPIO and gpiozero are Raspberry Pi libraries - on a UNO Q the pins are the sketch's.
* The soil probe reads drier than its panel: calibrate the sketch's AIR_MV / WATER_MV on your supply; run the probe on
  5V (its regulator drops out at 3.3 V).
* The page does not open: the address is http://192.168.1.51:7000/ and the program must have printed "serving on". A
  monitor sometimes needs Go a second time. Use the page's REFRESH link to see new values.
* A paused simulation shows the SIMULATION LOG: click the Schematic Capture tab.

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot, the sketch, the program, the terminal's text and the simulation log:
  https://www.theengineeringprojects.com/forum/category/arduino-uno-q-proteus-library

SUPPORT US
This library is free. If it saves you time, please support our work:
  https://www.theengineeringprojects.com/donate

WEBSITE
  https://www.theengineeringprojects.com/

LICENCES AND THIRD-PARTY NOTES
* The Arduino UNO Q board model, the Bridge, the TEP runtime, the terminals and the network (TEPNET.DLL, the compiled
  .pyc files in TEPPi\runtime with the stand-ins arduino.app_utils, smbus2, spidev, serial and the Raspberry Pi, Jetson
  and BeagleBone ones), the symbols and artwork (TEPUNOQ.LIB), the part models (TEPDHT, TEPCAPSOIL, TEPWS2812 and
  TEPRELAY .DLL / .LIB, the Laptop and Mobile WiFi Monitors' TEPLAPTOP.LIB / TEPMOBILE.LIB in TEPNET.DLL),
  Arduino_RouterBridge and Arduino_LED_Matrix in the add-on and the demo apps are made by The Engineering Projects. Our
  stand-ins follow the APIs of Arduino's app_utils, Arduino_RouterBridge and Arduino_LED_Matrix; none of their code is
  copied. The source code of the models is not included (nor the runtime's: it ships compiled for the included Python
  3.11).
* "TEP Boards for Proteus" (Arduino Code) contains the Arduino AVR core's files under the LGPL 2.1 and our own files
  under the MIT licence (its LICENSE files). The demo's sketch uses the DHT sensor library 1.4.6 and Adafruit NeoPixel
  1.12.3 (MIT and LGPL 3, by Adafruit) - install them in the Arduino IDE to compile it; the .hex is included.
* TEPPi\python is the official embeddable Python 3.11.9 for Windows (32-bit) from python.org, unchanged, under the
  Python Software Foundation License (TEPPi\python\LICENSE.txt).
* TEPPi\runtime\gpiozero is gpiozero 2.0.1.post3 and TEPPi\runtime\colorzero is colorzero 2.0, unchanged, under the BSD
  3-Clause licence (their LICENSE files in the dist-info folders) - for our Raspberry Pi boards.
* Proteus is a product of Labcenter Electronics and is not included. Arduino and UNO are trademarks of Arduino S.r.l.;
  Qualcomm and Dragonwing are trademarks of Qualcomm; STM32 is a trademark of STMicroelectronics. This library is not
  made or endorsed by Arduino, Qualcomm, STMicroelectronics or Labcenter.

MODEL SCOPE AND LIMITS
Modelled: the sketch on the headers' pins (D0 - D13, A0 - A5, SDA / SCL), PWM and interrupts on any pin, Serial1, Wire,
SPI, the LED matrix, RGB LED 3 / 4; the Python program with the Bridge both ways, wlan0 (the join, DHCP, TCP and UDP to
every TEP network part), RGB LED 1 / 2, the board's /proc and /sys files (/proc/cpuinfo: four ARMv8 cores, model
"Arduino UNO Q"), a short boot before the program starts, both terminals. Not modelled: Debian (no desktop, no shell
commands, no apt, no os.system), App Lab's Bricks (the Web UI brick, AI models - serve your page with http.server as the
demo does), the STM32's own peripherals beyond the Arduino API (CAN, the DACs, the op-amps, its 14-bit ADC's speed), the
Qwiic, JMISC, JMEDIA, JCTL and JSPI connectors, the camera, display and audio interfaces, USB-C, Bluetooth, C programs
and C extensions on Linux. The sketch runs on an ATmega2560 at 16 MHz (not a 160 MHz Cortex-M33: heavy sketches are
slower), the Python side takes no simulation time for pure Python code. The model's own choices: the board's IP address
(192.168.1.51 for UQ1), the boot time, the router; the simulation runs below real time.

VERSION
TEP Arduino UNO Q library V1.0 (Oct 2026). Device ARDUINO UNO Q (TEPUNOQ.LIB / TEPNET.DLL with TEPPi: Python 3.11.9 and
the TEP runtime 0.2). TEP Boards for Proteus 1.16.0. Demo apps UNO-Q-Greenhouse and UNO-Q-Blink V1.0.