Project Files of Raspberry Pi 5 Library for Proteus: MLX90614, Fan, Web Server

RASPBERRY PI 5 LIBRARY FOR PROTEUS - V1.0 (BCM2712 2.4 GHZ, 8 GB, RP1, GIGABIT ETHERNET, WI-FI, 40-PIN HEADER)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: AN IR SMART FAN (MLX90614, TB6612FNG, 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/raspberry-pi-5-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-5-proteus-library
The demo's parts are our libraries (included) - their articles:
  MLX90614: https://www.theengineeringprojects.com/2026/10/mlx90614-ir-thermometer-library-for-proteus-v1-0.html
  TB6612:   https://www.theengineeringprojects.com/2026/10/tb6612fng-motor-driver-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
The earlier boards of this series:
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-model-b-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-1-model-b-plus-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-2-model-b-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-3-model-b-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-3-model-b-plus-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-3-model-a-plus-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-4-model-b-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Raspberry-Pi-5-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMLX90614.LIB                                  55.2 KB   the MLX90614 thermometer (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPMOTOR.LIB                                     16.2 KB   the TT gear motor (demo), to LIBRARY
|   |-- TEPRPI5.LIB                                      60.5 KB   the Raspberry Pi 5, to LIBRARY
|   |-- TEPTB6612.LIB                                    71.1 KB   the TB6612FNG driver (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPMLX90614.DLL                                 338.5 KB   the MLX90614 thermometer, to MODELS
|   |-- TEPMOTOR.DLL                                    153.5 KB   the TT gear motor, to MODELS
|   |-- TEPNET.DLL                                       2.38 MB   the Pi + monitors + network, to MODELS
|   |-- TEPTB6612.DLL                                   296.0 KB   the TB6612FNG driver, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  893.7 KB   TEP Pi runtime, gpiozero (62 files)
|-- Python Code/
|   |-- blink.py                                          0.3 KB   an LED on GPIO17 (the default)
|   |-- smart_fan.py                                      7.4 KB   the demo
|-- Proteus Simulation/
|   |-- Pi-5-IR-Smart-Fan.pdsprj                         33.6 KB   the demo: IR smart fan
|   |-- smart_fan.py                                      7.4 KB   the program of the demo
|   |-- TEPMLX90614.DLL                                 338.5 KB   copy of the model
|   |-- TEPMOTOR.DLL                                    153.5 KB   copy of the model
|   |-- TEPNET.DLL                                       2.38 MB   copy of the model
|   |-- TEPTB6612.DLL                                   296.0 KB   copy of the model
|-- README.txt                                          ~20.3 KB   this file
Total: 25.02 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Raspberry Pi 5 (2023) as one Proteus part - and a way to run Raspberry Pi programs in Proteus 8.5.
Proteus cannot run Raspberry Pi OS, so this library does not emulate Linux. It does what matters for electronics: the
board runs YOUR PYTHON PROGRAM (a .py file, the PROGRAM property) against the circuit on the sheet, with the Python
libraries a Pi uses for its pins, its I2C / SPI / UART buses and its network.
  * At Run the board starts Python 3.11 (included: the TEPPi folder) with our TEP Pi runtime, then your program.
    The program and Proteus work in lockstep: while the program runs, Proteus waits; while the program sleeps, waits
    for a pin, a bus or the network, Proteus runs. So time.sleep(0.5) is 0.5 s of simulation, a busy loop still moves
    the clock (about 1 us per GPIO call, as Python on the Pi 5's 2.4 GHz Cortex-A76), and every edge is on time.
    time.time(), time.monotonic(), time.strftime() and datetime.now() follow the simulation's clock too.
  * The Pi 5's GPIOs belong to its RP1 chip, so a Pi 5 program drives them through the Linux gpiochip with lgpio -
    and so does this board: lgpio is built in, and gpiozero runs on it (its LGPIOFactory, as on a real Pi 5).
  * The network: eth0 when the Ethernet cable is in at Run (ETHERNET IN, the default; a click on the RJ45 plugs or
    unplugs it), wlan0 when it is out - wlan0 then joins the network in the WIFISSID / WIFIPASS properties (default: our
    router "TEP-WiFi", password 12345678 - the network of our ESP32 / Arduino Wi-Fi parts and the Laptop / Mobile WiFi
    Monitors) 2.3 to 3.5 s after Run. One network interface at a time; the Pi is 192.168.1.51 (192.168.1.(50 + the
    part's number)), the name raspberrypi.local. The wired Pi and the Wi-Fi monitors meet on the same router.
  * Threads work (gpiozero's threads, your own threading.Thread, Timer, Queue, Lock): every wait is in simulation time;
    an error in a thread is printed as Python prints it ("Exception in thread ...").
  * The Python libraries for the pins (the same names, numbers and messages as on a Pi):
      lgpio         lg 0.2's module: gpiochip_open (gpiochip 0; 4 is the same chip), gpio_claim_input / output /
                    alert with SET_PULL_UP / DOWN / NONE, gpio_read, gpio_write, gpio_free, gpio_get_mode, callback()
                    with RISING_EDGE / FALLING_EDGE / BOTH_EDGES and debounce, tx_pwm (0.1 - 10000 Hz), tx_servo,
                    tx_pulse and tx_busy (made by the board, steady while the program sleeps), the group_ functions,
                    i2c_open and the i2c_read / write functions on bus 1, spi_open / spi_xfer on SPI0, serial_open on
                    the UART; errors raise lgpio.error
      gpiozero      LED, PWMLED, Button, OutputDevice, Buzzer, Servo, AngularServo, Motor, MotionSensor,
                    DistanceSensor, CPUTemperature and the rest (gpiozero 2.0.1, unchanged, on lgpio)
      RPi.GPIO      the same API as on the earlier boards (on a real Pi 5 it comes from the rpi-lgpio package)
      spidev        SPI0 on GPIO11 (SCLK), GPIO10 (MOSI), GPIO9 (MISO), CE0 = GPIO8, CE1 = GPIO7, modes 0 to 3, up to
                    8 MHz; xfer / xfer2 take up to 4096 bytes (spidev's bufsiz), writebytes2 any length
      smbus2 / smbus  I2C bus 1 on GPIO2 (SDA) / GPIO3 (SCL) at 100 kHz, the Pi's 1.8 k pull-ups: the byte / block
                    reads and writes, i2c_rdwr with i2c_msg; a device that does not answer gives OSError [Errno 121]
                    Remote I/O error
      serial        pyserial on /dev/ttyAMA0 (the Pi 5's UART0: TXD GPIO14, RXD GPIO15; /dev/serial0 is accepted too):
                    any baud rate, timeouts, back-to-back bytes
      1-Wire        the DS18B20's files under /sys/bus/w1/devices (w1-gpio on GPIO4), as the kernel makes them
      Adafruit_DHT, adafruit_dht + board   DHT11 / DHT22 on any GPIO
      socket        TCP and UDP on eth0 or wlan0, http.server / socketserver, urllib.request, select
  * The Pi's own files: /proc/cpuinfo (Revision d04170, four ARMv8 processors), /proc/device-tree/model ("Raspberry Pi
    5 Model B Rev 1.0"), /dev/gpiochip0 and /dev/gpiochip4, the CPU temperature in /sys/class/thermal (gpiozero's
    CPUTemperature), /proc/loadavg, /proc/meminfo (8 GB).
  * The Pi Terminal (our TEP window, no Windows title bar): the shell prompt (pi@raspberrypi:~ $ python3 ...), the
    program's output (OUT) and errors (ERR, as Python prints them on a Pi), a line for input() (IN); its Board tab
    shows the GPIOs (BCM numbers), the LEDs, the supply pins and RESTART PROGRAM. Click the HDMI0 socket or the
    processor to open it.
  * The LEDs: PWR (red) and ACT (green: it flickers while the board boots and when the program prints) at the left
    edge by the power button, and the RJ45 jack's own LEDs - LNK (green) and 100 (yellow), lit with the cable in.
  * The header's supply pins power the modules wired to them, as on the bench: 5V, 3V3 and GND as logic levels (an
    analog VCC reading sees 5 V on either rail).
The board is drawn our way at its real size (85 x 56 mm, rounded corners, four mounting holes) from the Raspberry Pi 5
drawing: the 40-pin header along the top edge, the metal shield can of the dual-band Wi-Fi / Bluetooth 5.0 module under
pin 1 with the raspberry logo below it, the PCIe connector on the left edge with the microSD card out of the edge below
it, the power button and the PWR / ACT LEDs at the left edge, the Renesas DA9091 power chip, the BCM2712 under its
silver heat spreader with the LPDDR4X above it, the RP1 I/O controller, the fan connector by the USB 2.0 pair, the
stacked USB 2.0 and blue USB 3.0 pairs and the RJ45 at the bottom of the right edge, the Ethernet PHY turned 45 degrees,
the PoE+ header, the two CAM/DISP connectors, the RTC battery and UART connectors, and along the bottom the USB-C power
socket and the two micro-HDMI sockets. The 40 pins leave the top edge as one comb 50 thou apart, each with a
colour-coded tag: 5V red, 3V3 orange, GND black, GPIO green, I2C blue, SPI pink, UART purple, ID_SD / ID_SC grey.

ONE DEVICE (search "RASPBERRY" in Pick Devices):
  RASPBERRY PI 5  "Raspberry Pi 5" V1.0 (category Microprocessor ICs > Raspberry Pi), prefix PI, model TEPNET.DLL
                  (with the TEPPi folder)
The same TEPNET.DLL also runs our Raspberry Pi Model B, 1 Model B+, 2 Model B, 3 Model B, 3 Model B+, 3 Model A+ and
4 Model B, our Ethernet and Wi-Fi shields, modules and boards and the Laptop / Mobile WiFi Monitors; it replaces any
older TEPNET.DLL (keep only this newest one in MODELS). The TEPPi folder in this zip adds lgpio: replace the older one.

TEST STATUS
V1.0: verified in Proteus 8.5 on 24 Oct 2026 with the demo project as shipped. What the Proteus runs showed:
* Pi-5-IR-Smart-Fan: eth0 is up 1.5 s after Run (the RJ45's LNK and 100 lit); the program prints "Raspberry Pi 5 Model
  B Rev 1.0", "gpiozero pin factory: LGPIOFactory; MLX90614 at 0x5A: object 35.41 C, room 24.99 C" (OBJECT 36 C,
  MATTE 0.95) and "serving on http://192.168.1.51:8000/".
* AUTO at 35.5 C: the fan at 55 %; the TB6612FNG's pop-up shows FORWARD (CW) 55 %, AIN1 / AIN2 HIGH / LOW, PWMA "PWM
  55 % at 1000 Hz", STBY HIGH, VM 5.00 V. The laptop and the phone open the page (text links on the laptop, buttons
  on the phone).
* The MLX90614's TEA preset (70 C): the reading rises (smoothed) - AUTO 100 % from 45.29 C, HOT! from 52.16 C and D1
  blinks; the pop-up reads OK, 0 PEC errors, 0 NACKs.
* 50 % on the phone: "the page: /50", MANUAL 50 %; REVERSE AIRFLOW on the laptop: INTAKE - the driver's pop-up shows
  REVERSE (CCW) 50 %, AIN1 / AIN2 LOW / HIGH, -2.44 V on the motor (2.68 V forward at 55 %).
* The ROOM preset (25 C): the alarm goes off at 46 C; AUTO on the phone: AUTO 0 % - AIN1 / AIN2 LOW, PWMA LOW, the
  driver STOP, the motor at rest.
* The Board tab: the BCM2712 at 2.4 GHz quad Cortex-A76, GPIO2 / GPIO3 pulled up, GPIO25 (STBY) HIGH, GPIO12 / 17 /
  23 / 24 LOW at the end, 5V 5.00 V, 3V3 3.30 V, "No errors".
* Speed on our test PC: about 20 to 50 % of real time with the two pop-ups, the two monitors and the Pi Terminal 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 - use the folder that already holds
   Proteus's own .LIB files). TEPRPI5.LIB is the Pi; TEPMLX90614.LIB (the IR thermometer), TEPTB6612.LIB (the motor
   driver), TEPMOTOR.LIB (the TT gear motor), 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 Pi runtime; the Pi 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 TEPRPI5.IDX (and the .IDX of a part library you replaced) from the LIBRARY folder if it is there.
5. Start Proteus. In Pick Devices (P) search "RASPBERRY".
Nothing else to install: Python is in TEPPi (no Python on the PC needed, none is changed).

RUN THE DEMO
Keep the .py file and the DLLs beside the project in "Proteus Simulation" (the TEPPi folder in MODELS).
  Pi-5-IR-Smart-Fan.pdsprj - PI1 runs smart_fan.py on Ethernet (the cable in): U1 = a GY-906 MLX90614 infra-red
  thermometer (SDA / SCL on GPIO2 / GPIO3, VIN on 3V3, address 0x5A, OBJECT 36 C), DRV1 = a TB6612FNG motor driver
  (PWMA on GPIO12, AIN1 on GPIO23, AIN2 on GPIO24, STBY on GPIO25, VCC on 3V3, VM on the 5 V supply rail) with M1 = a
  TT gear motor as the fan on AO1 / AO2, D1 = a green alarm LED on GPIO17 through R1 330R; PC1 = the Laptop WiFi
  Monitor and MOB1 = the Mobile WiFi Monitor on the same network. The thermometer and the driver are the Advance parts:
  their pop-up windows open at Run.
  Press Run: eth0 is up in about 1.5 s; the Pi Terminal shows the board, gpiozero's pin factory (LGPIOFactory), the
  first temperatures and "serving on http://192.168.1.51:8000/". The fan starts in AUTO: off below 30 C, 30 % at
  30 C rising to 100 % at 45 C, in 5 % steps (the object's reading is smoothed and a dead band keeps the speed steady).
  On the laptop or the phone open that address (Browser, the address, Go): the page shows the object's and the room's
  temperatures, the fan's speed and mode, the airflow and the alarm, with REFRESH, AUTO, OFF, 50 %, 100 % and REVERSE
  AIRFLOW (text links on the laptop, buttons on the phone). Change the scene in the MLX90614's pop-up (the presets
  ICE, ROOM, SKIN, TEA, BOILING, OVEN, or OBJECT -10 / -1 / +1 / +10): from 50 C the alarm LED blinks (gpiozero's
  blink) and the page says HOT!. 50 % and 100 % set the speed by hand, OFF stops the fan, AUTO hands it back to the
  temperature, REVERSE AIRFLOW turns the motor the other way (EXHAUST / INTAKE).
  The program is pure Python on lgpio - i2c_read_i2c_block_data for the MLX90614's RAM words with their PEC checked
  (CRC-8), gpio_claim_output / gpio_write for AIN1, AIN2 and STBY, tx_pwm at 1000 Hz on PWMA - plus gpiozero's LED,
  a control thread every 0.5 s and http.server.

YOUR OWN PROGRAMS
Write the program with any editor, put the .py next to your project and set the Pi's PROGRAM property to its name (or
a full path). Start from Python Code\blink.py (an LED on GPIO17 with gpiozero). Python's standard library is there;
other pure-Python packages work when you copy them next to your program. Use BCM numbers (gpiozero's LED(17),
lgpio's gpio_write(h, 17, 1)) - the GPIO numbers are the line numbers of gpiochip 0.
A program that never sleeps and never touches a pin for 3 real seconds is left running on its own (the simulation
goes on); input() waits for a line typed in the Pi Terminal.

THE 40-PIN HEADER (BCM numbers - the tags on the board)
   1 3V3        2 5V          3 GPIO2 SDA    4 5V          5 GPIO3 SCL    6 GND         7 GPIO4 (1-Wire)
   8 GPIO14 TXD 9 GND        10 GPIO15 RXD  11 GPIO17     12 GPIO18      13 GPIO27     14 GND
  15 GPIO22    16 GPIO23     17 3V3         18 GPIO24     19 GPIO10 MOSI 20 GND        21 GPIO9 MISO
  22 GPIO25    23 GPIO11 SCLK 24 GPIO8 CE0  25 GND        26 GPIO7 CE1   27 ID_SD      28 ID_SC
  29 GPIO5     30 GND        31 GPIO6       32 GPIO12     33 GPIO13      34 GND        35 GPIO19
  36 GPIO16    37 GPIO26     38 GPIO20      39 GND        40 GPIO21
3.3 V logic: GPIO2 / GPIO3 have the Pi's 1.8 k pull-ups to 3.3 V; the pull-ups / pull-downs of lgpio and RPi.GPIO are
weak drives. ID_SD / ID_SC (27, 28, GPIO0 / GPIO1) are kept for a HAT's ID EEPROM; leave them free, as on a real Pi.
The fan, PoE+, UART, RTC battery and power-button connectors are drawn, not pins of the part.

PROPERTIES (double-click the Pi > Edit Properties)
  PROGRAM    the Python program (default blink.py; a name next to the project or a full path)
  AUTOOPEN   the Pi Terminal at Run: YES (default) or NO
  ETHERNET   the cable to the router at Run: IN (default: eth0) or OUT (the network on wlan0)
  WIFISSID   the Wi-Fi network wlan0 joins (default TEP-WiFi)
  WIFIPASS   its password (default 12345678)
  PYTHON     a python.exe of your own (empty: TEPPi's)
  RUNTIME    the TEP Pi 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).
* "ModuleNotFoundError: No module named 'lgpio'": an older TEPPi folder is in MODELS - replace it with this one.
* "python3: can't open file": the PROGRAM file is not next to the project - put it there or give a full path.
* lgpio.error: 'GPIO not allocated': claim the GPIO first (gpio_claim_output / gpio_claim_input / gpio_claim_alert)
  with the handle from gpiochip_open(0).
* lgpio.error: 'I2C read failed' or OSError: [Errno 121] Remote I/O error: no part answers at that address - the
  MLX90614 is 0x5A; check its VIN / GND and SDA / SCL.
* The motor does not turn: STBY must be HIGH, AIN1 / AIN2 one HIGH and one LOW, PWM on PWMA, and VM needs the motor's
  own supply (2.5 - 13.5 V) - the driver's pop-up shows each input and the output.
* The page does not open: the address is http://192.168.1.51:8000/ (the port the program serves), 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 (the monitors' Reload repeats the last link, e.g. 50 %).
* 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 program, the Pi Terminal's text and the simulation log:
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-5-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 Raspberry Pi board model, the TEP Pi runtime, the Pi Terminal and the network (TEPNET.DLL, the compiled .pyc files
  in TEPPi\runtime with the stand-ins lgpio, RPi, smbus2, smbus, spidev, serial, Adafruit_DHT, adafruit_dht, board),
  the symbols and artwork (TEPRPI5.LIB), the part models (TEPMLX90614, TEPTB6612 and TEPMOTOR .DLL / .LIB, the Laptop
  and Mobile WiFi Monitors' TEPLAPTOP.LIB / TEPMOBILE.LIB in TEPNET.DLL) and the demo program are made by The
  Engineering Projects. Our stand-ins follow the APIs of lgpio, RPi.GPIO, smbus2, py-spidev, pyserial, Adafruit_DHT
  and adafruit-circuitpython-dht; 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).
* 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).
* Proteus is a product of Labcenter Electronics and is not included. Raspberry Pi is a trademark of Raspberry Pi Ltd.
  This library is not made or endorsed by Raspberry Pi Ltd or Labcenter.

MODEL SCOPE AND LIMITS
Modelled: the 26 GPIOs of the 40-pin header (inputs, outputs, pull-ups / pull-downs, edges and alerts, software PWM and
pulse trains), the I2C, SPI, UART, 1-Wire and DHT buses as the Pi's drivers drive them, the supply pins, Ethernet (eth0,
the cable) and Wi-Fi (wlan0: the join, DHCP, TCP and UDP to every TEP network part), one interface at a time, the LEDs,
a 0.5 s boot before the program starts, the Pi's /proc, /sys and /dev/gpiochip files above, the Pi Terminal. Not
modelled: Raspberry Pi OS (no desktop, no shell commands, no apt, no os.system), Bluetooth, the 5 GHz band and the
Gigabit speed (the network is the same TEP network at any band), PoE, wlan0 and eth0 at the same time, Wi-Fi scanning
from the program, the four cores (one program, its threads take turns), the RP1's PIO and its extra UART, I2C and SPI
buses (device-tree overlays), hardware PWM (lgpio's PWM is software-timed here and on a real Pi), the power button, the
real-time clock and its battery, the fan connector, PCIe, the debug UART connector, the micro-HDMI outputs, the camera
and display connectors, USB 2.0 / 3.0, the microSD card's files, a HAT's ID EEPROM, C programs and C extensions, the
real CPU's speed (each GPIO call takes about 1 us; pure Python code takes no simulation time), real-time jitter. The
model's own choices: the board's IP address (192.168.1.51 for PI1), the boot time, the router; the simulation runs
below real time.

VERSION
TEP Raspberry Pi 5 library V1.0 (Oct 2026). Device RASPBERRY PI 5 (TEPRPI5.LIB / TEPNET.DLL with TEPPi: Python 3.11.9
and the TEP Pi runtime 0.2 with lgpio). Demo program smart_fan.py V1.0, blink.py.