Initial import

code/lib/Adafruit_VL53L0X-1.2.3/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,46 @@
+Thank you for opening an issue on an Adafruit Arduino library repository.  To
+improve the speed of resolution please review the following guidelines and
+common troubleshooting steps below before creating the issue:
+
+- **Do not use GitHub issues for troubleshooting projects and issues.**  Instead use
+  the forums at http://forums.adafruit.com to ask questions and troubleshoot why
+  something isn't working as expected.  In many cases the problem is a common issue
+  that you will more quickly receive help from the forum community.  GitHub issues
+  are meant for known defects in the code.  If you don't know if there is a defect
+  in the code then start with troubleshooting on the forum first.
+
+- **If following a tutorial or guide be sure you didn't miss a step.** Carefully
+  check all of the steps and commands to run have been followed.  Consult the
+  forum if you're unsure or have questions about steps in a guide/tutorial.
+
+- **For Arduino projects check these very common issues to ensure they don't apply**:
+
+  - For uploading sketches or communicating with the board make sure you're using
+    a **USB data cable** and **not** a **USB charge-only cable**.  It is sometimes
+    very hard to tell the difference between a data and charge cable!  Try using the
+    cable with other devices or swapping to another cable to confirm it is not
+    the problem.
+
+  - **Be sure you are supplying adequate power to the board.**  Check the specs of
+    your board and plug in an external power supply.  In many cases just
+    plugging a board into your computer is not enough to power it and other
+    peripherals.
+
+  - **Double check all soldering joints and connections.**  Flakey connections
+    cause many mysterious problems.  See the [guide to excellent soldering](https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools) for examples of good solder joints.
+
+  - **Ensure you are using an official Arduino or Adafruit board.** We can't
+    guarantee a clone board will have the same functionality and work as expected
+    with this code and don't support them.
+
+If you're sure this issue is a defect in the code and checked the steps above
+please fill in the following fields to provide enough troubleshooting information.
+You may delete the guideline and text above to just leave the following details:
+
+- Arduino board:  **INSERT ARDUINO BOARD NAME/TYPE HERE**
+
+- Arduino IDE version (found in Arduino -> About Arduino menu):  **INSERT ARDUINO
+  VERSION HERE**
+
+- List the steps to reproduce the problem below (if possible attach a sketch or
+  copy the sketch code in too): **LIST REPRO STEPS BELOW**

code/lib/Adafruit_VL53L0X-1.2.3/.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,26 @@
+Thank you for creating a pull request to contribute to Adafruit's GitHub code!
+Before you open the request please review the following guidelines and tips to
+help it be more easily integrated:
+
+- **Describe the scope of your change--i.e. what the change does and what parts
+  of the code were modified.**  This will help us understand any risks of integrating
+  the code.
+
+- **Describe any known limitations with your change.**  For example if the change
+  doesn't apply to a supported platform of the library please mention it.
+
+- **Please run any tests or examples that can exercise your modified code.**  We
+  strive to not break users of the code and running tests/examples helps with this
+  process.
+
+Thank you again for contributing!  We will try to test and integrate the change
+as soon as we can, but be aware we have many GitHub repositories to manage and
+can't immediately respond to every request.  There is no need to bump or check in
+on a pull request (it will clutter the discussion of the request).
+
+Also don't be worried if the request is closed or not integrated--sometimes the
+priorities of Adafruit's GitHub code (education, ease of use) might not match the
+priorities of the pull request.  Don't fret, the open source community thrives on
+forks and GitHub makes it easy to keep your changes in a forked repo.
+
+After reviewing the guidelines above you can delete this text from the pull request.

code/lib/Adafruit_VL53L0X-1.2.3/.github/workflows/githubci.yml

@@ -0,0 +1,32 @@
+name: Arduino Library CI
+
+on: [pull_request, push, repository_dispatch]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+    - uses: actions/checkout@v3
+    - uses: actions/checkout@v3
+      with:
+         repository: adafruit/ci-arduino
+         path: ci
+
+    - name: pre-install
+      run: bash ci/actions_install.sh
+
+    - name: test platforms
+      run: python3 ci/build_platform.py main_platforms
+
+    - name: clang
+      run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r .
+
+    - name: doxygen
+      env:
+        GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }}
+        PRETTYNAME : "Adafruit VL53L0X Library"
+      run: bash ci/doxy_gen_and_deploy.sh

code/lib/Adafruit_VL53L0X-1.2.3/.gitignore

@@ -0,0 +1,4 @@
+*.c~
+*.cpp~
+*.h~
+.DS_Store

code/lib/Adafruit_VL53L0X-1.2.3/README.md

@@ -0,0 +1,13 @@
+# Adafruit VL53L0X Library [![Build Status](https://github.com/adafruit/Adafruit_VL53L0X/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_VL53L0X/actions)[![Documentation](https://github.com/adafruit/ci-arduino/blob/master/assets/doxygen_badge.svg)](http://adafruit.github.io/Adafruit_VL53L0X/html/index.html)
+
+<img src="https://cdn-shop.adafruit.com/970x728/3317-03.jpg" height="300"/>
+
+This is a library for the Adafruit VL53L0X time-of-flight breakout:
+  * https://www.adafruit.com/products/3317
+ 
+Check out the links above for our tutorials and wiring diagrams. This chip uses I2C to communicate
+
+Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
+
+Written by Limor Fried/Ladyada for Adafruit Industries.
+MIT license, all text above must be included in any redistribution

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x/vl53l0x.ino

@@ -0,0 +1,36 @@
+#include "Adafruit_VL53L0X.h"
+
+Adafruit_VL53L0X lox = Adafruit_VL53L0X();
+
+void setup() {
+  Serial.begin(115200);
+
+  // wait until serial port opens for native USB devices
+  while (! Serial) {
+    delay(1);
+  }
+  
+  Serial.println("Adafruit VL53L0X test");
+  if (!lox.begin()) {
+    Serial.println(F("Failed to boot VL53L0X"));
+    while(1);
+  }
+  // power 
+  Serial.println(F("VL53L0X API Simple Ranging example\n\n")); 
+}
+
+
+void loop() {
+  VL53L0X_RangingMeasurementData_t measure;
+    
+  Serial.print("Reading a measurement... ");
+  lox.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
+
+  if (measure.RangeStatus != 4) {  // phase failures have incorrect data
+    Serial.print("Distance (mm): "); Serial.println(measure.RangeMilliMeter);
+  } else {
+    Serial.println(" out of range ");
+  }
+    
+  delay(100);
+}

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x_Interrupt/vl53l0x_Interrupt.ino

@@ -0,0 +1,90 @@
+#include "Adafruit_VL53L0X.h"
+const byte VL53LOX_InterruptPin = 6;
+const byte VL53LOX_ShutdownPin = 9;
+volatile byte VL53LOX_State = LOW;
+Adafruit_VL53L0X lox = Adafruit_VL53L0X();
+
+void setup() {
+  Serial.begin(115200);
+
+  // wait until serial port opens for native USB devices
+  while (!Serial) {
+    delay(1);
+  }
+  Serial.println(F("VL53L0X API Interrupt Ranging example\n\n"));
+
+  pinMode(VL53LOX_ShutdownPin, INPUT_PULLUP);
+  pinMode(VL53LOX_InterruptPin, INPUT_PULLUP);
+  attachInterrupt(digitalPinToInterrupt(VL53LOX_InterruptPin), VL53LOXISR,
+                  CHANGE);
+  pinMode(LED_BUILTIN, OUTPUT);
+  digitalWrite(LED_BUILTIN, LOW);
+
+  // if lox.begin failes its becasue it was a warm boot and the VL53LOX is in
+  // continues mesurement mode we can use an IO pin to reset the device in case
+  // we get stuck in this mode
+  while (!lox.begin()) {
+    Serial.println(F("Failed to boot VL53L0X"));
+    Serial.println("Adafruit VL53L0X XShut set Low to Force HW Reset");
+    digitalWrite(VL53LOX_ShutdownPin, LOW);
+    delay(100);
+    digitalWrite(VL53LOX_ShutdownPin, HIGH);
+    Serial.println("Adafruit VL53L0X XShut set high to Allow Boot");
+    delay(100);
+  }
+
+  // Second Parameter options are VL53L0X_GPIOFUNCTIONALITY_OFF,
+  // VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW,
+  // VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH,
+  // VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT,
+  // VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY
+
+  Serial.println("Set GPIO Config so if range is lower the LowThreshold "
+                 "trigger Gpio Pin ");
+  lox.setGpioConfig(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+                    VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW,
+                    VL53L0X_INTERRUPTPOLARITY_LOW);
+
+  // Set Interrupt Treashholds
+  // Low reading set to 50mm  High Set to 100mm
+  FixPoint1616_t LowThreashHold = (50 * 65536.0);
+  FixPoint1616_t HighThreashHold = (100 * 65536.0);
+  Serial.println("Set Interrupt Threasholds... ");
+  lox.setInterruptThresholds(LowThreashHold, HighThreashHold, true);
+
+  // Enable Continous Measurement Mode
+  Serial.println("Set Mode VL53L0X_DEVICEMODE_CONTINUOUS_RANGING... ");
+  lox.setDeviceMode(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, false);
+
+  Serial.println("StartMeasurement... ");
+  lox.startMeasurement();
+}
+
+void VL53LOXISR() {
+  // Read if we are high or low
+  VL53LOX_State = digitalRead(VL53LOX_InterruptPin);
+  // set the built in LED to reflect in range on for Out of range off for in
+  // range
+  digitalWrite(LED_BUILTIN, VL53LOX_State);
+}
+
+void loop() {
+  if (VL53LOX_State == LOW) {
+    VL53L0X_RangingMeasurementData_t measure;
+    Serial.print("Reading a measurement... ");
+    lox.getRangingMeasurement(
+        &measure, false); // pass in 'true' to get debug data printout!
+
+    if (measure.RangeStatus != 4) { // phase failures have incorrect data
+      Serial.print("Distance (mm): ");
+      Serial.println(measure.RangeMilliMeter);
+    } else {
+      Serial.println(" out of range ");
+    }
+    // you have to clear the interrupt to get triggered again
+    lox.clearInterruptMask(false);
+
+  } else {
+    delay(10);
+  }
+}

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x_continuous/vl53l0x_continuous.ino

@@ -0,0 +1,30 @@
+#include "Adafruit_VL53L0X.h"
+
+Adafruit_VL53L0X lox = Adafruit_VL53L0X();
+
+void setup() {
+  Serial.begin(115200);
+
+  // wait until serial port opens for native USB devices
+  while (! Serial) {
+    delay(1);
+  }
+
+  Serial.println("Adafruit VL53L0X test.");
+  if (!lox.begin()) {
+    Serial.println(F("Failed to boot VL53L0X"));
+    while(1);
+  }
+  // power
+  Serial.println(F("VL53L0X API Continuous Ranging example\n\n"));
+
+  // start continuous ranging
+  lox.startRangeContinuous();
+}
+
+void loop() {
+  if (lox.isRangeComplete()) {
+    Serial.print("Distance in mm: ");
+    Serial.println(lox.readRange());
+  }
+}

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x_dual/vl53l0x_dual.ino

@@ -0,0 +1,111 @@
+#include "Adafruit_VL53L0X.h"
+
+// address we will assign if dual sensor is present
+#define LOX1_ADDRESS 0x30
+#define LOX2_ADDRESS 0x31
+
+// set the pins to shutdown
+#define SHT_LOX1 7
+#define SHT_LOX2 6
+
+// objects for the vl53l0x
+Adafruit_VL53L0X lox1 = Adafruit_VL53L0X();
+Adafruit_VL53L0X lox2 = Adafruit_VL53L0X();
+
+// this holds the measurement
+VL53L0X_RangingMeasurementData_t measure1;
+VL53L0X_RangingMeasurementData_t measure2;
+
+/*
+    Reset all sensors by setting all of their XSHUT pins low for delay(10), then set all XSHUT high to bring out of reset
+    Keep sensor #1 awake by keeping XSHUT pin high
+    Put all other sensors into shutdown by pulling XSHUT pins low
+    Initialize sensor #1 with lox.begin(new_i2c_address) Pick any number but 0x29 and it must be under 0x7F. Going with 0x30 to 0x3F is probably OK.
+    Keep sensor #1 awake, and now bring sensor #2 out of reset by setting its XSHUT pin high.
+    Initialize sensor #2 with lox.begin(new_i2c_address) Pick any number but 0x29 and whatever you set the first sensor to
+ */
+void setID() {
+  // all reset
+  digitalWrite(SHT_LOX1, LOW);    
+  digitalWrite(SHT_LOX2, LOW);
+  delay(10);
+  // all unreset
+  digitalWrite(SHT_LOX1, HIGH);
+  digitalWrite(SHT_LOX2, HIGH);
+  delay(10);
+
+  // activating LOX1 and resetting LOX2
+  digitalWrite(SHT_LOX1, HIGH);
+  digitalWrite(SHT_LOX2, LOW);
+
+  // initing LOX1
+  if(!lox1.begin(LOX1_ADDRESS)) {
+    Serial.println(F("Failed to boot first VL53L0X"));
+    while(1);
+  }
+  delay(10);
+
+  // activating LOX2
+  digitalWrite(SHT_LOX2, HIGH);
+  delay(10);
+
+  //initing LOX2
+  if(!lox2.begin(LOX2_ADDRESS)) {
+    Serial.println(F("Failed to boot second VL53L0X"));
+    while(1);
+  }
+}
+
+void read_dual_sensors() {
+  
+  lox1.rangingTest(&measure1, false); // pass in 'true' to get debug data printout!
+  lox2.rangingTest(&measure2, false); // pass in 'true' to get debug data printout!
+
+  // print sensor one reading
+  Serial.print(F("1: "));
+  if(measure1.RangeStatus != 4) {     // if not out of range
+    Serial.print(measure1.RangeMilliMeter);
+  } else {
+    Serial.print(F("Out of range"));
+  }
+  
+  Serial.print(F(" "));
+
+  // print sensor two reading
+  Serial.print(F("2: "));
+  if(measure2.RangeStatus != 4) {
+    Serial.print(measure2.RangeMilliMeter);
+  } else {
+    Serial.print(F("Out of range"));
+  }
+  
+  Serial.println();
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  // wait until serial port opens for native USB devices
+  while (! Serial) { delay(1); }
+
+  pinMode(SHT_LOX1, OUTPUT);
+  pinMode(SHT_LOX2, OUTPUT);
+
+  Serial.println(F("Shutdown pins inited..."));
+
+  digitalWrite(SHT_LOX1, LOW);
+  digitalWrite(SHT_LOX2, LOW);
+
+  Serial.println(F("Both in reset mode...(pins are low)"));
+  
+  
+  Serial.println(F("Starting..."));
+  setID();
+ 
+}
+
+void loop() {
+   
+  read_dual_sensors();
+  delay(100);
+}

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x_multi_extended/vl53l0x_multi_extended.ino

