Project Files of Raspberry Pi 1 Model B+ Library for Proteus: TFT LCD Touch Demo

RASPBERRY PI 1 MODEL B+ LIBRARY FOR PROTEUS - V1.0 (BCM2835, 512 MB, THE 40-PIN GPIO HEADER, 4 USB, ETHERNET)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: A 2.8" ILI9341 SPI TFT WITH TOUCH, DRIVEN FROM PYTHON
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-1-model-b-plus-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-1-model-b-plus-proteus-library
The demo uses our TFT ILI9341 + Touch library (included) - its article:
  https://www.theengineeringprojects.com/2026/10/tft-ili9341-library-for-proteus-v1-0.html
The first board of this series, the Raspberry Pi Model B (the 26-pin original):
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-model-b-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Raspberry-Pi-1-Model-B-Plus-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPILI9341.LIB                                  127.8 KB   the TFT (demo), to LIBRARY
|   |-- TEPRPIBP.LIB                                     55.7 KB   the Raspberry Pi 1 Model B+, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPILI9341.DLL                                  353.5 KB   the TFT, to MODELS
|   |-- TEPNET.DLL                                       2.37 MB   the Pi + the network, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  855.0 KB   TEP Pi runtime, gpiozero (61 files)
|-- Python Code/
|   |-- blink.py                                          0.3 KB   an LED on GPIO17 (the default)
|   |-- tft_dashboard.py                                 10.8 KB   the demo
|-- Proteus Simulation/
|   |-- Pi-1-Model-B-Plus-TFT-Dashboard.pdsprj           23.8 KB   the demo: TFT touch dashboard
|   |-- TEPILI9341.DLL                                  353.5 KB   copy of the model
|   |-- TEPNET.DLL                                       2.37 MB   copy of the model
|   |-- tft_dashboard.py                                 10.8 KB   the program of the demo
|-- README.txt                                          ~15.7 KB   this file
Total: 24.04 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Raspberry Pi 1 Model B+ (revision 1.2, 2014) 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, 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 7 us per GPIO call, as Python on the B+'s 700 MHz ARM11), and every edge is on time. time.time(),
    time.strftime() and datetime.now() follow the simulation's clock too.
  * Threads work (gpiozero's threads, your own threading.Thread, Timer, Queue): every wait is 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, 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, up to
                    8 MHz; xfer / xfer2 take up to 4096 bytes (spidev's bufsiz), writebytes2 any length
      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 0010, BCM2835), /proc/device-tree/model ("Raspberry Pi Model B Plus
    Rev 1.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 LEDs: PWR (red) and ACT (green: it flickers while the board boots and when the program prints) in the corner
    under pin 1, and the RJ45 jack's own LEDs - LNK (green, it flickers with the traffic) and 100 (yellow).
  * The header's supply pins drive their nets: modules wired to the Pi's 5V, 3V3 and GND get their power from it.
The board is drawn our way at its real size (85 x 56 mm, rounded corners, four mounting holes), from the B+ mechanical
drawing: the 40-pin header along the top edge, PWR / ACT and the RUN pads under pin 1, the DSI display connector on
the left with the microSD card under it, the Samsung RAM on the BCM2835, the SMSC LAN9514, the two stacked USB pairs
and the RJ45 on the right, the micro-USB power socket with the switch-mode supply, HDMI, the CSI camera connector and
the black 4-pole A/V jack along the bottom. 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 1 MODEL B+  "Raspberry Pi 1 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 Raspberry Pi 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).

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-1-Model-B-Plus-TFT-Dashboard: the program starts 0.5 s after Run, resets and sets up the ILI9341 (SLPOUT, DISPON,
  MADCTL 0xE8: 320 x 240 landscape, 16-bit colour), clears the screen and draws the dashboard; the backlight fades in
  (PWM on GPIO18). The time, the CPU temperature (gpiozero's CPUTemperature) with a sweeping bar chart, the address
  192.168.1.51 (eth0, 1.2 s after Run) and the uptime update twice a second.
* The touch: a press held on LED ON with the mouse - the XPT2046 reports x 81, y 208 (raw 2936, 744), the LED on GPIO27
  lights, the button gets its white frame and the screen says ON; a press on LED OFF - x 233, y 204 (raw 1209, 807),
  the LED goes off. The Pi Terminal prints each touch and a reading every 2 s.
* The Board tab: the BCM pins (HIGH / LOW outputs, pull-up inputs), the LEDs, 5V 5.00 V and 3V3 3.30 V.
* The RJ45's own LEDs (LNK, 100) light with the cable in; PWR stays on, ACT flickers while the board boots.
* Speed on our test PC: about 40 to 60 % of real time with the TFT 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). TEPRPIBP.LIB is the Pi; TEPILI9341.LIB is the demo's TFT.
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 TEPRPIBP.IDX and TEPILI9341.IDX 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 DEMO
Keep the .py file and the DLLs beside the project in "Proteus Simulation" (the TEPPi folder in MODELS).
  Pi-1-Model-B-Plus-TFT-Dashboard.pdsprj - PI1 runs tft_dashboard.py: TFT1 is a 2.8" ILI9341 SPI TFT (320 x 240) with
  the XPT2046 touch film, both on SPI0 - the TFT on CE0 (DC GPIO25, RESET GPIO24, LED = the backlight on GPIO18 with
  PWM), the touch on CE1 (T_IRQ GPIO17); D1 is an LED on GPIO27 through R1 220R; 3V3 and GND come from the Pi's
  header. Press Run: the program resets and sets up the TFT, clears it, draws the dashboard - the time, the CPU
  temperature with a sweeping chart, the Pi's address, the uptime, the LED's state and two buttons - and fades the
  backlight in. Click and hold LED ON or LED OFF on the TFT's glass with the mouse: the touch controller reports the
  point, the program switches the LED and frames the active button; the terminal prints each touch and a reading
  every 2 s. The program is pure Python - spidev and RPi.GPIO, its own ILI9341 and XPT2046 code, an 8 x 14 font.

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 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; RPi.GPIO's pull-ups / pull-downs 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.

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.
* The TFT stays white: it is still asleep or never set up - send SLPOUT (0x11), wait 120 ms, then DISPON (0x29); the
  TFT's STATUS panel under the board names the problem. Keep DC low for a command byte and high for its data.
* The picture is mirrored or on its side: MADCTL (0x36) sets the rotation - 0xE8 is landscape and upright here.
* A touch lands in the wrong place: this film reads X 3855 at the left edge and 240 at the right, Y 3805 at the top
  and 290 at the bottom (control bytes 0x90 and 0xD0); keep the mouse button down long enough for the program's poll.
* OverflowError: Argument list size exceeds 4096 bytes: split xfer / xfer2 transfers, or use writebytes2.
* 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-1-model-b-plus-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 (TEPRPIBP.LIB), the TFT model (TEPILI9341.DLL and TEPILI9341.LIB) and the demo program 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).
* The demo program's 8 x 14 font is rasterised from Cascadia Mono (Microsoft, SIL Open Font License 1.1).
* 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, 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 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 and A/V outputs, the camera and display connectors, USB, the microSD card's files, hardware PWM
(GPIO18 is software PWM here), a HAT's ID EEPROM, 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 1 Model B+ library V1.0 (Oct 2026). Device RASPBERRY PI 1 MODEL B+ (TEPRPIBP.LIB / TEPNET.DLL with
TEPPi: Python 3.11.9 and the TEP Pi runtime 0.2). Demo program tft_dashboard.py V1.0, blink.py.