Revision 0:1c8c01640f54, committed 2019-10-01

Comitter:

deepanaishtaweera174

Date:

Tue Oct 01 12:33:27 2019 +0000

Commit message:

hey

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.travis.yml	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,21 @@
+python:
+  - "2.7"
+
+before_install:
+  - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
+  - sudo apt-get update -qq
+  - sudo apt-get install -qq gcc-arm-none-eabi --force-yes
+  # Print versions we use
+  - arm-none-eabi-gcc --version
+  - python --version
+
+install:
+  - sudo pip install mbed-cli
+
+env:
+  - TARGET=NUCLEO_F411RE
+  - TOOLCHAIN=GCC_ARM
+
+script:
+  - mbed deploy
+  - mbed compile --library --target ${TARGET} --toolchain ${TOOLCHAIN}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LICENSE.txt	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,95 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Daisuke Baba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+=================================================================
+
+Copyright (c) 2016 Pololu Corporation.  For more information, see
+
+https://www.pololu.com/
+https://forum.pololu.com/
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+=================================================================
+
+Most of the functionality of this library is based on the VL53L0X
+API provided by ST (STSW-IMG005), and some of the explanatory
+comments are quoted or paraphrased from the API source code, API
+user manual (UM2039), and the VL53L0X datasheet.
+
+The following applies to source code reproduced or derived from
+the API:
+
+-----------------------------------------------------------------
+
+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.
+
+-----------------------------------------------------------------

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,13 @@
+TARGET ?= NUCLEO_F411RE
+TOOLCHAIN ?= GCC_ARM
+
+.PHONY: all
+
+all:
+	mbed compile --library -m $(TARGET) -t $(TOOLCHAIN)
+
+debug:
+	mbed compile --library --options debug-info -m $(TARGET) -t $(TOOLCHAIN)
+
+clean-build:
+	mbed -c compile --library -m $(TARGET) -t $(TOOLCHAIN)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/README.md	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,155 @@
+# VL53L0X library for mbed OS 5
+
+[![GitHub release](https://img.shields.io/github/release/dbaba/vl53l0x-mbedos.svg)](https://github.com/dbaba/vl53l0x-mbedos/releases/latest)
+[![Build Status](https://travis-ci.org/dbaba/vl53l0x-mbedos.svg?branch=master)](https://travis-ci.org/dbaba/vl53l0x-mbedos)
+
+## Summary
+
+This is a library for mbed OS that helps interface with ST's [VL53L0X time-of-flight distance sensor](https://www.pololu.com/product/2490). The library makes it simple to configure the sensor and read range data from it via I²C.
+
+This project is a fork of [www.pololu.com](https://www.pololu.com/)'s [vl53l0x-arduino](https://github.com/pololu/vl53l0x-arduino).
+
+## Supported platforms
+
+This library is designed to work with the mbed-cli v0.9.1 or later.  This library should support any mbed enabled board with mbed OS 5.
+
+## Getting started
+
+### Hardware
+
+A [VL53L0X carrier](https://www.pololu.com/product/2490) can be purchased from Pololu's website.  Before continuing, careful reading of the [product page](https://www.pololu.com/product/2490) as well as the VL53L0X datasheet is recommended.
+
+Make the following connections between the mbed and the VL53L0X board:
+
+#### mbed boards with [pololu VL53L0X board](https://www.pololu.com/product/2490)
+
+* internal pull-up resistors are implemented
+
+
+    mbed      VL53L0X board
+    -------   -------------
+        3V3 - VDD
+        GND - GND
+        SDA - SDA
+        SCL - SCL
+
+#### mbed boards with ST VL53L0X
+
+e.g. [53L0-SATEL-I1](http://www.st.com/content/st_com/en/products/evaluation-tools/product-evaluation-tools/proximity-sensors-and-imaging-ics-eval-boards/53l0-satel-i1.html)
+
+    mbed      VL53L0X / 53L0-SATEL-I1
+    -------   -------------
+        3V3 -+--+- VDD
+             |  |
+           <4K7>|
+             |<4K7>
+             |  |
+        SDA -+--|- SDA
+        SCL ----+- SCL
+        GND ------ GND
+
+### Software
+
+Use [`mbed-cli`](https://github.com/ARMmbed/mbed-cli) to install this library.
+
+```
+mbed add https://github.com/dbaba/vl53l0x-mbedos
+```
+
+## ST's VL53L0X API and this library
+
+Most of the functionality of this library is based on the [VL53L0X API](http://www.st.com/content/st_com/en/products/embedded-software/proximity-sensors-software/stsw-img005.html) provided by ST (STSW-IMG005), and some of the explanatory comments in the code are quoted or paraphrased from the API source code, API user manual (UM2039), and the VL53L0X datasheet. For more explanation about the library code and how it was derived from the API, see the comments in VL53L0X.cpp.
+
+This library is intended to provide a quicker and easier way to get started using the VL53L0X with an Arduino-compatible controller, in contrast to customizing and compiling ST's API for the Arduino. The library has a more streamlined interface, as well as smaller storage and memory footprints. However, it does not implement some of the more advanced functionality available in the API (for example, calibrating the sensor to work well under a cover glass), and it has less robust error checking. For advanced applications, especially when storage and memory are less of an issue, consider using the VL53L0X API directly.
+
+## Library reference
+
+* `uint8_t last_status`<br>
+  The status of the last I&sup2;C write transmission. See the [`Wire.endTransmission()` documentation](http://arduino.cc/en/Reference/WireEndTransmission) for return values.
+
+* `VL53L0X(void)`<br>
+  Constructor.
+
+* `void setAddress(uint8_t new_addr)`<br>
+  Changes the I&sup2;C slave device address of the VL53L0X to the given value (7-bit).
+
+* `uint8_t getAddress(void)`<br>
+  Returns the current I&sup2;C address.
+
+* `bool init(bool io_2v8 = true)`<br>
+  Iniitializes and configures the sensor. If the optional argument `io_2v8` is true (the default if not specified), the sensor is configured for 2V8 mode (2.8 V I/O); if false, the sensor is left in 1V8 mode. The return value is a boolean indicating whether the initialization completed successfully.
+
+* `void writeReg(uint8_t reg, uint8_t value)`<br>
+  Writes an 8-bit sensor register with the given value.
+
+  Register address constants are defined by the regAddr enumeration type in VL53L0X.h.<br>
+  Example use: `sensor.writeReg(VL53L0X::SYSRANGE_START, 0x01);`
+
+* `void writeReg16Bit(uint8_t reg, uint16_t value)`<br>
+  Writes a 16-bit sensor register with the given value.
+
+* `void writeReg32Bit(uint8_t reg, uint32_t value)`<br>
+  Writes a 32-bit sensor register with the given value.
+
+* `uint8_t readReg(uint8_t reg)`<br>
+  Reads an 8-bit sensor register and returns the value read.
+
+* `uint16_t readReg16Bit(uint8_t reg)`<br>
+  Reads a 16-bit sensor register and returns the value read.
+
+* `uint32_t readReg32Bit(uint8_t reg)`<br>
+  Reads a 32-bit sensor register and returns the value read.
+
+* `void writeMulti(uint8_t reg, uint8_t const * src, uint8_t count)`<br>
+  Writes an arbitrary number of bytes from the given array to the sensor, starting at the given register.
+
+* `void readMulti(uint8_t reg, uint8_t * dst, uint8_t count)`<br>
+  Reads an arbitrary number of bytes from the sensor, starting at the given register, into the given array.
+
+* `bool setSignalRateLimit(float limit_Mcps)`<br>
+  Sets the return signal rate limit to the given value in units of MCPS (mega counts per second). This is the minimum amplitude of the signal reflected from the target and received by the sensor necessary for it to report a valid reading. Setting a lower limit increases the potential range of the sensor but also increases the likelihood of getting an inaccurate reading because of reflections from objects other than the intended target. This limit is initialized to 0.25 MCPS by default. The return value is a boolean indicating whether the requested limit was valid.
+
+* `float getSignalRateLimit(void)`<br>
+  Returns the current return signal rate limit in MCPS.
+
+* `bool setMeasurementTimingBudget(uint32_t budget_us)`<br>
+  Sets the measurement timing budget to the given value in microseconds. This is the time allowed for one range measurement; a longer timing budget allows for more accurate measurements. The default budget is about 33000 microseconds, or 33 ms; the minimum is 20 ms. The return value is a boolean indicating whether the requested budget was valid.
+
+* `uint32_t getMeasurementTimingBudget(void)`<br>
+  Returns the current measurement timing budget in microseconds.
+
+* `bool setVcselPulsePeriod(vcselPeriodType type, uint8_t period_pclks)`
+  Sets the VCSEL (vertical cavity surface emitting laser) pulse period for the given period type (`VL53L0X::VcselPeriodPreRange` or `VL53L0X::VcselPeriodFinalRange`) to the given value (in PCLKs). Longer periods increase the potential range of the sensor. Valid values are (even numbers only):
+
+  Pre: 12 to 18 (initialized to 14 by default)<br>
+  Final: 8 to 14 (initialized to 10 by default)
+
+  The return value is a boolean indicating whether the requested period was valid.
+
+* `uint8_t getVcselPulsePeriod(vcselPeriodType type)`<br>
+  Returns the current VCSEL pulse period for the given period type.
+
+* `void startContinuous(uint32_t period_ms = 0)`<br>
+  Starts continuous ranging measurements. If the optional argument `period_ms` is 0 (the default if not specified), continuous back-to-back mode is used (the sensor takes measurements as often as possible); if it is nonzero, continuous timed mode is used, with the specified inter-measurement period in milliseconds determining how often the sensor takes a measurement.
+
+* `void stopContinuous(void)`<br>
+  Stops continuous mode.
+
+* `uint8_t readRangeContinuousMillimeters(void)`<br>
+  Returns a range reading in millimeters when continuous mode is active.
+
+* `uint16_t readRangeSingleMillimeters(void)`<br>
+  Performs a single-shot ranging measurement and returns the reading in millimeters.
+
+* `void setTimeout(uint16_t timeout)`<br>
+  Sets a timeout period in milliseconds after which read operations will abort if the sensor is not ready. A value of 0 disables the timeout.
+
+* `uint16_t getTimeout(void)`<br>
+  Returns the current timeout period setting.
+
+* `bool timeoutOccurred(void)`<br>
+  Indicates whether a read timeout has occurred since the last call to `timeoutOccurred()`.
+
+## Version history
+
+* 1.0.0 (2016 Sep 12): Initial release for mbed OS 5

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL53L0X.cpp	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,1077 @@
+// Most of the functionality of this library is based on the VL53L0X API
+// provided by ST (STSW-IMG005), and some of the explanatory comments are quoted
+// or paraphrased from the API source code, API user manual (UM2039), and the
+// VL53L0X datasheet.
+
+#include <memory>
+#include <VL53L0X.h>
+
+// Defines /////////////////////////////////////////////////////////////////////
+
+// The Arduino two-wire interface uses a 7-bit number for the address,
+// and sets the last bit correctly based on reads and writes
+#define ADDRESS_DEFAULT (0b0101001 << 1)
+
+// Record the current time to check an upcoming timeout against
+#define startTimeout() (timeout_start_ms = millis())
+
+// Check if timeout is enabled (set to nonzero value) and has expired
+#define checkTimeoutExpired() (io_timeout > 0 && ((uint16_t)millis() - timeout_start_ms) > io_timeout)
+
+// Decode VCSEL (vertical cavity surface emitting laser) pulse period in PCLKs
+// from register value
+// based on VL53L0X_decode_vcsel_period()
+#define decodeVcselPeriod(reg_val)      (((reg_val) + 1) << 1)
+
+// Encode VCSEL pulse period register value from period in PCLKs
+// based on VL53L0X_encode_vcsel_period()
+#define encodeVcselPeriod(period_pclks) (((period_pclks) >> 1) - 1)
+
+// Calculate macro period in *nanoseconds* from VCSEL period in PCLKs
+// based on VL53L0X_calc_macro_period_ps()
+// PLL_period_ps = 1655; macro_period_vclks = 2304
+#define calcMacroPeriod(vcsel_period_pclks) ((((uint32_t)2304 * (vcsel_period_pclks) * 1655) + 500) / 1000)
+
+// Transmission status (https://www.arduino.cc/en/Reference/WireEndTransmission)
+#define ERR_OK 0
+#define ERR_NACK_ADDR 2 // received NACK on transmit of address
+#define ERR_NACK_DATA 3 // received NACK on transmit of data
+#define ERR_OTHER 4
+
+#define millis() timer->read_ms()
+
+// Constructors ////////////////////////////////////////////////////////////////
+
+VL53L0X::VL53L0X(I2C* i2c, Timer* timer)
+  : address(ADDRESS_DEFAULT)
+  , io_timeout(0) // no timeout
+  , did_timeout(false)
+  , i2c(i2c)
+  , timer(timer)
+{
+}
+
+// Public Methods //////////////////////////////////////////////////////////////
+
+void VL53L0X::setAddress(uint8_t new_addr)
+{
+  writeReg(I2C_SLAVE_DEVICE_ADDRESS, new_addr & 0x7F);
+  address = new_addr << 1;
+}
+
+// Initialize sensor using sequence based on VL53L0X_DataInit(),
+// VL53L0X_StaticInit(), and VL53L0X_PerformRefCalibration().
+// This function does not perform reference SPAD calibration
+// (VL53L0X_PerformRefSpadManagement()), since the API user manual says that it
+// is performed by ST on the bare modules; it seems like that should work well
+// enough unless a cover glass is added.
+// If io_2v8 (optional) is true or not given, the sensor is configured for 2V8
+// mode.
+bool VL53L0X::init(bool io_2v8)
+{
+  // VL53L0X_DataInit() begin
+
+  // sensor uses 1V8 mode for I/O by default; switch to 2V8 mode if necessary
+  if (io_2v8)
+  {
+    writeReg(VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
+      readReg(VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV) | 0x01); // set bit 0
+  }
+
+  // "Set I2C standard mode"
+  writeReg(0x88, 0x00);
+
+  writeReg(0x80, 0x01);
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+  stop_variable = readReg(0x91);
+  writeReg(0x00, 0x01);
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x00);
+
+  // disable SIGNAL_RATE_MSRC (bit 1) and SIGNAL_RATE_PRE_RANGE (bit 4) limit checks
+  writeReg(MSRC_CONFIG_CONTROL, readReg(MSRC_CONFIG_CONTROL) | 0x12);
+
+  // set final range signal rate limit to 0.25 MCPS (million counts per second)
+  setSignalRateLimit(0.25);
+
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0xFF);
+
+  // VL53L0X_DataInit() end
+
+  // VL53L0X_StaticInit() begin
+
+  uint8_t spad_count;
+  bool spad_type_is_aperture;
+  if (!getSpadInfo(&spad_count, &spad_type_is_aperture)) { return false; }
+
+  // The SPAD map (RefGoodSpadMap) is read by VL53L0X_get_info_from_device() in
+  // the API, but the same data seems to be more easily readable from
+  // GLOBAL_CONFIG_SPAD_ENABLES_REF_0 through _6, so read it from there
+  uint8_t ref_spad_map[6];
+  readMulti(GLOBAL_CONFIG_SPAD_ENABLES_REF_0, ref_spad_map, 6);
+
+  // -- VL53L0X_set_reference_spads() begin (assume NVM values are valid)
+
+  writeReg(0xFF, 0x01);
+  writeReg(DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
+  writeReg(DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
+  writeReg(0xFF, 0x00);
+  writeReg(GLOBAL_CONFIG_REF_EN_START_SELECT, 0xB4);
+
+  uint8_t first_spad_to_enable = spad_type_is_aperture ? 12 : 0; // 12 is the first aperture spad
+  uint8_t spads_enabled = 0;
+
+  for (uint8_t i = 0; i < 48; i++)
+  {
+    if (i < first_spad_to_enable || spads_enabled == spad_count)
+    {
+      // This bit is lower than the first one that should be enabled, or
+      // (reference_spad_count) bits have already been enabled, so zero this bit
+      ref_spad_map[i / 8] &= ~(1 << (i % 8));
+    }
+    else if ((ref_spad_map[i / 8] >> (i % 8)) & 0x1)
+    {
+      spads_enabled++;
+    }
+  }
+
+  writeMulti(GLOBAL_CONFIG_SPAD_ENABLES_REF_0, ref_spad_map, 6);
+
+  // -- VL53L0X_set_reference_spads() end
+
+  // -- VL53L0X_load_tuning_settings() begin
+  // DefaultTuningSettings from vl53l0x_tuning.h
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x09, 0x00);
+  writeReg(0x10, 0x00);
+  writeReg(0x11, 0x00);
+
+  writeReg(0x24, 0x01);
+  writeReg(0x25, 0xFF);
+  writeReg(0x75, 0x00);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x4E, 0x2C);
+  writeReg(0x48, 0x00);
+  writeReg(0x30, 0x20);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x30, 0x09);
+  writeReg(0x54, 0x00);
+  writeReg(0x31, 0x04);
+  writeReg(0x32, 0x03);
+  writeReg(0x40, 0x83);
+  writeReg(0x46, 0x25);
+  writeReg(0x60, 0x00);
+  writeReg(0x27, 0x00);
+  writeReg(0x50, 0x06);
+  writeReg(0x51, 0x00);
+  writeReg(0x52, 0x96);
+  writeReg(0x56, 0x08);
+  writeReg(0x57, 0x30);
+  writeReg(0x61, 0x00);
+  writeReg(0x62, 0x00);
+  writeReg(0x64, 0x00);
+  writeReg(0x65, 0x00);
+  writeReg(0x66, 0xA0);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x22, 0x32);
+  writeReg(0x47, 0x14);
+  writeReg(0x49, 0xFF);
+  writeReg(0x4A, 0x00);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x7A, 0x0A);
+  writeReg(0x7B, 0x00);
+  writeReg(0x78, 0x21);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x23, 0x34);
+  writeReg(0x42, 0x00);
+  writeReg(0x44, 0xFF);
+  writeReg(0x45, 0x26);
+  writeReg(0x46, 0x05);
+  writeReg(0x40, 0x40);
+  writeReg(0x0E, 0x06);
+  writeReg(0x20, 0x1A);
+  writeReg(0x43, 0x40);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x34, 0x03);
+  writeReg(0x35, 0x44);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x31, 0x04);
+  writeReg(0x4B, 0x09);
+  writeReg(0x4C, 0x05);
+  writeReg(0x4D, 0x04);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x44, 0x00);
+  writeReg(0x45, 0x20);
+  writeReg(0x47, 0x08);
+  writeReg(0x48, 0x28);
+  writeReg(0x67, 0x00);
+  writeReg(0x70, 0x04);
+  writeReg(0x71, 0x01);
+  writeReg(0x72, 0xFE);
+  writeReg(0x76, 0x00);
+  writeReg(0x77, 0x00);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x0D, 0x01);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x01);
+  writeReg(0x01, 0xF8);
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x8E, 0x01);
+  writeReg(0x00, 0x01);
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x00);
+
+  // -- VL53L0X_load_tuning_settings() end
+
+  // "Set interrupt config to new sample ready"
+  // -- VL53L0X_SetGpioConfig() begin
+
+  writeReg(SYSTEM_INTERRUPT_CONFIG_GPIO, 0x04);
+  writeReg(GPIO_HV_MUX_ACTIVE_HIGH, readReg(GPIO_HV_MUX_ACTIVE_HIGH) & ~0x10); // active low
+  writeReg(SYSTEM_INTERRUPT_CLEAR, 0x01);
+
+  // -- VL53L0X_SetGpioConfig() end
+
+  measurement_timing_budget_us = getMeasurementTimingBudget();
+
+  // "Disable MSRC and TCC by default"
+  // MSRC = Minimum Signal Rate Check
+  // TCC = Target CentreCheck
+  // -- VL53L0X_SetSequenceStepEnable() begin
+
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0xE8);
+
+  // -- VL53L0X_SetSequenceStepEnable() end
+
+  // "Recalculate timing budget"
+  setMeasurementTimingBudget(measurement_timing_budget_us);
+
+  // VL53L0X_StaticInit() end
+
+  // VL53L0X_PerformRefCalibration() begin (VL53L0X_perform_ref_calibration())
+
+  // -- VL53L0X_perform_vhv_calibration() begin
+
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0x01);
+  if (!performSingleRefCalibration(0x40)) { return false; }
+
+  // -- VL53L0X_perform_vhv_calibration() end
+
+  // -- VL53L0X_perform_phase_calibration() begin
+
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0x02);
+  if (!performSingleRefCalibration(0x00)) { return false; }
+
+  // -- VL53L0X_perform_phase_calibration() end
+
+  // "restore the previous Sequence Config"
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0xE8);
+
+  // VL53L0X_PerformRefCalibration() end
+
+  return true;
+}
+
+// Write an 8-bit register
+void VL53L0X::writeReg(uint8_t reg, uint8_t value)
+{
+  char data[] = {
+    reg,
+    value
+  };
+  if (i2c->write(address, data, 2)) {
+    last_status = ERR_OTHER;
+  } else {
+    last_status = ERR_OK;
+  }
+}
+
+// Write a 16-bit register
+void VL53L0X::writeReg16Bit(uint8_t reg, uint16_t value)
+{
+  char data[] = {
+    reg,
+    static_cast<char>((value >> 8) & 0xFF), // value high byte
+    static_cast<char>(value        & 0xFF)  // value low byte
+  };
+  if (i2c->write(address, data, 3)) {
+    last_status = ERR_OTHER;
+  } else {
+    last_status = ERR_OK;
+  }
+}
+
+// Write a 32-bit register
+void VL53L0X::writeReg32Bit(uint8_t reg, uint32_t value)
+{
+  char data[] = {
+    reg,
+    static_cast<char>((value >> 24) & 0xFF), // value highest byte
+    static_cast<char>((value >> 16) & 0xFF),
+    static_cast<char>((value >>  8) & 0xFF),
+    static_cast<char>(value         & 0xFF)  // value lowest byte
+  };
+  if (i2c->write(address, data, 5)) {
+    last_status = ERR_OTHER;
+  } else {
+    last_status = ERR_OK;
+  }
+}
+
+// Read an 8-bit register
+uint8_t VL53L0X::readReg(uint8_t reg)
+{
+  uint8_t value;
+
+  if (i2c->write(address, reinterpret_cast<char *>(&reg), 1)) {
+    last_status = ERR_NACK_ADDR;
+    return 0;
+  }
+  if (i2c->read(address, reinterpret_cast<char *>(&value), 1)) {
+    last_status = ERR_NACK_DATA;
+    return 0;
+  }
+  last_status = ERR_OK;
+
+  return value;
+}
+
+// Read a 16-bit register
+uint16_t VL53L0X::readReg16Bit(uint8_t reg)
+{
+  uint16_t value;
+  uint8_t data[2];
+
+  if (i2c->write(address, reinterpret_cast<char *>(&reg), 1)) {
+    last_status = ERR_NACK_ADDR;
+    return 0;
+  }
+  if (i2c->read(address, reinterpret_cast<char *>(data), 2)) {
+    last_status = ERR_NACK_DATA;
+    return 0;
+  }
+  last_status = ERR_OK;
+
+  value  = static_cast<uint16_t>(data[0] << 8); // value high byte
+  value |=                       data[1];       // value low byte
+
+  return value;
+}
+
+// Read a 32-bit register
+uint32_t VL53L0X::readReg32Bit(uint8_t reg)
+{
+  uint32_t value;
+  uint8_t data[4];
+
+  if (i2c->write(address, reinterpret_cast<char *>(&reg), 1)) {
+    last_status = ERR_NACK_ADDR;
+    return 0;
+  }
+  if (i2c->read(address, reinterpret_cast<char *>(data), 4)) {
+    last_status = ERR_NACK_DATA;
+    return 0;
+  }
+  last_status = ERR_OK;
+
+  value  = static_cast<uint32_t>(data[0] << 24); // value highest byte
+  value |= static_cast<uint32_t>(data[1] << 16);
+  value |= static_cast<uint32_t>(data[2] <<  8);
+  value |=                       data[3];       // value lowest byte
+
+  return value;
+}
+
+// Write an arbitrary number of bytes from the given array to the sensor,
+// starting at the given register
+void VL53L0X::writeMulti(uint8_t reg, uint8_t const * src, uint8_t count)
+{
+  if (i2c->write(address, reinterpret_cast<char *>(&reg), 1, true)) {
+    last_status = ERR_NACK_ADDR;
+    return;
+  }
+
+  if (i2c->write(address, const_cast<char *>(
+      reinterpret_cast<const char *>(src)), count)) {
+    last_status = ERR_NACK_DATA;
+    return;
+  }
+  last_status = ERR_OK;
+}
+
+// Read an arbitrary number of bytes from the sensor, starting at the given
+// register, into the given array
+void VL53L0X::readMulti(uint8_t reg, uint8_t * dst, uint8_t count)
+{
+  if (i2c->write(address, reinterpret_cast<char *>(&reg), 1)) {
+    last_status = ERR_NACK_ADDR;
+    return;
+  }
+  if (i2c->read(address, reinterpret_cast<char *>(dst), count)) {
+    last_status = ERR_NACK_DATA;
+    return;
+  }
+  last_status = ERR_OK;
+}
+
+// Set the return signal rate limit check value in units of MCPS (mega counts
+// per second). "This represents the amplitude of the signal reflected from the
+// target and detected by the device"; setting this limit presumably determines
+// the minimum measurement necessary for the sensor to report a valid reading.
+// Setting a lower limit increases the potential range of the sensor but also
+// seems to increase the likelihood of getting an inaccurate reading because of
+// unwanted reflections from objects other than the intended target.
+// Defaults to 0.25 MCPS as initialized by the ST API and this library.
+bool VL53L0X::setSignalRateLimit(float limit_Mcps)
+{
+  if (limit_Mcps < 0 || limit_Mcps > 511.99) { return false; }
+
+  // Q9.7 fixed point format (9 integer bits, 7 fractional bits)
+  writeReg16Bit(FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT, limit_Mcps * (1 << 7));
+  return true;
+}
+
+// Get the return signal rate limit check value in MCPS
+float VL53L0X::getSignalRateLimit(void)
+{
+  return (float)readReg16Bit(FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT) / (1 << 7);
+}
+
+// Set the measurement timing budget in microseconds, which is the time allowed
+// for one measurement; the ST API and this library take care of splitting the
+// timing budget among the sub-steps in the ranging sequence. A longer timing
+// budget allows for more accurate measurements. Increasing the budget by a
+// factor of N decreases the range measurement standard deviation by a factor of
+// sqrt(N). Defaults to about 33 milliseconds; the minimum is 20 ms.
+// based on VL53L0X_set_measurement_timing_budget_micro_seconds()
+bool VL53L0X::setMeasurementTimingBudget(uint32_t budget_us)
+{
+  SequenceStepEnables enables;
+  SequenceStepTimeouts timeouts;
+
+  uint16_t const StartOverhead      = 1320; // note that this is different than the value in get_
+  uint16_t const EndOverhead        = 960;
+  uint16_t const MsrcOverhead       = 660;
+  uint16_t const TccOverhead        = 590;
+  uint16_t const DssOverhead        = 690;
+  uint16_t const PreRangeOverhead   = 660;
+  uint16_t const FinalRangeOverhead = 550;
+
+  uint32_t const MinTimingBudget = 20000;
+
+  if (budget_us < MinTimingBudget) { return false; }
+
+  uint32_t used_budget_us = StartOverhead + EndOverhead;
+
+  getSequenceStepEnables(&enables);
+  getSequenceStepTimeouts(&enables, &timeouts);
+
+  if (enables.tcc)
+  {
+    used_budget_us += (timeouts.msrc_dss_tcc_us + TccOverhead);
+  }
+
+  if (enables.dss)
+  {
+    used_budget_us += 2 * (timeouts.msrc_dss_tcc_us + DssOverhead);
+  }
+  else if (enables.msrc)
+  {
+    used_budget_us += (timeouts.msrc_dss_tcc_us + MsrcOverhead);
+  }
+
+  if (enables.pre_range)
+  {
+    used_budget_us += (timeouts.pre_range_us + PreRangeOverhead);
+  }
+
+  if (enables.final_range)
+  {
+    used_budget_us += FinalRangeOverhead;
+
+    // "Note that the final range timeout is determined by the timing
+    // budget and the sum of all other timeouts within the sequence.
+    // If there is no room for the final range timeout, then an error
+    // will be set. Otherwise the remaining time will be applied to
+    // the final range."
+
+    if (used_budget_us > budget_us)
+    {
+      // "Requested timeout too big."
+      return false;
+    }
+
+    uint32_t final_range_timeout_us = budget_us - used_budget_us;
+
+    // set_sequence_step_timeout() begin
+    // (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE)
+
+    // "For the final range timeout, the pre-range timeout
+    //  must be added. To do this both final and pre-range
+    //  timeouts must be expressed in macro periods MClks
+    //  because they have different vcsel periods."
+
+    uint16_t final_range_timeout_mclks =
+      timeoutMicrosecondsToMclks(final_range_timeout_us,
+                                 timeouts.final_range_vcsel_period_pclks);
+
+    if (enables.pre_range)
+    {
+      final_range_timeout_mclks += timeouts.pre_range_mclks;
+    }
+
+    writeReg16Bit(FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+      encodeTimeout(final_range_timeout_mclks));
+
+    // set_sequence_step_timeout() end
+
+    measurement_timing_budget_us = budget_us; // store for internal reuse
+  }
+  return true;
+}
+
+// Get the measurement timing budget in microseconds
+// based on VL53L0X_get_measurement_timing_budget_micro_seconds()
+// in us
+uint32_t VL53L0X::getMeasurementTimingBudget(void)
+{
+  SequenceStepEnables enables;
+  SequenceStepTimeouts timeouts;
+
+  uint16_t const StartOverhead     = 1910; // note that this is different than the value in set_
+  uint16_t const EndOverhead        = 960;
+  uint16_t const MsrcOverhead       = 660;
+  uint16_t const TccOverhead        = 590;
+  uint16_t const DssOverhead        = 690;
+  uint16_t const PreRangeOverhead   = 660;
+  uint16_t const FinalRangeOverhead = 550;
+
+  // "Start and end overhead times always present"
+  uint32_t budget_us = StartOverhead + EndOverhead;
+
+  getSequenceStepEnables(&enables);
+  getSequenceStepTimeouts(&enables, &timeouts);
+
+  if (enables.tcc)
+  {
+    budget_us += (timeouts.msrc_dss_tcc_us + TccOverhead);
+  }
+
+  if (enables.dss)
+  {
+    budget_us += 2 * (timeouts.msrc_dss_tcc_us + DssOverhead);
+  }
+  else if (enables.msrc)
+  {
+    budget_us += (timeouts.msrc_dss_tcc_us + MsrcOverhead);
+  }
+
+  if (enables.pre_range)
+  {
+    budget_us += (timeouts.pre_range_us + PreRangeOverhead);
+  }
+
+  if (enables.final_range)
+  {
+    budget_us += (timeouts.final_range_us + FinalRangeOverhead);
+  }
+
+  measurement_timing_budget_us = budget_us; // store for internal reuse
+  return budget_us;
+}
+
+// Set the VCSEL (vertical cavity surface emitting laser) pulse period for the
+// given period type (pre-range or final range) to the given value in PCLKs.
+// Longer periods seem to increase the potential range of the sensor.
+// Valid values are (even numbers only):
+//  pre:  12 to 18 (initialized default: 14)
+//  final: 8 to 14 (initialized default: 10)
+// based on VL53L0X_set_vcsel_pulse_period()
+bool VL53L0X::setVcselPulsePeriod(vcselPeriodType type, uint8_t period_pclks)
+{
+  uint8_t vcsel_period_reg = encodeVcselPeriod(period_pclks);
+
+  SequenceStepEnables enables;
+  SequenceStepTimeouts timeouts;
+
+  getSequenceStepEnables(&enables);
+  getSequenceStepTimeouts(&enables, &timeouts);
+
+  // "Apply specific settings for the requested clock period"
+  // "Re-calculate and apply timeouts, in macro periods"
+
+  // "When the VCSEL period for the pre or final range is changed,
+  // the corresponding timeout must be read from the device using
+  // the current VCSEL period, then the new VCSEL period can be
+  // applied. The timeout then must be written back to the device
+  // using the new VCSEL period.
+  //
+  // For the MSRC timeout, the same applies - this timeout being
+  // dependant on the pre-range vcsel period."
+
+
+  if (type == VcselPeriodPreRange)
+  {
+    // "Set phase check limits"
+    switch (period_pclks)
+    {
+      case 12:
+        writeReg(PRE_RANGE_CONFIG_VALID_PHASE_HIGH, 0x18);
+        break;
+
+      case 14:
+        writeReg(PRE_RANGE_CONFIG_VALID_PHASE_HIGH, 0x30);
+        break;
+
+      case 16:
+        writeReg(PRE_RANGE_CONFIG_VALID_PHASE_HIGH, 0x40);
+        break;
+
+      case 18:
+        writeReg(PRE_RANGE_CONFIG_VALID_PHASE_HIGH, 0x50);
+        break;
+
+      default:
+        // invalid period
+        return false;
+    }
+    writeReg(PRE_RANGE_CONFIG_VALID_PHASE_LOW, 0x08);
+
+    // apply new VCSEL period
+    writeReg(PRE_RANGE_CONFIG_VCSEL_PERIOD, vcsel_period_reg);
+
+    // update timeouts
+
+    // set_sequence_step_timeout() begin
+    // (SequenceStepId == VL53L0X_SEQUENCESTEP_PRE_RANGE)
+
+    uint16_t new_pre_range_timeout_mclks =
+      timeoutMicrosecondsToMclks(timeouts.pre_range_us, period_pclks);
+
+    writeReg16Bit(PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+      encodeTimeout(new_pre_range_timeout_mclks));
+
+    // set_sequence_step_timeout() end
+
+    // set_sequence_step_timeout() begin
+    // (SequenceStepId == VL53L0X_SEQUENCESTEP_MSRC)
+
+    uint16_t new_msrc_timeout_mclks =
+      timeoutMicrosecondsToMclks(timeouts.msrc_dss_tcc_us, period_pclks);
+
+    writeReg(MSRC_CONFIG_TIMEOUT_MACROP,
+      (new_msrc_timeout_mclks > 256) ? 255 : (new_msrc_timeout_mclks - 1));
+
+    // set_sequence_step_timeout() end
+  }
+  else if (type == VcselPeriodFinalRange)
+  {
+    switch (period_pclks)
+    {
+      case 8:
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_HIGH, 0x10);
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_LOW,  0x08);
+        writeReg(GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
+        writeReg(ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
+        writeReg(0xFF, 0x01);
+        writeReg(ALGO_PHASECAL_LIM, 0x30);
+        writeReg(0xFF, 0x00);
+        break;
+
+      case 10:
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_HIGH, 0x28);
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_LOW,  0x08);
+        writeReg(GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+        writeReg(ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
+        writeReg(0xFF, 0x01);
+        writeReg(ALGO_PHASECAL_LIM, 0x20);
+        writeReg(0xFF, 0x00);
+        break;
+
+      case 12:
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_HIGH, 0x38);
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_LOW,  0x08);
+        writeReg(GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+        writeReg(ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
+        writeReg(0xFF, 0x01);
+        writeReg(ALGO_PHASECAL_LIM, 0x20);
+        writeReg(0xFF, 0x00);
+        break;
+
+      case 14:
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_HIGH, 0x48);
+        writeReg(FINAL_RANGE_CONFIG_VALID_PHASE_LOW,  0x08);
+        writeReg(GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+        writeReg(ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
+        writeReg(0xFF, 0x01);
+        writeReg(ALGO_PHASECAL_LIM, 0x20);
+        writeReg(0xFF, 0x00);
+        break;
+
+      default:
+        // invalid period
+        return false;
+    }
+
+    // apply new VCSEL period
+    writeReg(FINAL_RANGE_CONFIG_VCSEL_PERIOD, vcsel_period_reg);
+
+    // update timeouts
+
+    // set_sequence_step_timeout() begin
+    // (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE)
+
+    // "For the final range timeout, the pre-range timeout
+    //  must be added. To do this both final and pre-range
+    //  timeouts must be expressed in macro periods MClks
+    //  because they have different vcsel periods."
+
+    uint16_t new_final_range_timeout_mclks =
+      timeoutMicrosecondsToMclks(timeouts.final_range_us, period_pclks);
+
+    if (enables.pre_range)
+    {
+      new_final_range_timeout_mclks += timeouts.pre_range_mclks;
+    }
+
+    writeReg16Bit(FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+      encodeTimeout(new_final_range_timeout_mclks));
+
+    // set_sequence_step_timeout end
+  }
+  else
+  {
+    // invalid type
+    return false;
+  }
+
+  // "Finally, the timing budget must be re-applied"
+
+  setMeasurementTimingBudget(measurement_timing_budget_us);
+
+  // "Perform the phase calibration. This is needed after changing on vcsel period."
+  // VL53L0X_perform_phase_calibration() begin
+
+  uint8_t sequence_config = readReg(SYSTEM_SEQUENCE_CONFIG);
+  writeReg(SYSTEM_SEQUENCE_CONFIG, 0x02);
+  performSingleRefCalibration(0x0);
+  writeReg(SYSTEM_SEQUENCE_CONFIG, sequence_config);
+
+  // VL53L0X_perform_phase_calibration() end
+
+  return true;
+}
+
+// Get the VCSEL pulse period in PCLKs for the given period type.
+// based on VL53L0X_get_vcsel_pulse_period()
+uint8_t VL53L0X::getVcselPulsePeriod(vcselPeriodType type)
+{
+  if (type == VcselPeriodPreRange)
+  {
+    return decodeVcselPeriod(readReg(PRE_RANGE_CONFIG_VCSEL_PERIOD));
+  }
+  else if (type == VcselPeriodFinalRange)
+  {
+    return decodeVcselPeriod(readReg(FINAL_RANGE_CONFIG_VCSEL_PERIOD));
+  }
+  else { return 255; }
+}
+
+// Start continuous ranging measurements. If period_ms (optional) is 0 or not
+// given, continuous back-to-back mode is used (the sensor takes measurements as
+// often as possible); otherwise, continuous timed mode is used, with the given
+// inter-measurement period in milliseconds determining how often the sensor
+// takes a measurement.
+// based on VL53L0X_StartMeasurement()
+void VL53L0X::startContinuous(uint32_t period_ms)
+{
+  writeReg(0x80, 0x01);
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+  writeReg(0x91, stop_variable);
+  writeReg(0x00, 0x01);
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x00);
+
+  if (period_ms != 0)
+  {
+    // continuous timed mode
+
+    // VL53L0X_SetInterMeasurementPeriodMilliSeconds() begin
+
+    uint16_t osc_calibrate_val = readReg16Bit(OSC_CALIBRATE_VAL);
+
+    if (osc_calibrate_val != 0)
+    {
+      period_ms *= osc_calibrate_val;
+    }
+
+    writeReg32Bit(SYSTEM_INTERMEASUREMENT_PERIOD, period_ms);
+
+    // VL53L0X_SetInterMeasurementPeriodMilliSeconds() end
+
+    writeReg(SYSRANGE_START, 0x04); // VL53L0X_REG_SYSRANGE_MODE_TIMED
+  }
+  else
+  {
+    // continuous back-to-back mode
+    writeReg(SYSRANGE_START, 0x02); // VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK
+  }
+}
+
+// Stop continuous measurements
+// based on VL53L0X_StopMeasurement()
+void VL53L0X::stopContinuous(void)
+{
+  writeReg(SYSRANGE_START, 0x01); // VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT
+
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+  writeReg(0x91, 0x00);
+  writeReg(0x00, 0x01);
+  writeReg(0xFF, 0x00);
+}
+
+// Returns a range reading in millimeters when continuous mode is active
+// (readRangeSingleMillimeters() also calls this function after starting a
+// single-shot range measurement)
+uint16_t VL53L0X::readRangeContinuousMillimeters(void)
+{
+  startTimeout();
+  while ((readReg(RESULT_INTERRUPT_STATUS) & 0x07) == 0)
+  {
+    if (checkTimeoutExpired())
+    {
+      did_timeout = true;
+      return 65535;
+    }
+  }
+
+  // assumptions: Linearity Corrective Gain is 1000 (default);
+  // fractional ranging is not enabled
+  uint16_t range = readReg16Bit(RESULT_RANGE_STATUS + 10);
+
+  writeReg(SYSTEM_INTERRUPT_CLEAR, 0x01);
+
+  return range;
+}
+
+// Performs a single-shot range measurement and returns the reading in
+// millimeters
+// based on VL53L0X_PerformSingleRangingMeasurement()
+uint16_t VL53L0X::readRangeSingleMillimeters(void)
+{
+  writeReg(0x80, 0x01);
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+  writeReg(0x91, stop_variable);
+  writeReg(0x00, 0x01);
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x00);
+
+  writeReg(SYSRANGE_START, 0x01);
+
+  // "Wait until start bit has been cleared"
+  startTimeout();
+  while (readReg(SYSRANGE_START) & 0x01)
+  {
+    if (checkTimeoutExpired())
+    {
+      did_timeout = true;
+      return 65535;
+    }
+  }
+
+  return readRangeContinuousMillimeters();
+}
+
+// Did a timeout occur in one of the read functions since the last call to
+// timeoutOccurred()?
+bool VL53L0X::timeoutOccurred()
+{
+  bool tmp = did_timeout;
+  did_timeout = false;
+  return tmp;
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+// Get reference SPAD (single photon avalanche diode) count and type
+// based on VL53L0X_get_info_from_device(),
+// but only gets reference SPAD count and type
+bool VL53L0X::getSpadInfo(uint8_t * count, bool * type_is_aperture)
+{
+  uint8_t tmp;
+
+  writeReg(0x80, 0x01);
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x00);
+
+  writeReg(0xFF, 0x06);
+  writeReg(0x83, readReg(0x83) | 0x04);
+  writeReg(0xFF, 0x07);
+  writeReg(0x81, 0x01);
+
+  writeReg(0x80, 0x01);
+
+  writeReg(0x94, 0x6b);
+  writeReg(0x83, 0x00);
+  startTimeout();
+  while (readReg(0x83) == 0x00)
+  {
+    if (checkTimeoutExpired()) { return false; }
+  }
+  writeReg(0x83, 0x01);
+  tmp = readReg(0x92);
+
+  *count = tmp & 0x7f;
+  *type_is_aperture = (tmp >> 7) & 0x01;
+
+  writeReg(0x81, 0x00);
+  writeReg(0xFF, 0x06);
+  writeReg(0x83, readReg( 0x83  & ~0x04));
+  writeReg(0xFF, 0x01);
+  writeReg(0x00, 0x01);
+
+  writeReg(0xFF, 0x00);
+  writeReg(0x80, 0x00);
+
+  return true;
+}
+
+// Get sequence step enables
+// based on VL53L0X_GetSequenceStepEnables()
+void VL53L0X::getSequenceStepEnables(SequenceStepEnables * enables)
+{
+  uint8_t sequence_config = readReg(SYSTEM_SEQUENCE_CONFIG);
+
+  enables->tcc          = (sequence_config >> 4) & 0x1;
+  enables->dss          = (sequence_config >> 3) & 0x1;
+  enables->msrc         = (sequence_config >> 2) & 0x1;
+  enables->pre_range    = (sequence_config >> 6) & 0x1;
+  enables->final_range  = (sequence_config >> 7) & 0x1;
+}
+
+// Get sequence step timeouts
+// based on get_sequence_step_timeout(),
+// but gets all timeouts instead of just the requested one, and also stores
+// intermediate values
+void VL53L0X::getSequenceStepTimeouts(SequenceStepEnables const * enables, SequenceStepTimeouts * timeouts)
+{
+  timeouts->pre_range_vcsel_period_pclks = getVcselPulsePeriod(VcselPeriodPreRange);
+
+  timeouts->msrc_dss_tcc_mclks = readReg(MSRC_CONFIG_TIMEOUT_MACROP) + 1;
+  timeouts->msrc_dss_tcc_us =
+    timeoutMclksToMicroseconds(timeouts->msrc_dss_tcc_mclks,
+                               timeouts->pre_range_vcsel_period_pclks);
+
+  timeouts->pre_range_mclks =
+    decodeTimeout(readReg16Bit(PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI));
+  timeouts->pre_range_us =
+    timeoutMclksToMicroseconds(timeouts->pre_range_mclks,
+                               timeouts->pre_range_vcsel_period_pclks);
+
+  timeouts->final_range_vcsel_period_pclks = getVcselPulsePeriod(VcselPeriodFinalRange);
+
+  timeouts->final_range_mclks =
+    decodeTimeout(readReg16Bit(FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI));
+
+  if (enables->pre_range)
+  {
+    timeouts->final_range_mclks -= timeouts->pre_range_mclks;
+  }
+
+  timeouts->final_range_us =
+    timeoutMclksToMicroseconds(timeouts->final_range_mclks,
+                               timeouts->final_range_vcsel_period_pclks);
+}
+
+// Decode sequence step timeout in MCLKs from register value
+// based on VL53L0X_decode_timeout()
+// Note: the original function returned a uint32_t, but the return value is
+// always stored in a uint16_t.
+uint16_t VL53L0X::decodeTimeout(uint16_t reg_val)
+{
+  // format: "(LSByte * 2^MSByte) + 1"
+  return (uint16_t)((reg_val & 0x00FF) <<
+         (uint16_t)((reg_val & 0xFF00) >> 8)) + 1;
+}
+
+// Encode sequence step timeout register value from timeout in MCLKs
+// based on VL53L0X_encode_timeout()
+// Note: the original function took a uint16_t, but the argument passed to it
+// is always a uint16_t.
+uint16_t VL53L0X::encodeTimeout(uint16_t timeout_mclks)
+{
+  // format: "(LSByte * 2^MSByte) + 1"
+
+  uint32_t ls_byte = 0;
+  uint16_t ms_byte = 0;
+
+  if (timeout_mclks > 0)
+  {
+    ls_byte = timeout_mclks - 1;
+
+    while ((ls_byte & 0xFFFFFF00) > 0)
+    {
+      ls_byte >>= 1;
+      ms_byte++;
+    }
+
+    return (ms_byte << 8) | (ls_byte & 0xFF);
+  }
+  else { return 0; }
+}
+
+// Convert sequence step timeout from MCLKs to microseconds with given VCSEL period in PCLKs
+// based on VL53L0X_calc_timeout_us()
+uint32_t VL53L0X::timeoutMclksToMicroseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks)
+{
+  uint32_t macro_period_ns = calcMacroPeriod(vcsel_period_pclks);
+
+  return ((timeout_period_mclks * macro_period_ns) + (macro_period_ns / 2)) / 1000;
+}
+
+// Convert sequence step timeout from microseconds to MCLKs with given VCSEL period in PCLKs
+// based on VL53L0X_calc_timeout_mclks()
+uint32_t VL53L0X::timeoutMicrosecondsToMclks(uint32_t timeout_period_us, uint8_t vcsel_period_pclks)
+{
+  uint32_t macro_period_ns = calcMacroPeriod(vcsel_period_pclks);
+
+  return (((timeout_period_us * 1000) + (macro_period_ns / 2)) / macro_period_ns);
+}
+
+
+// based on VL53L0X_perform_single_ref_calibration()
+bool VL53L0X::performSingleRefCalibration(uint8_t vhv_init_byte)
+{
+  writeReg(SYSRANGE_START, 0x01 | vhv_init_byte); // VL53L0X_REG_SYSRANGE_MODE_START_STOP
+
+  startTimeout();
+  while ((readReg(RESULT_INTERRUPT_STATUS) & 0x07) == 0)
+  {
+    if (checkTimeoutExpired()) { return false; }
+  }
+
+  writeReg(SYSTEM_INTERRUPT_CLEAR, 0x01);
+
+  writeReg(SYSRANGE_START, 0x00);
+
+  return true;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL53L0X.h	Tue Oct 01 12:33:27 2019 +0000
@@ -0,0 +1,177 @@
+#ifndef VL53L0X_h
+#define VL53L0X_h
+
+#include <mbed.h>
+
+class VL53L0X
+{
+  public:
+    // register addresses from API vl53l0x_device.h (ordered as listed there)
+    enum regAddr
+    {
+      SYSRANGE_START                              = 0x00,
+
+      SYSTEM_THRESH_HIGH                          = 0x0C,
+      SYSTEM_THRESH_LOW                           = 0x0E,
+
+      SYSTEM_SEQUENCE_CONFIG                      = 0x01,
+      SYSTEM_RANGE_CONFIG                         = 0x09,
+      SYSTEM_INTERMEASUREMENT_PERIOD              = 0x04,
+
+      SYSTEM_INTERRUPT_CONFIG_GPIO                = 0x0A,
+
+      GPIO_HV_MUX_ACTIVE_HIGH                     = 0x84,
+
+      SYSTEM_INTERRUPT_CLEAR                      = 0x0B,
+
+      RESULT_INTERRUPT_STATUS                     = 0x13,
+      RESULT_RANGE_STATUS                         = 0x14,
+
+      RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN       = 0xBC,
+      RESULT_CORE_RANGING_TOTAL_EVENTS_RTN        = 0xC0,
+      RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF       = 0xD0,
+      RESULT_CORE_RANGING_TOTAL_EVENTS_REF        = 0xD4,
+      RESULT_PEAK_SIGNAL_RATE_REF                 = 0xB6,
+
+      ALGO_PART_TO_PART_RANGE_OFFSET_MM           = 0x28,
+
+      I2C_SLAVE_DEVICE_ADDRESS                    = 0x8A,
+
+      MSRC_CONFIG_CONTROL                         = 0x60,
+
+      PRE_RANGE_CONFIG_MIN_SNR                    = 0x27,
+      PRE_RANGE_CONFIG_VALID_PHASE_LOW            = 0x56,
+      PRE_RANGE_CONFIG_VALID_PHASE_HIGH           = 0x57,
+      PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT          = 0x64,
+
+      FINAL_RANGE_CONFIG_MIN_SNR                  = 0x67,
+      FINAL_RANGE_CONFIG_VALID_PHASE_LOW          = 0x47,
+      FINAL_RANGE_CONFIG_VALID_PHASE_HIGH         = 0x48,
+      FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT = 0x44,
+
+      PRE_RANGE_CONFIG_SIGMA_THRESH_HI            = 0x61,
+      PRE_RANGE_CONFIG_SIGMA_THRESH_LO            = 0x62,
+
+      PRE_RANGE_CONFIG_VCSEL_PERIOD               = 0x50,
+      PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI          = 0x51,
+      PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO          = 0x52,
+
+      SYSTEM_HISTOGRAM_BIN                        = 0x81,
+      HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT       = 0x33,
+      HISTOGRAM_CONFIG_READOUT_CTRL               = 0x55,
+
+      FINAL_RANGE_CONFIG_VCSEL_PERIOD             = 0x70,
+      FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI        = 0x71,
+      FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO        = 0x72,
+      CROSSTALK_COMPENSATION_PEAK_RATE_MCPS       = 0x20,
+
+      MSRC_CONFIG_TIMEOUT_MACROP                  = 0x46,
+
+      SOFT_RESET_GO2_SOFT_RESET_N                 = 0xBF,
+      IDENTIFICATION_MODEL_ID                     = 0xC0,
+      IDENTIFICATION_REVISION_ID                  = 0xC2,
+
+      OSC_CALIBRATE_VAL                           = 0xF8,
+
+      GLOBAL_CONFIG_VCSEL_WIDTH                   = 0x32,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_0            = 0xB0,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_1            = 0xB1,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_2            = 0xB2,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_3            = 0xB3,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_4            = 0xB4,
+      GLOBAL_CONFIG_SPAD_ENABLES_REF_5            = 0xB5,
+
+      GLOBAL_CONFIG_REF_EN_START_SELECT           = 0xB6,
+      DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD         = 0x4E,
+      DYNAMIC_SPAD_REF_EN_START_OFFSET            = 0x4F,
+      POWER_MANAGEMENT_GO1_POWER_FORCE            = 0x80,
+
+      VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV           = 0x89,
+
+      ALGO_PHASECAL_LIM                           = 0x30,
+      ALGO_PHASECAL_CONFIG_TIMEOUT                = 0x30,
+    };
+
+    enum vcselPeriodType { VcselPeriodPreRange, VcselPeriodFinalRange };
+
+    uint8_t last_status; // status of last I2C transmission
+
+    VL53L0X(I2C*, Timer*);
+
+    void setAddress(uint8_t new_addr);
+    inline uint8_t getAddress(void) { return address; }
+
+    bool init(bool io_2v8 = true);
+
+    void writeReg(uint8_t reg, uint8_t value);
+    void writeReg16Bit(uint8_t reg, uint16_t value);
+    void writeReg32Bit(uint8_t reg, uint32_t value);
+    uint8_t readReg(uint8_t reg);
+    uint16_t readReg16Bit(uint8_t reg);
+    uint32_t readReg32Bit(uint8_t reg);
+
+    void writeMulti(uint8_t reg, uint8_t const * src, uint8_t count);
+    void readMulti(uint8_t reg, uint8_t * dst, uint8_t count);
+
+    bool setSignalRateLimit(float limit_Mcps);
+    float getSignalRateLimit(void);
+
+    bool setMeasurementTimingBudget(uint32_t budget_us);
+    uint32_t getMeasurementTimingBudget(void);
+
+    bool setVcselPulsePeriod(vcselPeriodType type, uint8_t period_pclks);
+    uint8_t getVcselPulsePeriod(vcselPeriodType type);
+
+    void startContinuous(uint32_t period_ms = 0);
+    void stopContinuous(void);
+    uint16_t readRangeContinuousMillimeters(void);
+    uint16_t readRangeSingleMillimeters(void);
+
+    inline void setTimeout(uint16_t timeout) { io_timeout = timeout; }
+    inline uint16_t getTimeout(void) { return io_timeout; }
+    bool timeoutOccurred(void);
+
+  private:
+    // TCC: Target CentreCheck
+    // MSRC: Minimum Signal Rate Check
+    // DSS: Dynamic Spad Selection
+
+    struct SequenceStepEnables
+    {
+      bool tcc, msrc, dss, pre_range, final_range;
+    };
+
+    struct SequenceStepTimeouts
+    {
+      uint16_t pre_range_vcsel_period_pclks, final_range_vcsel_period_pclks;
+
+      uint16_t msrc_dss_tcc_mclks, pre_range_mclks, final_range_mclks;
+      uint32_t msrc_dss_tcc_us,    pre_range_us,    final_range_us;
+    };
+
+    uint8_t address;
+    uint16_t io_timeout;
+    bool did_timeout;
+    uint16_t timeout_start_ms;
+
+    uint8_t stop_variable; // read by init and used when starting measurement; is StopVariable field of VL53L0X_DevData_t structure in API
+    uint32_t measurement_timing_budget_us;
+
+    bool getSpadInfo(uint8_t * count, bool * type_is_aperture);
+
+    void getSequenceStepEnables(SequenceStepEnables * enables);
+    void getSequenceStepTimeouts(SequenceStepEnables const * enables, SequenceStepTimeouts * timeouts);
+
+    bool performSingleRefCalibration(uint8_t vhv_init_byte);
+
+    static uint16_t decodeTimeout(uint16_t value);
+    static uint16_t encodeTimeout(uint16_t timeout_mclks);
+    static uint32_t timeoutMclksToMicroseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks);
+    static uint32_t timeoutMicrosecondsToMclks(uint32_t timeout_period_us, uint8_t vcsel_period_pclks);
+
+    // mbed members
+    I2C* i2c;
+    Timer* timer;
+};
+
+#endif