@@ -0,0 +1,422 @@
+#include <Adafruit_VL53L0X.h>
+#include <Wire.h>
+
+// Define which Wire objects to use, may depend on platform
+// or on your configurations.
+#define SENSOR1_WIRE Wire
+#define SENSOR2_WIRE Wire
+#if defined(WIRE_IMPLEMENT_WIRE1)
+#define SENSOR3_WIRE Wire1
+#define SENSOR4_WIRE Wire1
+#else
+#define SENSOR3_WIRE Wire
+#define SENSOR4_WIRE Wire
+#endif
+// Setup mode for doing reads
+typedef enum {
+  RUN_MODE_DEFAULT = 1,
+  RUN_MODE_ASYNC,
+  RUN_MODE_GPIO,
+  RUN_MODE_CONT
+} runmode_t;
+
+runmode_t run_mode = RUN_MODE_DEFAULT;
+uint8_t show_command_list = 1;
+
+typedef struct {
+  Adafruit_VL53L0X *psensor; // pointer to object
+  TwoWire *pwire;
+  int id;            // id for the sensor
+  int shutdown_pin;  // which pin for shutdown;
+  int interrupt_pin; // which pin to use for interrupts.
+  Adafruit_VL53L0X::VL53L0X_Sense_config_t
+      sensor_config;     // options for how to use the sensor
+  uint16_t range;        // range value used in continuous mode stuff.
+  uint8_t sensor_status; // status from last ranging in continuous.
+} sensorList_t;
+
+// Actual object, could probably include in structure above61
+Adafruit_VL53L0X sensor1;
+Adafruit_VL53L0X sensor2;
+#ifndef ARDUINO_ARCH_AVR // not enough memory on uno for 4 objects
+Adafruit_VL53L0X sensor3;
+Adafruit_VL53L0X sensor4;
+#endif
+// Setup for 4 sensors
+sensorList_t sensors[] = {
+#ifndef ARDUINO_ARCH_AVR // not enough memory on uno for 4 objects
+    {&sensor1, &SENSOR1_WIRE, 0x30, 0, 1,
+     Adafruit_VL53L0X::VL53L0X_SENSE_LONG_RANGE, 0, 0},
+    {&sensor2, &SENSOR2_WIRE, 0x31, 2, 3,
+     Adafruit_VL53L0X::VL53L0X_SENSE_HIGH_SPEED, 0, 0},
+    {&sensor3, &SENSOR3_WIRE, 0x32, 4, 5,
+     Adafruit_VL53L0X::VL53L0X_SENSE_DEFAULT, 0, 0},
+    {&sensor4, &SENSOR4_WIRE, 0x33, 6, 7,
+     Adafruit_VL53L0X::VL53L0X_SENSE_DEFAULT, 0, 0}
+#else
+    // AVR sensors move to other pins
+    {&sensor1, &SENSOR1_WIRE, 0x30, 6, 8,
+     Adafruit_VL53L0X::VL53L0X_SENSE_LONG_RANGE, 0, 0},
+    {&sensor2, &SENSOR2_WIRE, 0x31, 7, 9,
+     Adafruit_VL53L0X::VL53L0X_SENSE_HIGH_SPEED, 0, 0},
+#endif
+};
+
+const int COUNT_SENSORS = sizeof(sensors) / sizeof(sensors[0]);
+
+const uint16_t ALL_SENSORS_PENDING = ((1 << COUNT_SENSORS) - 1);
+uint16_t sensors_pending = ALL_SENSORS_PENDING;
+uint32_t sensor_last_cycle_time;
+
+/*
+    Reset all sensors by setting all of their XSHUT pins low for delay(10), then
+   set all XSHUT high to bring out of reset
+    Keep sensor #1 awake by keeping XSHUT pin high
+    Put all other sensors into shutdown by pulling XSHUT pins low
+    Initialize sensor #1 with lox.begin(new_i2c_address) Pick any number but
+   0x29 and it must be under 0x7F. Going with 0x30 to 0x3F is probably OK.
+    Keep sensor #1 awake, and now bring sensor #2 out of reset by setting its
+   XSHUT pin high.
+    Initialize sensor #2 with lox.begin(new_i2c_address) Pick any number but
+   0x29 and whatever you set the first sensor to
+*/
+void Initialize_sensors() {
+  bool found_any_sensors = false;
+  // Set all shutdown pins low to shutdown sensors
+  for (int i = 0; i < COUNT_SENSORS; i++)
+    digitalWrite(sensors[i].shutdown_pin, LOW);
+  delay(10);
+
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    // one by one enable sensors and set their ID
+    digitalWrite(sensors[i].shutdown_pin, HIGH);
+    delay(10); // give time to wake up.
+    if (sensors[i].psensor->begin(sensors[i].id, false, sensors[i].pwire,
+                                  sensors[i].sensor_config)) {
+      found_any_sensors = true;
+    } else {
+      Serial.print(i, DEC);
+      Serial.print(F(": failed to start\n"));
+    }
+  }
+  if (!found_any_sensors) {
+    Serial.println("No valid sensors found");
+    while (1)
+      ;
+  }
+}
+//====================================================================
+// Simple Sync read sensors.
+//====================================================================
+void read_sensors() {
+  // First use simple function
+  uint16_t ranges_mm[COUNT_SENSORS];
+  bool timeouts[COUNT_SENSORS];
+  uint32_t stop_times[COUNT_SENSORS];
+
+  digitalWrite(13, HIGH);
+  uint32_t start_time = millis();
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    ranges_mm[i] = sensors[i].psensor->readRange();
+    timeouts[i] = sensors[i].psensor->timeoutOccurred();
+    stop_times[i] = millis();
+  }
+  uint32_t delta_time = millis() - start_time;
+  digitalWrite(13, LOW);
+
+  Serial.print(delta_time, DEC);
+  Serial.print(F(" "));
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    Serial.print(i, DEC);
+    Serial.print(F(":"));
+    Serial.print(ranges_mm[i], DEC);
+    Serial.print(F(" "));
+    Serial.print(stop_times[i] - start_time, DEC);
+    if (timeouts[i])
+      Serial.print(F("(TIMEOUT) "));
+    else
+      Serial.print(F("          "));
+    start_time = stop_times[i];
+  }
+  Serial.println();
+}
+
+//====================================================================
+// ASync read sensors.
+//====================================================================
+void timed_async_read_sensors() {
+  // First use simple function
+  uint16_t ranges_mm[COUNT_SENSORS];
+  bool timeouts[COUNT_SENSORS];
+  uint32_t stop_times[COUNT_SENSORS];
+
+  digitalWrite(13, HIGH);
+  uint32_t start_time = millis();
+
+  // Tell all sensors to start.
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    ranges_mm[i] = sensors[i].psensor->startRange();
+  }
+  // We could call to see if done, but this version the readRange will wait
+  // until ready
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    ranges_mm[i] = sensors[i].psensor->readRangeResult();
+    timeouts[i] = sensors[i].psensor->timeoutOccurred();
+    stop_times[i] = millis();
+  }
+  uint32_t delta_time = millis() - start_time;
+  digitalWrite(13, LOW);
+
+  Serial.print(delta_time, DEC);
+  Serial.print(F(" "));
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    Serial.print(i, DEC);
+    Serial.print(F(":"));
+    Serial.print(ranges_mm[i], DEC);
+    Serial.print(F(" "));
+    Serial.print(stop_times[i] - start_time, DEC);
+    if (timeouts[i])
+      Serial.print(F("(TIMEOUT) "));
+    else
+      Serial.print(F("          "));
+    start_time = stop_times[i];
+  }
+  Serial.println();
+}
+
+//====================================================================
+// ASync read sensors.
+//====================================================================
+void timed_async_read_gpio() {
+  // First use simple function
+  uint16_t ranges_mm[COUNT_SENSORS];
+  bool timeouts[COUNT_SENSORS];
+  uint32_t stop_times[COUNT_SENSORS];
+
+  digitalWrite(13, HIGH);
+  uint32_t start_time = millis();
+  uint32_t mask = 1;
+
+  // Tell all sensors to start.
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    ranges_mm[i] = sensors[i].psensor->startRange();
+    sensors_pending |= mask;
+    mask <<= 1;
+  }
+
+  // lets play by reading the different GPIO pins until we find all of them went
+  // low.
+  while (sensors_pending &&
+         ((millis() - start_time) < 1000)) { // break if not all after a second
+    // We could call to see if done, but this version the readRange will wait
+    // until ready
+    mask = 1;
+    for (int i = 0; i < COUNT_SENSORS; i++) {
+      if ((sensors_pending & mask) && !digitalRead(sensors[i].interrupt_pin)) {
+        ranges_mm[i] = sensors[i].psensor->readRangeResult();
+        timeouts[i] = sensors[i].psensor->timeoutOccurred();
+        stop_times[i] = millis();
+        sensors_pending ^= mask;
+      }
+      mask <<= 1;
+    }
+  }
+
+  uint32_t delta_time = millis() - start_time;
+  digitalWrite(13, LOW);
+
+  Serial.print(delta_time, DEC);
+  Serial.print(F(" "));
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    Serial.print(i, DEC);
+    Serial.print(F(":"));
+    Serial.print(ranges_mm[i], DEC);
+    Serial.print(F(" "));
+    Serial.print(stop_times[i] - start_time, DEC);
+    if (timeouts[i])
+      Serial.print(F("(TIMEOUT) "));
+    else
+      Serial.print(F("          "));
+    start_time = stop_times[i];
+  }
+  Serial.println();
+}
+//===============================================================
+// Continuous range test code
+//===============================================================
+
+void start_continuous_range(uint16_t cycle_time) {
+  if (cycle_time == 0)
+    cycle_time = 100;
+  Serial.print(F("start Continuous range mode cycle time: "));
+  Serial.println(cycle_time, DEC);
+  for (uint8_t i = 0; i < COUNT_SENSORS; i++) {
+    sensors[i].psensor->startRangeContinuous(cycle_time); // do 100ms cycle
+  }
+  sensors_pending = ALL_SENSORS_PENDING;
+  sensor_last_cycle_time = millis();
+}
+
+void stop_continuous_range() {
+  Serial.println(F("Stop Continuous range mode"));
+  for (uint8_t i = 0; i < COUNT_SENSORS; i++) {
+    sensors[i].psensor->stopRangeContinuous();
+  }
+  delay(100); // give time for it to complete.
+}
+
+void Process_continuous_range() {
+
+  uint16_t mask = 1;
+  for (uint8_t i = 0; i < COUNT_SENSORS; i++) {
+    bool range_complete = false;
+    if (sensors_pending & mask) {
+      if (sensors[i].interrupt_pin >= 0)
+        range_complete = !digitalRead(sensors[i].interrupt_pin);
+      else
+        range_complete = sensors[i].psensor->isRangeComplete();
+      if (range_complete) {
+        sensors[i].range = sensors[i].psensor->readRangeResult();
+        sensors[i].sensor_status = sensors[i].psensor->readRangeStatus();
+        sensors_pending ^= mask;
+      }
+    }
+    mask <<= 1; // setup to test next one
+  }
+  // See if we have all of our sensors read OK
+  uint32_t delta_time = millis() - sensor_last_cycle_time;
+  if (!sensors_pending || (delta_time > 1000)) {
+    digitalWrite(13, !digitalRead(13));
+    Serial.print(delta_time, DEC);
+    Serial.print(F("("));
+    Serial.print(sensors_pending, HEX);
+    Serial.print(F(")"));
+    mask = 1;
+    for (uint8_t i = 0; i < COUNT_SENSORS; i++) {
+      Serial.print(F(" : "));
+      if (sensors_pending & mask)
+        Serial.print(F("TTT")); // show timeout in this one
+      else {
+        Serial.print(sensors[i].range, DEC);
+        if (sensors[i].sensor_status == VL53L0X_ERROR_NONE)
+          Serial.print(F("  "));
+        else {
+          Serial.print(F("#"));
+          Serial.print(sensors[i].sensor_status, DEC);
+        }
+      }
+    }
+    // setup for next pass
+    Serial.println();
+    sensor_last_cycle_time = millis();
+    sensors_pending = ALL_SENSORS_PENDING;
+  }
+}
+
+//====================================================================
+// Setup
+//====================================================================
+void setup() {
+  Serial.begin(115200);
+  Wire.begin();
+#if defined(WIRE_IMPLEMENT_WIRE1)
+  Wire1.begin();
+#endif
+  // wait until serial port opens ... For 5 seconds max
+  while (!Serial && millis() < 5000)
+    ;
+
+  pinMode(13, OUTPUT);
+
+  // initialize all of the pins.
+  Serial.println(F("VL53LOX_multi start, initialize IO pins"));
+  for (int i = 0; i < COUNT_SENSORS; i++) {
+    pinMode(sensors[i].shutdown_pin, OUTPUT);
+    digitalWrite(sensors[i].shutdown_pin, LOW);
+
+    if (sensors[i].interrupt_pin >= 0)
+      pinMode(sensors[i].interrupt_pin, INPUT_PULLUP);
+  }
+  Serial.println(F("Starting..."));
+  Initialize_sensors();
+}
+
+//====================================================================
+// loop
+//====================================================================
+void loop() {
+  if (Serial.available()) {
+    uint16_t cycle_time = 0;
+    uint8_t ch = Serial.read();
+    int t;
+    while ((t = Serial.read()) != -1) {
+      if ((t >= '0') && (t <= '9'))
+        cycle_time = cycle_time * 10 + t - '0';
+    }
+
+    runmode_t prev_run_mode = run_mode;
+    // See what the user typed in
+    switch (ch) {
+    case 'd':
+    case 'D':
+      run_mode = RUN_MODE_DEFAULT;
+      Serial.println(F("\n*** Default mode ***"));
+      break;
+    case 'a':
+    case 'A':
+      Serial.println(F("\n*** Async mode ***"));
+      run_mode = RUN_MODE_ASYNC;
+      break;
+    case 'g':
+    case 'G':
+      Serial.println(F("\n*** GPIO mode ***"));
+      run_mode = RUN_MODE_GPIO;
+      break;
+    case 'c':
+    case 'C':
+      run_mode = RUN_MODE_CONT;
+      break;
+
+    default:
+      show_command_list = 1;
+      run_mode = RUN_MODE_DEFAULT;
+    }
+    if (run_mode != prev_run_mode) {
+      // if previous mode was continuous mode, shut it down
+      if (prev_run_mode == RUN_MODE_CONT)
+        stop_continuous_range();
+      if (run_mode == RUN_MODE_CONT)
+        start_continuous_range(cycle_time);
+    } else if (run_mode == RUN_MODE_CONT) {
+      // Already was in continuous but maybe different speed, try to update
+      start_continuous_range(cycle_time);
+    }
+  }
+  if (show_command_list) {
+    Serial.println(
+        F("\nSet run mode by entering one of the following letters"));
+    Serial.println(F("    D - Default mode"));
+    Serial.println(
+        F("    A - Asynchronous mode - Try starting all Seonsors at once"));
+    Serial.println(F("    G - Asynchronous mode - Like above use GPIO pins"));
+    Serial.println(
+        F("    C - Continuous mode - Try starting all Seonsors at once"));
+    show_command_list = 0;
+  }
+  switch (run_mode) {
+  case RUN_MODE_DEFAULT:
+    read_sensors();
+    break;
+  case RUN_MODE_ASYNC:
+    timed_async_read_sensors();
+    break;
+  case RUN_MODE_GPIO:
+    timed_async_read_gpio();
+    break;
+  case RUN_MODE_CONT:
+    Process_continuous_range();
+    break;
+  }
+  if (run_mode != RUN_MODE_CONT)
+    delay(250);
+}

code/lib/Adafruit_VL53L0X-1.2.3/examples/vl53l0x_oled/vl53l0x_oled.ino

@@ -0,0 +1,61 @@
+/* This example shows how to take
+range measurements with the VL53L0X and display on a SSD1306 OLED.
+
+The range readings are in units of mm. */
+
+#include <Wire.h>
+#include "Adafruit_VL53L0X.h"
+#include <SPI.h>
+#include <Adafruit_GFX.h>
+#include <Adafruit_SSD1306.h>
+
+Adafruit_SSD1306 display = Adafruit_SSD1306();
+
+Adafruit_VL53L0X lox = Adafruit_VL53L0X();
+
+#if (SSD1306_LCDHEIGHT != 32)
+ #error("Height incorrect, please fix Adafruit_SSD1306.h!");
+#endif
+
+void setup()
+{
+  Serial.begin(9600);
+    
+  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32)
+  // init done
+  display.display();
+  delay(1000);
+    
+  
+  Wire.begin();
+
+  if (!lox.begin()) {
+    Serial.println(F("Failed to boot VL53L0X"));
+    while(1);
+  }
+
+  // text display big!
+  display.setTextSize(4);
+  display.setTextColor(WHITE);
+}
+
+void loop()
+{
+  VL53L0X_RangingMeasurementData_t measure;
+
+  lox.rangingTest(&measure, false); // pass in 'true' to get debug data printout!
+
+  if (measure.RangeStatus != 4) {  // phase failures have incorrect data
+      display.clearDisplay();
+      display.setCursor(0,0);
+      display.print(measure.RangeMilliMeter);
+      display.print("mm");
+      display.display();
+      Serial.println();
+      delay(50);
+  } else {
+    display.display();
+    display.clearDisplay();
+    return;
+  }
+}

code/lib/Adafruit_VL53L0X-1.2.3/keywords.txt

@@ -0,0 +1,27 @@
+Adafruit_VL53L0X	KEYWORD1
+begin	KEYWORD2
+setAddress	KEYWORD2
+getAddress	KEYWORD2
+configSensor	KEYWORD2
+rangingTest	KEYWORD2
+printRangeStatus	KEYWORD2
+readRange	KEYWORD2
+readRangeStatus	KEYWORD2
+startRange	KEYWORD2
+isRangeComplete	KEYWORD2
+waitRangeComplete	KEYWORD2
+readRangeResult	KEYWORD2
+startRangeContinuous	KEYWORD2
+stopRangeContinuous	KEYWORD2
+setMeasurementTimingBudgetMicroSeconds	KEYWORD2
+getMeasurementTimingBudgetMicroSeconds	KEYWORD2
+setVcselPulsePeriod	KEYWORD2
+getVcselPulsePeriod	KEYWORD2
+setLimitCheckEnable	KEYWORD2
+getLimitCheckEnable	KEYWORD2
+setLimitCheckValue	KEYWORD2
+getLimitCheckValue	KEYWORD2
+VL53L0X_SENSE_DEFAULT	LITERAL1
+VL53L0X_SENSE_LONG_RANGE	LITERAL1
+VL53L0X_SENSE_HIGH_SPEED	LITERAL1
+VL53L0X_SENSE_HIGH_ACCURACY	LITERAL1

code/lib/Adafruit_VL53L0X-1.2.3/library.properties

@@ -0,0 +1,10 @@
+name=Adafruit_VL53L0X
+version=1.2.2
+author=Adafruit
+maintainer=adafruit <support@adafruit.com>
+sentence=Sensor driver for VL53L0X Time of Flight sensor
+paragraph=Sensor driver for VL53L0X Time of Flight sensor
+category=Sensors
+url=https://github.com/adafruit/Adafruit_VL53L0X
+architectures=*
+depends=Adafruit SSD1306, Adafruit GFX Library

code/lib/Adafruit_VL53L0X-1.2.3/src/Adafruit_VL53L0X.cpp

