Project Files of VL53L0X Sensor Library for Proteus V1.1 (GY-530 + Arduino)

VL53L0X TIME-OF-FLIGHT DISTANCE SENSOR (GY-530) LIBRARY FOR PROTEUS - V1.1
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/09/vl53l0x-proteus-library.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/vl53l0x-proteus-library
The demo uses our TEP Serial Monitor Advance (included) instead of Proteus's
Virtual Terminal - its own article:
  https://www.theengineeringprojects.com/2026/10/serial-monitor-advance-proteus-library.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
VL53L0X-TEP-v1.1/
|-- Proteus Library Files/
|   |-- ArduinoV3TEP.IDX                          0.8 KB   its index -> LIBRARY folder
|   |-- ArduinoV3TEP.LIB                         95.6 KB   TEP Arduino UNO (demo) -> LIBRARY folder
|   |-- TEPSERIALMON.LIB                         11.1 KB   TEP Serial Monitor Advance -> LIBRARY folder
|   |-- TEPVL53L0X.LIB                           44.5 KB   VL53L0X Simple + Advance (2 devices) -> LIBRARY
|-- Proteus Model Files/
|   |-- TEPSERIALMON.DLL                        978.0 KB   Serial Monitor model -> MODELS folder
|   |-- TEPVL53L0X.DLL                          537.0 KB   the TEP I2C sensor model -> MODELS
|-- Proteus Simulation/
|   |-- TEPSERIALMON.DLL                        978.0 KB   copy of the monitor model
|   |-- TEPVL53L0X.DLL                          537.0 KB   copy of the model so the demo runs as is
|   |-- VL53L0X_Demo.hex                         42.5 KB   both UNOs (the demo sketch v1.1)
|   |-- VL53L0X-ArduinoUnoV3.pdsprj              22.9 KB   demo: UNO 1 + VL53L0X Simple, UNO 2 + Advance
|-- Arduino Code/
|   |-- VL53L0X_Demo/VL53L0X_Demo.ino             4.8 KB   sketch (source of the .hex)
|   |-- libraries/VL53L0X/                       54.5 KB   Pololu VL53L0X 1.3.1, MIT + ST BSD, 8 files
|-- README.txt                                  ~26.8 KB   this file
Total: 3.26 MB (unzipped). The C++ source code of the model is not included.

