Project Files of Jetson Nano Library for Proteus: TF-Luna LiDAR, PCA9685 Servo

JETSON NANO LIBRARY FOR PROTEUS - V1.0 (NVIDIA JETSON NANO DEVELOPER KIT: TEGRA X1, 4 GB, GIGABIT ETHERNET, 40-PIN J41)
YOUR PYTHON PROGRAM RUNS ON THE BOARD - DEMO: A LIDAR BARRIER GATE (TF-LUNA ON THE UART, PCA9685 + SG90, 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/jetson-nano-library-for-proteus.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/jetson-nano-proteus-library
The demo's parts are our libraries (included) - their articles:
  TF-Luna:  https://www.theengineeringprojects.com/2026/10/tf-luna-lidar-sensor-library-for-proteus-v1-0.html
  PCA9685:  https://www.theengineeringprojects.com/2026/10/pca9685-servo-driver-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 Raspberry Pi boards run the same way (the same 40-pin header) - for example:
  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-400-library-for-proteus.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
Jetson-Nano-TEP-v1.0/
|-- Proteus Library Files/
|   |-- TEPJNANO.LIB                                     52.1 KB   the Jetson Nano, to LIBRARY
|   |-- TEPLAPTOP.LIB                                    39.5 KB   the laptop (demo), to LIBRARY
|   |-- TEPMOBILE.LIB                                    13.1 KB   the phone (demo), to LIBRARY
|   |-- TEPPCA9685.LIB                                  129.4 KB   the PCA9685 + the SG90 (demo), to LIBRARY
|   |-- TEPTFLUNA.LIB                                    50.3 KB   the TF-Luna LiDAR (demo), to LIBRARY
|-- Proteus Model Files/
|   |-- TEPNET.DLL                                       2.38 MB   the board + monitors + network, to MODELS
|   |-- TEPPCA9685.DLL                                  323.0 KB   the PCA9685 + the SG90, to MODELS
|   |-- TEPTFLUNA.DLL                                   309.5 KB   the TF-Luna LiDAR, to MODELS
|   |-- TEPPi/python/                                   17.54 MB   Python 3.11.9 embeddable (33 files)
|   |-- TEPPi/runtime/                                  903.5 KB   TEP Pi runtime, gpiozero (64 files)
|-- Python Code/
|   |-- barrier_gate.py                                   7.1 KB   the demo
|   |-- blink.py                                          0.5 KB   an LED on GPIO17 (the default)
|-- Proteus Simulation/
|   |-- barrier_gate.py                                   7.1 KB   the program of the demo
|   |-- Jetson-Nano-LiDAR-Barrier-Gate.pdsprj            32.1 KB   the demo: LiDAR barrier gate
|   |-- TEPNET.DLL                                       2.38 MB   copy of the model
|   |-- TEPPCA9685.DLL                                  323.0 KB   copy of the model
|   |-- TEPTFLUNA.DLL                                   309.5 KB   copy of the model
|-- README.txt                                          ~18.1 KB   this file
Total: 24.76 MB (unzipped). The source code of the models and of the TEP Pi runtime is not included.

WHAT IS IT?
The NVIDIA Jetson Nano Developer Kit (2019; the A02 carrier board) as one Proteus part - and a way to run Jetson
programs in Proteus 8.5. Proteus cannot run Ubuntu or CUDA, so this library does not emulate Linux or the GPU. 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 Jetson uses for its 40-pin header J41, 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.8 us per GPIO call, as Python on the Nano's 1.43 GHz Cortex-A57), and every edge is on time.
    time.time(), time.monotonic(), time.strftime() and datetime.now() follow the simulation's clock too.
  * The network: eth0, Gigabit Ethernet, with the cable in at Run (ETHERNET IN, the default; a click on the Ethernet
    jack plugs or unplugs it). The developer kit has no Wi-Fi of its own (an M.2 card is not modelled). The board is
    192.168.1.51 (192.168.1.(50 + the part's number)), the name jetson-nano.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 same names, numbers and messages as on a Jetson):
      Jetson.GPIO   NVIDIA's Jetson.GPIO 2.1: setmode BOARD or BCM (TEGRA_SOC / CVM names not offered), setup,
                    output, input, cleanup, add_event_detect / event_detected / wait_for_edge with callbacks and
                    bouncetime, PWM on the Nano's two PWM pins 32 and 33. As on a real Nano: setup()'s pull_up_down
                    is ignored with a warning (the pulls are set in the pinmux - give a button its own pull-up),
                    the I2C pins (3, 5, 27, 28) and the UART pins (8, 10) are not GPIO channels ("Channel 3 is
                    invalid"), "import RPi.GPIO" gives Jetson.GPIO too.
      spidev        SPI1 on pins 19 (MOSI), 21 (MISO), 23 (SCK), 24 (CS0), 26 (CS1) as /dev/spidev0.0 / 0.1, modes
                    0 to 3, up to 8 MHz; xfer / xfer2 take up to 4096 bytes, writebytes2 any length
      smbus2 / smbus  I2C bus 1 on pins 3 (SDA) and 5 (SCL) at 100 kHz: read_byte, write_byte, the byte / block reads
                    and writes, write_quick, i2c_rdwr with i2c_msg; a device that does not answer gives OSError
                    [Errno 121] Remote I/O error. (Bus 0 on pins 27 / 28 is not modelled.)
      serial        pyserial on /dev/ttyTHS1 (the header's UART: TXD pin 8, RXD pin 10), any baud rate, timeouts,
                    reset_input_buffer, back-to-back bytes
      socket        TCP and UDP on eth0, http.server / socketserver, urllib.request, select
    gpiozero is shipped for our Raspberry Pi boards; it does not run on a Jetson (as on a real one).
  * The board's own files: /proc/cpuinfo (four ARMv8 processors), /proc/device-tree/model ("NVIDIA Jetson Nano
    Developer Kit"), /proc/device-tree/compatible (nvidia,p3450-0000), the CPU temperature in /sys/class/thermal,
    /proc/loadavg, /proc/meminfo (4 GB).
  * The terminal (our TEP window, no Windows title bar): the shell prompt (jetson@jetson-nano:~$ python3 ...), the
    program's output (OUT) and errors (ERR, as Python prints them on a Jetson), a line for input() (IN); its Board tab
    shows the pins (by BCM number), the LED, the supply pins and RESTART PROGRAM. Click the DisplayPort / HDMI stack or
    the heatsink to open it.
  * The LED: the green power LED by the micro-USB, lit while the board runs.
  * 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 (100 x 80 mm) from NVIDIA's carrier-board layout, turned a quarter turn to
the left: on the real board J41 runs along the right edge; here it runs along the top edge, so its 40 pins leave the
board as one comb 50 thou apart, like every Raspberry Pi of our series (pin 1 on the left). So the I/O edge faces right:
from the bottom the 5 V barrel jack, the DisplayPort + HDMI stack, the two blue USB 3.0 pairs, the Gigabit Ethernet jack
and the micro-USB; the black heatsink with its four screws over the module, the module's edge and its SO-DIMM connector
beside it, the 4-pin fan header J15, the PoE header J38 in the top-left corner, along the bottom edge the button header
J40, the serial header J44, the camera connector J13 and the J48 jumper, and the power LED by the micro-USB. (The A02
has one camera connector; the B01 carrier board of 2020 has two and its button header J50 under the module.) Each pin
has a colour-coded tag: 5V red, 3V3 orange, GND black, GPIO green, I2C blue (pins 27 / 28: SDA0 / SCL0), SPI pink,
UART purple.

ONE DEVICE (search "JETSON" in Pick Devices):
  JETSON NANO DEVELOPER KIT  "NVIDIA Jetson Nano Developer Kit" V1.0 (category Microprocessor ICs > NVIDIA Jetson),
                             prefix JN, model TEPNET.DLL (with the TEPPi folder)
The same TEPNET.DLL also runs our Raspberry Pi boards (Model B to 5, the Zeros, the 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).

TEST STATUS
V1.0: verified in Proteus 8.5 on 24 Oct 2026 with the demo project as shipped. What the Proteus runs showed:
* Jetson-Nano-LiDAR-Barrier-Gate: the terminal shows "jetson@jetson-nano:~$ python3 barrier_gate.py"; eth0 is up (the
  cable in), the first TF-Luna frame reads "301 cm  strength 716  34.8 C" (the target at 300 cm, FPS 10 in the demo) and
  1.5 s after Run the program prints "serving on http://192.168.1.51:8000/". The PCA9685's pop-up: RUNNING 50.0 Hz,
  PRE_SCALE 121 (50.03 Hz), MODE1 0x21 AWAKE AI ALLCALL, OE LOW (pin 7); the SG90 on CH 0 at 0 degrees (the barrier
  down).
* The laptop and the phone open the page: the distance and the strength, the gate, the mode, the threshold (100 cm), the
  cars counted, the LiDAR's temperature - text links on the laptop, buttons on the phone.
* The TF-Luna pop-up's 50 cm preset (a car): "50 cm  strength 25662", 0.3 s later "the gate goes up (50 cm, AUTO)";
  the PCA9685's CH 0 at 1498 us, SERVO1 89.4 deg; the phone's page: Gate UP, Cars 1.
* The 400 cm preset (the car gone): 3 s later "the gate goes down (400 cm, AUTO)".
* LOCK on the laptop, then 50 cm again: the barrier stays down ("Gate: DOWN - mode LOCKED", Cars 1); AUTO on the phone:
  "the gate goes up"; 200 CM on the phone: the threshold 200 cm; 400 cm: down again 3 s later.
* The Board tab: the Tegra X1 at 1.43 GHz, the PWR LED, GPIO2 / GPIO3 pulled up, GPIO4 (OE, pin 7) LOW, GPIO14 / 15
  (the UART) HIGH between bytes, 5V 5.00 V, 3V3 3.30 V, "No errors".
* Speed on our test PC: about 30 % of real time with the two 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). TEPJNANO.LIB is the Jetson Nano; TEPTFLUNA.LIB (the LiDAR), TEPPCA9685.LIB (the servo
   driver and the SG90), 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 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 TEPJNANO.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 "JETSON".
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).
  Jetson-Nano-LiDAR-Barrier-Gate.pdsprj - JN1 runs barrier_gate.py on Ethernet (the cable in): U1 = a TF-Luna LiDAR on
  the UART (5V, RXD on pin 8 = TXD, TXD on pin 10 = RXD, CFG open = UART mode; the demo's target at 300 cm, FPS 10),
  PCA1 = a PCA9685 16-channel servo driver on I2C bus 1 (VCC on 3V3, SDA pin 3, SCL pin 5, OE on pin 7, V+ on 5V),
  SERVO1 = an SG90 on PWM0 - the barrier; PC1 = the Laptop WiFi Monitor and MOB1 = the Mobile WiFi Monitor on the same
  router. The LiDAR and the driver are the Advance parts: their pop-up windows open at Run.
  Press Run: eth0 is up and the program serves its page. It reads every TF-Luna frame (59 59, the distance, the
  strength, the temperature, a checksum) and moves the barrier: in AUTO mode it goes up when a car is closer than the
  threshold (100 cm) for 0.3 s - one more car counted - and down when the lane has been clear for 3 s. Put a car in
  front of the LiDAR with its pop-up's presets (10, 50, 100, 200, 400, 800 cm, NONE), SWEEP or APPROACH. On the
  laptop or the phone open http://192.168.1.51:8000/ (Browser, the address, Go): the page shows the distance and the
  strength, the gate and the mode, the threshold, the cars and the LiDAR's temperature, with REFRESH, AUTO, HOLD OPEN,
  LOCK, 50 CM, 100 CM and 200 CM.
  The program is pure Python: pyserial for the frames, smbus2 for the PCA9685 (sleep, PRE_SCALE 121 for 50 Hz, wake with
  auto-increment, restart; each servo pulse as the channel's OFF count of 4096), Jetson.GPIO in BOARD mode for OE, a
  thread for the gate 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 pin 12, BOARD numbering). Python's standard library is there;
other pure-Python packages work when you copy them next to your program. Use GPIO.setmode(GPIO.BOARD) with the header's
pin numbers (the Jetson way) or GPIO.setmode(GPIO.BCM).
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 40-PIN HEADER J41 (BOARD numbers; BCM numbers in brackets, as Jetson.GPIO's BCM mode)
   1 3V3          2 5V           3 I2C1 SDA (2)  4 5V           5 I2C1 SCL (3)  6 GND          7 GPIO (4)
   8 UART TXD     9 GND         10 UART RXD     11 GPIO (17)   12 GPIO (18)    13 GPIO (27)   14 GND
  15 GPIO (22)   16 GPIO (23)   17 3V3          18 GPIO (24)   19 SPI MOSI (10) 20 GND        21 SPI MISO (9)
  22 GPIO (25)   23 SPI SCK (11) 24 SPI CS0 (8) 25 GND         26 SPI CS1 (7)  27 I2C0 SDA    28 I2C0 SCL
  29 GPIO (5)    30 GND         31 GPIO (6)     32 PWM (12)    33 PWM (13)     34 GND         35 GPIO (19)
  36 GPIO (16)   37 GPIO (26)   38 GPIO (20)    39 GND         40 GPIO (21)
3.3 V logic. Pins 19 - 26 are SPI and 32 / 33 PWM after the pinmux is set (jetson-io); here they are ready at Run.

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 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.
* ValueError: Channel 3 is invalid: pins 3, 5, 8, 10, 27 and 28 belong to I2C and the UART on a Jetson - use another
  pin for GPIO.
* ValueError: Channel 12 is not a PWM: only pins 32 and 33 make PWM on a Jetson Nano.
* A button never reads LOW / HIGH: Jetson.GPIO ignores pull_up_down - wire a pull-up (10 kohm to 3V3) yourself.
* No TF-Luna frames: CFG (pin 5) must be open at power-on (UART mode) - to GND it starts in I2C mode; 115200 baud on
  /dev/ttyTHS1, the sensor's TXD to the board's RXD (pin 10).
* The servo does not move: OE LOW (pin 7), the PCA9685 woken after the prescale, V+ on 5V.
* 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/jetson-nano-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 Jetson Nano board model, the TEP Pi runtime, the terminal and the network (TEPNET.DLL, the compiled .pyc files in
  TEPPi\runtime with the stand-ins Jetson.GPIO, lgpio, RPi, smbus2, smbus, spidev, serial, Adafruit_DHT, adafruit_dht,
  board), the symbols and artwork (TEPJNANO.LIB), the part models (TEPTFLUNA and TEPPCA9685 .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 Jetson.GPIO, RPi.GPIO, 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. NVIDIA and Jetson are trademarks of NVIDIA
  Corporation; TF-Luna is a Benewake product. This library is not made or endorsed by NVIDIA, Benewake or Labcenter.

MODEL SCOPE AND LIMITS
Modelled: the GPIOs of the 40-pin header (inputs, outputs, edges, PWM on pins 32 / 33), the I2C (bus 1), SPI and UART
buses 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, a short boot before the program starts, the board's /proc and /sys files above, the
terminal. Not modelled: Ubuntu / L4T (no desktop, no shell commands, no apt, no os.system), the GPU, CUDA, TensorRT and
the cameras (no AI inference - the program is plain Python), the M.2 slot and Wi-Fi, the four cores (one program, its
threads take turns), I2C bus 0 on pins 27 / 28, the pinmux and jetson-io, the HDMI / DisplayPort outputs, USB, the
microSD card's files, the fan header, PoE, the button and serial headers, C programs and C extensions, the real CPU's
speed (each GPIO call takes about 1.8 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 JN1), the boot time, the router; the simulation runs below real time.

VERSION
TEP Jetson Nano library V1.0 (Oct 2026). Device JETSON NANO DEVELOPER KIT (TEPJNANO.LIB / TEPNET.DLL with TEPPi: Python
3.11.9 and the TEP Pi runtime 0.2). Demo program barrier_gate.py V1.0, blink.py.