@@ -0,0 +1,974 @@
+/*!
+ * @file Adafruit_VL53L0X.cpp
+ *
+ * @mainpage Adafruit VL53L0X time-of-flight sensor
+ *
+ * @section intro_sec Introduction
+ *
+ * This is the documentation for Adafruit's VL53L0X driver for the
+ * Arduino platform.  It is designed specifically to work with the
+ * Adafruit VL53L0X breakout: https://www.adafruit.com/product/3317
+ *
+ * These sensors use I2C to communicate, 2 pins (SCL+SDA) are required
+ * to interface with the breakout.
+ *
+ * Adafruit invests time and resources providing this open source code,
+ * please support Adafruit and open-source hardware by purchasing
+ * products from Adafruit!
+ *
+ * @section dependencies Dependencies
+ *
+ *
+ * @section author Author
+ *
+ * Written by Limor Fried/Ladyada for Adafruit Industries.
+ *
+ * Updated by Andrew DeVries for Digital Example to include methods needed for
+ * Interrupt triggering
+ *
+ * @section license License
+ *
+ * BSD license, all text here must be included in any redistribution.
+ *
+ */
+
+#include "Adafruit_VL53L0X.h"
+#include "vl53l0x_api_core.h"
+
+#define VERSION_REQUIRED_MAJOR 1 ///< Required sensor major version
+#define VERSION_REQUIRED_MINOR 0 ///< Required sensor minor version
+#define VERSION_REQUIRED_BUILD 1 ///< Required sensor build
+
+#define STR_HELPER(x) #x     ///< a string helper
+#define STR(x) STR_HELPER(x) ///< string helper wrapper
+
+/**************************************************************************/
+/*!
+    @brief  Setups the I2C interface and hardware
+    @param  i2c_addr Optional I2C address the sensor can be found on. Default is
+   0x29
+    @param debug Optional debug flag. If true, debug information will print out
+   via Serial.print during setup. Defaults to false.
+    @param  i2c Optional I2C bus the sensor is located on. Default is Wire
+    @param vl_config Sensor configuration
+    @returns True if device is set up, false on any failure
+*/
+/**************************************************************************/
+boolean Adafruit_VL53L0X::begin(uint8_t i2c_addr, boolean debug, TwoWire *i2c,
+                                VL53L0X_Sense_config_t vl_config) {
+  uint32_t refSpadCount;
+  uint8_t isApertureSpads;
+  uint8_t VhvSettings;
+  uint8_t PhaseCal;
+
+  // Initialize Comms
+  pMyDevice->I2cDevAddr = VL53L0X_I2C_ADDR; // default
+  pMyDevice->comms_type = 1;
+  pMyDevice->comms_speed_khz = 400;
+  pMyDevice->i2c = i2c;
+
+  pMyDevice->i2c->begin(); // VL53L0X_i2c_init();
+
+  // unclear if this is even needed:
+  if (VL53L0X_IMPLEMENTATION_VER_MAJOR != VERSION_REQUIRED_MAJOR ||
+      VL53L0X_IMPLEMENTATION_VER_MINOR != VERSION_REQUIRED_MINOR ||
+      VL53L0X_IMPLEMENTATION_VER_SUB != VERSION_REQUIRED_BUILD) {
+    if (debug) {
+      Serial.println(F(
+          "Found " STR(VL53L0X_IMPLEMENTATION_VER_MAJOR) "." STR(VL53L0X_IMPLEMENTATION_VER_MINOR) "." STR(
+              VL53L0X_IMPLEMENTATION_VER_SUB) " rev " STR(VL53L0X_IMPLEMENTATION_VER_REVISION)));
+      Serial.println(F("Requires " STR(VERSION_REQUIRED_MAJOR) "." STR(
+          VERSION_REQUIRED_MINOR) "." STR(VERSION_REQUIRED_BUILD)));
+    }
+
+    Status = VL53L0X_ERROR_NOT_SUPPORTED;
+
+    return false;
+  }
+
+  Status = VL53L0X_DataInit(&MyDevice); // Data initialization
+
+  if (!setAddress(i2c_addr)) {
+    return false;
+  }
+
+  Status = VL53L0X_GetDeviceInfo(&MyDevice, &DeviceInfo);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("VL53L0X Info:"));
+      Serial.print(F("Device Name: "));
+      Serial.print(DeviceInfo.Name);
+      Serial.print(F(", Type: "));
+      Serial.print(DeviceInfo.Type);
+      Serial.print(F(", ID: "));
+      Serial.println(DeviceInfo.ProductId);
+
+      Serial.print(F("Rev Major: "));
+      Serial.print(DeviceInfo.ProductRevisionMajor);
+      Serial.print(F(", Minor: "));
+      Serial.println(DeviceInfo.ProductRevisionMinor);
+    }
+
+    if ((DeviceInfo.ProductRevisionMajor != 1) ||
+        (DeviceInfo.ProductRevisionMinor != 1)) {
+      if (debug) {
+        Serial.print(F("Error expected cut 1.1 but found "));
+        Serial.print(DeviceInfo.ProductRevisionMajor);
+        Serial.print(',');
+        Serial.println(DeviceInfo.ProductRevisionMinor);
+      }
+
+      Status = VL53L0X_ERROR_NOT_SUPPORTED;
+    }
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("VL53L0X: StaticInit"));
+    }
+
+    Status = VL53L0X_StaticInit(pMyDevice); // Device Initialization
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("VL53L0X: PerformRefSpadManagement"));
+    }
+
+    Status = VL53L0X_PerformRefSpadManagement(
+        pMyDevice, &refSpadCount, &isApertureSpads); // Device Initialization
+
+    if (debug) {
+      Serial.print(F("refSpadCount = "));
+      Serial.print(refSpadCount);
+      Serial.print(F(", isApertureSpads = "));
+      Serial.println(isApertureSpads);
+    }
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("VL53L0X: PerformRefCalibration"));
+    }
+
+    Status = VL53L0X_PerformRefCalibration(pMyDevice, &VhvSettings,
+                                           &PhaseCal); // Device Initialization
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
+    if (debug) {
+      Serial.println(F("VL53L0X: SetDeviceMode"));
+    }
+
+    Status = VL53L0X_SetDeviceMode(
+        pMyDevice,
+        VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
+  }
+
+  // call off to the config function to do the last part of configuration.
+  if (Status == VL53L0X_ERROR_NONE) {
+    configSensor(vl_config);
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    return true;
+  } else {
+    if (debug) {
+      Serial.print(F("VL53L0X Error: "));
+      Serial.println(Status);
+    }
+
+    return false;
+  }
+}
+
+/**************************************************************************/
+/*!
+    @brief  Change the I2C address of the sensor
+    @param  newAddr the new address to set the sensor to
+    @returns True if address was set successfully, False otherwise
+*/
+/**************************************************************************/
+boolean Adafruit_VL53L0X::setAddress(uint8_t newAddr) {
+  newAddr &= 0x7F;
+
+  Status = VL53L0X_SetDeviceAddress(pMyDevice, newAddr * 2); // 7->8 bit
+
+  delay(10);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    pMyDevice->I2cDevAddr = newAddr; // 7 bit addr
+    return true;
+  }
+  return false;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Configure the sensor for one of the ways the example ST
+    sketches configure the sensors for different usages.
+    @param  vl_config Which configureation you are trying to configure for
+    It should be one of the following
+        VL53L0X_SENSE_DEFAULT
+        VL53L0X_SENSE_LONG_RANGE
+        VL53L0X_SENSE_HIGH_SPEED,
+        VL53L0X_SENSE_HIGH_ACCURACY
+
+    @returns True if address was set successfully, False otherwise
+*/
+/**************************************************************************/
+boolean Adafruit_VL53L0X::configSensor(VL53L0X_Sense_config_t vl_config) {
+  // All of them appear to configure a few things
+
+  // Serial.print(F("VL53L0X: configSensor "));
+  // Serial.println((int)vl_config, DEC);
+  // Enable/Disable Sigma and Signal check
+  Status = VL53L0X_SetLimitCheckEnable(
+      pMyDevice, VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    Status = VL53L0X_SetLimitCheckEnable(
+        pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+  }
+
+  if (Status != VL53L0X_ERROR_NONE)
+    return false;
+
+  switch (vl_config) {
+  case VL53L0X_SENSE_DEFAULT:
+    // Taken directly from SDK vl5310x_SingleRanging_example.c
+    // Maybe should convert to helper functions but...
+    // Serial.println("  VL53L0X_SENSE_DEFAULT");
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetLimitCheckEnable(
+          pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 1);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetLimitCheckValue(
+          pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+          (FixPoint1616_t)(1.5 * 0.023 * 65536));
+    }
+    break;
+  case VL53L0X_SENSE_LONG_RANGE:
+    Serial.println("  VL53L0X_SENSE_LONG_RANGE");
+    Status = VL53L0X_SetLimitCheckValue(
+        pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+        (FixPoint1616_t)(0.1 * 65536));
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetLimitCheckValue(pMyDevice,
+                                          VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                                          (FixPoint1616_t)(60 * 65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 33000);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetVcselPulsePeriod(pMyDevice,
+                                           VL53L0X_VCSEL_PERIOD_PRE_RANGE, 18);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetVcselPulsePeriod(
+          pMyDevice, VL53L0X_VCSEL_PERIOD_FINAL_RANGE, 14);
+    }
+    break;
+  case VL53L0X_SENSE_HIGH_SPEED:
+    // Serial.println("  VL53L0X_SENSE_HIGH_SPEED");
+    Status = VL53L0X_SetLimitCheckValue(
+        pMyDevice, VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+        (FixPoint1616_t)(0.25 * 65536));
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetLimitCheckValue(pMyDevice,
+                                          VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                                          (FixPoint1616_t)(32 * 65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, 30000);
+    }
+    break;
+  case VL53L0X_SENSE_HIGH_ACCURACY:
+    // increase timing budget to 200 ms
+
+    if (Status == VL53L0X_ERROR_NONE) {
+      setLimitCheckValue(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                         (FixPoint1616_t)(0.25 * 65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+      setLimitCheckValue(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                         (FixPoint1616_t)(18 * 65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+      setMeasurementTimingBudgetMicroSeconds(200000);
+    }
+    // Not sure about ignore threshold, try turnning it off...
+    if (Status == VL53L0X_ERROR_NONE) {
+      Status = VL53L0X_SetLimitCheckEnable(
+          pMyDevice, VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+    }
+
+    break;
+  }
+
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  get a ranging measurement from the device
+    @param  RangingMeasurementData the pointer to the struct the data will be
+   stored in
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns True if address was set successfully, False otherwise
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::getSingleRangingMeasurement(
+    VL53L0X_RangingMeasurementData_t *RangingMeasurementData, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  FixPoint1616_t LimitCheckCurrent;
+
+  /*
+   *  Step  4 : Test ranging mode
+   */
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: PerformSingleRangingMeasurement"));
+    }
+    Status = VL53L0X_PerformSingleRangingMeasurement(pMyDevice,
+                                                     RangingMeasurementData);
+
+    if (debug) {
+      printRangeStatus(RangingMeasurementData);
+    }
+
+    if (debug) {
+      VL53L0X_GetLimitCheckCurrent(pMyDevice,
+                                   VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                                   &LimitCheckCurrent);
+
+      Serial.print(F("RANGE IGNORE THRESHOLD: "));
+      Serial.println((float)LimitCheckCurrent / 65536.0);
+
+      Serial.print(F("Measured distance: "));
+      Serial.println(RangingMeasurementData->RangeMilliMeter);
+    }
+  }
+
+  return Status;
+}
+/**************************************************************************/
+/*!
+    @brief Start the ranging measurement from the device
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::startMeasurement(boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: StartMeasurement"));
+    }
+    Status = VL53L0X_StartMeasurement(pMyDevice);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Stop ranging measurement from the device
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::stopMeasurement(boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: StopMeasurement"));
+    }
+    Status = VL53L0X_StopMeasurement(pMyDevice);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Stop ranging measurement from the device
+    @param LimitCheckId Limit Check ID (0<= LimitCheckId <
+   VL53L0X_GetNumberOfLimitCheck() ).
+    @param pLimitCheckCurrent Pointer to current Value for a given LimitCheckId.
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::getLimitCheckCurrent(
+    uint8_t LimitCheckId, FixPoint1616_t *pLimitCheckCurrent, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  uint16_t intLimitCheckId = LimitCheckId;
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: getLimitCheckCurrent"));
+    }
+    Status = VL53L0X_GetLimitCheckCurrent(pMyDevice, intLimitCheckId,
+                                          pLimitCheckCurrent);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set a new device mode
+    @param   DeviceMode            New device mode to apply
+                                   Valid values are:
+                                   VL53L0X_DEVICEMODE_SINGLE_RANGING
+                                   VL53L0X_DEVICEMODE_CONTINUOUS_RANGING
+                                   VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING
+                                   VL53L0X_DEVICEMODE_SINGLE_HISTOGRAM
+                                   VL53L0X_HISTOGRAMMODE_REFERENCE_ONLY
+                                   VL53L0X_HISTOGRAMMODE_RETURN_ONLY
+                                   VL53L0X_HISTOGRAMMODE_BOTH
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::setDeviceMode(VL53L0X_DeviceModes DeviceMode,
+                                              boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: setDeviceMode"));
+    }
+    Status = VL53L0X_SetDeviceMode(pMyDevice, DeviceMode);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Set low and high Interrupt thresholds
+    @param ThresholdLow     Low threshold (mm, lux ..., depending on the mode)
+    @param ThresholdHigh    High threshold (mm, lux ..., depending on the mode)
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::setInterruptThresholds(
+    FixPoint1616_t ThresholdLow, FixPoint1616_t ThresholdHigh, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: setInterruptThresholds"));
+    }
+    // ST API Comments "no dependency on DeviceMode for Ewok " so device mode
+    // not used but API requires something so pass in
+    // VL53L0X_DEVICEMODE_CONTINUOUS_RANGING even though not used
+    Status = VL53L0X_SetInterruptThresholds(
+        pMyDevice, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, ThresholdLow,
+        ThresholdHigh);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Get high and low Interrupt thresholds
+    @param pThresholdLow    Low threshold (mm, lux ..., depending on the mode)
+    @param pThresholdHigh   High threshold (mm, lux ..., depending on the mode)
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error
+Adafruit_VL53L0X::getInterruptThresholds(FixPoint1616_t *pThresholdLow,
+                                         FixPoint1616_t *pThresholdHigh,
+                                         boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: getInterruptThresholds"));
+    }
+    // ST API Comments "no dependency on DeviceMode for Ewok " so device mode
+    // not used but API requires something so pass in
+    // VL53L0X_DEVICEMODE_CONTINUOUS_RANGING even though not used
+    Status = VL53L0X_GetInterruptThresholds(
+        pMyDevice, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, pThresholdLow,
+        pThresholdHigh);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Get current new device mode
+    @param pDeviceMode Pointer to current apply mode value
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::getDeviceMode(VL53L0X_DeviceModes *pDeviceMode,
+                                              boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: getDeviceMode"));
+    }
+    Status = VL53L0X_GetDeviceMode(pMyDevice, pDeviceMode);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Clear system interrupt condition
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::clearInterruptMask(boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: clearInterruptMask"));
+    }
+    Status = VL53L0X_ClearInterruptMask(pMyDevice, 0);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Set the configuration of GPIO pin 0
+    @param DeviceMode Device Mode associated to the Gpio.
+    @param Functionality Select Pin functionality.
+    @param Polarity Set interrupt polarity. Active high or active low.
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::setGpioConfig(
+    VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
+    VL53L0X_InterruptPolarity Polarity, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: setGpioConfig"));
+    }
+    //  Pin is always 0, Devicemode is ignored if not
+    //  VL53L0X_DEVICEMODE_GPIO_DRIVE or VL53L0X_DEVICEMODE_GPIO_OSC
+    Status = VL53L0X_SetGpioConfig(pMyDevice, 0, DeviceMode, Functionality,
+                                   Polarity);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief Get current configuration for GPIO pin 0
+    @param   pDeviceMode Pointer to Device Mode associated to the Gpio.
+    @param   pFunctionality Pointer to Pin functionality.
+    @param   pPolarity Pointer to interrupt polarity. Active high or active low.
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns status code
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::getGpioConfig(
+    VL53L0X_DeviceModes *pDeviceMode, VL53L0X_GpioFunctionality *pFunctionality,
+    VL53L0X_InterruptPolarity *pPolarity, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: getGpioConfig"));
+    }
+    //  Pin is always 0, Devicemode is ignored if not
+    //  VL53L0X_DEVICEMODE_GPIO_DRIVE or VL53L0X_DEVICEMODE_GPIO_OSC
+
+    Status = VL53L0X_GetGpioConfig(pMyDevice, 0, pDeviceMode, pFunctionality,
+                                   pPolarity);
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief  get a ranging measurement from the device
+    @param  RangingMeasurementData the pointer to the struct the data will be
+   stored in
+    @param debug Optional debug flag. If true debug information will print via
+   Serial.print during execution. Defaults to false.
+    @returns VL53L0X_ERROR_NONE or Error if one occured
+*/
+/**************************************************************************/
+VL53L0X_Error Adafruit_VL53L0X::getRangingMeasurement(
+    VL53L0X_RangingMeasurementData_t *RangingMeasurementData, boolean debug) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  FixPoint1616_t LimitCheckCurrent;
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (debug) {
+      Serial.println(F("sVL53L0X: getRangingMeasurement"));
+    }
+    Status =
+        VL53L0X_GetRangingMeasurementData(pMyDevice, RangingMeasurementData);
+
+    if (debug) {
+      printRangeStatus(RangingMeasurementData);
+    }
+
+    if (debug) {
+      VL53L0X_GetLimitCheckCurrent(pMyDevice,
+                                   VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                                   &LimitCheckCurrent);
+
+      Serial.print(F("RANGE IGNORE THRESHOLD: "));
+      Serial.println((float)LimitCheckCurrent / 65536.0);
+
+      Serial.print(F("Measured distance: "));
+      Serial.println(RangingMeasurementData->RangeMilliMeter);
+    }
+  }
+
+  return Status;
+}
+
+/**************************************************************************/
+/*!
+    @brief  print a ranging measurement out via Serial.print in a human-readable
+   format
+    @param pRangingMeasurementData a pointer to the ranging measurement data
+*/
+/**************************************************************************/
+void Adafruit_VL53L0X::printRangeStatus(
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData) {
+  char buf[VL53L0X_MAX_STRING_LENGTH];
+  uint8_t RangeStatus;
+
+  /*
+   * New Range Status: data is valid when pRangingMeasurementData->RangeStatus =
+   * 0
+   */
+
+  RangeStatus = pRangingMeasurementData->RangeStatus;
+
+  VL53L0X_GetRangeStatusString(RangeStatus, buf);
+
+  Serial.print(F("Range Status: "));
+  Serial.print(RangeStatus);
+  Serial.print(F(" : "));
+  Serial.println(buf);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Single shot ranging. Be sure to check the return of readRangeStatus
+    to before using the return value!
+    @return Distance in millimeters if valid
+*/
+/**************************************************************************/
+
+uint16_t Adafruit_VL53L0X::readRange(void) {
+  VL53L0X_RangingMeasurementData_t measure; // keep our own private copy
+
+  Status = getSingleRangingMeasurement(&measure, false);
+  _rangeStatus = measure.RangeStatus;
+
+  if (Status == VL53L0X_ERROR_NONE)
+    return measure.RangeMilliMeter;
+  // Other status return something totally out of bounds...
+  return 0xffff;
+}
+
+/**************************************************************************/
+/*!
+    @brief  Request ranging success/error message (retrieve after ranging)
+    @returns One of possible VL6180X_ERROR_* values
+*/
+/**************************************************************************/
+
+uint8_t Adafruit_VL53L0X::readRangeStatus(void) { return _rangeStatus; }
+
+/**************************************************************************/
+/*!
+    @brief  Start a range operation
+    @return true if range operation successfully started.
+*/
+/**************************************************************************/
+
+boolean Adafruit_VL53L0X::startRange(void) {
+
+  /* This function will do a complete single ranging
+   * Here we fix the mode! */
+  // first lets set the device in SINGLE_Ranging mode
+  Status = VL53L0X_SetDeviceMode(pMyDevice, VL53L0X_DEVICEMODE_SINGLE_RANGING);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    // Lets start up the measurement
+    Status = VL53L0X_StartMeasurement(pMyDevice);
+  }
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Checks to see if a range operation has completed
+    @return true if range operation completed or an error has happened
+*/
+/**************************************************************************/
+
+boolean Adafruit_VL53L0X::isRangeComplete(void) {
+  uint8_t NewDataReady = 0;
+  Status = VL53L0X_GetMeasurementDataReady(pMyDevice, &NewDataReady);
+  return ((Status != VL53L0X_ERROR_NONE) || (NewDataReady == 1));
+}
+
+/**************************************************************************/
+/*!
+    @brief  Wait until Range operation has completed.
+    @return true if range operation completed, false if error.
+*/
+/**************************************************************************/
+
+boolean Adafruit_VL53L0X::waitRangeComplete(void) {
+  Status = VL53L0X_measurement_poll_for_completion(pMyDevice);
+
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Return the range in mm for the last operation.
+    @return Range in mm.
+*/
+/**************************************************************************/
+
+uint16_t Adafruit_VL53L0X::readRangeResult(void) {
+  VL53L0X_RangingMeasurementData_t measure; // keep our own private copy
+
+  Status = VL53L0X_GetRangingMeasurementData(pMyDevice, &measure);
+  _rangeStatus = measure.RangeStatus;
+  if (Status == VL53L0X_ERROR_NONE)
+    Status = VL53L0X_ClearInterruptMask(pMyDevice, 0);
+
+  if ((Status == VL53L0X_ERROR_NONE) && (_rangeStatus != 4))
+    return measure.RangeMilliMeter;
+
+  return 0xffff; // some out of range value
+}
+
+/**************************************************************************/
+/*!
+    @brief  Start a continuous range operation
+    @param period_ms inter measurement period in milliseconds
+    @return True if successful, false otherwise
+*/
+/**************************************************************************/
+boolean Adafruit_VL53L0X::startRangeContinuous(uint16_t period_ms) {
+  /* This function will do a complete single ranging
+   * Here we fix the mode! */
+  // first lets set the device in SINGLE_Ranging mode
+  Status = VL53L0X_SetDeviceMode(pMyDevice,
+                                 VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    Status =
+        VL53L0X_SetInterMeasurementPeriodMilliSeconds(pMyDevice, period_ms);
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    // Lets start up the measurement
+    Status = VL53L0X_StartMeasurement(pMyDevice);
+  }
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Stop a continuous ranging operation
+*/
+/**************************************************************************/
+void Adafruit_VL53L0X::stopRangeContinuous(void) {
+
+  Status = VL53L0X_StopMeasurement(pMyDevice);
+
+  // lets wait until that completes.
+  uint32_t StopCompleted = 0;
+  uint32_t LoopNb;
+
+  // Wait until it finished
+  // use timeout to avoid deadlock
+  if (Status == VL53L0X_ERROR_NONE) {
+    LoopNb = 0;
+    do {
+      Status = VL53L0X_GetStopCompletedStatus(pMyDevice, &StopCompleted);
+      if ((StopCompleted == 0x00) || Status != VL53L0X_ERROR_NONE) {
+        break;
+      }
+      LoopNb = LoopNb + 1;
+      VL53L0X_PollingDelay(pMyDevice);
+    } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
+
+    if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
+      Status = VL53L0X_ERROR_TIME_OUT;
+    }
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    Status = VL53L0X_ClearInterruptMask(
+        pMyDevice, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+  }
+}
+
+/**************************************************************************/
+/*!
+    @brief  Wrapper to ST library code to budget how long a measurement
+    should take
+    @param  budget_us the new budget
+    @returns True if success
+*/
+/**************************************************************************/
+boolean
+Adafruit_VL53L0X::setMeasurementTimingBudgetMicroSeconds(uint32_t budget_us) {
+  Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(pMyDevice, budget_us);
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Wrapper to ST library code to budget how long a measurement
+    should take
+    @returns the current budget time in microseconds.
+*/
+/**************************************************************************/
+uint32_t Adafruit_VL53L0X::getMeasurementTimingBudgetMicroSeconds() {
+  uint32_t budget_us;
+  Status =
+      VL53L0X_GetMeasurementTimingBudgetMicroSeconds(pMyDevice, &budget_us);
+  return (budget_us);
+}
+
+/**************************************************************************/
+/*!
+    @brief Sets the VCSEL pulse period.
+
+    @param   VcselPeriodType       VCSEL period identifier (pre-range|final).
+    @param   VCSELPulsePeriod          VCSEL period value
+    @returns True if success
+*/
+/**************************************************************************/
+boolean
+Adafruit_VL53L0X::setVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType,
+                                      uint8_t VCSELPulsePeriod) {
+  Status =
+      VL53L0X_SetVcselPulsePeriod(pMyDevice, VcselPeriodType, VCSELPulsePeriod);
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief Gets the VCSEL pulse period.
+
+    @param   VcselPeriodType       VCSEL period identifier (pre-range|final).
+    @returns the current pulse peried for the given type.
+*/
+/**************************************************************************/
+uint8_t
+Adafruit_VL53L0X::getVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType) {
+  uint8_t cur_period;
+  Status = VL53L0X_GetVcselPulsePeriod(pMyDevice, VcselPeriodType, &cur_period);
+  return (cur_period);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Enable/Disable a specific limit check
+
+    @param   LimitCheckId                  Limit Check ID
+     (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+    @param   LimitCheckEnable              if 1 the check limit
+     corresponding to LimitCheckId is Enabled
+                                           if 0 the check limit
+     corresponding to LimitCheckId is disabled
+    @return  true if succeeded
+ */
+/**************************************************************************/
+boolean Adafruit_VL53L0X::setLimitCheckEnable(uint16_t LimitCheckId,
+                                              uint8_t LimitCheckEnable) {
+  Status =
+      VL53L0X_SetLimitCheckEnable(pMyDevice, LimitCheckId, LimitCheckEnable);
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Get specific limit check enable state
+    @param   LimitCheckId                  Limit Check ID
+     (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+    @return  current state of limit enabled
+ */
+/**************************************************************************/
+uint8_t Adafruit_VL53L0X::getLimitCheckEnable(uint16_t LimitCheckId) {
+
+  uint8_t cur_limit;
+  Status = VL53L0X_GetLimitCheckEnable(pMyDevice, LimitCheckId, &cur_limit);
+  return (cur_limit);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Set a specific limit check value
+    @param  LimitCheckId  Limit Check ID
+     (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+    LimitCheckId
+    @param  LimitCheckValue  Limit Check Value
+    @return  true if succeeded.
+ */
+/**************************************************************************/
+
+boolean Adafruit_VL53L0X::setLimitCheckValue(uint16_t LimitCheckId,
+                                             FixPoint1616_t LimitCheckValue) {
+
+  Status = VL53L0X_SetLimitCheckValue(pMyDevice, LimitCheckId, LimitCheckValue);
+  return (Status == VL53L0X_ERROR_NONE);
+}
+
+/**************************************************************************/
+/*!
+    @brief  Get a specific limit check value
+    @param   LimitCheckId                  Limit Check ID
+     (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+    @return  limit check value in FixPoint1616
+ */
+/**************************************************************************/
+FixPoint1616_t Adafruit_VL53L0X::getLimitCheckValue(uint16_t LimitCheckId) {
+
+  FixPoint1616_t LimitCheckValue;
+  Status =
+      VL53L0X_GetLimitCheckValue(pMyDevice, LimitCheckId, &LimitCheckValue);
+  return (LimitCheckValue);
+}

code/lib/Adafruit_VL53L0X-1.2.3/src/Adafruit_VL53L0X.h

@@ -0,0 +1,164 @@
+/*!
+ * @file Adafruit_VL53L0X.h
+
+  This is a library for the Adafruit VL53L0X Sensor Breakout
+
+  Designed specifically to work with the VL53L0X sensor from Adafruit
+  ----> https://www.adafruit.com/products/3317
+
+  These sensors use I2C to communicate, 2 pins are required to
+  interface
+  Adafruit invests time and resources providing this open source code,
+  please support Adafruit and open-source hardware by purchasing
+  products from Adafruit!
+
+  Written by Limor Fried/Ladyada for Adafruit Industries.
+  Updated by Andrew DeVries for Digital Example to include methods needed for
+  Interrupt triggering.
+  BSD license, all text above must be included in any
+  redistribution
+ ****************************************************/
+
+#ifndef ADAFRUIT_VL53L0X_H
+#define ADAFRUIT_VL53L0X_H
+
+#if (ARDUINO >= 100)
+#include "Arduino.h"
+#else
+#include "WProgram.h"
+#endif
+
+#include "Wire.h"
+#include "vl53l0x_api.h"
+
+#define VL53L0X_I2C_ADDR 0x29 ///< Default sensor I2C address
+
+/**************************************************************************/
+/*!
+    @brief  Class that stores state and functions for interacting with VL53L0X
+   time-of-flight sensor chips
+*/
+/**************************************************************************/
+class Adafruit_VL53L0X {
+public:
+  /** Sensor configurations */
+  typedef enum {
+    VL53L0X_SENSE_DEFAULT = 0,
+    VL53L0X_SENSE_LONG_RANGE,
+    VL53L0X_SENSE_HIGH_SPEED,
+    VL53L0X_SENSE_HIGH_ACCURACY
+  } VL53L0X_Sense_config_t;
+
+  boolean begin(uint8_t i2c_addr = VL53L0X_I2C_ADDR, boolean debug = false,
+                TwoWire *i2c = &Wire,
+                VL53L0X_Sense_config_t vl_config = VL53L0X_SENSE_DEFAULT);
+  boolean setAddress(uint8_t newAddr);
+
+  // uint8_t getAddress(void); // not currently implemented
+
+  /**************************************************************************/
+  /*!
+      @brief  get a ranging measurement from the device
+      @param  pRangingMeasurementData the pointer to the struct the data will be
+     stored in
+      @param debug Optional debug flag. If true debug information will print via
+     Serial.print during execution. Defaults to false.
+      @returns True if address was set successfully, False otherwise
+  */
+  /**************************************************************************/
+  VL53L0X_Error
+  rangingTest(VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+              boolean debug = false) {
+    return getSingleRangingMeasurement(pRangingMeasurementData, debug);
+  };
+
+  VL53L0X_Error getSingleRangingMeasurement(
+      VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+      boolean debug = false);
+  void
+  printRangeStatus(VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
+
+  VL53L0X_Error getRangingMeasurement(
+      VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+      boolean debug = false);
+  VL53L0X_Error startMeasurement(boolean debug = false);
+  VL53L0X_Error stopMeasurement(boolean debug = false);
+  VL53L0X_Error getLimitCheckCurrent(uint8_t LimitCheckId,
+                                     FixPoint1616_t *pLimitCheckCurrent,
+                                     boolean debug = false);
+  VL53L0X_Error getDeviceMode(VL53L0X_DeviceModes *pDeviceMode,
+                              boolean debug = false);
+  VL53L0X_Error setDeviceMode(VL53L0X_DeviceModes DeviceMode,
+                              boolean debug = false);
+
+  VL53L0X_Error setInterruptThresholds(FixPoint1616_t ThresholdLow,
+                                       FixPoint1616_t ThresholdHigh,
+                                       boolean debug = false);
+  VL53L0X_Error getInterruptThresholds(FixPoint1616_t *pThresholdLow,
+                                       FixPoint1616_t *pThresholdHigh,
+                                       boolean debug = false);
+  VL53L0X_Error clearInterruptMask(boolean debug = false);
+
+  VL53L0X_Error getGpioConfig(VL53L0X_DeviceModes *pDeviceMode,
+                              VL53L0X_GpioFunctionality *pFunctionality,
+                              VL53L0X_InterruptPolarity *pPolarity,
+                              boolean debug = false);
+  VL53L0X_Error setGpioConfig(VL53L0X_DeviceModes DeviceMode,
+                              VL53L0X_GpioFunctionality Functionality,
+                              VL53L0X_InterruptPolarity Polarity,
+                              boolean debug = false);
+
+  VL53L0X_Error Status =
+      VL53L0X_ERROR_NONE; ///< indicates whether or not the sensor has
+                          ///< encountered an error
+  // Add similar methods as Adafruit_VL6180X class adapted to range of device
+  uint16_t readRange(void);
+  // float readLux(uint8_t gain);
+  uint8_t readRangeStatus(void);
+
+  boolean startRange(void);
+  boolean isRangeComplete(void);
+  boolean waitRangeComplete(void);
+  uint16_t readRangeResult(void);
+
+  boolean startRangeContinuous(uint16_t period_ms = 50);
+  void stopRangeContinuous(void);
+
+  //  void setTimeout(uint16_t timeout) { io_timeout = timeout; }
+  // uint16_t getTimeout(void) { return io_timeout; }
+  /**************************************************************************/
+  /*!
+      @brief  timeout status
+      @returns True if timeout has occurred, False otherwise
+  */
+  /**************************************************************************/
+  boolean timeoutOccurred(void) { return false; }
+
+  boolean configSensor(VL53L0X_Sense_config_t vl_config);
+
+  // Export some wrappers to internal setting functions
+  // that are used by the above helper function to allow
+  // more complete control.
+  boolean setMeasurementTimingBudgetMicroSeconds(uint32_t budget_us);
+  uint32_t getMeasurementTimingBudgetMicroSeconds(void);
+
+  boolean setVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType,
+                              uint8_t VCSELPulsePeriod);
+
+  uint8_t getVcselPulsePeriod(VL53L0X_VcselPeriod VcselPeriodType);
+
+  boolean setLimitCheckEnable(uint16_t LimitCheckId, uint8_t LimitCheckEnable);
+  uint8_t getLimitCheckEnable(uint16_t LimitCheckId);
+  boolean setLimitCheckValue(uint16_t LimitCheckId,
+                             FixPoint1616_t LimitCheckValue);
+  FixPoint1616_t getLimitCheckValue(uint16_t LimitCheckId);
+
+private:
+  VL53L0X_Dev_t MyDevice;
+  VL53L0X_Dev_t *pMyDevice = &MyDevice;
+  VL53L0X_DeviceInfo_t DeviceInfo;
+
+  uint8_t _rangeStatus;
+};
+
+#endif

code/lib/Adafruit_VL53L0X-1.2.3/src/core/src/vl53l0x_api_ranging.cpp

@@ -0,0 +1,40 @@
+/*******************************************************************************
+ Copyright 2016, STMicroelectronics International N.V.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of STMicroelectronics nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+ NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+ IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include "../../vl53l0x_api.h"
+#include "../../vl53l0x_api_core.h"
+
+#ifndef __KERNEL__
+#include <stdlib.h>
+#endif
+#define LOG_FUNCTION_START(fmt, ...)                                           \
+  _LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...)                                          \
+  _LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...)                                 \
+  _LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)

code/lib/Adafruit_VL53L0X-1.2.3/src/core/src/vl53l0x_api_strings.cpp

@@ -0,0 +1,406 @@
+/*******************************************************************************
+ Copyright 2016, STMicroelectronics International N.V.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of STMicroelectronics nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+ NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+ IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include "../../vl53l0x_api_strings.h"
+#include "../../vl53l0x_api.h"
+#include "../../vl53l0x_api_core.h"
+
+#ifndef __KERNEL__
+#include <stdlib.h>
+#endif
+
+#define LOG_FUNCTION_START(fmt, ...)                                           \
+  _LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...)                                          \
+  _LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...)                                 \
+  _LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)
+
+VL53L0X_Error
+VL53L0X_check_part_used(VL53L0X_DEV Dev, uint8_t *Revision,
+                        VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  uint8_t ModuleIdInt;
+  char *ProductId_tmp;
+
+  LOG_FUNCTION_START("");
+
+  Status = VL53L0X_get_info_from_device(Dev, 2);
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    ModuleIdInt = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ModuleId);
+
+    if (ModuleIdInt == 0) {
+      *Revision = 0;
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, "");
+    } else {
+      *Revision = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, Revision);
+      ProductId_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ProductId);
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, ProductId_tmp);
+    }
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}
+
+VL53L0X_Error
+VL53L0X_get_device_info(VL53L0X_DEV Dev,
+                        VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  uint8_t revision_id;
+  uint8_t Revision;
+
+  Status = VL53L0X_check_part_used(Dev, &Revision, pVL53L0X_DeviceInfo);
+  if (Status == VL53L0X_ERROR_NONE) {
+    if (Revision == 0) {
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+                         VL53L0X_STRING_DEVICE_INFO_NAME_TS0);
+    } else if ((Revision <= 34) && (Revision != 32)) {
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+                         VL53L0X_STRING_DEVICE_INFO_NAME_TS1);
+    } else if (Revision < 39) {
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+                         VL53L0X_STRING_DEVICE_INFO_NAME_TS2);
+    } else {
+      VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+                         VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
+    }
+
+    VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Type,
+                       VL53L0X_STRING_DEVICE_INFO_TYPE);
+  }
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
+                            &pVL53L0X_DeviceInfo->ProductType);
+  }
+  if (Status == VL53L0X_ERROR_NONE) {
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_REVISION_ID,
+                            &revision_id);
+    pVL53L0X_DeviceInfo->ProductRevisionMajor = 1;
+    pVL53L0X_DeviceInfo->ProductRevisionMinor = (revision_id & 0xF0) >> 4;
+  }
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_get_device_error_string(VL53L0X_DeviceError ErrorCode,
+                                              char *pDeviceErrorString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  LOG_FUNCTION_START("");
+
+  switch (ErrorCode) {
+  case VL53L0X_DEVICEERROR_NONE:
+    VL53L0X_COPYSTRING(pDeviceErrorString, VL53L0X_STRING_DEVICEERROR_NONE);
+    break;
+  case VL53L0X_DEVICEERROR_VCSELCONTINUITYTESTFAILURE:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE);
+    break;
+  case VL53L0X_DEVICEERROR_VCSELWATCHDOGTESTFAILURE:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE);
+    break;
+  case VL53L0X_DEVICEERROR_NOVHVVALUEFOUND:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND);
+    break;
+  case VL53L0X_DEVICEERROR_MSRCNOTARGET:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET);
+    break;
+  case VL53L0X_DEVICEERROR_SNRCHECK:
+    VL53L0X_COPYSTRING(pDeviceErrorString, VL53L0X_STRING_DEVICEERROR_SNRCHECK);
+    break;
+  case VL53L0X_DEVICEERROR_RANGEPHASECHECK:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK);
+    break;
+  case VL53L0X_DEVICEERROR_SIGMATHRESHOLDCHECK:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK);
+    break;
+  case VL53L0X_DEVICEERROR_TCC:
+    VL53L0X_COPYSTRING(pDeviceErrorString, VL53L0X_STRING_DEVICEERROR_TCC);
+    break;
+  case VL53L0X_DEVICEERROR_PHASECONSISTENCY:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY);
+    break;
+  case VL53L0X_DEVICEERROR_MINCLIP:
+    VL53L0X_COPYSTRING(pDeviceErrorString, VL53L0X_STRING_DEVICEERROR_MINCLIP);
+    break;
+  case VL53L0X_DEVICEERROR_RANGECOMPLETE:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE);
+    break;
+  case VL53L0X_DEVICEERROR_ALGOUNDERFLOW:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW);
+    break;
+  case VL53L0X_DEVICEERROR_ALGOOVERFLOW:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW);
+    break;
+  case VL53L0X_DEVICEERROR_RANGEIGNORETHRESHOLD:
+    VL53L0X_COPYSTRING(pDeviceErrorString,
+                       VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD);
+    break;
+
+  default:
+    VL53L0X_COPYSTRING(pDeviceErrorString, VL53L0X_STRING_UNKNOW_ERROR_CODE);
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_get_range_status_string(uint8_t RangeStatus,
+                                              char *pRangeStatusString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  LOG_FUNCTION_START("");
+
+  switch (RangeStatus) {
+  case 0:
+    VL53L0X_COPYSTRING(pRangeStatusString,
+                       VL53L0X_STRING_RANGESTATUS_RANGEVALID);
+    break;
+  case 1:
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_SIGMA);
+    break;
+  case 2:
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_SIGNAL);
+    break;
+  case 3:
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_MINRANGE);
+    break;
+  case 4:
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_PHASE);
+    break;
+  case 5:
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_HW);
+    break;
+
+  default: /**/
+    VL53L0X_COPYSTRING(pRangeStatusString, VL53L0X_STRING_RANGESTATUS_NONE);
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_get_pal_error_string(VL53L0X_Error PalErrorCode,
+                                           char *pPalErrorString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  LOG_FUNCTION_START("");
+
+  switch (PalErrorCode) {
+  case VL53L0X_ERROR_NONE:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_NONE);
+    break;
+  case VL53L0X_ERROR_CALIBRATION_WARNING:
+    VL53L0X_COPYSTRING(pPalErrorString,
+                       VL53L0X_STRING_ERROR_CALIBRATION_WARNING);
+    break;
+  case VL53L0X_ERROR_MIN_CLIPPED:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_MIN_CLIPPED);
+    break;
+  case VL53L0X_ERROR_UNDEFINED:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_UNDEFINED);
+    break;
+  case VL53L0X_ERROR_INVALID_PARAMS:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_INVALID_PARAMS);
+    break;
+  case VL53L0X_ERROR_NOT_SUPPORTED:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_NOT_SUPPORTED);
+    break;
+  case VL53L0X_ERROR_INTERRUPT_NOT_CLEARED:
+    VL53L0X_COPYSTRING(pPalErrorString,
+                       VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED);
+    break;
+  case VL53L0X_ERROR_RANGE_ERROR:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_RANGE_ERROR);
+    break;
+  case VL53L0X_ERROR_TIME_OUT:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_TIME_OUT);
+    break;
+  case VL53L0X_ERROR_MODE_NOT_SUPPORTED:
+    VL53L0X_COPYSTRING(pPalErrorString,
+                       VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED);
+    break;
+  case VL53L0X_ERROR_BUFFER_TOO_SMALL:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL);
+    break;
+  case VL53L0X_ERROR_GPIO_NOT_EXISTING:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING);
+    break;
+  case VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED:
+    VL53L0X_COPYSTRING(pPalErrorString,
+                       VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED);
+    break;
+  case VL53L0X_ERROR_CONTROL_INTERFACE:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_CONTROL_INTERFACE);
+    break;
+  case VL53L0X_ERROR_INVALID_COMMAND:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_INVALID_COMMAND);
+    break;
+  case VL53L0X_ERROR_DIVISION_BY_ZERO:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_DIVISION_BY_ZERO);
+    break;
+  case VL53L0X_ERROR_REF_SPAD_INIT:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_REF_SPAD_INIT);
+    break;
+  case VL53L0X_ERROR_NOT_IMPLEMENTED:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_ERROR_NOT_IMPLEMENTED);
+    break;
+
+  default:
+    VL53L0X_COPYSTRING(pPalErrorString, VL53L0X_STRING_UNKNOW_ERROR_CODE);
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_get_pal_state_string(VL53L0X_State PalStateCode,
+                                           char *pPalStateString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  LOG_FUNCTION_START("");
+
+  switch (PalStateCode) {
+  case VL53L0X_STATE_POWERDOWN:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_POWERDOWN);
+    break;
+  case VL53L0X_STATE_WAIT_STATICINIT:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_WAIT_STATICINIT);
+    break;
+  case VL53L0X_STATE_STANDBY:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_STANDBY);
+    break;
+  case VL53L0X_STATE_IDLE:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_IDLE);
+    break;
+  case VL53L0X_STATE_RUNNING:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_RUNNING);
+    break;
+  case VL53L0X_STATE_UNKNOWN:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_UNKNOWN);
+    break;
+  case VL53L0X_STATE_ERROR:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_ERROR);
+    break;
+
+  default:
+    VL53L0X_COPYSTRING(pPalStateString, VL53L0X_STRING_STATE_UNKNOWN);
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}
+
+VL53L0X_Error
+VL53L0X_get_sequence_steps_info(VL53L0X_SequenceStepId SequenceStepId,
+                                char *pSequenceStepsString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  LOG_FUNCTION_START("");
+
+  switch (SequenceStepId) {
+  case VL53L0X_SEQUENCESTEP_TCC:
+    VL53L0X_COPYSTRING(pSequenceStepsString, VL53L0X_STRING_SEQUENCESTEP_TCC);
+    break;
+  case VL53L0X_SEQUENCESTEP_DSS:
+    VL53L0X_COPYSTRING(pSequenceStepsString, VL53L0X_STRING_SEQUENCESTEP_DSS);
+    break;
+  case VL53L0X_SEQUENCESTEP_MSRC:
+    VL53L0X_COPYSTRING(pSequenceStepsString, VL53L0X_STRING_SEQUENCESTEP_MSRC);
+    break;
+  case VL53L0X_SEQUENCESTEP_PRE_RANGE:
+    VL53L0X_COPYSTRING(pSequenceStepsString,
+                       VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE);
+    break;
+  case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
+    VL53L0X_COPYSTRING(pSequenceStepsString,
+                       VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE);
+    break;
+
+  default:
+    Status = VL53L0X_ERROR_INVALID_PARAMS;
+  }
+
+  LOG_FUNCTION_END(Status);
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_get_limit_check_info(VL53L0X_DEV Dev,
+                                           uint16_t LimitCheckId,
+                                           char *pLimitCheckString) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  LOG_FUNCTION_START("");
+
+  switch (LimitCheckId) {
+  case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE);
+    break;
+  case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE);
+    break;
+  case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP);
+    break;
+  case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD);
+    break;
+
+  case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC);
+    break;
+
+  case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+    VL53L0X_COPYSTRING(pLimitCheckString,
+                       VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE);
+    break;
+
+  default:
+    VL53L0X_COPYSTRING(pLimitCheckString, VL53L0X_STRING_UNKNOW_ERROR_CODE);
+  }
+
+  LOG_FUNCTION_END(Status);
+  return Status;
+}