WHAT IS IT?
A simulation model of the ST VL53L0X laser time-of-flight distance sensor on
the common purple GY-VL53L0XV2 / GY-530 breakout, for Proteus 8. Your Arduino
talks to it over I2C exactly as to the real chip (address 0x29, or the address
your sketch moves it to) and the popular Pololu VL53L0X library runs
unmodified: init (the whole ST start-up sequence with the SPAD and reference
calibrations), readRangeSingleMillimeters, startContinuous / stopContinuous,
readRangeContinuousMillimeters, setMeasurementTimingBudget,
setSignalRateLimit, setVcselPulsePeriod, setAddress, setTimeout /
timeoutOccurred. A ranging takes its real time: the measurement timing budget
the registers give, computed with ST's formula (about 33 ms after init, 20 ms
"high speed", 200 ms "high accuracy"); continuous ranging repeats it
back-to-back or every inter-measurement period. You set the distance (0 .. 2000
mm) and the target: IDEAL (seen at every distance, as v1.0), WHITE, GREY or
BLACK - a darker target returns less signal, and below the signal rate limit
the sensor reports "no target" (8190), so each target has its range (white 1.2
m, grey 0.7 m, black 0.38 m with the default set-up; Pololu's long-range set-up
reaches about 2.3 / 1.35 / 0.73 m). Sliders, presets (NO TARGET, IDEAL, WHITE,
GREY, BLACK, 100 mm) or a click on the distance scale above the board set them.
The part looks like the GY-VL53L0XV2: the purple board with a round ear and a
mounting hole on each side, the VL53L0X with its emitter and receiver windows,
the two 7002 level-shifter transistors, the 2V8 regulator and the board print.
Above the board sits an animated time-of-flight view: the sensor seen from the
side sends laser pulses to the target on a 0 .. 2 m scale and they come back;
the dashed line shows how far this target can be seen; the distance, the target
type, the return signal and the limit are written below. On the board: a red PWR
LED, a blue I2C LED that flashes for every I2C transaction to this sensor and
an amber GPIO1 LED that lights while the GPIO1 interrupt is active - TEP
additions (the real board has no LED) - and the live I2C address (0x29, "I2C
OFF" while XSHUT is low).

TWO DEVICES IN ONE LIBRARY (search "VL53L0X" in Pick Devices):
  VL53L0X Simple    device VL53L0XTEP     "VL53L0X Time-of-Flight Sensor (GY-530) - Simple"
                    On-Sheet Panel: a control panel on the schematic next to the
                    board - six presets, the DISTANCE slider of v1.0 (drag it;
                    the target is a preset) and what your sketch READ over I2C
                    (decoded by the model: "SKETCH READ: 500 MM" or "8190 = NO
                    TARGET"), the target with its signal, the timing budget, the
                    signal limit and the VCSEL periods your sketch chose. The red
                    X in the panel's header closes it, the PANEL button on the
                    board opens it again. Your v1.0 designs keep working with
                    this device.
  VL53L0X Advance   device VL53L0XADVTEP  "VL53L0X Time-of-Flight Sensor (GY-530) - Advance"
                    Pop-Up Panel: only the board on the schematic; at Run a TEP
                    pop-up window opens - the same look as the TEP Serial Monitor
                    (move it by its header, resize it, minimise it). The tabs
                    Sensor and Test sit in the header; the gear and ? icons open
                    Settings and Help; the palette icon switches the theme:
                      Sensor    the live time-of-flight view (click the scale to
                                move the target), the presets, a click-slider with
                                - / + for both inputs, the last reading as big
                                tiles, and what the Arduino read over I2C (the
                                distance, the ranging mode, the budget, the I2C
                                address and the measured SCL clock)
                      Test      four tools measured on the model with your sketch:
                                I2C check, Timing, Step response, Range test (see
                                THE TEST TOOLS below)
                      Settings  theme (TEP Dark / Light), text size, open at Run,
                                window size - remembered for your Windows user
                      Help      Help & Support like the TEP Serial Monitor: report a
                                bug, suggest a feature, article, user guide,
                                updates, donate, website, forum; Copy diagnostics
                                (the inputs, what was read, the registers, the last
                                transactions, the test results) for a bug report
                    The OPEN PANEL button on the board opens the window again
                    after you close it.
Both devices use the same model (TEPVL53L0X.DLL) and the same properties.

NEW IN V1.1
* Two devices: VL53L0X Simple (panel on the sheet, close / open) and VL53L0X
  Advance (pop-up window with the live time-of-flight view, four test tools,
  settings and help) - see above.
* Board: the real GY-VL53L0XV2's look (purple, two round ears with holes, the
  sensor's two windows, the level shifters and the 2V8 regulator) with an
  animated time-of-flight view above it (laser pulses, the target on a 2 m
  scale, its range limit), PWR / I2C / GPIO1 LEDs (a TEP addition), the live
  I2C address, a PANEL / OPEN PANEL button and a SIMPLE / ADVANCE badge.
* Model - real ranging time (v1.0: approximate): the measurement timing budget
  from the registers with ST's formula (start 1.91 ms + end 0.96 ms + TCC, DSS /
  MSRC, pre-range and final range with their VCSEL periods) - 33.8 ms after the
  Pololu init, exactly what the library's getMeasurementTimingBudget() reports.
* Model - target types (v1.0: present / absent): WHITE (88 %), GREY (17 %) and
  BLACK (5 %) return a signal that falls with the square of the distance and
  grows with the VCSEL period; below the signal rate limit (0.25 MCPS by
  default, 0.1 in the long-range set-up) the result is 8190 with range status 4.
  The signal rate is in the result registers (MCPS). TARGET 0 / 1 behave as in
  v1.0.
* Model - an I2C transaction log (every read / write decoded: "read
  RESULT_RANGE (mm) -> 01 F4", "write SYSRANGE_START = 04") and the measured
  SCL clock.
* The demo: ONE project with two UNOs - UNO 1 with VL53L0X Simple, UNO 2 with
  VL53L0X Advance - each with the TEP Serial Monitor Advance instead of the
  Virtual Terminal (U3 = UNO 1, U4 = UNO 2, quick buttons) and an LED on A0.
* The demo sketch (v1.1) keeps every v1.0 line and adds: a proximity alarm on
  the LED (closer than 200 mm), and the Serial Monitor commands HELP, STATUS,
  MODE DEFAULT / LONG / FAST / ACCURATE, NEAR, ADDR. It prints nothing
  periodically except the readings.
* Version 1.1 everywhere; the C++ source code is no longer included (and
  neither is the Arduino AVR core archive - its GitHub link is below).

TEST STATUS
v1.1: verified in Proteus 8.5 on 8 Oct 2026 (the demo run from this package's
Proteus Simulation folder):
  * start-up: "TEP VL53L0X Demo v1.1 - type HELP in the Serial Monitor", then
    "Distance: 500 mm"; 100 mm: "Distance: 100 mm" and the GPIO1 LED; NO TARGET:
    "No target detected." and "Proximity: off";
  * the four tools on U2: I2C check (MODEL_ID EE, FINAL_TIMEOUT 0290 = 33.82 ms,
    0 NACKs, SCL 86 kHz); Timing (60 rangings of 33.82 ms every 50.00 ms, 12 reads
    every 251.7 ms, data age 24.1 / 33.3 ms); Step response (200 -> 800 -> 200 ->
    800 mm, seen after 234.6 / 244.5 / 254.5 ms); Range test, white (50 .. 1100 mm
    exact, 1400 mm = 0.18 MCPS, "8190 (no target)": "Your sketch saw the target up
    to 1100 mm and lost it at 1400 mm.").
After that run (PC-tested, to be re-checked in Proteus): the window text under the board is plain ASCII (a
middle dot showed as two odd characters in Proteus), the register names are
shorter and every register has its own row, the TARGET input shows its name
(NO TARGET / IDEAL / WHITE 88 % ...), and the Test pages fill the window. Later the
same day (PC-tested too): the Step response waits until the readings sit at the
start value before step 1.
PC tests (8 Oct 2026, this package's DLL / LIB / sketch):
  1770 automatic checks on a PC, 0 failed, plus the v1.0 test, unchanged and
  passing with the v1.1 model (VL53L0X: official Pololu initialization, SPAD
  handshake, single/continuous ranging, address change and no-target output); 13
  chip checks for v1.1 (the timing budget the library computes, single shot and
  continuous timing, the target types and the signal limit, the long-range
  set-up); 70 on the complete Proteus model (the LIB (pins, properties, both
  devices), power, XSHUT, the PWR / I2C / GPIO1 LEDs, the panel, red X / PANEL,
  OPEN PANEL, the pop-up pages and links, the decoded distance, the timing
  budget, the target types and their range, the long-range set-up, the address
  change, the presets, the lane click, the four tools, a design with the v1.0
  symbol); 27 with the real v1.1 demo sketch and the unmodified driver library
  on two UNOs (every v1.0 output line, the proximity LED, every Serial Monitor
  command, XSHUT, the Timing / Step response / Range test tools with the real
  sketch); 1660 on the rendered boards and pop-up windows (every page fits in
  TEP Dark and Light, at Large text and 150 % DPI; every tool's hint lines and
  every header state fit).
v1.0 (29 Sep 2026): the v1.0 demo was opened, run and checked in Proteus 8.5
  (500 mm at the start, 1432 mm after dragging the distance, "No target
  detected." without a target); the v1.0 tests (the unmodified Pololu library
  over the bit-level I2C slave: initialisation, SPAD handshake, single and
  continuous ranging, address change, no target) still pass with the v1.1
  model.

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPVL53L0X.LIB with both
   devices, TEPSERIALMON.LIB and the TEP Arduino UNO V3 library ArduinoV3TEP.LIB
   / .IDX used by the demo) 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).
3. Copy TEPVL53L0X.DLL and TEPSERIALMON.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
4. Updating from v1.0: replace TEPVL53L0X.LIB and TEPVL53L0X.DLL, and
   delete TEPVL53L0X.IDX if there is one in the LIBRARY folder. A v1.0 design
   keeps its v1.0 symbol: it runs with the new model and shows the v1.0 panel
   (without the v1.1 board parts and the red X) - re-pick the part to get the
   v1.1 symbol.
5. Start Proteus. In Pick Devices (P) search "VL53L0X": you get the Simple and
   the Advance device (category Sensors > Distance, as in v1.0).
The model DLL is the TEP I2C sensor family model: TEPMPU6050.DLL, TEPBMP280.DLL,
TEPMAX30102.DLL, TEPVL53L0X.DLL, TEPSHT31.DLL and TEPTCS34725.DLL are identical
files under the v1.0 names, so every v1.0 design finds its model.

RUN THE DEMO
"Proteus Simulation\VL53L0X-ArduinoUnoV3.pdsprj" - keep VL53L0X_Demo.hex and the
two DLLs beside the project.
  UNO 1 (ARD1): VL53L0X Simple (U1), Serial Monitor U3.
  UNO 2 (ARD2): VL53L0X Advance (U2), Serial Monitor U4.
  Both UNOs run VL53L0X_Demo.hex. An LED (D1 / D2) with 220 ohm on A0 of each
  UNO: the proximity alarm.
  1. Press Run. Both monitor windows open (9600 baud) and so does U2's pop-up.
     U3 and U4 show "TEP VL53L0X - change distance or target presence." and
     "TEP VL53L0X Demo v1.1 - type HELP in the Serial Monitor", then about 4
     times a second:
       Distance: 500 mm
     The laser pulses run to the target in the view above the board; the blue
     I2C LED flashes with every read.
  2. U1: drag DISTANCE - "Distance: 1234 mm". Click 100 mm: "Distance: 100 mm"
     and "Proximity: closer than the alarm distance (LED on)", LED D1 lights.
     NO TARGET: "No target detected.". WHITE, then drag past 1.2 m: the pulses
     stop at the dashed range line and U3 prints "No target detected." - the
     white target is too far for the default set-up. Close the panel with its
     red X and open it with PANEL.
  3. U3 / U4 quick buttons: STATUS, MODE LONG (now the white target is seen to
     about 2.3 m), MODE FAST (20 ms rangings), HELP. Type MODE ACCURATE (200 ms),
     MODE DEFAULT, NEAR 600, ADDR 30 (the board then shows I2C 0x30).
  4. U2 (Advance): the Sensor page shows the same inputs and what the sketch
     read; the Test page has the four tools (below).
  5. Close U2's window and open it again with OPEN PANEL on the board.
Closed a monitor window? Click OPEN MONITOR on the monitor part.

WIRING (as in the v1.0 demo)
VIN -> supply, GND -> GND, SCL -> A5, SDA -> A4, XSHUT -> supply (high = on;
low = the sensor is off and forgets its settings and address); GPIO1 not
connected (it is optional: it drives the GPIO1 LED and can go to D2 for
attachInterrupt).
In the sketch: VL53L0X sensor;  sensor.init();  sensor.startContinuous(50);
Serial 9600.
Serial Monitor RXD <- Arduino D1 (TX), Serial Monitor TXD -> Arduino D0 (RX),
Serial Monitor GND -> ground. RXD2 is not needed: I2C has no serial line to
watch. The proximity LED + 220 ohm from A0 to GND.
Pin order in Proteus: VIN GND SCL SDA GPIO1 XSHUT (v1.0; the real
GY-VL53L0XV2 header reads VCC GND SCL SDA GPIO1 XSHUT - VIN is its VCC).
REAL HARDWARE:
 * Supply: the board has a 2.8 V regulator and MOSFET level shifters - feed VIN
   with 3.3 V or 5 V; SDA / SCL / XSHUT work with a 5 V UNO.
 * I2C pull-ups: on the board (to its 2.8 V side and through the level
   shifters to VIN), so A4 / A5 need nothing else.
 * Address: 0x29 after every power-up. setAddress() is volatile: to use
   several sensors, hold all XSHUT pins low, then release one at a time and give
   each a new address.
 * Range: the datasheet's 2 m needs the long-range set-up, a white target and
   little ambient (sun) light; grey and black objects are seen much less far,
   as in the model. The real sensor has a few % noise and an offset (and a
   protective film over the windows - remove it).

THE TEST TOOLS (VL53L0X Advance, Test tab) - what they really measure
Every tool runs on the live model with your sketch: it changes the sensor's
inputs (and restores them) and watches the I2C reads your Arduino really makes -
it never talks to your Arduino. Each tool shows one "Good for:" line and one
line on how it measures.
  I2C check       Good for: checking that the VL53L0X answers and what your
                  sketch really wrote into it. The registers read live and
                  decoded (MODEL_ID 0xEE, the I2C address, SYSRANGE_START:
                  single / back-to-back / timed, the sequence steps, the
                  inter-measurement period, the signal rate limit, the VCSEL
                  periods, the final-range timeout = the budget, the GPIO1
                  configuration, the interrupt status, the range status - marked
                  when there is no usable signal - and the last result),
                  transactions, bytes, NACKs, the measured SCL clock and the
                  last transactions decoded (repeats folded). With the demo:
                  "write SYSRANGE_START = 04" (timed continuous), "read
                  RESULT_RANGE (mm) -> 01 F4" (500 mm).
  Timing          Good for: seeing how often new data exists and whether your
                  sketch reads it in time. Records for 1, 3 or 10 s every
                  ranging the VL53L0X makes and every distance read: the output
                  period (avg / min / max), the ranging time, the sketch's read
                  period, the data age at each read, reads of the same result
                  twice, and ST's timing budget formula with your registers.
                  With the demo: a 33.8 ms ranging every 50.0 ms
                  (startContinuous(50)); the sketch reads about every 250 ms
                  (its delay(250)), so it sees one ranging in five.
  Step response   Good for: seeing how quickly a change reaches your sketch -
                  ranging time and read period together. Steps the distance
                  (200 -> 800 mm, 500 -> 1500 mm or 30 -> 150 mm) 1, 3 or 5
                  times (1.5 s each) and plots every reading your sketch made;
                  per step: the first reading that shows it (10 %), 90 % and
                  settled (2 %). With the demo the step shows in the next
                  reading (within about 250 ms).
  Range test      Good for: finding how far your sensor sees a white, grey or
                  black target - and what the long-range set-up adds. Puts the
                  chosen target (White / Grey / Black / Ideal) at 50, 150, 300,
                  500, 800, 1100, 1400, 1700 and 2000 mm (1.6 s each), shows the
                  return signal next to the limit and what your sketch read
                  (8190 = no target), and sums up where the target was lost.
                  With the demo and a white target: seen to 1100 mm, lost at
                  1400 mm (range 1.20 m); after MODE LONG: seen to 2000 mm.

THE DEMO SKETCH ON THE SERIAL MONITOR (VL53L0X_Demo v1.1)
  HELP                    the command list
  STATUS                  mode, timing budget, signal limit, VCSEL periods, alarm
                          distance, I2C address
  MODE DEFAULT|LONG|FAST|ACCURATE   Pololu's example set-ups: LONG = 0.1 MCPS
                          + VCSEL 18 / 14, FAST = 20 ms, ACCURATE = 200 ms
  NEAR mm                 the proximity alarm distance (default 200 mm)
  ADDR hex                move the sensor to another I2C address (e.g. ADDR 30)
Monitor quick buttons in the demo: STATUS, MODE LONG, MODE FAST, HELP.
Every line the sketch prints has at most 80 characters (it fits the Serial Monitor's
Simple interface); longer answers are split, the second line indented.

EXPECTED MONITOR OUTPUT (U3 and U4)
  TEP VL53L0X - change distance or target presence.
  TEP VL53L0X Demo v1.1 - type HELP in the Serial Monitor
  Distance: 500 mm
After 100 mm on the panel:
  Distance: 100 mm
  Proximity: closer than the alarm distance (LED on)
After NO TARGET:
  No target detected.
After STATUS:
  Status: mode DEFAULT, timing budget 33.8 ms, signal limit 0.25 MCPS
    VCSEL 14/10, alarm below 200 mm, address 0x29

PROPERTIES (double-click the sensor > Edit Properties; the same on Simple and
Advance - the v1.0 properties)
  DISTANCE        distance to the target in mm, 0 .. 2000 (default 500)
  TARGET          0 = no target, 1 = ideal (seen at every distance, v1.0),
                  2 = white, 3 = grey, 4 = black (default 1)
The panel style is chosen by the device (Simple / Advance), not by a property.
The Advance window settings (theme, text size, open at Run, size) are on its
Settings page. The demo's Serial Monitors: BAUD 9600, THEME TEPDARK, AUTOOPEN
YES, QUICK1-4 as above (see the Serial Monitor's article for all its
properties).

LINKS.INI (OPTIONAL)
The Help page cards of the Advance device open web pages. To point them
somewhere else without a new DLL, put a text file named links.ini next to
TEPVL53L0X.DLL with lines KEY=URL, for example:
  ARTICLE=https://www.theengineeringprojects.com/...
Keys: WEBSITE, FORUM, BUG_REPORT, FEATURE_REQUEST, ARTICLE, USER_GUIDE,
UPDATE_CHECK, DONATE. Only http:// and https:// links are used; lines starting
with # are comments.

TROUBLESHOOTING
* "VL53L0X not found. Check power, SDA, SCL and XSHUT/VCC.": check VIN / GND
  (the PWR LED must be lit and the board shows "I2C 0x29"), XSHUT high, SDA ->
  A4, SCL -> A5.
* "No target detected.": TARGET is 0, or the target is beyond its range (white
  1.2 m, grey 0.7 m, black 0.38 m in the default set-up) - the view above the
  board shows the range line; try MODE LONG.
* "Ranging timeout.": the sensor answers but never finishes a ranging - e.g.
  XSHUT went low and high again while running (the sensor restarted
  un-initialised: reset the Arduino).
* The readings lag: the demo reads about 4 times a second; the sensor itself
  ranges every 50 ms (Timing tool).
* After ADDR the sensor is lost when XSHUT or the power cycles: the address goes
  back to 0x29 (it is not stored).
* The part is not simulated / no panel: TEPVL53L0X.DLL is missing from MODELS
  and from the project folder. No monitor window: TEPSERIALMON.DLL is missing,
  or click OPEN MONITOR on the monitor part.
* Advance: the pop-up does not appear - click OPEN PANEL on the board, use
  Proteus's Debug menu, or turn "Open the panel at Run" on its Settings page
  back on.
* Simple: the red X does not close the panel / the board looks like v1.0 - the
  design still holds the v1.0 symbol; replace TEPVL53L0X.LIB, delete
  TEPVL53L0X.IDX and re-pick the part.
* Your own sketch uses SoftwareSerial to receive: Proteus 8.5 cannot receive
  with SoftwareSerial (pin-change interrupts are not simulated) - use the
  hardware Serial (as the demo does) or AltSoftSerial.

BUG REPORTS AND FEATURE REQUESTS
Please post them in our forum with a screenshot, the Serial Monitor text, the
simulation log and (Advance) the Copy diagnostics text:
  https://www.theengineeringprojects.com/forum/category/vl53l0x-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 VL53L0X model (TEPVL53L0X.DLL), the symbols and artwork and the TEP Serial
  Monitor Advance (TEPSERIALMON.LIB / .DLL) are made by The Engineering
  Projects. The model is an independent implementation written from the
  VL53L0X datasheet and ST's published timing-budget formula; it contains no S
…