Project Files of Raspberry Pi 3 Model B+ Library for Proteus: Keypad, I2C LCD, Servo

RASPBERRY PI 3 MODEL B+ LIBRARY FOR PROTEUS - V1.0 (BCM2837B0 1.4 GHZ, 1 GB, DUAL-BAND WI-FI, 40-PIN HEADER, POE HEADER)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: A KEYPAD DOOR LOCK (4X4 KEYPAD, I2C LCD 20X4, SG90 SERVO AS THE BOLT)
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-3-model-b-plus-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-3-model-b-plus-proteus-library
The demo's parts are our libraries (included) - their articles:
  Keypad:   https://www.theengineeringprojects.com/2026/10/membrane-keypad-library-for-proteus-v1-0.html
  LCD:      https://www.theengineeringprojects.com/2026/10/i2c-lcd-20x4-library-for-proteus-v1-0.html
  SG90:     https://www.theengineeringprojects.com/2026/10/pca9685-servo-driver-library-for-proteus-v1-0.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
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Raspberry-Pi-3-Model-B-Plus-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPI2CLCD20X4.LIB                               205.4 KB   the I2C LCD 20x4 (demo), to LIBRARY
|   |-- TEPKEYPAD.LIB                                   162.5 KB   the keypad (demo), to LIBRARY
|   |-- TEPPCA9685.LIB                                  129.4 KB   the SG90 (demo), to LIBRARY
|   |-- TEPRPI3BP.LIB                                    61.1 KB   the Raspberry Pi 3 Model B+, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPKEYPAD.DLL                                   300.5 KB   the keypad, to MODELS
|   |-- TEPLCD.DLL                                      409.0 KB   every TEP LCD, to MODELS
|   |-- TEPNET.DLL                                       2.37 MB   the Pi + network, to MODELS
|   |-- TEPPCA9685.DLL                                  323.0 KB   the SG90, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  856.3 KB   TEP Pi runtime, gpiozero (61 files)
|-- Python Code/
|   |-- blink.py                                          0.3 KB   an LED on GPIO17 (the default)
|   |-- door_lock.py                                      7.5 KB   the demo
|-- Proteus Simulation/
|   |-- door_lock.py                                      7.5 KB   the program of the demo
|   |-- Pi-3-Model-B-Plus-Keypad-Door-Lock.pdsprj        29.5 KB   the demo: keypad door lock
|   |-- TEPKEYPAD.DLL                                   300.5 KB   copy of the model
|   |-- TEPLCD.DLL                                      409.0 KB   copy of the model
|   |-- TEPNET.DLL                                       2.37 MB   copy of the model
|   |-- TEPPCA9685.DLL                                  323.0 KB   copy of the model
|-- README.txt                                          ~18.5 KB   this file
Total: 25.75 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Raspberry Pi 3 Model B+ (V1.3, 2018) 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 2.6 us per GPIO call, as Python on the B+'s 1.4 GHz Cortex-A53), and every edge is on time.
    time.time(), time.monotonic(), time.strftime() and datetime.now() follow the simulation's clock too.
  * The network: eth0 when the Ethernet cable is in at Run (ETHERNET IN, the default here; 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.
  * Threads work (gpiozero's threads, your own threading.Thread, Timer, Queue): 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):
      RPi.GPIO      setmode, setup and output with one pin or a list, 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, OutputDevice, Buzzer, Servo, AngularServo, MotionSensor, DistanceSensor,
                    CPUTemperature and the rest (gpiozero 2.0.1, unchanged, on RPi.GPIO)
      serial        pyserial on /dev/serial0 (on a Pi 3 B+ = /dev/ttyS0, the mini UART; /dev/ttyAMA0 is accepted too):
                    TXD GPIO14, RXD GPIO15, any baud rate, timeouts, back-to-back bytes
      smbus2 / smbus  I2C bus 1 on GPIO2 (SDA) / GPIO3 (SCL) at 100 kHz, the Pi's 1.8 k pull-ups: read_byte,
                    write_byte, the byte / block reads and writes, write_quick, i2c_rdwr with i2c_msg (one write of any
                    length = one I2C transaction); 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
      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 a020d3, four ARMv8 processors), /proc/device-tree/model ("Raspberry Pi
    3 Model B Plus Rev 1.3"), the CPU temperature in /sys/class/thermal (gpiozero's CPUTemperature), /proc/loadavg,
    /proc/meminfo (1 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 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) standing at the
    left edge above the micro-USB, 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 3
Model B+ drawing: the 40-pin header along the top edge, the metal shield can of the dual-band Wi-Fi / Bluetooth module
(the raspberry pressed into its lid) under pin 1, the DSI display connector with the microSD card under it, the
BCM2837B0 under its silver heat spreader (the 1 GB RAM is on the underside, as on the real board), the 4-pin PoE header
under the top-right mounting hole with the PEN / RUN pads and the raspberry logo beside it, the Microchip LAN7515
(USB hub + Gigabit Ethernet), the MaxLinear MXL7704 power chip by the micro-USB, PWR / ACT at the left edge, the two
stacked USB pairs and the RJ45 on the right, 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 3 MODEL B+  "Raspberry Pi 3 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, 1 Model B+, 2 Model B and 3 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-3-Model-B-Plus-Keypad-Door-Lock: the program starts 0.5 s after Run and prints "ready"; the LCD shows the closed
  padlock, DOOR LOCKED, "Enter PIN: ____", "# OK  * CLEAR" and "Tries left: 3". The keypad's pop-up: READY - C1 - C4
  driven LOW in turn, R1 - R4 pulled up, 31 to 41 scans a second; its LAST SCAN shows the four columns LOW one after
  the other in 74 us.
* 1 2 3 5 # clicked in the keypad's pop-up: one "key" line per press in the Pi Terminal, then "PIN 1235: wrong - 2
  tries left"; the LCD showed "Wrong PIN!" and "Tries left: 2" for 2 s.
* TYPE 1234# (the pop-up's action): "PIN ok - door open (servo 90 deg)" - the SG90's horn turned to 90 deg, D1 lit,
  the LCD showed the open padlock, DOOR OPEN, "Welcome!", "Bolt: servo 90 deg" and "Locks in 5 s" counting down.
* C, 2 5 8 0 # while the door was open: "new PIN saved"; A locked it at once (servo 0 deg, D1 off); 2 5 8 0 # opened
  it again, and 5 s later "door locked (servo 0 deg) - after 5 s".
* The LCD's pop-up: 4-bit, 2 lines = 4 rows, the two padlocks in CGRAM 0 and 1, VCC 4.99 V, contrast good, each
  character as two E pulses 360 us apart. The keypad's Event log: every key down / up (0.150 s), no warning.
* The Board tab: the BCM2837B0 at 1.4 GHz, GPIO5 / 6 / 13 / 19 pull-up, GPIO26 / 16 / 20 / 21 HIGH between scans,
  GPIO18 (the servo's pulses) and GPIO23 (D1), 5V 5.00 V, 3V3 3.30 V, "No errors".
* Speed on our test PC: about 33 % of real time with the two pop-ups 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). TEPRPI3BP.LIB is the Pi; TEPKEYPAD.LIB, TEPI2CLCD20X4.LIB and TEPPCA9685.LIB (the SG90)
   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). TEPLCD.DLL is the newest build of our
   LCD model (the LCD Keypad Shield's): it runs every TEP LCD, so it may replace the one an LCD library put there.
4. Delete TEPRPI3BP.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-3-Model-B-Plus-Keypad-Door-Lock.pdsprj - PI1 runs door_lock.py: U1 = a 4x4 membrane keypad (R1 - R4 on GPIO5, 6,
  13, 19 read with the Pi's pull-ups, C1 - C4 on GPIO26, 16, 20, 21 driven LOW in turn), LCD1 = a 20x4 LCD with its
  I2C backpack (PCF8574 at 0x27, SDA / SCL on GPIO2 / GPIO3, VCC 5V), SERVO1 = an SG90 micro servo as the door's bolt
  (SIG on GPIO18, V+ 5V), D1 = the door LED on GPIO23 through R1 330R. The keypad and the LCD are the Advance parts:
  their pop-up windows open at Run (the keypad's shows the scan, the LCD's the screen and its bus).
  Press Run: the LCD shows DOOR LOCKED, "Enter PIN: ____", "# OK  * CLEAR" and the tries left. Type the PIN (1234) and
  # on the keypad - click its keys on the sheet or in its pop-up, or press TYPE 1234# in the pop-up: the servo turns the
  bolt to 90 deg, D1 lights, the LCD says DOOR OPEN with a countdown, and 5 s later the door locks again (servo 0 deg).
  A wrong PIN shows "Wrong PIN!" and the tries left; three wrong PINs lock the keypad for 30 s. * clears what you
  typed, A locks the open door at once, C (while the door is open) sets a new 4-digit PIN with #. The Pi Terminal logs
  each key with its time. The program is pure Python - RPi.GPIO for the keypad scan, smbus2 (i2c_msg) for the LCD with
  its own HD44780 driver and two padlock characters, gpiozero's AngularServo and LED.

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.
The 4-pin PoE header and the PEN / RUN pads are drawn, not pins of the part (a PoE HAT is not modelled).

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).
* "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.
* No key reaches the program: the keypad's pop-up says what the scan looks like - "NO SCAN" when no column is driven
  LOW in turn (check the column pins), a row "not pulled up" when the rows were set up without PUD_UP. Keep scanning
  while the program waits (a long time.sleep() between scans loses short presses).
* The LCD stays blank or shows blocks: the backpack's address is 0x27 (the ADDRESS property / the pads), VCC needs 5V,
  and the program must send the 4-bit start (0x30 three times, then 0x20) before its first command.
* OSError: [Errno 121] Remote I/O error: no part answers at that address - check its VCC / GND and SDA / SCL.
* The servo does not move: SIG on GPIO18 and V+ on 5V; gpiozero's AngularServo with min_pulse_width 0.5 ms and
  max_pulse_width 2.5 ms (the SG90's 500 - 2500 us for 0 - 180 deg).
* 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-3-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 (TEPRPI3BP.LIB), the part models (TEPKEYPAD, TEPLCD and TEPPCA9685 .DLL with TEPKEYPAD.LIB,
  TEPI2CLCD20X4.LIB and TEPPCA9685.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).
* 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 (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 and /sys 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 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 2.6 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 3 Model B+ library V1.0 (Oct 2026). Device RASPBERRY PI 3 MODEL B+ (TEPRPI3BP.LIB / TEPNET.DLL with
TEPPi: Python 3.11.9 and the TEP Pi runtime 0.2). Demo program door_lock.py V1.0, blink.py.