code/lib/Adafruit_VL53L0X-1.2.3/src/platform/src/vl53l0x_i2c_comms.cpp

@@ -0,0 +1,128 @@
+#include "../../vl53l0x_def.h"
+#include "../../vl53l0x_i2c_platform.h"
+
+//#define I2C_DEBUG
+
+int VL53L0X_i2c_init(TwoWire *i2c) {
+  i2c->begin();
+  return VL53L0X_ERROR_NONE;
+}
+
+int VL53L0X_write_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata,
+                        uint32_t count, TwoWire *i2c) {
+  i2c->beginTransmission(deviceAddress);
+  i2c->write(index);
+#ifdef I2C_DEBUG
+  Serial.print("\tWriting ");
+  Serial.print(count);
+  Serial.print(" to addr 0x");
+  Serial.print(index, HEX);
+  Serial.print(": ");
+#endif
+  while (count--) {
+    i2c->write((uint8_t)pdata[0]);
+#ifdef I2C_DEBUG
+    Serial.print("0x");
+    Serial.print(pdata[0], HEX);
+    Serial.print(", ");
+#endif
+    pdata++;
+  }
+#ifdef I2C_DEBUG
+  Serial.println();
+#endif
+  i2c->endTransmission();
+  return VL53L0X_ERROR_NONE;
+}
+
+int VL53L0X_read_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata,
+                       uint32_t count, TwoWire *i2c) {
+  i2c->beginTransmission(deviceAddress);
+  i2c->write(index);
+  i2c->endTransmission();
+  i2c->requestFrom(deviceAddress, (byte)count);
+#ifdef I2C_DEBUG
+  Serial.print("\tReading ");
+  Serial.print(count);
+  Serial.print(" from addr 0x");
+  Serial.print(index, HEX);
+  Serial.print(": ");
+#endif
+
+  while (count--) {
+    pdata[0] = i2c->read();
+#ifdef I2C_DEBUG
+    Serial.print("0x");
+    Serial.print(pdata[0], HEX);
+    Serial.print(", ");
+#endif
+    pdata++;
+  }
+#ifdef I2C_DEBUG
+  Serial.println();
+#endif
+  return VL53L0X_ERROR_NONE;
+}
+
+int VL53L0X_write_byte(uint8_t deviceAddress, uint8_t index, uint8_t data,
+                       TwoWire *i2c) {
+  return VL53L0X_write_multi(deviceAddress, index, &data, 1, i2c);
+}
+
+int VL53L0X_write_word(uint8_t deviceAddress, uint8_t index, uint16_t data,
+                       TwoWire *i2c) {
+  uint8_t buff[2];
+  buff[1] = data & 0xFF;
+  buff[0] = data >> 8;
+  return VL53L0X_write_multi(deviceAddress, index, buff, 2, i2c);
+}
+
+int VL53L0X_write_dword(uint8_t deviceAddress, uint8_t index, uint32_t data,
+                        TwoWire *i2c) {
+  uint8_t buff[4];
+
+  buff[3] = data & 0xFF;
+  buff[2] = data >> 8;
+  buff[1] = data >> 16;
+  buff[0] = data >> 24;
+
+  return VL53L0X_write_multi(deviceAddress, index, buff, 4, i2c);
+}
+
+int VL53L0X_read_byte(uint8_t deviceAddress, uint8_t index, uint8_t *data,
+                      TwoWire *i2c) {
+  return VL53L0X_read_multi(deviceAddress, index, data, 1, i2c);
+}
+
+int VL53L0X_read_word(uint8_t deviceAddress, uint8_t index, uint16_t *data,
+                      TwoWire *i2c) {
+  uint8_t buff[2];
+  int r = VL53L0X_read_multi(deviceAddress, index, buff, 2, i2c);
+
+  uint16_t tmp;
+  tmp = buff[0];
+  tmp <<= 8;
+  tmp |= buff[1];
+  *data = tmp;
+
+  return r;
+}
+
+int VL53L0X_read_dword(uint8_t deviceAddress, uint8_t index, uint32_t *data,
+                       TwoWire *i2c) {
+  uint8_t buff[4];
+  int r = VL53L0X_read_multi(deviceAddress, index, buff, 4, i2c);
+
+  uint32_t tmp;
+  tmp = buff[0];
+  tmp <<= 8;
+  tmp |= buff[1];
+  tmp <<= 8;
+  tmp |= buff[2];
+  tmp <<= 8;
+  tmp |= buff[3];
+
+  *data = tmp;
+
+  return r;
+}

