Project Files of Raspberry Pi Model B Library for Proteus: Python GPIO Simulation

RASPBERRY PI MODEL B LIBRARY FOR PROTEUS - V1.0 (THE ORIGINAL PI: BCM2835, 512 MB, 26-PIN HEADER, ETHERNET)
YOUR PYTHON PROGRAM RUNS ON THE BOARD: RPi.GPIO, gpiozero, smbus2, spidev, serial, sockets, http.server
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-model-b-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-model-b-proteus-library
The demos use our I2C LCD 16x2, HC-SR04, DS18B20 and DHT22 libraries (all included) - their articles:
  https://www.theengineeringprojects.com/2026/10/i2c-lcd-16x2-library-for-proteus-v1-0.html
  https://www.theengineeringprojects.com/2026/10/ultrasonic-sensor-library-for-proteus-v2-0.html
  https://www.theengineeringprojects.com/2026/10/ds18b20-library-for-proteus-v1-0.html
  https://www.theengineeringprojects.com/2026/10/dht11-dht22-library-for-proteus-v1-0.html
The web demo is opened by our Laptop WiFi Monitor and Mobile WiFi Monitor (both included) - their articles:
  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
Raspberry-Pi-Model-B-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPDHT.LIB                                      155.3 KB   DHT11 / DHT22 (demo), to LIBRARY
|   |-- TEPDS18B20.LIB                                   88.0 KB   DS18B20 (demo), to LIBRARY
|   |-- TEPHCSR04.LIB                                   170.1 KB   HC-SR04 (demo), to LIBRARY
|   |-- TEPI2CLCD16X2.LIB                               181.4 KB   I2C LCD 16x2 (demo), to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop, to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone, to LIBRARY
|   |-- TEPRPIB.LIB                                      48.7 KB   the Raspberry Pi Model B, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPDHT.DLL                                      306.5 KB   the DHT22, to MODELS
|   |-- TEPDS18B20.DLL                                  305.0 KB   the DS18B20, to MODELS
|   |-- TEPHCSR04.DLL                                   382.5 KB   the HC-SR04, to MODELS
|   |-- TEPLCD.DLL                                      371.0 KB   the LCD, to MODELS
|   |-- TEPNET.DLL                                       2.36 MB   the Pi + monitors, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                   1.60 MB   TEP Pi runtime, gpiozero (90 files)
|-- Python Code/
|   |-- blink.py                                          0.3 KB   an LED on GPIO17 (the default)
|   |-- distance_meter.py                                 1.9 KB   demo 1
|   |-- weather_web.py                                    2.4 KB   demo 2
|-- Proteus Simulation/
|   |-- distance_meter.py                                 1.9 KB   the program of demo 1
|   |-- Pi-Model-B-Distance-Meter.pdsprj                 44.2 KB   demo 1: HC-SR04 + I2C LCD
|   |-- Pi-Model-B-Weather-Web.pdsprj                    30.6 KB   demo 2: web page
|   |-- TEPDHT.DLL                                      306.5 KB   copy of the model
|   |-- TEPDS18B20.DLL                                  305.0 KB   copy of the model
|   |-- TEPHCSR04.DLL                                   382.5 KB   copy of the model
|   |-- TEPLCD.DLL                                      371.0 KB   copy of the model
|   |-- TEPNET.DLL                                       2.36 MB   copy of the model
|   |-- weather_web.py                                    2.4 KB   the program of demo 2
|-- README.txt                                          ~15.3 KB   this file
Total: 27.31 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The original Raspberry Pi Model B (revision 2, 2012) 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.
  * 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 or for the network, Proteus runs. So time.sleep(0.5) is 0.5 s of simulation, a busy loop still moves
    the clock (about 7 us per GPIO call, as Python on the Model B's 700 MHz ARM11), and every edge is on time.
  * Threads work (gpiozero's blink, hold and sampling threads, your own threading.Thread, Timer, Queue): every wait
    is a wait in simulation time.
  * The Python libraries for the pins (the same names, numbers and messages as on a Pi):
      RPi.GPIO      setmode, setup, output, input, cleanup, add_event_detect / event_detected / wait_for_edge with
                    callbacks and bouncetime, PWM (software PWM made by the board, steady while the program sleeps)
      gpiozero      LED, PWMLED, Button, LEDBoard, Buzzer, Servo, MotionSensor, LineSensor, DistanceSensor,
                    CPUTemperature and the rest (gpiozero 2.0.1, unchanged, on RPi.GPIO)
      smbus2 / smbus  I2C bus 1 on GPIO2 (SDA) / GPIO3 (SCL) at 100 kHz, the Pi's 1.8 k pull-ups; a device that does
                    not answer gives OSError [Errno 121] Remote I/O error
      spidev        SPI0 on GPIO11 (SCLK), GPIO10 (MOSI), GPIO9 (MISO), CE0 = GPIO8, CE1 = GPIO7, modes 0 to 3
      serial        pyserial on /dev/serial0 (= /dev/ttyAMA0): TXD GPIO14, RXD GPIO15, any baud rate
      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 the board's Ethernet, http.server / socketserver, urllib.request, select
  * The Pi's own files: /proc/cpuinfo (Revision 000e, BCM2835), /proc/device-tree/model ("Raspberry Pi Model B Rev
    2"), the CPU temperature in /sys/class/thermal (gpiozero's CPUTemperature), /proc/loadavg, /proc/meminfo.
  * Ethernet: the RJ45 is a cable to our virtual router (the same network as our ESP32 / Arduino Wi-Fi parts and the
    Laptop / Mobile WiFi Monitors). eth0 gets 192.168.1.51 (192.168.1.(50 + the part's number)) 1.2 s after Run,
    the name raspberrypi.local. Click the RJ45 jack to pull the cable or plug it in.
  * 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 HDMI socket or the
    processor to open it.
  * The status LEDs: PWR, ACT (the SD card: it flickers while the board boots and when the program prints), FDX, LNK
    (it flickers with the network traffic) and 100.
  * The header's supply pins drive their nets: modules wired to the Pi's 5V, 3V3 and GND get their power from it, as
    on the bench.
The board is drawn our way at its real size (85.6 x 56 mm): P1 in the top-left corner with P5's pads under it, the
yellow RCA video and blue audio jacks, the five LEDs, the stacked USB sockets and the RJ45 on the right, HDMI and the
camera connector at the bottom, micro-USB power, the display connector and the SD card on the left, the Samsung RAM on
the BCM2835 and the SMSC LAN9512. P1's 26 pins leave the top edge as one comb 50 thou apart (each pin under its column),
each with a colour-coded tag: 5V red, 3V3 orange, GND black, GPIO green, I2C blue, SPI pink, UART purple.

ONE DEVICE (search "RASPBERRY" in Pick Devices):
  RASPBERRY PI MODEL B  "Raspberry Pi Model B" V1.0 (category Microprocessor ICs > Raspberry Pi), prefix PI, model
                        TEPNET.DLL (with the TEPPi folder)
The same TEPNET.DLL also runs 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).

TEST STATUS
V1.0: verified in Proteus 8.5 on 24 Oct 2026 with the demo projects as shipped (the windows off-screen, posted clicks
and keys). What the Proteus runs showed:
* Pi-Model-B-Distance-Meter: the program starts 0.5 s after Run; gpiozero's DistanceSensor follows the
  HC-SR04's swinging object (14.8 cm to 141.7 cm), the I2C LCD shows "Distance: 14.8cm" and "TOO CLOSE!", the LED on
  GPIO17 lights below 20 cm, the terminal prints a reading every 0.5 s; gpiozero's PWMSoftwareFallback warning
  appears as on a real Pi.
* Pi-Model-B-Weather-Web: eth0 up 1.2 s after Run (192.168.1.51); the DS18B20 reads 24.0 C through /sys/bus/w1
  (crc YES), the DHT22 24.0 C and 50.0 %; the laptop (192.168.1.21) and the phone (192.168.1.41) open the page:
  HTTP 200; http.server logs each request in the Pi Terminal.
* The Board tab: the BCM pins (HIGH / LOW outputs, pull-up / pull-dn inputs), the LEDs, 5V 5.00 V and 3V3 3.30 V.
* Our test projects: gpiozero LED.blink / Button, RPi.GPIO edges with callbacks, software PWM (100 Hz), input() from
  the terminal, an I2C scan (0x27 found), SPI0 looped back in modes 0, 1, 2 and 3 (5 bytes each, all equal), I2C
  with no device (OSError [Errno 121] Remote I/O error), the UART looped back at 9600 and 115200 baud.
* Speed on our test PC: about 50 to 80 % of real time with 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). TEPRPIB.LIB is the Pi; the others are the demos' 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 (this one is the first with the Raspberry Pi).
4. Delete TEPRPIB.IDX (and the IDX files of the other LIBs) from the LIBRARY folder if they are 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 DEMOS
Keep the .py files and the DLLs beside the projects in "Proteus Simulation" (the TEPPi folder in MODELS).
  Pi-Model-B-Distance-Meter.pdsprj - PI1 runs distance_meter.py: U1 an HC-SR04 (TRIG GPIO23, ECHO GPIO24; its object
  swings from 60 cm), LCD1 an I2C LCD 16x2 (0x27 on SDA / SCL), the LED D1 on GPIO17 through R1 220R. The modules get
  5V and GND from the Pi's header (net labels 5V, GND). Press Run: after the 0.5 s boot the program starts - the LCD
  shows the distance and a bar, the terminal prints each reading, the LED lights closer than 20 cm.
  Pi-Model-B-Weather-Web.pdsprj - PI1 runs weather_web.py: U1 a DS18B20 on GPIO4 (1-Wire), DHT1 a DHT22 on GPIO17, both
  from the Pi's 3V3 and GND; PC1 the Laptop WiFi Monitor and MOB1 the Mobile WiFi Monitor (home page
  http://192.168.1.51:8000/). Press Run: "waiting for the network ...", then "serving on http://192.168.1.51:8000/"
  when eth0 is up; the readings every 2 s. In the laptop's or the phone's browser press Go: the page with both
  temperatures and the humidity; the terminal logs each request as http.server does on a Pi.

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). Python's standard library is there; other
pure-Python packages work when you copy them next to your program. Use BCM numbers (GPIO.setmode(GPIO.BCM),
gpiozero's LED(17)) or GPIO.setmode(GPIO.BOARD) with the header's pin numbers.
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 HEADER P1 (26 pins, 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
3.3 V logic: GPIO2 / GPIO3 have the Pi's 1.8 k pull-ups to 3.3 V; RPi.GPIO's pull-ups / pull-downs are weak drives.

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) or OUT
  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).
* "python3: can't open file": the PROGRAM file is not next to the project - put it there or give a full path.
* ModuleNotFoundError for a package: only the libraries above are built in; copy a pure-Python package's folder next to
  your program. C extensions (numpy, OpenCV, picamera) do not work.
* OSError [Errno 121] Remote I/O error: no I2C device answered its address - check SDA / SCL and the address.
* An LCD stays blank: give its controller time (the HD44780 wants about 5 ms after each init command).
* The page does not open: eth0 comes up 1.2 s after Run (the cable must be in); use the address the program prints.
* 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-model-b-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 RPi, smbus2, smbus, spidev, serial, Adafruit_DHT, adafruit_dht, board), the
  symbols and artwork (TEPRPIB.LIB) and the module models of the demos (TEPLCD.DLL, TEPHCSR04.DLL, TEPDS18B20.DLL,
  TEPDHT.DLL and their LIBs) are made by The Engineering Projects. Our stand-ins follow the APIs of 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 17 GPIOs of P1 (inputs, outputs, RPi.GPIO's pull-ups / pull-downs, edges, software PWM), the I2C, SPI,
UART, 1-Wire and DHT buses as the Pi's drivers drive them, the supply pins, Ethernet with TCP and UDP to every TEP
network part (DHCP 1.2 s after Run, the cable), the five status LEDs, a 0.5 s boot before the program starts, the
Pi's /proc and /sys files above, the Pi Terminal. Not modelled: Raspberry Pi OS (no desktop, no shell commands, no apt,
no os.system), the HDMI, RCA video and audio outputs, the camera and display connectors, USB, the SD card's files,
hardware PWM (GPIO18 is software PWM here), the P5 header, C programs and C extensions, the real CPU's speed (each GPIO
call takes about 7 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 Model B library V1.0 (Oct 2026). Device RASPBERRY PI MODEL B (TEPRPIB.LIB / TEPNET.DLL with TEPPi:
Python 3.11.9 and the TEP Pi runtime 0.2). Demo programs distance_meter.py and weather_web.py V1.0, blink.py.