Project Files of Raspberry Pi 2 Model B Library for Proteus: I2C Sensors, OLED

RASPBERRY PI 2 MODEL B LIBRARY FOR PROTEUS - V1.0 (BCM2836 QUAD CORE, 1 GB, THE 40-PIN GPIO HEADER, 4 USB, ETHERNET)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: FOUR I2C PARTS ON ONE BUS (BME280, BH1750, MPU6050 AND AN SSD1306 OLED)
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-2-model-b-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-2-model-b-proteus-library
The demo's parts are our libraries (included) - their articles:
  BME280:  https://www.theengineeringprojects.com/2026/09/bme280-sensor-library-for-proteus.html
  BH1750:  https://www.theengineeringprojects.com/2026/09/bh1750-light-sensor-library-for-proteus.html
  MPU6050: https://www.theengineeringprojects.com/2026/09/mpu6050-proteus-library.html
  OLED:    https://www.theengineeringprojects.com/2026/10/oled-ssd1306-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
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Raspberry-Pi-2-Model-B-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPBH1750.LIB                                   132.6 KB   BH1750 (demo), to LIBRARY
|   |-- TEPBME280.LIB                                    89.4 KB   BME280 (demo), to LIBRARY
|   |-- TEPMPU6050.LIB                                  130.9 KB   MPU6050 (demo), to LIBRARY
|   |-- TEPOLED12864.LIB                                112.4 KB   the OLED (demo), to LIBRARY
|   |-- TEPRPI2B.LIB                                     55.6 KB   the Raspberry Pi 2 Model B, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPBH1750.DLL                                   363.0 KB   BH1750, to MODELS
|   |-- TEPBME280.DLL                                   381.0 KB   BME280, to MODELS
|   |-- TEPMPU6050.DLL                                  537.0 KB   MPU6050, to MODELS
|   |-- TEPNET.DLL                                       2.37 MB   the Pi + the network, to MODELS
|   |-- TEPOLED.DLL                                     323.0 KB   the OLED, 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)
|   |-- i2c_station.py                                    9.2 KB   the demo
|-- Proteus Simulation/
|   |-- i2c_station.py                                    9.2 KB   the program of the demo
|   |-- Pi-2-Model-B-I2C-Sensors.pdsprj                  32.6 KB   the demo: four I2C parts
|   |-- TEPBH1750.DLL                                   363.0 KB   copy of the model
|   |-- TEPBME280.DLL                                   381.0 KB   copy of the model
|   |-- TEPMPU6050.DLL                                  537.0 KB   copy of the model
|   |-- TEPNET.DLL                                       2.37 MB   copy of the model
|   |-- TEPOLED.DLL                                     323.0 KB   copy of the model
|-- README.txt                                          ~16.8 KB   this file
Total: 26.83 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Raspberry Pi 2 Model B (V1.1, 2015) 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 4 us per GPIO call, as Python on the Pi 2's 900 MHz Cortex-A7), 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; 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, 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: read_byte_data,
                    write_byte_data, read_i2c_block_data, write_i2c_block_data, write_quick (i2cdetect's probe),
                    i2c_rdwr with i2c_msg; 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, timeouts,
                    back-to-back bytes (a sensor's whole frame)
      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 a01041, four ARMv7 processors), /proc/device-tree/model ("Raspberry Pi
    2 Model B Rev 1.1"), the CPU temperature in /sys/class/thermal (gpiozero's CPUTemperature), /proc/loadavg,
    /proc/meminfo (1 GB).
  * 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 power the modules wired to them, as on the bench: 5V, 3V3 and GND as logic levels (an
    analog VCC reading - the OLED's pop-up - 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): 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 BCM2836 (BROADCOM BCM2836RIFBG - the 1 GB RAM is on the underside, as on the real board), the SMSC
LAN9514, the two stacked USB pairs and the RJ45 on the right, the micro-USB power socket, 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 2 MODEL B   "Raspberry Pi 2 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 and 1 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-2-Model-B-I2C-Sensors: the program starts 0.5 s after Run and scans the bus as i2cdetect -y 1 prints it: 0x23
  (BH1750), 0x3c (the OLED), 0x68 (MPU6050), 0x76 (BME280). It reads the BME280's calibration, wakes the MPU6050,
  starts the BH1750, sets up the SSD1306 and then prints a line and redraws the OLED every second: 25.0 C 50.0 %
  1013.3 hPa 100 lx roll +0 pitch +0 (the parts' default values).
* The pop-ups' presets (posted clicks: BME280 RAINY, BH1750 Office 500, MPU6050 TILT 30) reach the program at its
  next reading: 16.0 C 92.0 % 1002.0 hPa 500 lx roll +0 pitch +30 - in the Pi Terminal and on the OLED. The MPU6050's
  pop-up shows the tilt the program read (pitch 29.9), the BME280's the I2C burst reads, the BH1750's the 500 lx.
* The supply: every part powers up from the Pi's 3V3 / GND (the Board tab: 5V 5.00 V, 3V3 3.30 V; the OLED's pop-up
  reads its VCC as 5.00 V - the simulation's 3V3 is a logic level).
* The Board tab: GPIO2 / GPIO3 with the Pi's pull-ups, the other BCM pins inputs, the LEDs (PWR, ACT, LNK, 100).
* The same TEPNET.DLL ran our earlier Pi demos again: the Model B distance meter (HC-SR04 on 5V), its weather web
  page (DS18B20, DHT22) and its UART loop-back, the B+ TFT dashboard and the Pi 3 Wi-Fi air station.
* Speed on our test PC: about 25 % of real time with the four 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). TEPRPI2B.LIB is the Pi; TEPBME280.LIB, TEPBH1750.LIB, TEPMPU6050.LIB and TEPOLED12864.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 TEPRPI2B.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-2-Model-B-I2C-Sensors.pdsprj - PI1 runs i2c_station.py: four I2C parts on the Pi's one bus (SDA GPIO2, SCL GPIO3),
  all powered from the Pi's 3V3 and GND - U1 = BME280 at 0x76 (SDO to GND, CSB to 3V3: I2C), U2 = BH1750 at 0x23
  (ADDR to GND), U3 = MPU6050 at 0x68 (AD0 to GND) and OLED1 = the 0.96" SSD1306 OLED 128 x 64 at 0x3C. Each part is
  the Advance version: its pop-up window opens at Run with the live values and the controls to change them.
  Press Run: the program scans the bus and prints the result as i2cdetect -y 1 does, reads the BME280's calibration,
  wakes the MPU6050, starts the BH1750, sets up the OLED, and then once a second reads the temperature, humidity and
  pressure (with Bosch's compensation formulas), the light in lux and the tilt (roll and pitch from the acceleration),
  prints one line and draws the four values on the OLED. Change a value in a pop-up (a slider or a preset such as
  RAINY, Office 500, TILT 30): the next reading shows it. The program is pure Python - smbus2 only, no sensor
  libraries, its own SSD1306 code and 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.
* OSError: [Errno 121] Remote I/O error: no part answers at that address - check the address pins (SDO, ADDR, AD0),
  the part's VCC / GND and that SDA / SCL go to GPIO2 / GPIO3; run the scan (the demo's first lines) to see who answers.
* A part's pop-up says NO POWER: its VCC is not on the Pi's 3V3 (or 5V) net or its GND not on GND.
* The OLED stays dark: it needs its set-up commands first (display off, the charge pump 8D 14, display on AF); the
  OLED's pop-up (Tests tab) names what is missing.
* A reading does not change after a pop-up click: the program reads once a second - wait for the next line.
* 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-2-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 (TEPRPI2B.LIB), the part models (TEPBME280, TEPBH1750, TEPMPU6050 and TEPOLED .DLL / .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). Its BME280
  compensation follows the formulas in Bosch's BME280 datasheet.
* 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 such as i2cdetect, no apt, no os.system), 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), I2C clock stretching and speeds other than 100 kHz, a HAT's ID EEPROM, C programs and C
extensions, the real CPU's speed (each GPIO call takes about 4 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 2 Model B library V1.0 (Oct 2026). Device RASPBERRY PI 2 MODEL B (TEPRPI2B.LIB / TEPNET.DLL with
TEPPi: Python 3.11.9 and the TEP Pi runtime 0.2). Demo program i2c_station.py V1.0, blink.py.