code/lib/Adafruit_VL53L0X-1.2.3/src/platform/src/vl53l0x_platform.cpp

@@ -0,0 +1,285 @@
+/*******************************************************************************
+Copyright 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+
+/**
+ * @file VL53L0X_i2c.c
+ *
+ * Copyright (C) 2014 ST MicroElectronics
+ *
+ * provide variable word size byte/Word/dword VL6180x register access via i2c
+ *
+ */
+#include "../../vl53l0x_platform.h"
+#include "../../vl53l0x_api.h"
+#include "../../vl53l0x_i2c_platform.h"
+
+#define LOG_FUNCTION_START(fmt, ...)                                           \
+  _LOG_FUNCTION_START(TRACE_MODULE_PLATFORM, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...)                                          \
+  _LOG_FUNCTION_END(TRACE_MODULE_PLATFORM, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...)                                 \
+  _LOG_FUNCTION_END_FMT(TRACE_MODULE_PLATFORM, status, fmt, ##__VA_ARGS__)
+
+/**
+ * @def I2C_BUFFER_CONFIG
+ *
+ * @brief Configure Device register I2C access
+ *
+ * @li 0 : one GLOBAL buffer \n
+ *   Use one global buffer of MAX_I2C_XFER_SIZE byte in data space \n
+ *   This solution is not multi-Device compliant nor multi-thread cpu safe \n
+ *   It can be the best option for small 8/16 bit MCU without stack and limited
+ * ram  (STM8s, 80C51 ...)
+ *
+ * @li 1 : ON_STACK/local \n
+ *   Use local variable (on stack) buffer \n
+ *   This solution is multi-thread with use of i2c resource lock or mutex see
+ * VL6180x_GetI2CAccess() \n
+ *
+ * @li 2 : User defined \n
+ *    Per Device potentially dynamic allocated. Requires VL6180x_GetI2cBuffer()
+ * to be implemented.
+ * @ingroup Configuration
+ */
+#define I2C_BUFFER_CONFIG 1
+/** Maximum buffer size to be used in i2c */
+#define VL53L0X_MAX_I2C_XFER_SIZE                                              \
+  64 /* Maximum buffer size to be used in i2c                                  \
+      */
+
+#if I2C_BUFFER_CONFIG == 0
+/* GLOBAL config buffer */
+uint8_t i2c_global_buffer[VL53L0X_MAX_I2C_XFER_SIZE];
+
+#define DECL_I2C_BUFFER
+#define VL53L0X_GetLocalBuffer(Dev, n_byte) i2c_global_buffer
+
+#elif I2C_BUFFER_CONFIG == 1
+/* ON STACK */
+#define DECL_I2C_BUFFER uint8_t LocBuffer[VL53L0X_MAX_I2C_XFER_SIZE];
+#define VL53L0X_GetLocalBuffer(Dev, n_byte) LocBuffer
+#elif I2C_BUFFER_CONFIG == 2
+/* user define buffer type declare DECL_I2C_BUFFER  as access  via
+ * VL53L0X_GetLocalBuffer */
+#define DECL_I2C_BUFFER
+#else
+#error "invalid I2C_BUFFER_CONFIG "
+#endif
+
+#define VL53L0X_I2C_USER_VAR /* none but could be for a flag var to get/pass   \
+                                to mutex interruptible  return flags and try   \
+                                again */
+#define VL53L0X_GetI2CAccess(Dev) /* todo mutex acquire */
+#define VL53L0X_DoneI2CAcces(Dev) /* todo mutex release */
+
+VL53L0X_Error VL53L0X_LockSequenceAccess(VL53L0X_DEV Dev) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_UnlockSequenceAccess(VL53L0X_DEV Dev) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+  return Status;
+}
+
+// the ranging_sensor_comms.dll will take care of the page selection
+VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
+                                 uint32_t count) {
+
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int = 0;
+  uint8_t deviceAddress;
+
+  if (count >= VL53L0X_MAX_I2C_XFER_SIZE) {
+    Status = VL53L0X_ERROR_INVALID_PARAMS;
+  }
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int =
+      VL53L0X_write_multi(deviceAddress, index, pdata, count, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+// the ranging_sensor_comms.dll will take care of the page selection
+VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
+                                uint32_t count) {
+  VL53L0X_I2C_USER_VAR
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  if (count >= VL53L0X_MAX_I2C_XFER_SIZE) {
+    Status = VL53L0X_ERROR_INVALID_PARAMS;
+  }
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_read_multi(deviceAddress, index, pdata, count, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_write_byte(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_write_word(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_write_dword(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index,
+                                 uint8_t AndData, uint8_t OrData) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+  uint8_t data;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_read_byte(deviceAddress, index, &data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  if (Status == VL53L0X_ERROR_NONE) {
+    data = (data & AndData) | OrData;
+    status_int = VL53L0X_write_byte(deviceAddress, index, data, Dev->i2c);
+
+    if (status_int != 0)
+      Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+  }
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_read_byte(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_read_word(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data) {
+  VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+  int32_t status_int;
+  uint8_t deviceAddress;
+
+  deviceAddress = Dev->I2cDevAddr;
+
+  status_int = VL53L0X_read_dword(deviceAddress, index, data, Dev->i2c);
+
+  if (status_int != 0)
+    Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+  return Status;
+}
+
+#define VL53L0X_POLLINGDELAY_LOOPNB 250
+VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev) {
+  VL53L0X_Error status = VL53L0X_ERROR_NONE;
+  volatile uint32_t i;
+  LOG_FUNCTION_START("");
+
+  for (i = 0; i < VL53L0X_POLLINGDELAY_LOOPNB; i++) {
+    // Do nothing
+    asm("nop");
+  }
+
+  LOG_FUNCTION_END(status);
+  return status;
+}

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_api_calibration.h

@@ -0,0 +1,87 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of STMicroelectronics nor the
+          names of its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_CALIBRATION_H_
+#define _VL53L0X_API_CALIBRATION_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VL53L0X_Error VL53L0X_perform_xtalk_calibration(
+    VL53L0X_DEV Dev, FixPoint1616_t XTalkCalDistance,
+    FixPoint1616_t *pXTalkCompensationRateMegaCps);
+
+VL53L0X_Error
+VL53L0X_perform_offset_calibration(VL53L0X_DEV Dev,
+                                   FixPoint1616_t CalDistanceMilliMeter,
+                                   int32_t *pOffsetMicroMeter);
+
+VL53L0X_Error VL53L0X_set_offset_calibration_data_micro_meter(
+    VL53L0X_DEV Dev, int32_t OffsetCalibrationDataMicroMeter);
+
+VL53L0X_Error VL53L0X_get_offset_calibration_data_micro_meter(
+    VL53L0X_DEV Dev, int32_t *pOffsetCalibrationDataMicroMeter);
+
+VL53L0X_Error VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev);
+
+VL53L0X_Error VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
+                                                  uint32_t *refSpadCount,
+                                                  uint8_t *isApertureSpads);
+
+VL53L0X_Error VL53L0X_set_reference_spads(VL53L0X_DEV Dev, uint32_t count,
+                                          uint8_t isApertureSpads);
+
+VL53L0X_Error VL53L0X_get_reference_spads(VL53L0X_DEV Dev, uint32_t *pSpadCount,
+                                          uint8_t *pIsApertureSpads);
+
+VL53L0X_Error VL53L0X_perform_phase_calibration(VL53L0X_DEV Dev,
+                                                uint8_t *pPhaseCal,
+                                                const uint8_t get_data_enable,
+                                                const uint8_t restore_config);
+
+VL53L0X_Error VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
+                                              uint8_t *pVhvSettings,
+                                              uint8_t *pPhaseCal,
+                                              uint8_t get_data_enable);
+
+VL53L0X_Error VL53L0X_set_ref_calibration(VL53L0X_DEV Dev, uint8_t VhvSettings,
+                                          uint8_t PhaseCal);
+
+VL53L0X_Error VL53L0X_get_ref_calibration(VL53L0X_DEV Dev,
+                                          uint8_t *pVhvSettings,
+                                          uint8_t *pPhaseCal);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_CALIBRATION_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_api_core.h

@@ -0,0 +1,109 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_CORE_H_
+#define _VL53L0X_API_CORE_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VL53L0X_Error VL53L0X_reverse_bytes(uint8_t *data, uint32_t size);
+
+VL53L0X_Error VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev);
+
+uint8_t VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks);
+
+uint8_t VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg);
+
+uint32_t VL53L0X_isqrt(uint32_t num);
+
+uint32_t VL53L0X_quadrature_sum(uint32_t a, uint32_t b);
+
+VL53L0X_Error VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option);
+
+VL53L0X_Error
+VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
+                               VL53L0X_VcselPeriod VcselPeriodType,
+                               uint8_t VCSELPulsePeriodPCLK);
+
+VL53L0X_Error
+VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
+                               VL53L0X_VcselPeriod VcselPeriodType,
+                               uint8_t *pVCSELPulsePeriodPCLK);
+
+uint32_t VL53L0X_decode_timeout(uint16_t encoded_timeout);
+
+VL53L0X_Error get_sequence_step_timeout(VL53L0X_DEV Dev,
+                                        VL53L0X_SequenceStepId SequenceStepId,
+                                        uint32_t *pTimeOutMicroSecs);
+
+VL53L0X_Error set_sequence_step_timeout(VL53L0X_DEV Dev,
+                                        VL53L0X_SequenceStepId SequenceStepId,
+                                        uint32_t TimeOutMicroSecs);
+
+VL53L0X_Error VL53L0X_set_measurement_timing_budget_micro_seconds(
+    VL53L0X_DEV Dev, uint32_t MeasurementTimingBudgetMicroSeconds);
+
+VL53L0X_Error VL53L0X_get_measurement_timing_budget_micro_seconds(
+    VL53L0X_DEV Dev, uint32_t *pMeasurementTimingBudgetMicroSeconds);
+
+VL53L0X_Error VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
+                                           uint8_t *pTuningSettingBuffer);
+
+VL53L0X_Error VL53L0X_calc_sigma_estimate(
+    VL53L0X_DEV Dev, VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *pSigmaEstimate, uint32_t *pDmax_mm);
+
+VL53L0X_Error VL53L0X_get_total_xtalk_rate(
+    VL53L0X_DEV Dev, VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *ptotal_xtalk_rate_mcps);
+
+VL53L0X_Error VL53L0X_get_total_signal_rate(
+    VL53L0X_DEV Dev, VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *ptotal_signal_rate_mcps);
+
+VL53L0X_Error VL53L0X_get_pal_range_status(
+    VL53L0X_DEV Dev, uint8_t DeviceRangeStatus, FixPoint1616_t SignalRate,
+    uint16_t EffectiveSpadRtnCount,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    uint8_t *pPalRangeStatus);
+
+uint32_t VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev, uint32_t timeout_period_us,
+                                    uint8_t vcsel_period_pclks);
+
+uint16_t VL53L0X_encode_timeout(uint32_t timeout_macro_clks);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_CORE_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_api_ranging.h

@@ -0,0 +1,43 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_RANGING_H_
+#define _VL53L0X_API_RANGING_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_RANGING_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_api_strings.h

