Project Files of BeagleBone Black Library for Proteus: ADC, TDS, Turbidity, Flow

BEAGLEBONE BLACK LIBRARY FOR PROTEUS - V1.0 (AM3358 CORTEX-A8 1 GHZ, 512 MB, ETHERNET, P8 / P9, THE 1.8 V ADC)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: A DRINKING-WATER STATION (TDS + TURBIDITY ON THE ADC, YF-S201, 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/beaglebone-black-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/beaglebone-black-proteus-library
The demo's parts are our libraries (included) - their articles:
  TDS meter:   https://www.theengineeringprojects.com/2026/10/tds-meter-library-for-proteus-v1-0.html
  Turbidity:   https://www.theengineeringprojects.com/2026/10/turbidity-sensor-library-for-proteus-v1-0.html
  YF-S201:     https://www.theengineeringprojects.com/2026/10/yf-s201-water-flow-sensor-library-for-proteus-v1-0.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
Our other Linux boards run the same way - for example:
  https://www.theengineeringprojects.com/2026/10/raspberry-pi-4-model-b-library-for-proteus.html
  https://www.theengineeringprojects.com/2026/10/jetson-nano-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
BeagleBone-Black-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPBBB.LIB                                       88.5 KB   the BeagleBone Black, to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPTDS.LIB                                       63.4 KB   the TDS meter (demo), to LIBRARY
|   |-- TEPTURBIDITY.LIB                                 68.2 KB   the turbidity sensor (demo), to LIBRARY
|   |-- TEPYFS201.LIB                                    65.9 KB   the YF-S201 (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPNET.DLL                                       2.40 MB   the board + monitors + network, to MODELS
|   |-- TEPTDS.DLL                                      314.5 KB   the TDS meter, to MODELS
|   |-- TEPTURBIDITY.DLL                                322.0 KB   the turbidity sensor, to MODELS
|   |-- TEPYFS201.DLL                                   292.5 KB   the YF-S201, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  930.0 KB   TEP Pi runtime, gpiozero (70 files)
|-- Python Code/
|   |-- blink.py                                          0.6 KB   an LED on P8_10 + USR3 (the default)
|   |-- water_station.py                                  7.1 KB   the demo
|-- Proteus Simulation/
|   |-- BeagleBone-Black-Water-Station.pdsprj            33.3 KB   the demo: drinking-water station
|   |-- TEPNET.DLL                                       2.40 MB   copy of the model
|   |-- TEPTDS.DLL                                      314.5 KB   copy of the model
|   |-- TEPTURBIDITY.DLL                                322.0 KB   copy of the model
|   |-- TEPYFS201.DLL                                   292.5 KB   copy of the model
|   |-- water_station.py                                  7.1 KB   the program of the demo
|-- README.txt                                          ~19.0 KB   this file
Total: 25.47 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The BeagleBone Black (Rev C, 2014: BeagleBoard.org's open-hardware board) as one Proteus part - and a way to run
BeagleBone programs in Proteus 8.5. Proteus cannot run Debian, 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 library a BeagleBone uses for its expansion headers P8 and P9 (Adafruit_BBIO), its ADC, its
buses and its network.
  * At Run the board starts Python 3.11 (included: the TEPPi folder) with our TEP 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 8 us per GPIO call, as Python and Adafruit_BBIO on the AM3358's 1 GHz Cortex-A8), and every edge is on
    time. time.time(), time.monotonic(), time.strftime() and datetime.now() follow the simulation's clock too.
  * The ADC: AIN0 - AIN6 on P9 read the voltage of their pins in the circuit (12 bits, 0 - 1.8 V): ADC.read() 0.0 - 1.0,
    ADC.read_raw() 0 - 4095, or the board's IIO files /sys/bus/iio/devices/iio:device0/in_voltageN_raw. Each read takes
    about 0.16 ms of simulation. VDD_ADC (P9_32) gives the 1.8 V reference for a potentiometer, GNDA_ADC (P9_34) is the
    ADC's ground. More than 1.8 V on an AIN pin reads 4095 and Proteus warns: a real board's ADC is damaged above 1.8 V,
    so a sensor with a bigger output needs a divider (the demo's 15k / 10k).
  * The network: eth0, 10/100 Ethernet, with the cable in at Run (ETHERNET IN, the default; a click on the Ethernet jack
    plugs or unplugs it). The board is 192.168.1.51 (192.168.1.(50 + the part's number)), the name beaglebone.local, on
    our router "TEP-WiFi" - the network of our ESP32 / Arduino Wi-Fi parts and the Laptop / Mobile WiFi Monitors.
  * Threads work (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 Python libraries for the pins (the names of Adafruit_BBIO 1.2 on a BeagleBone):
      Adafruit_BBIO.GPIO  setup / output / input / cleanup by header key ("P8_10") or GPIO name ("GPIO2_4"), the pulls,
                          add_event_detect / event_detected / wait_for_edge with callbacks and bouncetime, and the four
                          user LEDs "USR0" - "USR3"
      Adafruit_BBIO.ADC   setup(), read() and read_raw() on "AIN0" - "AIN6" or "P9_39", "P9_40", "P9_37", "P9_38",
                          "P9_33", "P9_36", "P9_35"
      Adafruit_BBIO.PWM   start / set_duty_cycle / set_frequency / stop / cleanup on P9_14, P9_16, P8_13, P8_19, P9_21,
                          P9_22, P9_28, P9_29, P9_31 and P9_42 (the model makes the edges)
      Adafruit_BBIO.UART  setup("UART1"), then pyserial on /dev/ttyS1 (/dev/ttyO1 on older images): TXD P9_24, RXD P9_26
      smbus2 / smbus      I2C2 on P9_19 (SCL) and P9_20 (SDA) as bus 2 (SMBus(2)), 100 kHz, with the board's pull-ups; a
                          device that does not answer gives OSError [Errno 121] Remote I/O error
      spidev              SPI0 on P9_17 (CS0), P9_18 (D1, MOSI), P9_21 (D0, MISO), P9_22 (SCLK) as /dev/spidev0.0, modes
                          0 to 3, up to 8 MHz; xfer / xfer2 take up to 4096 bytes, writebytes2 any length
      socket              TCP and UDP on eth0, http.server / socketserver, urllib.request, select
    RPi.GPIO and gpiozero are not installed on a BeagleBone ("No module named 'RPi'", as on a real one).
  * The board's own files: /proc/cpuinfo (one ARMv7 processor, "Generic AM33XX"), /proc/device-tree/model ("TI AM335x
    BeagleBone Black"), /proc/device-tree/compatible (ti,am335x-bone-black), the CPU temperature in /sys/class/thermal,
    /proc/loadavg, /proc/meminfo (512 MB), the ADC's IIO files.
  * The terminal (our TEP window, no Windows title bar): the shell prompt (debian@beaglebone:~$ python3 ...), the
    program's output (OUT) and errors (ERR, as Python prints them), a line for input() (IN); its Board tab shows the
    header's GPIOs (by header key), AIN0 - AIN6 in volts, the user LEDs, the supply pins and RESTART PROGRAM. Click the
    AM3358 or the serial header J1 to open it.
  * The LEDs: the blue power LED, lit while the board runs, and the four blue user LEDs. Until the program takes them,
    Linux's triggers drive them: USR0 the heartbeat (two blinks a second), USR1 the microSD (off), USR2 the CPU (with
    the program's output) and USR3 the eMMC (the boot); GPIO.setup("USR0", GPIO.OUT) gives one to the program.
  * The header's supply pins power the modules wired to them, as on the bench: SYS_5V, VDD_5V, VDD_3V3 and DGND as logic
    levels (an analog VCC reading sees 5 V on either rail).
The board is drawn our way at its real size (86.4 x 54.6 mm) from BeagleBoard.org's component-side silkscreen, turned a
quarter turn to the left: the Ethernet jack and the 5 V jack on the left edge, the USB host socket on the right edge, P8
along the top edge, P9 along the bottom edge, pin 1 of both at the Ethernet end, as on the real board. Each header's 46
pins leave the board as one comb 50 thou apart - P8 up, P9 down - with a colour-coded tag on every pin: SYS_5V / VDD_5V
red, VDD_3V3 orange, DGND black, GPIO green, I2C blue, SPI pink, UART purple, PWM amber, the ADC teal, and grey for the
pins the eMMC and the HDMI framer hold and for PWR_BUT / RESET. The black board, the black female headers, the AM3358,
the eMMC, the DDR3, the TPS65217 power chip, the Ethernet PHY, the HDMI framer, the 6-pin serial header J1, the POWER,
RESET and BOOT buttons, the blue power LED and the user LEDs USR0 - USR3.

ONE DEVICE (search "BEAGLEBONE" in Pick Devices):
  BEAGLEBONE BLACK  "BeagleBone Black" V1.0 (category Microprocessor ICs > BeagleBone), prefix BB, model TEPNET.DLL
                    (with the TEPPi folder)
The same TEPNET.DLL also runs our Raspberry Pi boards, the Jetson Nano, 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).

TEST STATUS
V1.0: verified in Proteus 8.5 on 24 Oct 2026 with the demo project as shipped. What the Proteus runs showed:
* BeagleBone-Black-Water-Station: the terminal shows "debian@beaglebone:~$ python3 water_station.py"; eth0 is up (the
  cable in) and 1.5 s after Run the program prints "serving on http://192.168.1.51:8000/". Tap water (250 ppm, 1 NTU):
  AIN0 0.2515 V = "TDS 239 ppm" (the 15k / 10k divider loads the meter's output a little: 4 % low), AIN1 1.6055 V = the
  probe at 4.01 V, which the curve's 4.2 V reads as "645 NTU ... TOO CLOUDY" - USR0 (the program runs) and USR3 lit.
* CAL CLEAR on the laptop: "clear water 4.01 V", then "TDS 241 ppm  0 NTU ... SAFE TO DRINK".
* The YF-S201's TAP preset: "6.0 L/min", 0.1 L a second added; USR1 lit.
* RIVER (250 NTU) and SEA on the pop-ups: "TDS 1039 - 1043 ppm  245 NTU ... TDS TOO HIGH and TOO CLOUDY" (the meter's
  output stops at the top of its range) - all four user LEDs and the power LED lit.
* CLEAR and MINERAL (420 ppm): "TDS 404 ppm  0 NTU ... SAFE TO DRINK"; TDS 300 on the phone: "TDS TOO HIGH"; RESET
  LITRES: 0.00 L. The laptop's and the phone's pages followed every step.
* The Board tab: the AM3358 at 1 GHz, the GPIOs by header key (P9_19 / P9_20 pulled up, P8_12 the pulses), AIN0 0.44 V
  and AIN1 1.60 V in volts and counts, USR0 - USR3, SYS_5V 5.00 V, VDD_3V3 3.30 V, VDD_ADC 1.80 V, "No errors".
* Speed on our test PC: about 15 % of real time with the three pop-ups, the two monitors and the 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). TEPBBB.LIB is the BeagleBone Black; TEPTDS.LIB (the TDS meter), TEPTURBIDITY.LIB (the
   turbidity sensor), TEPYFS201.LIB (the flow sensor), 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 runtime; the board 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 TEPBBB.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 "BEAGLEBONE".
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).
  BeagleBone-Black-Water-Station.pdsprj - BB1 runs water_station.py on Ethernet (the cable in): U1 = a TDS meter (VCC on
  VDD_3V3) whose output A goes through R1 15k to AIN0 (P9_39) and R2 10k to GNDA_ADC; U2 = a turbidity sensor (VCC on
  SYS_5V) whose OUT goes through R3 15k to AIN1 (P9_40) and R4 10k to GNDA_ADC; U3 = a YF-S201 flow sensor (VCC on
  SYS_5V) whose OUT is on P8_12; PC1 = the Laptop WiFi Monitor and MOB1 = the Mobile WiFi Monitor on the same router.
  The three sensors are the Advance parts: their pop-up windows open at Run.
  The dividers: 10 / (15 + 10) = 0.4 of the sensor's voltage reaches the pin - the turbidity sensor's 4.5 V becomes
  1.8 V, the ADC's top. The program multiplies back by 2.5.
  Press Run: eth0 is up and the program serves its page. Ten times a second it reads both ADC inputs (the TDS averaged
  over 1 s, the turbidity over 5 s), counts the flow sensor's pulses (FALLING edges on P8_12: 450 a litre), and every
  second works out the TDS (the meter's published conversion), the turbidity (the sensor's published curve), the flow
  and the litres, says SAFE TO DRINK, TDS TOO HIGH or TOO CLOUDY, and sets the user LEDs: USR0 the program runs, USR1
  the water flows, USR2 the TDS is over its limit, USR3 the water is cloudy.
  The turbidity probe must be calibrated: its output moves with its supply and every probe differs, so a new probe reads
  clear water as cloudy. With clear water at the probe, click CAL CLEAR on the page: the program keeps that voltage as
  this probe's clear water. Then change the water with the pop-ups' presets (TDS: TAP 250 ppm, MINERAL 420, SEA - over
  the range; turbidity: CLEAR, TAP, POND 60 NTU, RIVER 250 NTU; the flow: OFF, TAP, SHOWER ...). On the laptop or the
  phone open http://192.168.1.51:8000/ (Browser, the address, Go): the page shows the verdict, the TDS and its limit,
  the turbidity, its limit and the probe's voltage, the flow and the litres, with REFRESH, TDS 300, TDS 500, TDS 1000,
  NTU 50, NTU 100, CAL CLEAR and RESET LITRES.
  The program is pure Python: Adafruit_BBIO.ADC for the two sensors, Adafruit_BBIO.GPIO for the pulses (a callback) and
  the user LEDs, a thread for the readings and http.server.

YOUR OWN PROGRAMS
Write the program with any editor, put the .py next to your project and set the board's PROGRAM property to its name (or
a full path). Start from Python Code\blink.py (an LED on P8_10 and the user LED USR3). Python's standard library is
there; other pure-Python packages work when you copy them next to your program.
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 terminal.

THE HEADERS P8 AND P9 (the modelled pins; the keys Adafruit_BBIO takes)
  P8: 1, 2 DGND; 7 - 19 GPIO (P8_13 and P8_19 PWM); 26 GPIO. P8_3 - 6 and P8_20 - 25 belong to the eMMC, P8_27 - 46 to
      the HDMI framer (as at power-on): not modelled - GPIO.setup refuses them.
  P9: 1, 2 DGND; 3, 4 VDD_3V3; 5, 6 VDD_5V; 7, 8 SYS_5V; 9 PWR_BUT; 10 SYS_RESETN; 11 - 31 GPIO (17 / 18 / 21 / 22 SPI0,
      19 / 20 I2C2, 24 / 26 UART1, 14 / 16 PWM); 32 VDD_ADC (1.8 V); 33 AIN4; 34 GNDA_ADC; 35 AIN6; 36 AIN5; 37 AIN2;
      38 AIN3; 39 AIN0; 40 AIN1; 41, 42 GPIO (P9_42 PWM); 43 - 46 DGND.
3.3 V logic: the GPIO pins are not 5 V tolerant; the AIN pins take 1.8 V at most.

PROPERTIES (double-click the board > Edit Properties)
  PROGRAM    the Python program (default blink.py; a name next to the project or a full path)
  AUTOOPEN   the terminal at Run: YES (default) or NO
  ETHERNET   the cable to the router at Run: IN (default: eth0) or OUT (no network)
  PYTHON     a python.exe of your own (empty: TEPPi's)
  RUNTIME    the TEP 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.
* RuntimeError: You must setup() ADC prior to calling read. - call ADC.setup() first.
* "AIN0 ... the ADC takes 1.8 V at most" in the simulation log: the pin is above 1.8 V - add a divider.
* ValueError: P8_27 is used by the HDMI framer: use one of the free pins (the list above).
* The turbidity reads cloudy in clear water: calibrate - CAL CLEAR on the page with clear water at the probe.
* No flow: the sensor's OUT on P8_12, the tap open in its pop-up (DRIP gives no pulses).
* The page does not open: the address is http://192.168.1.51:8000/ (the port the program serves), and the program must
  have printed "serving 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 terminal's text and the simulation log:
  https://www.theengineeringprojects.com/forum/category/beaglebone-black-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 BeagleBone Black board model, the TEP runtime, the terminal and the network (TEPNET.DLL, the compiled .pyc files
  in TEPPi\runtime with the stand-ins Adafruit_BBIO, smbus2, smbus, spidev, serial and the Raspberry Pi and Jetson
  ones), the symbols and artwork (TEPBBB.LIB), the part models (TEPTDS, TEPTURBIDITY and TEPYFS201 .DLL / .LIB, 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 Adafruit_BBIO, smbus2, py-spidev and pyserial; 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) - for our Raspberry Pi boards.
* Proteus is a product of Labcenter Electronics and is not included. BeagleBone and BeagleBoard are trademarks of the
  BeagleBoard.org Foundation; Sitara is a trademark of Texas Instruments. This library is not made or endorsed by
  BeagleBoard.org, Texas Instruments, Adafruit or Labcenter.

MODEL SCOPE AND LIMITS
Modelled: the 37 GPIOs of P8 / P9 the eMMC and the HDMI framer leave free (inputs, outputs, pulls, edges, PWM), the ADC
(AIN0 - AIN6, 12 bits, 0 - 1.8 V, VDD_ADC, GNDA_ADC), I2C2, SPI0 and UART1 as Linux's drivers drive them, the supply
pins, Ethernet (eth0, the cable: the join, DHCP, TCP and UDP to every TEP network part), the power LED and the user LEDs
USR0 - USR3, a short boot before the program starts, the board's /proc and /sys files above, the terminal. Not modelled:
Debian (no desktop, no shell commands, no apt, no os.system, no config-pin), the PRUs, the eMMC's and the HDMI framer's
pins, the other UARTs, I2C1, SPI1, the eQEP encoders, the CAN buses, the micro-HDMI and USB, the microSD card's files,
the POWER, RESET and BOOT buttons, C programs and C extensions, the real CPU's speed (each GPIO call takes about 8 us,
an ADC read about 0.16 ms; pure Python code takes no simulation time), the ADC's sampling capacitor and input current
(a source of a few kohm reads true here), real-time jitter. The model's own choices: the board's IP address
(192.168.1.51 for BB1), the boot time, the router; the simulation runs below real time.

VERSION
TEP BeagleBone Black library V1.0 (Oct 2026). Device BEAGLEBONE BLACK (TEPBBB.LIB / TEPNET.DLL with TEPPi: Python 3.11.9
and the TEP runtime 0.2). Demo program water_station.py V1.0, blink.py.