Project Files of Raspberry Pi 500 Library for Proteus: MCP2515 CAN Bus Dashboard

RASPBERRY PI 500 LIBRARY FOR PROTEUS - V1.0 (A PI 5 IN A KEYBOARD: BCM2712 2.4 GHZ, 8 GB, RP1, GIGABIT ETHERNET, WI-FI)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: A CAN BUS DASHBOARD (MCP2515 ON SPI, AN ARDUINO ENGINE NODE, 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-500-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/raspberry-pi-500-proteus-library
The demo's parts are our libraries (included) - their articles:
  MCP2515:  https://www.theengineeringprojects.com/2026/10/mcp2515-can-bus-module-library-for-proteus-v1-0.html
  UNO V4.0: https://www.theengineeringprojects.com/2026/10/arduino-uno-library-for-proteus-v40.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
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-5-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-zero-w-library-for-proteus-v1-0.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-zero-2-w-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-400-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Raspberry-Pi-500-TEP-v1.0/
|-- Proteus Library Files/
|   |-- ArduinoV4TEP.LIB                                201.9 KB   the Arduino UNO V4.0 (demo), to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMCP2515.LIB                                   70.2 KB   the MCP2515 CAN module (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPRPI500.LIB                                   132.8 KB   the Raspberry Pi 500, to LIBRARY
|-- Proteus Model Files/
|   |-- TEPARDUINO.DLL                                  883.5 KB   the Arduino UNO V4.0, to MODELS
|   |-- TEPMCP2515.DLL                                  313.0 KB   the MCP2515 CAN module, to MODELS
|   |-- TEPNET.DLL                                       2.46 MB   the Pi + monitors + network, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  954.1 KB   TEP Pi runtime, gpiozero (72 files)
|-- Python Code/
|   |-- blink.py                                          0.3 KB   an LED on GPIO17 (the default)
|   |-- can_dashboard.py                                  9.7 KB   the demo
|-- Arduino Code/
|   |-- CAN_Node1/CAN_Node1.ino                           3.8 KB   the engine node (autowp-mcp2515)
|-- Proteus Simulation/
|   |-- can_dashboard.py                                  9.7 KB   the program of the demo
|   |-- CAN_Node1.hex                                    24.9 KB   ARD1, the engine node
|   |-- Pi-500-CAN-Dashboard.pdsprj                      41.4 KB   the demo: CAN bus dashboard
|   |-- TEPARDUINO.DLL                                  883.5 KB   copy of the model
|   |-- TEPMCP2515.DLL                                  313.0 KB   copy of the model
|   |-- TEPNET.DLL                                       2.46 MB   copy of the model
|-- README.txt                                          ~20.0 KB   this file
Total: 26.28 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The Raspberry Pi 500 (December 2024) 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 500'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 network: eth0 when the Ethernet cable is in at Run (ETHERNET IN, the default; a click on the Ethernet jack
    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). 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, Lock): every wait is in simulation time;
    an error in a thread is printed as Python prints it ("Exception in thread ...").
  * The Pi 500's GPIOs belong to its RP1 chip, as on the Pi 5, so a program drives them through the Linux gpiochip:
      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, callback() with
                    RISING_EDGE / FALLING_EDGE / BOTH_EDGES and debounce, tx_pwm, tx_servo, tx_pulse, the group_
                    functions, i2c_open / spi_open / serial_open; errors raise lgpio.error
      gpiozero      LED, PWMLED, Button, OutputDevice, Buzzer, Servo, Motor, MotionSensor, DistanceSensor,
                    CPUTemperature and the rest (gpiozero 2.0.1, unchanged, on lgpio - as on a real Pi 500)
      RPi.GPIO      the same API as on the earlier boards (on a real Pi 500 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; a device that does
                    not answer gives OSError [Errno 121] Remote I/O error
      serial        pyserial on /dev/ttyAMA0 (TXD GPIO14, RXD GPIO15; /dev/serial0 is accepted too)
      1-Wire, Adafruit_DHT / adafruit_dht + board, socket (TCP and UDP on eth0 or wlan0, http.server, urllib.request)
  * The Pi's own files: /proc/cpuinfo (Revision d04190, four ARMv8 processors), /proc/device-tree/model ("Raspberry Pi
    500 Rev 1.0"), /dev/gpiochip0 and /dev/gpiochip4, the CPU temperature in /sys/class/thermal, /proc/loadavg,
    /proc/meminfo (8 GB). gpiozero's pi_info() names the board "500".
  * 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 LED, the supply pins and RESTART PROGRAM. Click a micro-HDMI socket or the
    raspberry key to open it.
  * The LEDs: the green power LED at the top right of the keyboard, lit while the board runs; the Num Lock ("1") and
    Caps Lock ("A") LEDs beside it are drawn, not driven.
  * 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 Pi 500 has the Pi 400's case, so it is drawn the same way: from above at HALF its real size (286 x 122 mm drawn as
143 x 61 mm) - only the 40-pin header keeps the real 0.1 in pitch, so its comb matches every other Pi of the series: the
white case with its 78 keys in the US layout (the power key F10 with its power symbol, the raspberry key by Ctrl, the
arrow keys at the bottom right), the three LEDs at the top right, and along the back - drawn as a strip, as seen from
behind - from the left the Gigabit Ethernet jack, the two blue USB 3.0 sockets and the black USB 2.0, the USB-C power
socket, the two micro-HDMI sockets, the microSD slot, the 40-pin header and the Kensington slot. 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 500  "Raspberry Pi 500" 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+,
4 Model B, 5, Zero W, Zero 2 W and 400, 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 26 Oct 2026 with the demo project as shipped. What the Proteus run showed:
  * Pi-500-CAN-Dashboard: PI1 printed "MCP2515 ready: 500 kbps, 8 MHz crystal, normal mode; INT on GPIO25", eth0 came up
    and "dashboard on http://192.168.1.51:8000/" followed 1.5 s after Run; the first frame from the engine node arrived
    at once ("ID 0x100 03 52 3C 15" = 850 rpm, 60 C, 21 km/h), then a status line every 2 s ("900 rpm  coolant 60 C
    22 km/h  frames 2  LED off  ERROR ACTIVE"); the power LED on; both MCP2515 pop-ups measured 500 kbps on the bus.
  * The laptop (192.168.1.21) opened http://192.168.1.51:8000/json and the phone (192.168.1.41) the page (HTTP 200).
  * LED ON on the phone: "the page: LED ON - sent in ID 0x200"; the engine node's monitor printed "from node 2: LED ON"
    and its D7 LED lit. At 2800 rpm and more the dashboard said HIGH RPM, then OK again below.
  * CABLE on U1's pop-up (the Pi off the bus): "bus: ERROR PASSIVE (TEC 128, REC 0)", "dashboard: ENGINE NODE SILENT";
    CABLE again: "bus: ERROR ACTIVE (TEC 127, REC 0)", "dashboard: OK"; LED OFF on the phone - the LED went off.
  * About 86 s of simulation in 457 s on our PC with the two pop-ups, the UNO's monitor, the two monitors and the Pi
    Terminal open; no errors.

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). TEPRPI500.LIB is the Pi; TEPMCP2515.LIB (the CAN modules), ArduinoV4TEP.LIB (the engine
   node's Arduino UNO V4.0), 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 TEPRPI500.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 and .hex files and the DLLs beside the project in "Proteus Simulation" (the TEPPi folder in MODELS).
  Pi-500-CAN-Dashboard.pdsprj - PI1 runs can_dashboard.py on Ethernet (the cable in) with U1 = an MCP2515 + TJA1050 CAN
  module on SPI0 (VCC on 5V, GND, CS on GPIO8 = CE0, SO on GPIO9 = MISO, SI on GPIO10 = MOSI, SCK on GPIO11 = SCLK,
  INT on GPIO25). The other node of the bus is ARD1 = an Arduino UNO V4.0 running CAN_Node1.hex (the engine node of
  our MCP2515 library: its sketch is in Arduino Code) with U2 = its own MCP2515 module (CS D10, SI D11, SO D12, SCK
  D13, INT D2) and D1 = an LED on D7 (R1 220R). CANH / CANL of U1 and U2 are joined (the CANH_BUS / CANL_BUS labels).
  PC1 = the Laptop WiFi Monitor and MOB1 = the Mobile WiFi Monitor on the same network. Both modules are the Advance
  parts: their pop-up windows open at Run.
  The engine node sends ID 0x100 every 500 ms: the engine speed (rpm, 2 bytes), the coolant temperature and the road
  speed (made-up values that rise and fall). The Pi resets its MCP2515, sets 500 kbps for the 8 MHz crystal (CNF1
  0x00, CNF2 0x90, CNF3 0x82), lets both RX buffers take every frame and switches to normal mode; when INT goes LOW it
  reads the frame with READ RX BUFFER. Every second it sends ID 0x200 (byte 0 = the LED on the engine node's D7) and
  reads TEC, REC and EFLG (the error state). The dashboard warns of HIGH RPM (2800 rpm or more), COOLANT HOT (85 C or
  more) and an ENGINE NODE SILENT (no frame for 2 s). On the laptop or the phone open http://192.168.1.51:8000/
  (Browser, the address, Go): the engine data, the status, the bus (TEC, REC, the frames), LED ON / LED OFF; /json
  gives the same as JSON.
  Try CABLE on U1's pop-up: the Pi is off the bus - no frames (ENGINE NODE SILENT), its own frames get no
  acknowledgement, TEC climbs to 128 (ERROR PASSIVE); CABLE again - back to ERROR ACTIVE.
  The program is pure Python: spidev for the MCP2515's SPI instructions (RESET, READ, WRITE, BIT MODIFY, READ RX
  BUFFER, LOAD TX BUFFER, RTS), lgpio for INT, a thread for the bus and http.server for the page. On a real Pi you can
  also use the kernel's driver (dtoverlay=mcp2515-can0 and SocketCAN with python-can); the TEP runtime does not model
  SocketCAN, so the demo drives the chip itself.
  Note for a real build: many MCP2515 modules run the MCP2515 on 5 V, so its SO output swings to 5 V - too much for a
  Pi's 3.3 V GPIO9. Use a module with a 3.3 V MCP2515 (the TJA1050 alone on 5 V) or a level shifter on SO.

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 (gpiozero's LED(17), lgpio's
gpio_write(h, 17, 1) with the handle from gpiochip_open(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.
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: 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.
* "MCP2515 not answering": CS on GPIO8 (CE0), SCK, SI to MOSI, SO to MISO, the module's VCC on 5V and GND.
* No frames: CANH to CANH and CANL to CANL; both nodes at 500 kbps with the 8 MHz crystal (the module's pop-up shows
  the bit rate it measures on the bus); the engine node's hex next to the project.
* TEC climbs and the bus goes ERROR PASSIVE: nobody acknowledges the Pi's frames - the other node is off the bus
  (CABLE) or not running.
* The page does not open: the address is http://192.168.1.51:8000/ and the program must have printed "dashboard on". A
  monitor sometimes needs Go a second time. Use the page's REFRESH link to see new values.
* 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-500-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 (TEPRPI500.LIB), the part models (TEPMCP2515 .DLL / .LIB, the Arduino UNO V4.0's ArduinoV4TEP.LIB
  / TEPARDUINO.DLL, 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 RPi.GPIO, lgpio, 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 engine node's sketch (Arduino Code\CAN_Node1) uses autowp-mcp2515 1.3.1 (MIT, by autowp and Seeed Technology) -
  install it with the Arduino IDE's Library Manager to compile it; CAN_Node1.hex is included.
* 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.
  MCP2515 is a Microchip part, TJA1050 an NXP part; Arduino is a trademark of Arduino SA. This library is not made or
  endorsed by Raspberry Pi Ltd, Microchip, NXP, Arduino or Labcenter.

MODEL SCOPE AND LIMITS
Modelled: the 26 GPIOs of the 40-pin header (inputs, outputs, 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 power LED, 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), the kernel's drivers and device-tree overlays
(SocketCAN, the extra UART, I2C and SPI buses), the keyboard's keys (drawn, not pressed: no key reaches the program),
the power key, the Num Lock / Caps Lock LEDs, Bluetooth, the 5 GHz band and the Gigabit speed (the network is the same
TEP network at any band), wlan0 and eth0 at the same time, the four cores (one program, its threads take turns), the
micro-HDMI outputs, USB 2.0 / 3.0, the microSD card's files, the RP1's PIO, hardware PWM, 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 500 library V1.0 (Oct 2026). Device RASPBERRY PI 500 (TEPRPI500.LIB / TEPNET.DLL with TEPPi: Python
3.11.9 and the TEP Pi runtime 0.2). Demo program can_dashboard.py V1.0, blink.py; the engine node CAN_Node1 V1.0.