@@ -0,0 +1,233 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef VL53L0X_API_STRINGS_H_
+#define VL53L0X_API_STRINGS_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VL53L0X_Error
+VL53L0X_get_device_info(VL53L0X_DEV Dev,
+                        VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
+
+VL53L0X_Error VL53L0X_get_device_error_string(VL53L0X_DeviceError ErrorCode,
+                                              char *pDeviceErrorString);
+
+VL53L0X_Error VL53L0X_get_range_status_string(uint8_t RangeStatus,
+                                              char *pRangeStatusString);
+
+VL53L0X_Error VL53L0X_get_pal_error_string(VL53L0X_Error PalErrorCode,
+                                           char *pPalErrorString);
+
+VL53L0X_Error VL53L0X_get_pal_state_string(VL53L0X_State PalStateCode,
+                                           char *pPalStateString);
+
+VL53L0X_Error
+VL53L0X_get_sequence_steps_info(VL53L0X_SequenceStepId SequenceStepId,
+                                char *pSequenceStepsString);
+
+VL53L0X_Error VL53L0X_get_limit_check_info(VL53L0X_DEV Dev,
+                                           uint16_t LimitCheckId,
+                                           char *pLimitCheckString);
+
+#ifdef USE_EMPTY_STRING
+#define VL53L0X_STRING_DEVICE_INFO_NAME ""
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS0 ""
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS1 ""
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS2 ""
+#define VL53L0X_STRING_DEVICE_INFO_NAME_ES1 ""
+#define VL53L0X_STRING_DEVICE_INFO_TYPE ""
+
+/* PAL ERROR strings */
+#define VL53L0X_STRING_ERROR_NONE ""
+#define VL53L0X_STRING_ERROR_CALIBRATION_WARNING ""
+#define VL53L0X_STRING_ERROR_MIN_CLIPPED ""
+#define VL53L0X_STRING_ERROR_UNDEFINED ""
+#define VL53L0X_STRING_ERROR_INVALID_PARAMS ""
+#define VL53L0X_STRING_ERROR_NOT_SUPPORTED ""
+#define VL53L0X_STRING_ERROR_RANGE_ERROR ""
+#define VL53L0X_STRING_ERROR_TIME_OUT ""
+#define VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED ""
+#define VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL ""
+#define VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING ""
+#define VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED ""
+#define VL53L0X_STRING_ERROR_CONTROL_INTERFACE ""
+#define VL53L0X_STRING_ERROR_INVALID_COMMAND ""
+#define VL53L0X_STRING_ERROR_DIVISION_BY_ZERO ""
+#define VL53L0X_STRING_ERROR_REF_SPAD_INIT ""
+#define VL53L0X_STRING_ERROR_NOT_IMPLEMENTED ""
+
+#define VL53L0X_STRING_UNKNOW_ERROR_CODE ""
+
+/* Range Status */
+#define VL53L0X_STRING_RANGESTATUS_NONE ""
+#define VL53L0X_STRING_RANGESTATUS_RANGEVALID ""
+#define VL53L0X_STRING_RANGESTATUS_SIGMA ""
+#define VL53L0X_STRING_RANGESTATUS_SIGNAL ""
+#define VL53L0X_STRING_RANGESTATUS_MINRANGE ""
+#define VL53L0X_STRING_RANGESTATUS_PHASE ""
+#define VL53L0X_STRING_RANGESTATUS_HW ""
+
+/* Range Status */
+#define VL53L0X_STRING_STATE_POWERDOWN ""
+#define VL53L0X_STRING_STATE_WAIT_STATICINIT ""
+#define VL53L0X_STRING_STATE_STANDBY ""
+#define VL53L0X_STRING_STATE_IDLE ""
+#define VL53L0X_STRING_STATE_RUNNING ""
+#define VL53L0X_STRING_STATE_UNKNOWN ""
+#define VL53L0X_STRING_STATE_ERROR ""
+
+/* Device Specific */
+#define VL53L0X_STRING_DEVICEERROR_NONE ""
+#define VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE ""
+#define VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE ""
+#define VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND ""
+#define VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET ""
+#define VL53L0X_STRING_DEVICEERROR_SNRCHECK ""
+#define VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK ""
+#define VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK ""
+#define VL53L0X_STRING_DEVICEERROR_TCC ""
+#define VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY ""
+#define VL53L0X_STRING_DEVICEERROR_MINCLIP ""
+#define VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE ""
+#define VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW ""
+#define VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW ""
+#define VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD ""
+#define VL53L0X_STRING_DEVICEERROR_UNKNOWN ""
+
+/* Check Enable */
+#define VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE ""
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE ""
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP ""
+#define VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD ""
+
+/* Sequence Step */
+#define VL53L0X_STRING_SEQUENCESTEP_TCC ""
+#define VL53L0X_STRING_SEQUENCESTEP_DSS ""
+#define VL53L0X_STRING_SEQUENCESTEP_MSRC ""
+#define VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE ""
+#define VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE ""
+#else
+#define VL53L0X_STRING_DEVICE_INFO_NAME "VL53L0X cut1.0"
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS0 "VL53L0X TS0"
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS1 "VL53L0X TS1"
+#define VL53L0X_STRING_DEVICE_INFO_NAME_TS2 "VL53L0X TS2"
+#define VL53L0X_STRING_DEVICE_INFO_NAME_ES1 "VL53L0X ES1 or later"
+#define VL53L0X_STRING_DEVICE_INFO_TYPE "VL53L0X"
+
+/* PAL ERROR strings */
+#define VL53L0X_STRING_ERROR_NONE "No Error"
+#define VL53L0X_STRING_ERROR_CALIBRATION_WARNING "Calibration Warning Error"
+#define VL53L0X_STRING_ERROR_MIN_CLIPPED "Min clipped error"
+#define VL53L0X_STRING_ERROR_UNDEFINED "Undefined error"
+#define VL53L0X_STRING_ERROR_INVALID_PARAMS "Invalid parameters error"
+#define VL53L0X_STRING_ERROR_NOT_SUPPORTED "Not supported error"
+#define VL53L0X_STRING_ERROR_RANGE_ERROR "Range error"
+#define VL53L0X_STRING_ERROR_TIME_OUT "Time out error"
+#define VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED "Mode not supported error"
+#define VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL "Buffer too small"
+#define VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING "GPIO not existing"
+#define VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED                  \
+  "GPIO funct not supported"
+#define VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED "Interrupt not Cleared"
+#define VL53L0X_STRING_ERROR_CONTROL_INTERFACE "Control Interface Error"
+#define VL53L0X_STRING_ERROR_INVALID_COMMAND "Invalid Command Error"
+#define VL53L0X_STRING_ERROR_DIVISION_BY_ZERO "Division by zero Error"
+#define VL53L0X_STRING_ERROR_REF_SPAD_INIT "Reference Spad Init Error"
+#define VL53L0X_STRING_ERROR_NOT_IMPLEMENTED "Not implemented error"
+
+#define VL53L0X_STRING_UNKNOW_ERROR_CODE "Unknown Error Code"
+
+/* Range Status */
+#define VL53L0X_STRING_RANGESTATUS_NONE "No Update"
+#define VL53L0X_STRING_RANGESTATUS_RANGEVALID "Range Valid"
+#define VL53L0X_STRING_RANGESTATUS_SIGMA "Sigma Fail"
+#define VL53L0X_STRING_RANGESTATUS_SIGNAL "Signal Fail"
+#define VL53L0X_STRING_RANGESTATUS_MINRANGE "Min Range Fail"
+#define VL53L0X_STRING_RANGESTATUS_PHASE "Phase Fail"
+#define VL53L0X_STRING_RANGESTATUS_HW "Hardware Fail"
+
+/* Range Status */
+#define VL53L0X_STRING_STATE_POWERDOWN "POWERDOWN State"
+#define VL53L0X_STRING_STATE_WAIT_STATICINIT "Wait for staticinit State"
+#define VL53L0X_STRING_STATE_STANDBY "STANDBY State"
+#define VL53L0X_STRING_STATE_IDLE "IDLE State"
+#define VL53L0X_STRING_STATE_RUNNING "RUNNING State"
+#define VL53L0X_STRING_STATE_UNKNOWN "UNKNOWN State"
+#define VL53L0X_STRING_STATE_ERROR "ERROR State"
+
+/* Device Specific */
+#define VL53L0X_STRING_DEVICEERROR_NONE "No Update"
+#define VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE                  \
+  "VCSEL Continuity Test Failure"
+#define VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE                    \
+  "VCSEL Watchdog Test Failure"
+#define VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND "No VHV Value found"
+#define VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET "MSRC No Target Error"
+#define VL53L0X_STRING_DEVICEERROR_SNRCHECK "SNR Check Exit"
+#define VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK "Range Phase Check Error"
+#define VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK                         \
+  "Sigma Threshold Check Error"
+#define VL53L0X_STRING_DEVICEERROR_TCC "TCC Error"
+#define VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY "Phase Consistency Error"
+#define VL53L0X_STRING_DEVICEERROR_MINCLIP "Min Clip Error"
+#define VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE "Range Complete"
+#define VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW "Range Algo Underflow Error"
+#define VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW "Range Algo Overflow Error"
+#define VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD                        \
+  "Range Ignore Threshold Error"
+#define VL53L0X_STRING_DEVICEERROR_UNKNOWN "Unknown error code"
+
+/* Check Enable */
+#define VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE "SIGMA FINAL RANGE"
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE                     \
+  "SIGNAL RATE FINAL RANGE"
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP "SIGNAL REF CLIP"
+#define VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD                      \
+  "RANGE IGNORE THRESHOLD"
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC "SIGNAL RATE MSRC"
+#define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE "SIGNAL RATE PRE RANGE"
+
+/* Sequence Step */
+#define VL53L0X_STRING_SEQUENCESTEP_TCC "TCC"
+#define VL53L0X_STRING_SEQUENCESTEP_DSS "DSS"
+#define VL53L0X_STRING_SEQUENCESTEP_MSRC "MSRC"
+#define VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE "PRE RANGE"
+#define VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE "FINAL RANGE"
+#endif /* USE_EMPTY_STRING */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_def.h

@@ -0,0 +1,602 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of STMicroelectronics nor the
+          names of its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+/**
+ * @file VL53L0X_def.h
+ *
+ * @brief Type definitions for VL53L0X API.
+ *
+ */
+
+#ifndef _VL53L0X_DEF_H_
+#define _VL53L0X_DEF_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup VL53L0X_globaldefine_group VL53L0X Defines
+ *	@brief	  VL53L0X Defines
+ *	@{
+ */
+
+/** PAL SPECIFICATION major version */
+#define VL53L0X10_SPECIFICATION_VER_MAJOR 1
+/** PAL SPECIFICATION minor version */
+#define VL53L0X10_SPECIFICATION_VER_MINOR 2
+/** PAL SPECIFICATION sub version */
+#define VL53L0X10_SPECIFICATION_VER_SUB 7
+/** PAL SPECIFICATION sub version */
+#define VL53L0X10_SPECIFICATION_VER_REVISION 1440
+
+/** VL53L0X PAL IMPLEMENTATION major version */
+#define VL53L0X10_IMPLEMENTATION_VER_MAJOR 1
+/** VL53L0X PAL IMPLEMENTATION minor version */
+#define VL53L0X10_IMPLEMENTATION_VER_MINOR 0
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X10_IMPLEMENTATION_VER_SUB 9
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X10_IMPLEMENTATION_VER_REVISION 3673
+
+/** PAL SPECIFICATION major version */
+#define VL53L0X_SPECIFICATION_VER_MAJOR 1
+/** PAL SPECIFICATION minor version */
+#define VL53L0X_SPECIFICATION_VER_MINOR 2
+/** PAL SPECIFICATION sub version */
+#define VL53L0X_SPECIFICATION_VER_SUB 7
+/** PAL SPECIFICATION sub version */
+#define VL53L0X_SPECIFICATION_VER_REVISION 1440
+
+/** VL53L0X PAL IMPLEMENTATION major version */
+#define VL53L0X_IMPLEMENTATION_VER_MAJOR 1
+/** VL53L0X PAL IMPLEMENTATION minor version */
+#define VL53L0X_IMPLEMENTATION_VER_MINOR 0
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X_IMPLEMENTATION_VER_SUB 1
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X_IMPLEMENTATION_VER_REVISION 4606
+#define VL53L0X_DEFAULT_MAX_LOOP 200
+#define VL53L0X_MAX_STRING_LENGTH 32
+
+#include "vl53l0x_device.h"
+#include "vl53l0x_types.h"
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/** @brief Defines the parameters of the Get Version Functions
+ */
+typedef struct {
+  uint32_t revision; /*!< revision number */
+  uint8_t major;     /*!< major number */
+  uint8_t minor;     /*!< minor number */
+  uint8_t build;     /*!< build number */
+} VL53L0X_Version_t;
+
+/** @brief Defines the parameters of the Get Device Info Functions
+ */
+typedef struct {
+  char Name[VL53L0X_MAX_STRING_LENGTH];
+  /*!< Name of the Device e.g. Left_Distance */
+  char Type[VL53L0X_MAX_STRING_LENGTH];
+  /*!< Type of the Device e.g VL53L0X */
+  char ProductId[VL53L0X_MAX_STRING_LENGTH];
+  /*!< Product Identifier String	*/
+  uint8_t ProductType;
+  /*!< Product Type, VL53L0X = 1, VL53L1 = 2 */
+  uint8_t ProductRevisionMajor;
+  /*!< Product revision major */
+  uint8_t ProductRevisionMinor;
+  /*!< Product revision minor */
+} VL53L0X_DeviceInfo_t;
+
+/** @defgroup VL53L0X_define_Error_group Error and Warning code returned by API
+ *	The following DEFINE are used to identify the PAL ERROR
+ *	@{
+ */
+
+typedef int8_t VL53L0X_Error;
+
+#define VL53L0X_ERROR_NONE ((VL53L0X_Error)0)
+#define VL53L0X_ERROR_CALIBRATION_WARNING ((VL53L0X_Error)-1)
+/*!< Warning invalid calibration data may be in used
+        \a	VL53L0X_InitData()
+        \a VL53L0X_GetOffsetCalibrationData
+        \a VL53L0X_SetOffsetCalibrationData */
+#define VL53L0X_ERROR_MIN_CLIPPED ((VL53L0X_Error)-2)
+/*!< Warning parameter passed was clipped to min before to be applied */
+
+#define VL53L0X_ERROR_UNDEFINED ((VL53L0X_Error)-3)
+/*!< Unqualified error */
+#define VL53L0X_ERROR_INVALID_PARAMS ((VL53L0X_Error)-4)
+/*!< Parameter passed is invalid or out of range */
+#define VL53L0X_ERROR_NOT_SUPPORTED ((VL53L0X_Error)-5)
+/*!< Function is not supported in current mode or configuration */
+#define VL53L0X_ERROR_RANGE_ERROR ((VL53L0X_Error)-6)
+/*!< Device report a ranging error interrupt status */
+#define VL53L0X_ERROR_TIME_OUT ((VL53L0X_Error)-7)
+/*!< Aborted due to time out */
+#define VL53L0X_ERROR_MODE_NOT_SUPPORTED ((VL53L0X_Error)-8)
+/*!< Asked mode is not supported by the device */
+#define VL53L0X_ERROR_BUFFER_TOO_SMALL ((VL53L0X_Error)-9)
+/*!< ... */
+#define VL53L0X_ERROR_GPIO_NOT_EXISTING ((VL53L0X_Error)-10)
+/*!< User tried to setup a non-existing GPIO pin */
+#define VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED ((VL53L0X_Error)-11)
+/*!< unsupported GPIO functionality */
+#define VL53L0X_ERROR_INTERRUPT_NOT_CLEARED ((VL53L0X_Error)-12)
+/*!< Error during interrupt clear */
+#define VL53L0X_ERROR_CONTROL_INTERFACE ((VL53L0X_Error)-20)
+/*!< error reported from IO functions */
+#define VL53L0X_ERROR_INVALID_COMMAND ((VL53L0X_Error)-30)
+/*!< The command is not allowed in the current device state
+ *	(power down) */
+#define VL53L0X_ERROR_DIVISION_BY_ZERO ((VL53L0X_Error)-40)
+/*!< In the function a division by zero occurs */
+#define VL53L0X_ERROR_REF_SPAD_INIT ((VL53L0X_Error)-50)
+/*!< Error during reference SPAD initialization */
+#define VL53L0X_ERROR_NOT_IMPLEMENTED ((VL53L0X_Error)-99)
+/*!< Tells requested functionality has not been implemented yet or
+ * not compatible with the device */
+/** @} VL53L0X_define_Error_group */
+
+/** @defgroup VL53L0X_define_DeviceModes_group Defines Device modes
+ *	Defines all possible modes for the device
+ *	@{
+ */
+typedef uint8_t VL53L0X_DeviceModes;
+
+#define VL53L0X_DEVICEMODE_SINGLE_RANGING ((VL53L0X_DeviceModes)0)
+#define VL53L0X_DEVICEMODE_CONTINUOUS_RANGING ((VL53L0X_DeviceModes)1)
+#define VL53L0X_DEVICEMODE_SINGLE_HISTOGRAM ((VL53L0X_DeviceModes)2)
+#define VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING ((VL53L0X_DeviceModes)3)
+#define VL53L0X_DEVICEMODE_SINGLE_ALS ((VL53L0X_DeviceModes)10)
+#define VL53L0X_DEVICEMODE_GPIO_DRIVE ((VL53L0X_DeviceModes)20)
+#define VL53L0X_DEVICEMODE_GPIO_OSC ((VL53L0X_DeviceModes)21)
+/* ... Modes to be added depending on device */
+/** @} VL53L0X_define_DeviceModes_group */
+
+/** @defgroup VL53L0X_define_HistogramModes_group Defines Histogram modes
+ *	Defines all possible Histogram modes for the device
+ *	@{
+ */
+typedef uint8_t VL53L0X_HistogramModes;
+
+#define VL53L0X_HISTOGRAMMODE_DISABLED ((VL53L0X_HistogramModes)0)
+/*!< Histogram Disabled */
+#define VL53L0X_HISTOGRAMMODE_REFERENCE_ONLY ((VL53L0X_HistogramModes)1)
+/*!< Histogram Reference array only */
+#define VL53L0X_HISTOGRAMMODE_RETURN_ONLY ((VL53L0X_HistogramModes)2)
+/*!< Histogram Return array only */
+#define VL53L0X_HISTOGRAMMODE_BOTH ((VL53L0X_HistogramModes)3)
+/*!< Histogram both Reference and Return Arrays */
+/* ... Modes to be added depending on device */
+/** @} VL53L0X_define_HistogramModes_group */
+
+/** @defgroup VL53L0X_define_PowerModes_group List of available Power Modes
+ *	List of available Power Modes
+ *	@{
+ */
+
+typedef uint8_t VL53L0X_PowerModes;
+
+#define VL53L0X_POWERMODE_STANDBY_LEVEL1 ((VL53L0X_PowerModes)0)
+/*!< Standby level 1 */
+#define VL53L0X_POWERMODE_STANDBY_LEVEL2 ((VL53L0X_PowerModes)1)
+/*!< Standby level 2 */
+#define VL53L0X_POWERMODE_IDLE_LEVEL1 ((VL53L0X_PowerModes)2)
+/*!< Idle level 1 */
+#define VL53L0X_POWERMODE_IDLE_LEVEL2 ((VL53L0X_PowerModes)3)
+/*!< Idle level 2 */
+
+/** @} VL53L0X_define_PowerModes_group */
+
+/** @brief Defines all parameters for the device
+ */
+typedef struct {
+  VL53L0X_DeviceModes DeviceMode;
+  /*!< Defines type of measurement to be done for the next measure */
+  VL53L0X_HistogramModes HistogramMode;
+  /*!< Defines type of histogram measurement to be done for the next
+   *	measure */
+  uint32_t MeasurementTimingBudgetMicroSeconds;
+  /*!< Defines the allowed total time for a single measurement */
+  uint32_t InterMeasurementPeriodMilliSeconds;
+  /*!< Defines time between two consecutive measurements (between two
+   *	measurement starts). If set to 0 means back-to-back mode */
+  uint8_t XTalkCompensationEnable;
+  /*!< Tells if Crosstalk compensation shall be enable or not	 */
+  uint16_t XTalkCompensationRangeMilliMeter;
+  /*!< CrossTalk compensation range in millimeter	 */
+  FixPoint1616_t XTalkCompensationRateMegaCps;
+  /*!< CrossTalk compensation rate in Mega counts per seconds.
+   *	Expressed in 16.16 fixed point format.	*/
+  int32_t RangeOffsetMicroMeters;
+  /*!< Range offset adjustment (mm).	*/
+
+  uint8_t LimitChecksEnable[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+  /*!< This Array store all the Limit Check enable for this device. */
+  uint8_t LimitChecksStatus[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+  /*!< This Array store all the Status of the check linked to last
+   * measurement. */
+  FixPoint1616_t LimitChecksValue[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+  /*!< This Array store all the Limit Check value for this device */
+
+  uint8_t WrapAroundCheckEnable;
+  /*!< Tells if Wrap Around Check shall be enable or not */
+} VL53L0X_DeviceParameters_t;
+
+/** @defgroup VL53L0X_define_State_group Defines the current status of the
+ *device Defines the current status of the device
+ *	@{
+ */
+
+typedef uint8_t VL53L0X_State;
+
+#define VL53L0X_STATE_POWERDOWN ((VL53L0X_State)0)
+/*!< Device is in HW reset	*/
+#define VL53L0X_STATE_WAIT_STATICINIT ((VL53L0X_State)1)
+/*!< Device is initialized and wait for static initialization  */
+#define VL53L0X_STATE_STANDBY ((VL53L0X_State)2)
+/*!< Device is in Low power Standby mode   */
+#define VL53L0X_STATE_IDLE ((VL53L0X_State)3)
+/*!< Device has been initialized and ready to do measurements  */
+#define VL53L0X_STATE_RUNNING ((VL53L0X_State)4)
+/*!< Device is performing measurement */
+#define VL53L0X_STATE_UNKNOWN ((VL53L0X_State)98)
+/*!< Device is in unknown state and need to be rebooted	 */
+#define VL53L0X_STATE_ERROR ((VL53L0X_State)99)
+/*!< Device is in error state and need to be rebooted  */
+
+/** @} VL53L0X_define_State_group */
+
+/** @brief Structure containing the Dmax computation parameters and data
+ */
+typedef struct {
+  int32_t AmbTuningWindowFactor_K;
+  /*!<  internal algo tuning (*1000) */
+  int32_t RetSignalAt0mm;
+  /*!< intermediate dmax computation value caching */
+} VL53L0X_DMaxData_t;
+
+/**
+ * @struct VL53L0X_RangeData_t
+ * @brief Range measurement data.
+ */
+typedef struct {
+  uint32_t TimeStamp; /*!< 32-bit time stamp. */
+  uint32_t MeasurementTimeUsec;
+  /*!< Give the Measurement time needed by the device to do the
+   * measurement.*/
+
+  uint16_t RangeMilliMeter; /*!< range distance in millimeter. */
+
+  uint16_t RangeDMaxMilliMeter;
+  /*!< Tells what is the maximum detection distance of the device
+   * in current setup and environment conditions (Filled when
+   *	applicable) */
+
+  FixPoint1616_t SignalRateRtnMegaCps;
+  /*!< Return signal rate (MCPS)\n these is a 16.16 fix point
+   *	value, which is effectively a measure of target
+   *	 reflectance.*/
+  FixPoint1616_t AmbientRateRtnMegaCps;
+  /*!< Return ambient rate (MCPS)\n these is a 16.16 fix point
+   *	value, which is effectively a measure of the ambien
+   *	t light.*/
+
+  uint16_t EffectiveSpadRtnCount;
+  /*!< Return the effective SPAD count for the return signal.
+   *	To obtain Real value it should be divided by 256 */
+
+  uint8_t ZoneId;
+  /*!< Denotes which zone and range scheduler stage the range
+   *	data relates to. */
+  uint8_t RangeFractionalPart;
+  /*!< Fractional part of range distance. Final value is a
+   *	FixPoint168 value. */
+  uint8_t RangeStatus;
+  /*!< Range Status for the current measurement. This is device
+   *	dependent. Value = 0 means value is valid.
+   *	See \ref RangeStatusPage */
+} VL53L0X_RangingMeasurementData_t;
+
+#define VL53L0X_HISTOGRAM_BUFFER_SIZE 24
+
+/**
+ * @struct VL53L0X_HistogramData_t
+ * @brief Histogram measurement data.
+ */
+typedef struct {
+  /* Histogram Measurement data */
+  uint32_t HistogramData[VL53L0X_HISTOGRAM_BUFFER_SIZE];
+  /*!< Histogram data */
+  uint8_t HistogramType; /*!< Indicate the types of histogram data :
+  Return only, Reference only, both Return and Reference */
+  uint8_t FirstBin;      /*!< First Bin value */
+  uint8_t BufferSize;    /*!< Buffer Size - Set by the user.*/
+  uint8_t NumberOfBins;
+  /*!< Number of bins filled by the histogram measurement */
+
+  VL53L0X_DeviceError ErrorStatus;
+  /*!< Error status of the current measurement. \n
+  see @a ::VL53L0X_DeviceError @a VL53L0X_GetStatusErrorString() */
+} VL53L0X_HistogramMeasurementData_t;
+
+#define VL53L0X_REF_SPAD_BUFFER_SIZE 6
+
+/**
+ * @struct VL53L0X_SpadData_t
+ * @brief Spad Configuration Data.
+ */
+typedef struct {
+  uint8_t RefSpadEnables[VL53L0X_REF_SPAD_BUFFER_SIZE];
+  /*!< Reference Spad Enables */
+  uint8_t RefGoodSpadMap[VL53L0X_REF_SPAD_BUFFER_SIZE];
+  /*!< Reference Spad Good Spad Map */
+} VL53L0X_SpadData_t;
+
+typedef struct {
+  FixPoint1616_t OscFrequencyMHz; /* Frequency used */
+
+  uint16_t LastEncodedTimeout;
+  /* last encoded Time out used for timing budget*/
+
+  VL53L0X_GpioFunctionality Pin0GpioFunctionality;
+  /* store the functionality of the GPIO: pin0 */
+
+  uint32_t FinalRangeTimeoutMicroSecs;
+  /*!< Execution time of the final range*/
+  uint8_t FinalRangeVcselPulsePeriod;
+  /*!< Vcsel pulse period (pll clocks) for the final range measurement*/
+  uint32_t PreRangeTimeoutMicroSecs;
+  /*!< Execution time of the final range*/
+  uint8_t PreRangeVcselPulsePeriod;
+  /*!< Vcsel pulse period (pll clocks) for the pre-range measurement*/
+
+  uint16_t SigmaEstRefArray;
+  /*!< Reference array sigma value in 1/100th of [mm] e.g. 100 = 1mm */
+  uint16_t SigmaEstEffPulseWidth;
+  /*!< Effective Pulse width for sigma estimate in 1/100th
+   * of ns e.g. 900 = 9.0ns */
+  uint16_t SigmaEstEffAmbWidth;
+  /*!< Effective Ambient width for sigma estimate in 1/100th of ns
+   * e.g. 500 = 5.0ns */
+
+  uint8_t ReadDataFromDeviceDone; /* Indicate if read from device has
+  been done (==1) or not (==0) */
+  uint8_t ModuleId;               /* Module ID */
+  uint8_t Revision;               /* test Revision */
+  char ProductId[VL53L0X_MAX_STRING_LENGTH];
+  /* Product Identifier String  */
+  uint8_t ReferenceSpadCount;  /* used for ref spad management */
+  uint8_t ReferenceSpadType;   /* used for ref spad management */
+  uint8_t RefSpadsInitialised; /* reports if ref spads are initialised. */
+  uint32_t PartUIDUpper;       /*!< Unique Part ID Upper */
+  uint32_t PartUIDLower;       /*!< Unique Part ID Lower */
+  FixPoint1616_t SignalRateMeasFixed400mm; /*!< Peek Signal rate
+  at 400 mm*/
+
+} VL53L0X_DeviceSpecificParameters_t;
+
+/**
+ * @struct VL53L0X_DevData_t
+ *
+ * @brief VL53L0X PAL device ST private data structure \n
+ * End user should never access any of these field directly
+ *
+ * These must never access directly but only via macro
+ */
+typedef struct {
+  VL53L0X_DMaxData_t DMaxData;
+  /*!< Dmax Data */
+  int32_t Part2PartOffsetNVMMicroMeter;
+  /*!< backed up NVM value */
+  int32_t Part2PartOffsetAdjustmentNVMMicroMeter;
+  /*!< backed up NVM value representing additional offset adjustment */
+  VL53L0X_DeviceParameters_t CurrentParameters;
+  /*!< Current Device Parameter */
+  VL53L0X_RangingMeasurementData_t LastRangeMeasure;
+  /*!< Ranging Data */
+  VL53L0X_HistogramMeasurementData_t LastHistogramMeasure;
+  /*!< Histogram Data */
+  VL53L0X_DeviceSpecificParameters_t DeviceSpecificParameters;
+  /*!< Parameters specific to the device */
+  VL53L0X_SpadData_t SpadData;
+  /*!< Spad Data */
+  uint8_t SequenceConfig;
+  /*!< Internal value for the sequence config */
+  uint8_t RangeFractionalEnable;
+  /*!< Enable/Disable fractional part of ranging data */
+  VL53L0X_State PalState;
+  /*!< Current state of the PAL for this device */
+  VL53L0X_PowerModes PowerMode;
+  /*!< Current Power Mode	 */
+  uint16_t SigmaEstRefArray;
+  /*!< Reference array sigma value in 1/100th of [mm] e.g. 100 = 1mm */
+  uint16_t SigmaEstEffPulseWidth;
+  /*!< Effective Pulse width for sigma estimate in 1/100th
+   * of ns e.g. 900 = 9.0ns */
+  uint16_t SigmaEstEffAmbWidth;
+  /*!< Effective Ambient width for sigma estimate in 1/100th of ns
+   * e.g. 500 = 5.0ns */
+  uint8_t StopVariable;
+  /*!< StopVariable used during the stop sequence */
+  uint16_t targetRefRate;
+  /*!< Target Ambient Rate for Ref spad management */
+  FixPoint1616_t SigmaEstimate;
+  /*!< Sigma Estimate - based on ambient & VCSEL rates and
+   * signal_total_events */
+  FixPoint1616_t SignalEstimate;
+  /*!< Signal Estimate - based on ambient & VCSEL rates and cross talk */
+  FixPoint1616_t LastSignalRefMcps;
+  /*!< Latest Signal ref in Mcps */
+  uint8_t *pTuningSettingsPointer;
+  /*!< Pointer for Tuning Settings table */
+  uint8_t UseInternalTuningSettings;
+  /*!< Indicate if we use	 Tuning Settings table */
+  uint16_t LinearityCorrectiveGain;
+  /*!< Linearity Corrective Gain value in x1000 */
+  uint16_t DmaxCalRangeMilliMeter;
+  /*!< Dmax Calibration Range millimeter */
+  FixPoint1616_t DmaxCalSignalRateRtnMegaCps;
+  /*!< Dmax Calibration Signal Rate Return MegaCps */
+
+} VL53L0X_DevData_t;
+
+/** @defgroup VL53L0X_define_InterruptPolarity_group Defines the Polarity
+ * of the Interrupt
+ *	Defines the Polarity of the Interrupt
+ *	@{
+ */
+typedef uint8_t VL53L0X_InterruptPolarity;
+
+#define VL53L0X_INTERRUPTPOLARITY_LOW ((VL53L0X_InterruptPolarity)0)
+/*!< Set active low polarity best setup for falling edge. */
+#define VL53L0X_INTERRUPTPOLARITY_HIGH ((VL53L0X_InterruptPolarity)1)
+/*!< Set active high polarity best setup for rising edge. */
+
+/** @} VL53L0X_define_InterruptPolarity_group */
+
+/** @defgroup VL53L0X_define_VcselPeriod_group Vcsel Period Defines
+ *	Defines the range measurement for which to access the vcsel period.
+ *	@{
+ */
+typedef uint8_t VL53L0X_VcselPeriod;
+
+#define VL53L0X_VCSEL_PERIOD_PRE_RANGE ((VL53L0X_VcselPeriod)0)
+/*!<Identifies the pre-range vcsel period. */
+#define VL53L0X_VCSEL_PERIOD_FINAL_RANGE ((VL53L0X_VcselPeriod)1)
+/*!<Identifies the final range vcsel period. */
+
+/** @} VL53L0X_define_VcselPeriod_group */
+
+/** @defgroup VL53L0X_define_SchedulerSequence_group Defines the steps
+ * carried out by the scheduler during a range measurement.
+ *	@{
+ *	Defines the states of all the steps in the scheduler
+ *	i.e. enabled/disabled.
+ */
+typedef struct {
+  uint8_t TccOn;        /*!<Reports if Target Centre Check On  */
+  uint8_t MsrcOn;       /*!<Reports if MSRC On  */
+  uint8_t DssOn;        /*!<Reports if DSS On  */
+  uint8_t PreRangeOn;   /*!<Reports if Pre-Range On	*/
+  uint8_t FinalRangeOn; /*!<Reports if Final-Range On  */
+} VL53L0X_SchedulerSequenceSteps_t;
+
+/** @} VL53L0X_define_SchedulerSequence_group */
+
+/** @defgroup VL53L0X_define_SequenceStepId_group Defines the Polarity
+ *	of the Interrupt
+ *	Defines the the sequence steps performed during ranging..
+ *	@{
+ */
+typedef uint8_t VL53L0X_SequenceStepId;
+
+#define VL53L0X_SEQUENCESTEP_TCC ((VL53L0X_VcselPeriod)0)
+/*!<Target CentreCheck identifier. */
+#define VL53L0X_SEQUENCESTEP_DSS ((VL53L0X_VcselPeriod)1)
+/*!<Dynamic Spad Selection function Identifier. */
+#define VL53L0X_SEQUENCESTEP_MSRC ((VL53L0X_VcselPeriod)2)
+/*!<Minimum Signal Rate Check function Identifier. */
+#define VL53L0X_SEQUENCESTEP_PRE_RANGE ((VL53L0X_VcselPeriod)3)
+/*!<Pre-Range check Identifier. */
+#define VL53L0X_SEQUENCESTEP_FINAL_RANGE ((VL53L0X_VcselPeriod)4)
+/*!<Final Range Check Identifier. */
+
+#define VL53L0X_SEQUENCESTEP_NUMBER_OF_CHECKS 5
+/*!<Number of Sequence Step Managed by the API. */
+
+/** @} VL53L0X_define_SequenceStepId_group */
+
+/* MACRO Definitions */
+/** @defgroup VL53L0X_define_GeneralMacro_group General Macro Defines
+ *	General Macro Defines
+ *	@{
+ */
+
+/* Defines */
+#define VL53L0X_SETPARAMETERFIELD(Dev, field, value)                           \
+  PALDevDataSet(Dev, CurrentParameters.field, value)
+
+#define VL53L0X_GETPARAMETERFIELD(Dev, field, variable)                        \
+  variable = PALDevDataGet(Dev, CurrentParameters).field
+
+#define VL53L0X_SETARRAYPARAMETERFIELD(Dev, field, index, value)               \
+  PALDevDataSet(Dev, CurrentParameters.field[index], value)
+
+#define VL53L0X_GETARRAYPARAMETERFIELD(Dev, field, index, variable)            \
+  variable = PALDevDataGet(Dev, CurrentParameters).field[index]
+
+#define VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, field, value)                  \
+  PALDevDataSet(Dev, DeviceSpecificParameters.field, value)
+
+#define VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, field)                         \
+  PALDevDataGet(Dev, DeviceSpecificParameters).field
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT97(Value)                                \
+  (uint16_t)((Value >> 9) & 0xFFFF)
+#define VL53L0X_FIXPOINT97TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 9)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT88(Value)                                \
+  (uint16_t)((Value >> 8) & 0xFFFF)
+#define VL53L0X_FIXPOINT88TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 8)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT412(Value)                               \
+  (uint16_t)((Value >> 4) & 0xFFFF)
+#define VL53L0X_FIXPOINT412TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 4)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT313(Value)                               \
+  (uint16_t)((Value >> 3) & 0xFFFF)
+#define VL53L0X_FIXPOINT313TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 3)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT08(Value) (uint8_t)((Value >> 8) & 0x00FF)
+#define VL53L0X_FIXPOINT08TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 8)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT53(Value)                                \
+  (uint8_t)((Value >> 13) & 0x00FF)
+#define VL53L0X_FIXPOINT53TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 13)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT102(Value)                               \
+  (uint16_t)((Value >> 14) & 0x0FFF)
+#define VL53L0X_FIXPOINT102TOFIXPOINT1616(Value) (FixPoint1616_t)(Value << 12)
+
+#define VL53L0X_MAKEUINT16(lsb, msb)                                           \
+  (uint16_t)((((uint16_t)msb) << 8) + (uint16_t)lsb)
+
+/** @} VL53L0X_define_GeneralMacro_group */
+
+/** @} VL53L0X_globaldefine_group */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_DEF_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_device.h

@@ -0,0 +1,243 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+/**
+ * Device specific defines. To be adapted by implementer for the targeted
+ * device.
+ */
+
+#ifndef _VL53L0X_DEVICE_H_
+#define _VL53L0X_DEVICE_H_
+
+#include "vl53l0x_types.h"
+
+/** @defgroup VL53L0X_DevSpecDefines_group VL53L0X cut1.1 Device Specific
+ * Defines
+ *  @brief VL53L0X cut1.1 Device Specific Defines
+ *  @{
+ */
+
+/** @defgroup VL53L0X_DeviceError_group Device Error
+ *  @brief Device Error code
+ *
+ *  This enum is Device specific it should be updated in the implementation
+ *  Use @a VL53L0X_GetStatusErrorString() to get the string.
+ *  It is related to Status Register of the Device.
+ *  @{
+ */
+typedef uint8_t VL53L0X_DeviceError;
+
+#define VL53L0X_DEVICEERROR_NONE ((VL53L0X_DeviceError)0)
+/*!< 0  NoError  */
+#define VL53L0X_DEVICEERROR_VCSELCONTINUITYTESTFAILURE ((VL53L0X_DeviceError)1)
+#define VL53L0X_DEVICEERROR_VCSELWATCHDOGTESTFAILURE ((VL53L0X_DeviceError)2)
+#define VL53L0X_DEVICEERROR_NOVHVVALUEFOUND ((VL53L0X_DeviceError)3)
+#define VL53L0X_DEVICEERROR_MSRCNOTARGET ((VL53L0X_DeviceError)4)
+#define VL53L0X_DEVICEERROR_SNRCHECK ((VL53L0X_DeviceError)5)
+#define VL53L0X_DEVICEERROR_RANGEPHASECHECK ((VL53L0X_DeviceError)6)
+#define VL53L0X_DEVICEERROR_SIGMATHRESHOLDCHECK ((VL53L0X_DeviceError)7)
+#define VL53L0X_DEVICEERROR_TCC ((VL53L0X_DeviceError)8)
+#define VL53L0X_DEVICEERROR_PHASECONSISTENCY ((VL53L0X_DeviceError)9)
+#define VL53L0X_DEVICEERROR_MINCLIP ((VL53L0X_DeviceError)10)
+#define VL53L0X_DEVICEERROR_RANGECOMPLETE ((VL53L0X_DeviceError)11)
+#define VL53L0X_DEVICEERROR_ALGOUNDERFLOW ((VL53L0X_DeviceError)12)
+#define VL53L0X_DEVICEERROR_ALGOOVERFLOW ((VL53L0X_DeviceError)13)
+#define VL53L0X_DEVICEERROR_RANGEIGNORETHRESHOLD ((VL53L0X_DeviceError)14)
+
+/** @} end of VL53L0X_DeviceError_group */
+
+/** @defgroup VL53L0X_CheckEnable_group Check Enable list
+ *  @brief Check Enable code
+ *
+ *  Define used to specify the LimitCheckId.
+ *  Use @a VL53L0X_GetLimitCheckInfo() to get the string.
+ *  @{
+ */
+
+#define VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE 0
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE 1
+#define VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP 2
+#define VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD 3
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC 4
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE 5
+
+#define VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS 6
+
+/** @}  end of VL53L0X_CheckEnable_group */
+
+/** @defgroup VL53L0X_GpioFunctionality_group Gpio Functionality
+ *  @brief Defines the different functionalities for the device GPIO(s)
+ *  @{
+ */
+typedef uint8_t VL53L0X_GpioFunctionality;
+
+#define VL53L0X_GPIOFUNCTIONALITY_OFF                                          \
+  ((VL53L0X_GpioFunctionality)0) /*!< NO Interrupt  */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW                        \
+  ((VL53L0X_GpioFunctionality)1) /*!< Level Low (value < thresh_low)  */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH                       \
+  ((VL53L0X_GpioFunctionality)2) /*!< Level High (value > thresh_high) */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT                        \
+  ((VL53L0X_GpioFunctionality)3)
+/*!< Out Of Window (value < thresh_low OR value > thresh_high)  */
+#define VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY                            \
+  ((VL53L0X_GpioFunctionality)4) /*!< New Sample Ready  */
+
+/** @} end of VL53L0X_GpioFunctionality_group */
+
+/* Device register map */
+
+/** @defgroup VL53L0X_DefineRegisters_group Define Registers
+ *  @brief List of all the defined registers
+ *  @{
+ */
+#define VL53L0X_REG_SYSRANGE_START 0x000
+/** mask existing bit in #VL53L0X_REG_SYSRANGE_START*/
+#define VL53L0X_REG_SYSRANGE_MODE_MASK 0x0F
+/** bit 0 in #VL53L0X_REG_SYSRANGE_START write 1 toggle state in
+ * continuous mode and arm next shot in single shot mode */
+#define VL53L0X_REG_SYSRANGE_MODE_START_STOP 0x01
+/** bit 1 write 0 in #VL53L0X_REG_SYSRANGE_START set single shot mode */
+#define VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT 0x00
+/** bit 1 write 1 in #VL53L0X_REG_SYSRANGE_START set back-to-back
+ *  operation mode */
+#define VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK 0x02
+/** bit 2 write 1 in #VL53L0X_REG_SYSRANGE_START set timed operation
+ *  mode */
+#define VL53L0X_REG_SYSRANGE_MODE_TIMED 0x04
+/** bit 3 write 1 in #VL53L0X_REG_SYSRANGE_START set histogram operation
+ *  mode */
+#define VL53L0X_REG_SYSRANGE_MODE_HISTOGRAM 0x08
+
+#define VL53L0X_REG_SYSTEM_THRESH_HIGH 0x000C
+#define VL53L0X_REG_SYSTEM_THRESH_LOW 0x000E
+
+#define VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG 0x0001
+#define VL53L0X_REG_SYSTEM_RANGE_CONFIG 0x0009
+#define VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD 0x0004
+
+#define VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO 0x000A
+#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED 0x00
+#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_LOW 0x01
+#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH 0x02
+#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW 0x03
+#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY 0x04
+
+#define VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH 0x0084
+
+#define VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR 0x000B
+
+/* Result registers */
+#define VL53L0X_REG_RESULT_INTERRUPT_STATUS 0x0013
+#define VL53L0X_REG_RESULT_RANGE_STATUS 0x0014
+
+#define VL53L0X_REG_RESULT_CORE_PAGE 1
+#define VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN 0x00BC
+#define VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_RTN 0x00C0
+#define VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF 0x00D0
+#define VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_REF 0x00D4
+#define VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF 0x00B6
+
+/* Algo register */
+
+#define VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM 0x0028
+
+#define VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS 0x008a
+
+/* Check Limit registers */
+#define VL53L0X_REG_MSRC_CONFIG_CONTROL 0x0060
+
+#define VL53L0X_REG_PRE_RANGE_CONFIG_MIN_SNR 0X0027
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW 0x0056
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH 0x0057
+#define VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT 0x0064
+
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_SNR 0X0067
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW 0x0047
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH 0x0048
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT 0x0044
+
+#define VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_HI 0X0061
+#define VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_LO 0X0062
+
+/* PRE RANGE registers */
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD 0x0050
+#define VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI 0x0051
+#define VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO 0x0052
+
+#define VL53L0X_REG_SYSTEM_HISTOGRAM_BIN 0x0081
+#define VL53L0X_REG_HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT 0x0033
+#define VL53L0X_REG_HISTOGRAM_CONFIG_READOUT_CTRL 0x0055
+
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD 0x0070
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI 0x0071
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO 0x0072
+#define VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS 0x0020
+
+#define VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP 0x0046
+
+#define VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N 0x00bf
+#define VL53L0X_REG_IDENTIFICATION_MODEL_ID 0x00c0
+#define VL53L0X_REG_IDENTIFICATION_REVISION_ID 0x00c2
+
+#define VL53L0X_REG_OSC_CALIBRATE_VAL 0x00f8
+
+#define VL53L0X_SIGMA_ESTIMATE_MAX_VALUE 65535
+/* equivalent to a range sigma of 655.35mm */
+
+#define VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH 0x032
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 0x0B0
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_1 0x0B1
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_2 0x0B2
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_3 0x0B3
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_4 0x0B4
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_5 0x0B5
+
+#define VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT 0xB6
+#define VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD 0x4E /* 0x14E */
+#define VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET 0x4F    /* 0x14F */
+#define VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE 0x80
+
+/*
+ * Speed of light in um per 1E-10 Seconds
+ */
+
+#define VL53L0X_SPEED_OF_LIGHT_IN_AIR 2997
+
+#define VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV 0x0089
+
+#define VL53L0X_REG_ALGO_PHASECAL_LIM 0x0030 /* 0x130 */
+#define VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT 0x0030
+
+/** @} VL53L0X_DefineRegisters_group */
+
+/** @} VL53L0X_DevSpecDefines_group */
+
+#endif
+
+/* _VL53L0X_DEVICE_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_i2c_platform.h

@@ -0,0 +1,21 @@
+#include "Arduino.h"
+#include "Wire.h"
+
+// initialize I2C
+int VL53L0X_i2c_init(TwoWire *i2c);
+int VL53L0X_write_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata,
+                        uint32_t count, TwoWire *i2c);
+int VL53L0X_read_multi(uint8_t deviceAddress, uint8_t index, uint8_t *pdata,
+                       uint32_t count, TwoWire *i2c);
+int VL53L0X_write_byte(uint8_t deviceAddress, uint8_t index, uint8_t data,
+                       TwoWire *i2c);
+int VL53L0X_write_word(uint8_t deviceAddress, uint8_t index, uint16_t data,
+                       TwoWire *i2c);
+int VL53L0X_write_dword(uint8_t deviceAddress, uint8_t index, uint32_t data,
+                        TwoWire *i2c);
+int VL53L0X_read_byte(uint8_t deviceAddress, uint8_t index, uint8_t *data,
+                      TwoWire *i2c);
+int VL53L0X_read_word(uint8_t deviceAddress, uint8_t index, uint16_t *data,
+                      TwoWire *i2c);
+int VL53L0X_read_dword(uint8_t deviceAddress, uint8_t index, uint32_t *data,
+                       TwoWire *i2c);

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_interrupt_threshold_settings.h

@@ -0,0 +1,81 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of STMicroelectronics nor the
+          names of its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_
+#define _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint8_t InterruptThresholdSettings[] = {
+
+    /* Start of Interrupt Threshold Settings */
+    0x1, 0xff, 0x00, 0x1,  0x80, 0x01, 0x1, 0xff, 0x01, 0x1, 0x00, 0x00,
+    0x1, 0xff, 0x01, 0x1,  0x4f, 0x02, 0x1, 0xFF, 0x0E, 0x1, 0x00, 0x03,
+    0x1, 0x01, 0x84, 0x1,  0x02, 0x0A, 0x1, 0x03, 0x03, 0x1, 0x04, 0x08,
+    0x1, 0x05, 0xC8, 0x1,  0x06, 0x03, 0x1, 0x07, 0x8D, 0x1, 0x08, 0x08,
+    0x1, 0x09, 0xC6, 0x1,  0x0A, 0x01, 0x1, 0x0B, 0x02, 0x1, 0x0C, 0x00,
+    0x1, 0x0D, 0xD5, 0x1,  0x0E, 0x18, 0x1, 0x0F, 0x12, 0x1, 0x10, 0x01,
+    0x1, 0x11, 0x82, 0x1,  0x12, 0x00, 0x1, 0x13, 0xD5, 0x1, 0x14, 0x18,
+    0x1, 0x15, 0x13, 0x1,  0x16, 0x03, 0x1, 0x17, 0x86, 0x1, 0x18, 0x0A,
+    0x1, 0x19, 0x09, 0x1,  0x1A, 0x08, 0x1, 0x1B, 0xC2, 0x1, 0x1C, 0x03,
+    0x1, 0x1D, 0x8F, 0x1,  0x1E, 0x0A, 0x1, 0x1F, 0x06, 0x1, 0x20, 0x01,
+    0x1, 0x21, 0x02, 0x1,  0x22, 0x00, 0x1, 0x23, 0xD5, 0x1, 0x24, 0x18,
+    0x1, 0x25, 0x22, 0x1,  0x26, 0x01, 0x1, 0x27, 0x82, 0x1, 0x28, 0x00,
+    0x1, 0x29, 0xD5, 0x1,  0x2A, 0x18, 0x1, 0x2B, 0x0B, 0x1, 0x2C, 0x28,
+    0x1, 0x2D, 0x78, 0x1,  0x2E, 0x28, 0x1, 0x2F, 0x91, 0x1, 0x30, 0x00,
+    0x1, 0x31, 0x0B, 0x1,  0x32, 0x00, 0x1, 0x33, 0x0B, 0x1, 0x34, 0x00,
+    0x1, 0x35, 0xA1, 0x1,  0x36, 0x00, 0x1, 0x37, 0xA0, 0x1, 0x38, 0x00,
+    0x1, 0x39, 0x04, 0x1,  0x3A, 0x28, 0x1, 0x3B, 0x30, 0x1, 0x3C, 0x0C,
+    0x1, 0x3D, 0x04, 0x1,  0x3E, 0x0F, 0x1, 0x3F, 0x79, 0x1, 0x40, 0x28,
+    0x1, 0x41, 0x1E, 0x1,  0x42, 0x2F, 0x1, 0x43, 0x87, 0x1, 0x44, 0x00,
+    0x1, 0x45, 0x0B, 0x1,  0x46, 0x00, 0x1, 0x47, 0x0B, 0x1, 0x48, 0x00,
+    0x1, 0x49, 0xA7, 0x1,  0x4A, 0x00, 0x1, 0x4B, 0xA6, 0x1, 0x4C, 0x00,
+    0x1, 0x4D, 0x04, 0x1,  0x4E, 0x01, 0x1, 0x4F, 0x00, 0x1, 0x50, 0x00,
+    0x1, 0x51, 0x80, 0x1,  0x52, 0x09, 0x1, 0x53, 0x08, 0x1, 0x54, 0x01,
+    0x1, 0x55, 0x00, 0x1,  0x56, 0x0F, 0x1, 0x57, 0x79, 0x1, 0x58, 0x09,
+    0x1, 0x59, 0x05, 0x1,  0x5A, 0x00, 0x1, 0x5B, 0x60, 0x1, 0x5C, 0x05,
+    0x1, 0x5D, 0xD1, 0x1,  0x5E, 0x0C, 0x1, 0x5F, 0x3C, 0x1, 0x60, 0x00,
+    0x1, 0x61, 0xD0, 0x1,  0x62, 0x0B, 0x1, 0x63, 0x03, 0x1, 0x64, 0x28,
+    0x1, 0x65, 0x10, 0x1,  0x66, 0x2A, 0x1, 0x67, 0x39, 0x1, 0x68, 0x0B,
+    0x1, 0x69, 0x02, 0x1,  0x6A, 0x28, 0x1, 0x6B, 0x10, 0x1, 0x6C, 0x2A,
+    0x1, 0x6D, 0x61, 0x1,  0x6E, 0x0C, 0x1, 0x6F, 0x00, 0x1, 0x70, 0x0F,
+    0x1, 0x71, 0x79, 0x1,  0x72, 0x00, 0x1, 0x73, 0x0B, 0x1, 0x74, 0x00,
+    0x1, 0x75, 0x0B, 0x1,  0x76, 0x00, 0x1, 0x77, 0xA1, 0x1, 0x78, 0x00,
+    0x1, 0x79, 0xA0, 0x1,  0x7A, 0x00, 0x1, 0x7B, 0x04, 0x1, 0xFF, 0x04,
+    0x1, 0x79, 0x1D, 0x1,  0x7B, 0x27, 0x1, 0x96, 0x0E, 0x1, 0x97, 0xFE,
+    0x1, 0x98, 0x03, 0x1,  0x99, 0xEF, 0x1, 0x9A, 0x02, 0x1, 0x9B, 0x44,
+    0x1, 0x73, 0x07, 0x1,  0x70, 0x01, 0x1, 0xff, 0x01, 0x1, 0x00, 0x01,
+    0x1, 0xff, 0x00, 0x00, 0x00, 0x00};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_platform.h

@@ -0,0 +1,247 @@
+/*******************************************************************************
+Copyright 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+
+#ifndef _VL53L0X_PLATFORM_H_
+#define _VL53L0X_PLATFORM_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_i2c_platform.h"
+#include "vl53l0x_platform_log.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file vl53l0_platform.h
+ *
+ * @brief All end user OS/platform/application porting
+ */
+
+/**
+ * @defgroup VL53L0X_platform_group VL53L0 Platform Functions
+ * @brief    VL53L0 Platform Functions
+ *  @{
+ */
+
+/**
+ * @struct  VL53L0X_Dev_t
+ * @brief    Generic PAL device type that does link between API and platform
+ * abstraction layer
+ *
+ */
+typedef struct {
+  VL53L0X_DevData_t Data; /*!< embed ST Ewok Dev  data as "Data"*/
+
+  /*!< user specific field */
+  uint8_t I2cDevAddr; /*!< i2c device address user specific field */
+  uint8_t
+      comms_type; /*!< Type of comms : VL53L0X_COMMS_I2C or VL53L0X_COMMS_SPI */
+  uint16_t comms_speed_khz; /*!< Comms speed [kHz] : typically 400kHz for I2C */
+
+  TwoWire *i2c;
+
+} VL53L0X_Dev_t;
+
+/**
+ * @brief   Declare the device Handle as a pointer of the structure @a
+ * VL53L0X_Dev_t.
+ *
+ */
+typedef VL53L0X_Dev_t *VL53L0X_DEV;
+
+/**
+ * @def PALDevDataGet
+ * @brief Get ST private structure @a VL53L0X_DevData_t data access
+ *
+ * @param Dev       Device Handle
+ * @param field     ST structure field name
+ * It maybe used and as real data "ref" not just as "get" for sub-structure item
+ * like PALDevDataGet(FilterData.field)[i] or
+ * PALDevDataGet(FilterData.MeasurementIndex)++
+ */
+#define PALDevDataGet(Dev, field) (Dev->Data.field)
+
+/**
+ * @def PALDevDataSet(Dev, field, data)
+ * @brief  Set ST private structure @a VL53L0X_DevData_t data field
+ * @param Dev       Device Handle
+ * @param field     ST structure field name
+ * @param data      Data to be set
+ */
+#define PALDevDataSet(Dev, field, data) (Dev->Data.field) = (data)
+
+/**
+ * @defgroup VL53L0X_registerAccess_group PAL Register Access Functions
+ * @brief    PAL Register Access Functions
+ *  @{
+ */
+
+/**
+ * Lock comms interface to serialize all commands to a shared I2C interface for
+ * a specific device
+ * @param   Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_LockSequenceAccess(VL53L0X_DEV Dev);
+
+/**
+ * Unlock comms interface to serialize all commands to a shared I2C interface
+ * for a specific device
+ * @param   Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_UnlockSequenceAccess(VL53L0X_DEV Dev);
+
+/**
+ * Writes the supplied byte buffer to the device
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   pdata     Pointer to uint8_t buffer containing the data to be
+ * written
+ * @param   count     Number of bytes in the supplied byte buffer
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
+                                 uint32_t count);
+
+/**
+ * Reads the requested number of bytes from the device
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   pdata     Pointer to the uint8_t buffer to store read data
+ * @param   count     Number of uint8_t's to read
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata,
+                                uint32_t count);
+
+/**
+ * Write single byte register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      8 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data);
+
+/**
+ * Write word register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      16 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data);
+
+/**
+ * Write double word (4 byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      32 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data);
+
+/**
+ * Read single byte register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 8 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data);
+
+/**
+ * Read word (2byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 16 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data);
+
+/**
+ * Read dword (4byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 32 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data);
+
+/**
+ * Threat safe Update (read/modify/write) single byte register
+ *
+ * Final_reg = (Initial_reg & and_data) |or_data
+ *
+ * @param   Dev        Device Handle
+ * @param   index      The register index
+ * @param   AndData    8 bit and data
+ * @param   OrData     8 bit or data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index,
+                                 uint8_t AndData, uint8_t OrData);
+
+/** @} end of VL53L0X_registerAccess_group */
+
+/**
+ * @brief execute delay in all polling API call
+ *
+ * A typical multi-thread or RTOs implementation is to sleep the task for some
+ * 5ms (with 100Hz max rate faster polling is not needed) if nothing specific is
+ * need you can define it as an empty/void macro
+ * @code
+ * #define VL53L0X_PollingDelay(...) (void)0
+ * @endcode
+ * @param Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_PollingDelay(
+    VL53L0X_DEV Dev); /* usually best implemented as a real function */
+
+/** @} end of VL53L0X_platform_group */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_PLATFORM_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_platform_log.h

@@ -0,0 +1,119 @@
+/*******************************************************************************
+Copyright 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+
+#ifndef _VL53L0X_PLATFORM_LOG_H_
+#define _VL53L0X_PLATFORM_LOG_H_
+
+#include <stdio.h>
+#include <string.h>
+/* LOG Functions */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file vl53l0_platform_log.h
+ *
+ * @brief platform log function definition
+ */
+
+//#define VL53L0X_LOG_ENABLE 0
+
+enum {
+  TRACE_LEVEL_NONE,
+  TRACE_LEVEL_ERRORS,
+  TRACE_LEVEL_WARNING,
+  TRACE_LEVEL_INFO,
+  TRACE_LEVEL_DEBUG,
+  TRACE_LEVEL_ALL,
+  TRACE_LEVEL_IGNORE
+};
+
+enum {
+  TRACE_FUNCTION_NONE = 0,
+  TRACE_FUNCTION_I2C = 1,
+  TRACE_FUNCTION_ALL = 0x7fffffff // all bits except sign
+};
+
+enum {
+  TRACE_MODULE_NONE = 0x0,
+  TRACE_MODULE_API = 0x1,
+  TRACE_MODULE_PLATFORM = 0x2,
+  TRACE_MODULE_ALL = 0x7fffffff // all bits except sign
+};
+
+#ifdef VL53L0X_LOG_ENABLE
+
+#include <sys/time.h>
+
+extern uint32_t _trace_level;
+
+int32_t VL53L0X_trace_config(char *filename, uint32_t modules, uint32_t level,
+                             uint32_t functions);
+
+void trace_print_module_function(uint32_t module, uint32_t level,
+                                 uint32_t function, const char *format, ...);
+
+// extern FILE * log_file;
+
+#define LOG_GET_TIME() (int)clock()
+
+#define _LOG_FUNCTION_START(module, fmt, ...)                                  \
+  trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL,        \
+                              "%ld <START> %s " fmt "\n", LOG_GET_TIME(),      \
+                              __FUNCTION__, ##__VA_ARGS__);
+
+#define _LOG_FUNCTION_END(module, status, ...)                                 \
+  trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL,        \
+                              "%ld <END> %s %d\n", LOG_GET_TIME(),             \
+                              __FUNCTION__, (int)status, ##__VA_ARGS__)
+
+#define _LOG_FUNCTION_END_FMT(module, status, fmt, ...)                        \
+  trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL,        \
+                              "%ld <END> %s %d " fmt "\n", LOG_GET_TIME(),     \
+                              __FUNCTION__, (int)status, ##__VA_ARGS__)
+
+// __func__ is gcc only
+//#define VL53L0X_ErrLog( fmt, ...)  fprintf(stderr, "VL53L0X_ErrLog %s" fmt
+//"\n", __func__, ##__VA_ARGS__)
+
+#else /* VL53L0X_LOG_ENABLE no logging */
+#define VL53L0X_ErrLog(...) (void)0
+#define _LOG_FUNCTION_START(module, fmt, ...) (void)0
+#define _LOG_FUNCTION_END(module, status, ...) (void)0
+#define _LOG_FUNCTION_END_FMT(module, status, fmt, ...) (void)0
+#endif /* else */
+
+#define VL53L0X_COPYSTRING(str, ...) strcpy(str, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_PLATFORM_LOG_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_tuning.h

@@ -0,0 +1,87 @@
+/*******************************************************************************
+Copyright 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above copyright
+          notice, this list of conditions and the following disclaimer in the
+          documentation and/or other materials provided with the distribution.
+        * Neither the name of STMicroelectronics nor the
+          names of its contributors may be used to endorse or promote products
+          derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_TUNING_H_
+#define _VL53L0X_TUNING_H_
+
+#include "vl53l0x_def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+uint8_t DefaultTuningSettings[] = {
+
+    /* update 02/11/2015_v36 */
+    0x01, 0xFF, 0x01, 0x01, 0x00, 0x00,
+
+    0x01, 0xFF, 0x00, 0x01, 0x09, 0x00, 0x01, 0x10, 0x00, 0x01, 0x11, 0x00,
+
+    0x01, 0x24, 0x01, 0x01, 0x25, 0xff, 0x01, 0x75, 0x00,
+
+    0x01, 0xFF, 0x01, 0x01, 0x4e, 0x2c, 0x01, 0x48, 0x00, 0x01, 0x30, 0x20,
+
+    0x01, 0xFF, 0x00, 0x01, 0x30, 0x09, /* mja changed from 0x64. */
+    0x01, 0x54, 0x00, 0x01, 0x31, 0x04, 0x01, 0x32, 0x03, 0x01, 0x40, 0x83,
+    0x01, 0x46, 0x25, 0x01, 0x60, 0x00, 0x01, 0x27, 0x00, 0x01, 0x50, 0x06,
+    0x01, 0x51, 0x00, 0x01, 0x52, 0x96, 0x01, 0x56, 0x08, 0x01, 0x57, 0x30,
+    0x01, 0x61, 0x00, 0x01, 0x62, 0x00, 0x01, 0x64, 0x00, 0x01, 0x65, 0x00,
+    0x01, 0x66, 0xa0,
+
+    0x01, 0xFF, 0x01, 0x01, 0x22, 0x32, 0x01, 0x47, 0x14, 0x01, 0x49, 0xff,
+    0x01, 0x4a, 0x00,
+
+    0x01, 0xFF, 0x00, 0x01, 0x7a, 0x0a, 0x01, 0x7b, 0x00, 0x01, 0x78, 0x21,
+
+    0x01, 0xFF, 0x01, 0x01, 0x23, 0x34, 0x01, 0x42, 0x00, 0x01, 0x44, 0xff,
+    0x01, 0x45, 0x26, 0x01, 0x46, 0x05, 0x01, 0x40, 0x40, 0x01, 0x0E, 0x06,
+    0x01, 0x20, 0x1a, 0x01, 0x43, 0x40,
+
+    0x01, 0xFF, 0x00, 0x01, 0x34, 0x03, 0x01, 0x35, 0x44,
+
+    0x01, 0xFF, 0x01, 0x01, 0x31, 0x04, 0x01, 0x4b, 0x09, 0x01, 0x4c, 0x05,
+    0x01, 0x4d, 0x04,
+
+    0x01, 0xFF, 0x00, 0x01, 0x44, 0x00, 0x01, 0x45, 0x20, 0x01, 0x47, 0x08,
+    0x01, 0x48, 0x28, 0x01, 0x67, 0x00, 0x01, 0x70, 0x04, 0x01, 0x71, 0x01,
+    0x01, 0x72, 0xfe, 0x01, 0x76, 0x00, 0x01, 0x77, 0x00,
+
+    0x01, 0xFF, 0x01, 0x01, 0x0d, 0x01,
+
+    0x01, 0xFF, 0x00, 0x01, 0x80, 0x01, 0x01, 0x01, 0xF8,
+
+    0x01, 0xFF, 0x01, 0x01, 0x8e, 0x01, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x00,
+    0x01, 0x80, 0x00,
+
+    0x00, 0x00, 0x00};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_TUNING_H_ */

code/lib/Adafruit_VL53L0X-1.2.3/src/vl53l0x_types.h

@@ -0,0 +1,111 @@
+/*******************************************************************************
+Copyright 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+/**
+ * @file  vl53l0_types.h
+ * @brief VL53L0 types definition
+ */
+
+#ifndef VL53L0X_TYPES_H_
+#define VL53L0X_TYPES_H_
+
+/** @defgroup porting_type  Basic type definition
+ *  @ingroup  VL53L0X_platform_group
+ *
+ *  @brief  file vl53l0_types.h files hold basic type definition that may
+ * requires porting
+ *
+ *  contains type that must be defined for the platform\n
+ *  when target platform and compiler provide stdint.h and stddef.h it is enough
+ * to include it.\n If stdint.h is not available review and adapt all signed and
+ * unsigned 8/16/32 bits basic types. \n If stddef.h is not available review and
+ * adapt NULL definition .
+ */
+#include <stddef.h>
+#include <stdint.h>
+
+#ifndef NULL
+#error "Error NULL definition should be done. Please add required include "
+#endif
+
+#if !defined(STDINT_H) && !defined(_STDINT_H) && !defined(_GCC_STDINT_H) &&    \
+    !defined(__STDINT_DECLS) && !defined(_GCC_WRAP_STDINT_H)
+
+#pragma message(                                                               \
+    "Please review  type definition of STDINT define for your platform and add to list above ")
+
+/*
+ *  target platform do not provide stdint or use a different #define than above
+ *  to avoid seeing the message below adapt the #define list above or implement
+ *  all type and delete these pragma
+ */
+
+/** \ingroup VL53L0X_portingType_group
+ * @{
+ */
+
+typedef unsigned long long uint64_t;
+
+/** @brief Typedef defining 32 bit unsigned int type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned int uint32_t;
+
+/** @brief Typedef defining 32 bit int type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef int int32_t;
+
+/** @brief Typedef defining 16 bit unsigned short type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned short uint16_t;
+
+/** @brief Typedef defining 16 bit short type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef short int16_t;
+
+/** @brief Typedef defining 8 bit unsigned char type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned char uint8_t;
+
+/** @brief Typedef defining 8 bit char type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef signed char int8_t;
+
+/** @}  */
+#endif /* _STDINT_H */
+
+/** use where fractional values are expected
+ *
+ * Given a floating point value f it's .16 bit point is (int)(f*(1<<16))*/
+typedef uint32_t FixPoint1616_t;
+
+#endif /* VL53L0X_TYPES_H_ */