commit 6ebebd4d7aa9aa16a2322c41de61d41fd62140d4
Author: Andre Raming <araming@techfak.uni-bielefeld.de>
Date:   Wed Apr 24 11:38:25 2019 +0200

    added api st

diff --git a/Makefile b/Makefile
index 9c141d9..e7d2794 100755
--- a/Makefile
+++ b/Makefile
@@ -28,8 +28,13 @@ AMIROLLD_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
 
 # include paths
 AMIROLLD_INC = $(AMIROLLD_DIR) \
-               $(sort $(dir $(wildcard $(AMIROLLD_DIR)include/?*/)))
+               $(sort $(dir $(wildcard $(AMIROLLD_DIR)include/?*/)))\
+               $(AMIROLLD_DIR)include/VL53L0X/v1/Api_vl53l0x/core/inc \
+               $(AMIROLLD_DIR)include/VL53L0X/v1/Api_vl53l0x/platform/inc
+#$(info $(AMIROLLD_INC))
 
 # C sources
-AMIROLLD_CSRC = $(wildcard $(AMIROLLD_DIR)source/*/*/*.c)
-
+AMIROLLD_CSRC = $(shell find $(AMIROLLD_DIR)source/ -type f -regex "$(AMIROLLD_DIR)source/.+\.c")\
+		$(shell find $(AMIROLLD_DIR)include/ -type f -regex "$(AMIROLLD_DIR)include/.+\.c")
+#$(info $(AMIROLLD_CSRC))
+#exit
diff --git a/amiro-lld.h b/amiro-lld.h
index 06cbfbc..6523247 100644
--- a/amiro-lld.h
+++ b/amiro-lld.h
@@ -73,7 +73,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #error "incompatible AMiRo-LLD configuration file"
 #endif
 
-#include "periphALtypes.h"
+#include <periphALtypes.h>
 #include <periphAL.h>
 #if !defined(PERIPHAL_VERSION_MAJOR) || !defined(PERIPHAL_VERSION_MINOR)
 #error "invalid periphAL implementation"
diff --git a/include/VL53L0X/alld_VL53L0X.h b/include/VL53L0X/alld_VL53L0X.h
new file mode 100644
index 0000000..ff9d0b2
--- /dev/null
+++ b/include/VL53L0X/alld_VL53L0X.h
@@ -0,0 +1,44 @@
+/*
+AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
+Copyright (C) 2016..2019  Thomas Schöpping et al.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    alld_VL53L0X.h
+ *
+ * @addtogroup lld_proximity
+ * @{
+ */
+
+#ifndef AMIROLLD_VL53L0X_H
+#define AMIROLLD_VL53L0X_H
+
+#include <amiro-lld.h>
+
+#if defined(AMIROLLD_CFG_VL53L0X)
+
+#if (AMIROLLD_CFG_VL53L0X == 1)
+  #include "v1/alld_VL53L0X_v1.h"
+#else
+  #error "invalid value assigned to AMIROLLD_CFG_VL53L0X in alldconf.h"
+#endif
+
+#endif /* defined(AMIROLLD_CFG_VL53L0X) */
+
+#endif /* AMIROLLD_VL53L0X_H */
+
+/** @} */
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api.h
new file mode 100644
index 0000000..03f34a9
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api.h
@@ -0,0 +1,1959 @@
+/*******************************************************************************
+ 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_H_
+#define _VL53L0X_API_H_
+
+
+
+#include "vl53l0x_api_strings.h"
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+//#include "alld_vl53l0x.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+//#ifdef _MSC_VER
+//#   ifdef VL53L0X_API_EXPORTS
+//#       define VL53L0X_API  __declspec(dllexport)
+//#   else
+//#       define VL53L0X_API
+//#   endif
+//#else
+#define VL53L0X_API
+//#endif
+
+
+
+#define USE_I2C_2V8
+
+/** @defgroup VL53L0X_cut11_group VL53L0X cut1.1 Function Definition
+ *  @brief    VL53L0X cut1.1 Function Definition
+ *  @{
+ */
+
+/** @defgroup VL53L0X_general_group VL53L0X General Functions
+ *  @brief    General functions and definitions
+ *  @{
+ */
+
+/**
+ * @brief Return the VL53L0X PAL Implementation Version
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   pVersion              Pointer to current PAL Implementation Version
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetVersion(VL53L0X_Version_t *pVersion);
+
+/**
+ * @brief Return the PAL Specification Version used for the current
+ * implementation.
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   pPalSpecVersion       Pointer to current PAL Specification Version
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetPalSpecVersion(
+    VL53L0X_Version_t *pPalSpecVersion);
+
+/**
+ * @brief Reads the Product Revision for a for given Device
+ * This function can be used to distinguish cut1.0 from cut1.1.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                 Device Handle
+ * @param   pProductRevisionMajor  Pointer to Product Revision Major
+ * for a given Device
+ * @param   pProductRevisionMinor  Pointer to Product Revision Minor
+ * for a given Device
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetProductRevision(VL53L0X_DEV Dev,
+    uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor);
+
+/**
+ * @brief Reads the Device information for given Device
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                 Device Handle
+ * @param   pVL53L0X_DeviceInfo  Pointer to current device info for a given
+ *  Device
+ * @return  VL53L0X_ERROR_NONE   Success
+ * @return  "Other error code"  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
+    VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
+
+/**
+ * @brief Read current status of the error register for the selected device
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pDeviceErrorStatus    Pointer to current error code of the device
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDeviceErrorStatus(VL53L0X_DEV Dev,
+    VL53L0X_DeviceError *pDeviceErrorStatus);
+
+/**
+ * @brief Human readable Range Status string for a given RangeStatus
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   RangeStatus         The RangeStatus code as stored on
+ * @a VL53L0X_RangingMeasurementData_t
+ * @param   pRangeStatusString  The returned RangeStatus string.
+ * @return  VL53L0X_ERROR_NONE   Success
+ * @return  "Other error code"  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetRangeStatusString(uint8_t RangeStatus,
+    char *pRangeStatusString);
+
+/**
+ * @brief Human readable error string for a given Error Code
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   ErrorCode           The error code as stored on ::VL53L0X_DeviceError
+ * @param   pDeviceErrorString  The error string corresponding to the ErrorCode
+ * @return  VL53L0X_ERROR_NONE   Success
+ * @return  "Other error code"  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDeviceErrorString(
+    VL53L0X_DeviceError ErrorCode, char *pDeviceErrorString);
+
+/**
+ * @brief Human readable error string for current PAL error status
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   PalErrorCode       The error code as stored on @a VL53L0X_Error
+ * @param   pPalErrorString    The error string corresponding to the
+ * PalErrorCode
+ * @return  VL53L0X_ERROR_NONE  Success
+ * @return  "Other error code" See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetPalErrorString(VL53L0X_Error PalErrorCode,
+    char *pPalErrorString);
+
+/**
+ * @brief Human readable PAL State string
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   PalStateCode          The State code as stored on @a VL53L0X_State
+ * @param   pPalStateString       The State string corresponding to the
+ * PalStateCode
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetPalStateString(VL53L0X_State PalStateCode,
+    char *pPalStateString);
+
+/**
+ * @brief Reads the internal state of the PAL for a given Device
+ *
+ * @note This function doesn't access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pPalState             Pointer to current state of the PAL for a
+ * given Device
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetPalState(VL53L0X_DEV Dev,
+    VL53L0X_State *pPalState);
+
+/**
+ * @brief Set the power mode for a given Device
+ * The power mode can be Standby or Idle. Different level of both Standby and
+ * Idle can exists.
+ * This function should not be used when device is in Ranging state.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   PowerMode             The value of the power mode to set.
+ * see ::VL53L0X_PowerModes
+ *                                Valid values are:
+ *                                VL53L0X_POWERMODE_STANDBY_LEVEL1,
+ *                                VL53L0X_POWERMODE_IDLE_LEVEL1
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  VL53L0X_ERROR_MODE_NOT_SUPPORTED    This error occurs when PowerMode
+ * is not in the supported list
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetPowerMode(VL53L0X_DEV Dev,
+    VL53L0X_PowerModes PowerMode);
+
+/**
+ * @brief Get the power mode for a given Device
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pPowerMode            Pointer to the current value of the power
+ * mode. see ::VL53L0X_PowerModes
+ *                                Valid values are:
+ *                                VL53L0X_POWERMODE_STANDBY_LEVEL1,
+ *                                VL53L0X_POWERMODE_IDLE_LEVEL1
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetPowerMode(VL53L0X_DEV Dev,
+    VL53L0X_PowerModes *pPowerMode);
+
+/**
+ * Set or over-hide part to part calibration offset
+ * \sa VL53L0X_DataInit()   VL53L0X_GetOffsetCalibrationDataMicroMeter()
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                Device Handle
+ * @param   OffsetCalibrationDataMicroMeter    Offset (microns)
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  "Other error code"                 See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetOffsetCalibrationDataMicroMeter(
+    VL53L0X_DEV Dev, int32_t OffsetCalibrationDataMicroMeter);
+
+/**
+ * @brief Get part to part calibration offset
+ *
+ * @par Function Description
+ * Should only be used after a successful call to @a VL53L0X_DataInit to backup
+ * device NVM value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                Device Handle
+ * @param   pOffsetCalibrationDataMicroMeter   Return part to part
+ * calibration offset from device (microns)
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  "Other error code"                 See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetOffsetCalibrationDataMicroMeter(
+    VL53L0X_DEV Dev, int32_t *pOffsetCalibrationDataMicroMeter);
+
+/**
+ * Set the linearity corrective gain
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                Device Handle
+ * @param   LinearityCorrectiveGain            Linearity corrective
+ * gain in x1000
+ * if value is 1000 then no modification is applied.
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  "Other error code"                 See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetLinearityCorrectiveGain(VL53L0X_DEV Dev,
+    int16_t LinearityCorrectiveGain);
+
+/**
+ * @brief Get the linearity corrective gain
+ *
+ * @par Function Description
+ * Should only be used after a successful call to @a VL53L0X_DataInit to backup
+ * device NVM value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                Device Handle
+ * @param   pLinearityCorrectiveGain           Pointer to the linearity
+ * corrective gain in x1000
+ * if value is 1000 then no modification is applied.
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  "Other error code"                 See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLinearityCorrectiveGain(VL53L0X_DEV Dev,
+    uint16_t *pLinearityCorrectiveGain);
+
+/**
+ * Set Group parameter Hold state
+ *
+ * @par Function Description
+ * Set or remove device internal group parameter hold
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev      Device Handle
+ * @param   GroupParamHold   Group parameter Hold state to be set (on/off)
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED        Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetGroupParamHold(VL53L0X_DEV Dev,
+    uint8_t GroupParamHold);
+
+/**
+ * @brief Get the maximal distance for actual setup
+ * @par Function Description
+ * Device must be initialized through @a VL53L0X_SetParameters() prior calling
+ * this function.
+ *
+ * Any range value more than the value returned is to be considered as
+ * "no target detected" or
+ * "no target in detectable range"\n
+ * @warning The maximal distance depends on the setup
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev      Device Handle
+ * @param   pUpperLimitMilliMeter   The maximal range limit for actual setup
+ * (in millimeter)
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED        Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetUpperLimitMilliMeter(VL53L0X_DEV Dev,
+    uint16_t *pUpperLimitMilliMeter);
+
+
+/**
+ * @brief Get the Total Signal Rate
+ * @par Function Description
+ * This function will return the Total Signal Rate after a good ranging is done.
+ *
+ * @note This function access to Device
+ *
+ * @param   Dev      Device Handle
+ * @param   pTotalSignalRate   Total Signal Rate value in Mega count per second
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_GetTotalSignalRate(VL53L0X_DEV Dev,
+    FixPoint1616_t *pTotalSignalRate);
+
+/** @} VL53L0X_general_group */
+
+/** @defgroup VL53L0X_init_group VL53L0X Init Functions
+ *  @brief    VL53L0X Init Functions
+ *  @{
+ */
+
+/**
+ * @brief Set new device address
+ *
+ * After completion the device will answer to the new address programmed.
+ * This function should be called when several devices are used in parallel
+ * before start programming the sensor.
+ * When a single device us used, there is no need to call this function.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   DeviceAddress         The new Device address
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev,
+    uint8_t DeviceAddress);
+
+/**
+ *
+ * @brief One time device initialization
+ *
+ * To be called once and only once after device is brought out of reset
+ * (Chip enable) and booted see @a VL53L0X_WaitDeviceBooted()
+ *
+ * @par Function Description
+ * When not used after a fresh device "power up" or reset, it may return
+ * @a #VL53L0X_ERROR_CALIBRATION_WARNING meaning wrong calibration data
+ * may have been fetched from device that can result in ranging offset error\n
+ * If application cannot execute device reset or need to run VL53L0X_DataInit
+ * multiple time then it  must ensure proper offset calibration saving and
+ * restore on its own by using @a VL53L0X_GetOffsetCalibrationData() on first
+ * power up and then @a VL53L0X_SetOffsetCalibrationData() in all subsequent init
+ * This function will change the VL53L0X_State from VL53L0X_STATE_POWERDOWN to
+ * VL53L0X_STATE_WAIT_STATICINIT.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_DataInit(VL53L0X_DEV Dev);
+
+/**
+ * @brief Set the tuning settings pointer
+ *
+ * This function is used to specify the Tuning settings buffer to be used
+ * for a given device. The buffer contains all the necessary data to permit
+ * the API to write tuning settings.
+ * This function permit to force the usage of either external or internal
+ * tuning settings.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                             Device Handle
+ * @param   pTuningSettingBuffer            Pointer to tuning settings buffer.
+ * @param   UseInternalTuningSettings       Use internal tuning settings value.
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetTuningSettingBuffer(VL53L0X_DEV Dev,
+    uint8_t *pTuningSettingBuffer, uint8_t UseInternalTuningSettings);
+
+/**
+ * @brief Get the tuning settings pointer and the internal external switch
+ * value.
+ *
+ * This function is used to get the Tuning settings buffer pointer and the
+ * value.
+ * of the switch to select either external or internal tuning settings.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                        Device Handle
+ * @param   ppTuningSettingBuffer      Pointer to tuning settings buffer.
+ * @param   pUseInternalTuningSettings Pointer to store Use internal tuning
+ *                                     settings value.
+ * @return  VL53L0X_ERROR_NONE          Success
+ * @return  "Other error code"         See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetTuningSettingBuffer(VL53L0X_DEV Dev,
+    uint8_t **ppTuningSettingBuffer, uint8_t *pUseInternalTuningSettings);
+
+/**
+ * @brief Do basic device init (and eventually patch loading)
+ * This function will change the VL53L0X_State from
+ * VL53L0X_STATE_WAIT_STATICINIT to VL53L0X_STATE_IDLE.
+ * In this stage all default setting will be applied.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_StaticInit(VL53L0X_DEV Dev);
+
+/**
+ * @brief Wait for device booted after chip enable (hardware standby)
+ * This function can be run only when VL53L0X_State is VL53L0X_STATE_POWERDOWN.
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev      Device Handle
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED Not implemented
+ *
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev);
+
+/**
+ * @brief Do an hard reset or soft reset (depending on implementation) of the
+ * device \nAfter call of this function, device must be in same state as right
+ * after a power-up sequence.This function will change the VL53L0X_State to
+ * VL53L0X_STATE_POWERDOWN.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_ResetDevice(VL53L0X_DEV Dev);
+
+/** @} VL53L0X_init_group */
+
+/** @defgroup VL53L0X_parameters_group VL53L0X Parameters Functions
+ *  @brief    Functions used to prepare and setup the device
+ *  @{
+ */
+
+/**
+ * @brief  Prepare device for operation
+ * @par Function Description
+ * Update device with provided parameters
+ * @li Then start ranging operation.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pDeviceParameters     Pointer to store current device parameters.
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetDeviceParameters(VL53L0X_DEV Dev,
+    const VL53L0X_DeviceParameters_t *pDeviceParameters);
+
+/**
+ * @brief  Retrieve current device parameters
+ * @par Function Description
+ * Get actual parameters of the device
+ * @li Then start ranging operation.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pDeviceParameters     Pointer to store current device parameters.
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
+    VL53L0X_DeviceParameters_t *pDeviceParameters);
+
+/**
+ * @brief  Set a new device mode
+ * @par Function Description
+ * Set device to a new mode (ranging, histogram ...)
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @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
+ *
+ *
+ * @return  VL53L0X_ERROR_NONE               Success
+ * @return  VL53L0X_ERROR_MODE_NOT_SUPPORTED This error occurs when DeviceMode is
+ *                                          not in the supported list
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetDeviceMode(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes DeviceMode);
+
+/**
+ * @brief  Get current new device mode
+ * @par Function Description
+ * Get actual mode of the device(ranging, histogram ...)
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pDeviceMode           Pointer to current apply mode value
+ *                                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
+ *
+ * @return  VL53L0X_ERROR_NONE                   Success
+ * @return  VL53L0X_ERROR_MODE_NOT_SUPPORTED     This error occurs when
+ * DeviceMode is not in the supported list
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes *pDeviceMode);
+
+/**
+ * @brief  Sets the resolution of range measurements.
+ * @par Function Description
+ * Set resolution of range measurements to either 0.25mm if
+ * fraction enabled or 1mm if not enabled.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev               Device Handle
+ * @param   Enable            Enable high resolution
+ *
+ * @return  VL53L0X_ERROR_NONE               Success
+ * @return  "Other error code"              See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetRangeFractionEnable(VL53L0X_DEV Dev,
+    uint8_t Enable);
+
+/**
+ * @brief  Gets the fraction enable parameter indicating the resolution of
+ * range measurements.
+ *
+ * @par Function Description
+ * Gets the fraction enable state, which translates to the resolution of
+ * range measurements as follows :Enabled:=0.25mm resolution,
+ * Not Enabled:=1mm resolution.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev               Device Handle
+ * @param   pEnable           Output Parameter reporting the fraction enable state.
+ *
+ * @return  VL53L0X_ERROR_NONE                   Success
+ * @return  "Other error code"                  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetFractionEnable(VL53L0X_DEV Dev,
+    uint8_t *pEnable);
+
+/**
+ * @brief  Set a new Histogram mode
+ * @par Function Description
+ * Set device to a new Histogram mode
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   HistogramMode         New device mode to apply
+ *                                Valid values are:
+ *                                VL53L0X_HISTOGRAMMODE_DISABLED
+ *                                VL53L0X_DEVICEMODE_SINGLE_HISTOGRAM
+ *                                VL53L0X_HISTOGRAMMODE_REFERENCE_ONLY
+ *                                VL53L0X_HISTOGRAMMODE_RETURN_ONLY
+ *                                VL53L0X_HISTOGRAMMODE_BOTH
+ *
+ * @return  VL53L0X_ERROR_NONE                   Success
+ * @return  VL53L0X_ERROR_MODE_NOT_SUPPORTED     This error occurs when
+ * HistogramMode is not in the supported list
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetHistogramMode(VL53L0X_DEV Dev,
+    VL53L0X_HistogramModes HistogramMode);
+
+/**
+ * @brief  Get current new device mode
+ * @par Function Description
+ * Get current Histogram mode of a Device
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pHistogramMode        Pointer to current Histogram Mode value
+ *                                Valid values are:
+ *                                VL53L0X_HISTOGRAMMODE_DISABLED
+ *                                VL53L0X_DEVICEMODE_SINGLE_HISTOGRAM
+ *                                VL53L0X_HISTOGRAMMODE_REFERENCE_ONLY
+ *                                VL53L0X_HISTOGRAMMODE_RETURN_ONLY
+ *                                VL53L0X_HISTOGRAMMODE_BOTH
+ * @return  VL53L0X_ERROR_NONE     Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetHistogramMode(VL53L0X_DEV Dev,
+    VL53L0X_HistogramModes *pHistogramMode);
+
+/**
+ * @brief Set Ranging Timing Budget in microseconds
+ *
+ * @par Function Description
+ * Defines the maximum time allowed by the user to the device to run a
+ * full ranging sequence for the current mode (ranging, histogram, ASL ...)
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                Device Handle
+ * @param MeasurementTimingBudgetMicroSeconds  Max measurement time in
+ * microseconds.
+ *                                   Valid values are:
+ *                                   >= 17000 microsecs when wraparound enabled
+ *                                   >= 12000 microsecs when wraparound disabled
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned if
+ MeasurementTimingBudgetMicroSeconds out of range
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetMeasurementTimingBudgetMicroSeconds(
+    VL53L0X_DEV Dev, uint32_t MeasurementTimingBudgetMicroSeconds);
+
+/**
+ * @brief Get Ranging Timing Budget in microseconds
+ *
+ * @par Function Description
+ * Returns the programmed the maximum time allowed by the user to the
+ * device to run a full ranging sequence for the current mode
+ * (ranging, histogram, ASL ...)
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                    Device Handle
+ * @param   pMeasurementTimingBudgetMicroSeconds   Max measurement time in
+ * microseconds.
+ *                                   Valid values are:
+ *                                   >= 17000 microsecs when wraparound enabled
+ *                                   >= 12000 microsecs when wraparound disabled
+ * @return  VL53L0X_ERROR_NONE                      Success
+ * @return  "Other error code"                     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetMeasurementTimingBudgetMicroSeconds(
+    VL53L0X_DEV Dev, uint32_t *pMeasurementTimingBudgetMicroSeconds);
+
+/**
+ * @brief Gets the VCSEL pulse period.
+ *
+ * @par Function Description
+ * This function retrieves the VCSEL pulse period for the given period type.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                      Device Handle
+ * @param   VcselPeriodType          VCSEL period identifier (pre-range|final).
+ * @param   pVCSELPulsePeriod        Pointer to VCSEL period value.
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error VcselPeriodType parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriod);
+
+/**
+ * @brief Sets the VCSEL pulse period.
+ *
+ * @par Function Description
+ * This function retrieves the VCSEL pulse period for the given period type.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                       Device Handle
+ * @param   VcselPeriodType	      VCSEL period identifier (pre-range|final).
+ * @param   VCSELPulsePeriod          VCSEL period value
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error VcselPeriodType parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriod);
+
+/**
+ * @brief Sets the (on/off) state of a requested sequence step.
+ *
+ * @par Function Description
+ * This function enables/disables a requested sequence step.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   SequenceStepId	         Sequence step identifier.
+ * @param   SequenceStepEnabled          Demanded state {0=Off,1=On}
+ *                                       is enabled.
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error SequenceStepId parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled);
+
+/**
+ * @brief Gets the (on/off) state of a requested sequence step.
+ *
+ * @par Function Description
+ * This function retrieves the state of a requested sequence step, i.e. on/off.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   SequenceStepId         Sequence step identifier.
+ * @param   pSequenceStepEnabled   Out parameter reporting if the sequence step
+ *                                 is enabled {0=Off,1=On}.
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error SequenceStepId parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSequenceStepEnable(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, uint8_t *pSequenceStepEnabled);
+
+/**
+ * @brief Gets the (on/off) state of all sequence steps.
+ *
+ * @par Function Description
+ * This function retrieves the state of all sequence step in the scheduler.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   pSchedulerSequenceSteps      Pointer to struct containing result.
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
+    VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps);
+
+/**
+ * @brief Sets the timeout of a requested sequence step.
+ *
+ * @par Function Description
+ * This function sets the timeout of a requested sequence step.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   SequenceStepId               Sequence step identifier.
+ * @param   TimeOutMilliSecs             Demanded timeout
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error SequenceStepId parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetSequenceStepTimeout(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, FixPoint1616_t TimeOutMilliSecs);
+
+/**
+ * @brief Gets the timeout of a requested sequence step.
+ *
+ * @par Function Description
+ * This function retrieves the timeout of a requested sequence step.
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   SequenceStepId               Sequence step identifier.
+ * @param   pTimeOutMilliSecs            Timeout value.
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS  Error SequenceStepId parameter not
+ *                                       supported.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSequenceStepTimeout(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId,
+    FixPoint1616_t *pTimeOutMilliSecs);
+
+/**
+ * @brief Gets number of sequence steps managed by the API.
+ *
+ * @par Function Description
+ * This function retrieves the number of sequence steps currently managed
+ * by the API
+ *
+ * @note This function Accesses the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   pNumberOfSequenceSteps       Out parameter reporting the number of
+ *                                       sequence steps.
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetNumberOfSequenceSteps(VL53L0X_DEV Dev,
+    uint8_t *pNumberOfSequenceSteps);
+
+/**
+ * @brief Gets the name of a given sequence step.
+ *
+ * @par Function Description
+ * This function retrieves the name of sequence steps corresponding to
+ * SequenceStepId.
+ *
+ * @note This function doesn't Accesses the device
+ *
+ * @param   SequenceStepId               Sequence step identifier.
+ * @param   pSequenceStepsString         Pointer to Info string
+ *
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSequenceStepsInfo(
+    VL53L0X_SequenceStepId SequenceStepId, char *pSequenceStepsString);
+
+/**
+ * Program continuous mode Inter-Measurement period in milliseconds
+ *
+ * @par Function Description
+ * When trying to set too short time return  INVALID_PARAMS minimal value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                  Device Handle
+ * @param   InterMeasurementPeriodMilliSeconds   Inter-Measurement Period in ms.
+ * @return  VL53L0X_ERROR_NONE                    Success
+ * @return  "Other error code"                   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetInterMeasurementPeriodMilliSeconds(
+    VL53L0X_DEV Dev, uint32_t InterMeasurementPeriodMilliSeconds);
+
+/**
+ * Get continuous mode Inter-Measurement period in milliseconds
+ *
+ * @par Function Description
+ * When trying to set too short time return  INVALID_PARAMS minimal value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                                  Device Handle
+ * @param   pInterMeasurementPeriodMilliSeconds  Pointer to programmed
+ *  Inter-Measurement Period in milliseconds.
+ * @return  VL53L0X_ERROR_NONE                    Success
+ * @return  "Other error code"                   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetInterMeasurementPeriodMilliSeconds(
+    VL53L0X_DEV Dev, uint32_t *pInterMeasurementPeriodMilliSeconds);
+
+/**
+ * @brief Enable/Disable Cross talk compensation feature
+ *
+ * @note This function is not Implemented.
+ * Enable/Disable Cross Talk by set to zero the Cross Talk value
+ * by using @a VL53L0X_SetXTalkCompensationRateMegaCps().
+ *
+ * @param   Dev                       Device Handle
+ * @param   XTalkCompensationEnable   Cross talk compensation
+ *  to be set 0=disabled else = enabled
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetXTalkCompensationEnable(VL53L0X_DEV Dev,
+    uint8_t XTalkCompensationEnable);
+
+/**
+ * @brief Get Cross talk compensation rate
+ *
+ * @note This function is not Implemented.
+ * Enable/Disable Cross Talk by set to zero the Cross Talk value by
+ * using @a VL53L0X_SetXTalkCompensationRateMegaCps().
+ *
+ * @param   Dev                        Device Handle
+ * @param   pXTalkCompensationEnable   Pointer to the Cross talk compensation
+ *  state 0=disabled or 1 = enabled
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
+    uint8_t *pXTalkCompensationEnable);
+
+/**
+ * @brief Set Cross talk compensation rate
+ *
+ * @par Function Description
+ * Set Cross talk compensation rate.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                            Device Handle
+ * @param   XTalkCompensationRateMegaCps   Compensation rate in
+ *  Mega counts per second (16.16 fix point) see datasheet for details
+ * @return  VL53L0X_ERROR_NONE              Success
+ * @return  "Other error code"             See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
+    FixPoint1616_t XTalkCompensationRateMegaCps);
+
+/**
+ * @brief Get Cross talk compensation rate
+ *
+ * @par Function Description
+ * Get Cross talk compensation rate.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                            Device Handle
+ * @param   pXTalkCompensationRateMegaCps  Pointer to Compensation rate
+ in Mega counts per second (16.16 fix point) see datasheet for details
+ * @return  VL53L0X_ERROR_NONE              Success
+ * @return  "Other error code"             See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
+    FixPoint1616_t *pXTalkCompensationRateMegaCps);
+
+/**
+ * @brief Set Reference Calibration Parameters
+ *
+ * @par Function Description
+ * Set Reference Calibration Parameters.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                            Device Handle
+ * @param   VhvSettings                    Parameter for VHV
+ * @param   PhaseCal                       Parameter for PhaseCal
+ * @return  VL53L0X_ERROR_NONE              Success
+ * @return  "Other error code"             See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetRefCalibration(VL53L0X_DEV Dev,
+    uint8_t VhvSettings, uint8_t PhaseCal);
+
+/**
+ * @brief Get Reference Calibration Parameters
+ *
+ * @par Function Description
+ * Get Reference Calibration Parameters.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                            Device Handle
+ * @param   pVhvSettings                   Pointer to VHV parameter
+ * @param   pPhaseCal                      Pointer to PhaseCal Parameter
+ * @return  VL53L0X_ERROR_NONE              Success
+ * @return  "Other error code"             See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetRefCalibration(VL53L0X_DEV Dev,
+    uint8_t *pVhvSettings, uint8_t *pPhaseCal);
+
+/**
+ * @brief  Get the number of the check limit managed by a given Device
+ *
+ * @par Function Description
+ * This function give the number of the check limit managed by the Device
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   pNumberOfLimitCheck           Pointer to the number of check limit.
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetNumberOfLimitCheck(
+    uint16_t *pNumberOfLimitCheck);
+
+/**
+ * @brief  Return a description string for a given limit check number
+ *
+ * @par Function Description
+ * This function returns a description string for a given limit check number.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   pLimitCheckString             Pointer to the
+ description string of the given check limit.
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is
+ returned when LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLimitCheckInfo(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, char *pLimitCheckString);
+
+/**
+ * @brief  Return a the Status of the specified check limit
+ *
+ * @par Function Description
+ * This function returns the Status of the specified check limit.
+ * The value indicate if the check is fail or not.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   pLimitCheckStatus             Pointer to the
+ Limit Check Status of the given check limit.
+ * LimitCheckStatus :
+ * 0 the check is not fail
+ * 1 the check if fail or not enabled
+ *
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is
+ returned when LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLimitCheckStatus(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, uint8_t *pLimitCheckStatus);
+
+/**
+ * @brief  Enable/Disable a specific limit check
+ *
+ * @par Function Description
+ * This function Enable/Disable a specific limit check.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @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  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned
+ *  when LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, uint8_t LimitCheckEnable);
+
+/**
+ * @brief  Get specific limit check enable state
+ *
+ * @par Function Description
+ * This function get the enable state of a specific limit check.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ *  (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   pLimitCheckEnable             Pointer to the check limit enable
+ * value.
+ *  if 1 the check limit
+ *        corresponding to LimitCheckId is Enabled
+ *  if 0 the check limit
+ *        corresponding to LimitCheckId is disabled
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned
+ *  when LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, uint8_t *pLimitCheckEnable);
+
+/**
+ * @brief  Set a specific limit check value
+ *
+ * @par Function Description
+ * This function set a specific limit check value.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ *  (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   LimitCheckValue               Limit check Value for a given
+ * LimitCheckId
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned when either
+ *  LimitCheckId or LimitCheckValue value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, FixPoint1616_t LimitCheckValue);
+
+/**
+ * @brief  Get a specific limit check value
+ *
+ * @par Function Description
+ * This function get a specific limit check value from device then it updates
+ * internal values and check enables.
+ * The limit check is identified with the LimitCheckId.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ *  (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   pLimitCheckValue              Pointer to Limit
+ *  check Value for a given LimitCheckId.
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned
+ *  when LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, FixPoint1616_t *pLimitCheckValue);
+
+/**
+ * @brief  Get the current value of the signal used for the limit check
+ *
+ * @par Function Description
+ * This function get a the current value of the signal used for the limit check.
+ * To obtain the latest value you should run a ranging before.
+ * The value reported is linked to the limit check identified with the
+ * LimitCheckId.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   LimitCheckId                  Limit Check ID
+ *  (0<= LimitCheckId < VL53L0X_GetNumberOfLimitCheck() ).
+ * @param   pLimitCheckCurrent            Pointer to current Value for a
+ * given LimitCheckId.
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned when
+ * LimitCheckId value is out of range.
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetLimitCheckCurrent(VL53L0X_DEV Dev,
+    uint16_t LimitCheckId, FixPoint1616_t *pLimitCheckCurrent);
+
+/**
+ * @brief  Enable (or disable) Wrap around Check
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   WrapAroundCheckEnable  Wrap around Check to be set
+ *                                 0=disabled, other = enabled
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetWrapAroundCheckEnable(VL53L0X_DEV Dev,
+        uint8_t WrapAroundCheckEnable);
+
+/**
+ * @brief  Get setup of Wrap around Check
+ *
+ * @par Function Description
+ * This function get the wrapAround check enable parameters
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                     Device Handle
+ * @param   pWrapAroundCheckEnable  Pointer to the Wrap around Check state
+ *                                  0=disabled or 1 = enabled
+ * @return  VL53L0X_ERROR_NONE       Success
+ * @return  "Other error code"      See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
+        uint8_t *pWrapAroundCheckEnable);
+
+/**
+ * @brief   Set Dmax Calibration Parameters for a given device
+ * When one of the parameter is zero, this function will get parameter
+ * from NVM.
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   RangeMilliMeter        Calibration Distance
+ * @param   SignalRateRtnMegaCps   Signal rate return read at CalDistance
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetDmaxCalParameters(VL53L0X_DEV Dev,
+        uint16_t RangeMilliMeter, FixPoint1616_t SignalRateRtnMegaCps);
+
+/**
+ * @brief  Get Dmax Calibration Parameters for a given device
+ *
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                     Device Handle
+ * @param   pRangeMilliMeter        Pointer to Calibration Distance
+ * @param   pSignalRateRtnMegaCps   Pointer to Signal rate return
+ * @return  VL53L0X_ERROR_NONE       Success
+ * @return  "Other error code"      See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetDmaxCalParameters(VL53L0X_DEV Dev,
+    uint16_t *pRangeMilliMeter, FixPoint1616_t *pSignalRateRtnMegaCps);
+
+/** @} VL53L0X_parameters_group */
+
+/** @defgroup VL53L0X_measurement_group VL53L0X Measurement Functions
+ *  @brief    Functions used for the measurements
+ *  @{
+ */
+
+/**
+ * @brief Single shot measurement.
+ *
+ * @par Function Description
+ * Perform simple measurement sequence (Start measure, Wait measure to end,
+ * and returns when measurement is done).
+ * Once function returns, user can get valid data by calling
+ * VL53L0X_GetRangingMeasurement or VL53L0X_GetHistogramMeasurement
+ * depending on defined measurement mode
+ * User should Clear the interrupt in case this are enabled by using the
+ * function VL53L0X_ClearInterruptMask().
+ *
+ * @warning This function is a blocking function
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                  Device Handle
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev);
+
+/**
+ * @brief Perform Reference Calibration
+ *
+ * @details Perform a reference calibration of the Device.
+ * This function should be run from time to time before doing
+ * a ranging measurement.
+ * This function will launch a special ranging measurement, so
+ * if interrupt are enable an interrupt will be done.
+ * This function will clear the interrupt generated automatically.
+ *
+ * @warning This function is a blocking function
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                  Device Handle
+ * @param   pVhvSettings         Pointer to vhv settings parameter.
+ * @param   pPhaseCal            Pointer to PhaseCal parameter.
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev,
+    uint8_t *pVhvSettings, uint8_t *pPhaseCal);
+
+/**
+ * @brief Perform XTalk Measurement
+ *
+ * @details Measures the current cross talk from glass in front
+ * of the sensor.
+ * This functions performs a histogram measurement and uses the results
+ * to measure the crosstalk. For the function to be successful, there
+ * must be no target in front of the sensor.
+ *
+ * @warning This function is a blocking function
+ *
+ * @warning This function is not supported when the final range
+ * vcsel clock period is set below 10 PCLKS.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                  Device Handle
+ * @param   TimeoutMs            Histogram measurement duration.
+ * @param   pXtalkPerSpad        Output parameter containing the crosstalk
+ * measurement result, in MCPS/Spad. Format fixpoint 16:16.
+ * @param   pAmbientTooHigh      Output parameter which indicate that
+ * pXtalkPerSpad is not good if the Ambient is too high.
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS vcsel clock period not supported
+ * for this operation. Must not be less than 10PCLKS.
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformXTalkMeasurement(VL53L0X_DEV Dev,
+    uint32_t TimeoutMs, FixPoint1616_t *pXtalkPerSpad,
+    uint8_t *pAmbientTooHigh);
+
+/**
+ * @brief Perform XTalk Calibration
+ *
+ * @details Perform a XTalk calibration of the Device.
+ * This function will launch a ranging measurement, if interrupts
+ * are enabled an interrupt will be done.
+ * This function will clear the interrupt generated automatically.
+ * This function will program a new value for the XTalk compensation
+ * and it will enable the cross talk before exit.
+ * This function will disable the VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD.
+ *
+ * @warning This function is a blocking function
+ *
+ * @note This function Access to the device
+ *
+ * @note This function change the device mode to
+ * VL53L0X_DEVICEMODE_SINGLE_RANGING
+ *
+ * @param   Dev                  Device Handle
+ * @param   XTalkCalDistance     XTalkCalDistance value used for the XTalk
+ * computation.
+ * @param   pXTalkCompensationRateMegaCps  Pointer to new
+ * XTalkCompensation value.
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformXTalkCalibration(VL53L0X_DEV Dev,
+    FixPoint1616_t XTalkCalDistance,
+    FixPoint1616_t *pXTalkCompensationRateMegaCps);
+
+/**
+ * @brief Perform Offset Calibration
+ *
+ * @details Perform a Offset calibration of the Device.
+ * This function will launch a ranging measurement, if interrupts are
+ * enabled an interrupt will be done.
+ * This function will clear the interrupt generated automatically.
+ * This function will program a new value for the Offset calibration value
+ * This function will disable the VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD.
+ *
+ * @warning This function is a blocking function
+ *
+ * @note This function Access to the device
+ *
+ * @note This function does not change the device mode.
+ *
+ * @param   Dev                  Device Handle
+ * @param   CalDistanceMilliMeter     Calibration distance value used for the
+ * offset compensation.
+ * @param   pOffsetMicroMeter  Pointer to new Offset value computed by the
+ * function.
+ *
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformOffsetCalibration(VL53L0X_DEV Dev,
+    FixPoint1616_t CalDistanceMilliMeter, int32_t *pOffsetMicroMeter);
+
+/**
+ * @brief Start device measurement
+ *
+ * @details Started measurement will depend on device parameters set through
+ * @a VL53L0X_SetParameters()
+ * This is a non-blocking function.
+ * This function will change the VL53L0X_State from VL53L0X_STATE_IDLE to
+ * VL53L0X_STATE_RUNNING.
+ *
+ * @note This function Access to the device
+ *
+
+ * @param   Dev                  Device Handle
+ * @return  VL53L0X_ERROR_NONE                  Success
+ * @return  VL53L0X_ERROR_MODE_NOT_SUPPORTED    This error occurs when
+ * DeviceMode programmed with @a VL53L0X_SetDeviceMode is not in the supported
+ * list:
+ *                                   Supported mode are:
+ *                                   VL53L0X_DEVICEMODE_SINGLE_RANGING,
+ *                                   VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ *                                   VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING
+ * @return  VL53L0X_ERROR_TIME_OUT    Time out on start measurement
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_StartMeasurement(VL53L0X_DEV Dev);
+
+/**
+ * @brief Stop device measurement
+ *
+ * @details Will set the device in standby mode at end of current measurement\n
+ *          Not necessary in single mode as device shall return automatically
+ *          in standby mode at end of measurement.
+ *          This function will change the VL53L0X_State from VL53L0X_STATE_RUNNING
+ *          to VL53L0X_STATE_IDLE.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                  Device Handle
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_StopMeasurement(VL53L0X_DEV Dev);
+
+/**
+ * @brief Return Measurement Data Ready
+ *
+ * @par Function Description
+ * This function indicate that a measurement data is ready.
+ * This function check if interrupt mode is used then check is done accordingly.
+ * If perform function clear the interrupt, this function will not work,
+ * like in case of @a VL53L0X_PerformSingleRangingMeasurement().
+ * The previous function is blocking function, VL53L0X_GetMeasurementDataReady
+ * is used for non-blocking capture.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   pMeasurementDataReady  Pointer to Measurement Data Ready.
+ *  0=data not ready, 1 = data ready
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
+    uint8_t *pMeasurementDataReady);
+
+/**
+ * @brief Wait for device ready for a new measurement command.
+ * Blocking function.
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev      Device Handle
+ * @param   MaxLoop    Max Number of polling loop (timeout).
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_WaitDeviceReadyForNewMeasurement(VL53L0X_DEV Dev,
+    uint32_t MaxLoop);
+
+/**
+ * @brief Retrieve the Reference Signal after a measurements
+ *
+ * @par Function Description
+ * Get Reference Signal from last successful Ranging measurement
+ * This function return a valid value after that you call the
+ * @a VL53L0X_GetRangingMeasurementData().
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                      Device Handle
+ * @param   pMeasurementRefSignal    Pointer to the Ref Signal to fill up.
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"       See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetMeasurementRefSignal(VL53L0X_DEV Dev,
+    FixPoint1616_t *pMeasurementRefSignal);
+
+/**
+ * @brief Retrieve the measurements from device for a given setup
+ *
+ * @par Function Description
+ * Get data from last successful Ranging measurement
+ * @warning USER should take care about  @a VL53L0X_GetNumberOfROIZones()
+ * before get data.
+ * PAL will fill a NumberOfROIZones times the corresponding data
+ * structure used in the measurement function.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                      Device Handle
+ * @param   pRangingMeasurementData  Pointer to the data structure to fill up.
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"       See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
+
+/**
+ * @brief Retrieve the measurements from device for a given setup
+ *
+ * @par Function Description
+ * Get data from last successful Histogram measurement
+ * @warning USER should take care about  @a VL53L0X_GetNumberOfROIZones()
+ * before get data.
+ * PAL will fill a NumberOfROIZones times the corresponding data structure
+ * used in the measurement function.
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev                         Device Handle
+ * @param   pHistogramMeasurementData   Pointer to the histogram data structure.
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetHistogramMeasurementData(VL53L0X_DEV Dev,
+    VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData);
+
+/**
+ * @brief Performs a single ranging measurement and retrieve the ranging
+ * measurement data
+ *
+ * @par Function Description
+ * This function will change the device mode to VL53L0X_DEVICEMODE_SINGLE_RANGING
+ * with @a VL53L0X_SetDeviceMode(),
+ * It performs measurement with @a VL53L0X_PerformSingleMeasurement()
+ * It get data from last successful Ranging measurement with
+ * @a VL53L0X_GetRangingMeasurementData.
+ * Finally it clear the interrupt with @a VL53L0X_ClearInterruptMask().
+ *
+ * @note This function Access to the device
+ *
+ * @note This function change the device mode to
+ * VL53L0X_DEVICEMODE_SINGLE_RANGING
+ *
+ * @param   Dev                       Device Handle
+ * @param   pRangingMeasurementData   Pointer to the data structure to fill up.
+ * @return  VL53L0X_ERROR_NONE         Success
+ * @return  "Other error code"        See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
+
+/**
+ * @brief Performs a single histogram measurement and retrieve the histogram
+ * measurement data
+ *   Is equivalent to VL53L0X_PerformSingleMeasurement +
+ *   VL53L0X_GetHistogramMeasurementData
+ *
+ * @par Function Description
+ * Get data from last successful Ranging measurement.
+ * This function will clear the interrupt in case of these are enabled.
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev                        Device Handle
+ * @param   pHistogramMeasurementData  Pointer to the data structure to fill up.
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformSingleHistogramMeasurement(VL53L0X_DEV Dev,
+    VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData);
+
+/**
+ * @brief Set the number of ROI Zones to be used for a specific Device
+ *
+ * @par Function Description
+ * Set the number of ROI Zones to be used for a specific Device.
+ * The programmed value should be less than the max number of ROI Zones given
+ * with @a VL53L0X_GetMaxNumberOfROIZones().
+ * This version of API manage only one zone.
+ *
+ * @param   Dev                           Device Handle
+ * @param   NumberOfROIZones              Number of ROI Zones to be used for a
+ *  specific Device.
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  VL53L0X_ERROR_INVALID_PARAMS   This error is returned if
+ * NumberOfROIZones != 1
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t NumberOfROIZones);
+
+/**
+ * @brief Get the number of ROI Zones managed by the Device
+ *
+ * @par Function Description
+ * Get number of ROI Zones managed by the Device
+ * USER should take care about  @a VL53L0X_GetNumberOfROIZones()
+ * before get data after a perform measurement.
+ * PAL will fill a NumberOfROIZones times the corresponding data
+ * structure used in the measurement function.
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   pNumberOfROIZones     Pointer to the Number of ROI Zones value.
+ * @return  VL53L0X_ERROR_NONE     Success
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t *pNumberOfROIZones);
+
+/**
+ * @brief Get the Maximum number of ROI Zones managed by the Device
+ *
+ * @par Function Description
+ * Get Maximum number of ROI Zones managed by the Device.
+ *
+ * @note This function doesn't Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   pMaxNumberOfROIZones   Pointer to the Maximum Number
+ *  of ROI Zones value.
+ * @return  VL53L0X_ERROR_NONE      Success
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetMaxNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t *pMaxNumberOfROIZones);
+
+/** @} VL53L0X_measurement_group */
+
+/** @defgroup VL53L0X_interrupt_group VL53L0X Interrupt Functions
+ *  @brief    Functions used for interrupt managements
+ *  @{
+ */
+
+/**
+ * @brief Set the configuration of GPIO pin for a given device
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   Pin                   ID of the GPIO Pin
+ * @param   Functionality         Select Pin functionality.
+ *  Refer to ::VL53L0X_GpioFunctionality
+ * @param   DeviceMode            Device Mode associated to the Gpio.
+ * @param   Polarity              Set interrupt polarity. Active high
+ *   or active low see ::VL53L0X_InterruptPolarity
+ * @return  VL53L0X_ERROR_NONE                            Success
+ * @return  VL53L0X_ERROR_GPIO_NOT_EXISTING               Only Pin=0 is accepted.
+ * @return  VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED    This error occurs
+ * when Functionality programmed is not in the supported list:
+ *                             Supported value are:
+ *                             VL53L0X_GPIOFUNCTIONALITY_OFF,
+ *                             VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW,
+ *                             VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH,
+ VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT,
+ *                               VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
+    VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
+    VL53L0X_InterruptPolarity Polarity);
+
+/**
+ * @brief Get current configuration for GPIO pin for a given device
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                   Device Handle
+ * @param   Pin                   ID of the GPIO Pin
+ * @param   pDeviceMode           Pointer to Device Mode associated to the Gpio.
+ * @param   pFunctionality        Pointer to Pin functionality.
+ *  Refer to ::VL53L0X_GpioFunctionality
+ * @param   pPolarity             Pointer to interrupt polarity.
+ *  Active high or active low see ::VL53L0X_InterruptPolarity
+ * @return  VL53L0X_ERROR_NONE                            Success
+ * @return  VL53L0X_ERROR_GPIO_NOT_EXISTING               Only Pin=0 is accepted.
+ * @return  VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED   This error occurs
+ * when Functionality programmed is not in the supported list:
+ *                      Supported value are:
+ *                      VL53L0X_GPIOFUNCTIONALITY_OFF,
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW,
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH,
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT,
+ *                      VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
+    VL53L0X_DeviceModes *pDeviceMode,
+    VL53L0X_GpioFunctionality *pFunctionality,
+    VL53L0X_InterruptPolarity *pPolarity);
+
+/**
+ * @brief Set low and high Interrupt thresholds for a given mode
+ * (ranging, ALS, ...) for a given device
+ *
+ * @par Function Description
+ * Set low and high Interrupt thresholds for a given mode (ranging, ALS, ...)
+ * for a given device
+ *
+ * @note This function Access to the device
+ *
+ * @note DeviceMode is ignored for the current device
+ *
+ * @param   Dev              Device Handle
+ * @param   DeviceMode       Device Mode for which change thresholds
+ * @param   ThresholdLow     Low threshold (mm, lux ..., depending on the mode)
+ * @param   ThresholdHigh    High threshold (mm, lux ..., depending on the mode)
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetInterruptThresholds(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes DeviceMode, FixPoint1616_t ThresholdLow,
+    FixPoint1616_t ThresholdHigh);
+
+/**
+ * @brief  Get high and low Interrupt thresholds for a given mode
+ *  (ranging, ALS, ...) for a given device
+ *
+ * @par Function Description
+ * Get high and low Interrupt thresholds for a given mode (ranging, ALS, ...)
+ * for a given device
+ *
+ * @note This function Access to the device
+ *
+ * @note DeviceMode is ignored for the current device
+ *
+ * @param   Dev              Device Handle
+ * @param   DeviceMode       Device Mode from which read thresholds
+ * @param   pThresholdLow    Low threshold (mm, lux ..., depending on the mode)
+ * @param   pThresholdHigh   High threshold (mm, lux ..., depending on the mode)
+ * @return  VL53L0X_ERROR_NONE   Success
+ * @return  "Other error code"  See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
+    FixPoint1616_t *pThresholdHigh);
+
+/**
+ * @brief Return device stop completion status
+ *
+ * @par Function Description
+ * Returns stop completiob status.
+ * User shall call this function after a stop command
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   pStopStatus            Pointer to status variable to update
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
+    uint32_t *pStopStatus);
+
+
+/**
+ * @brief Clear given system interrupt condition
+ *
+ * @par Function Description
+ * Clear given interrupt(s).
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                  Device Handle
+ * @param   InterruptMask        Mask of interrupts to clear
+ * @return  VL53L0X_ERROR_NONE    Success
+ * @return  VL53L0X_ERROR_INTERRUPT_NOT_CLEARED    Cannot clear interrupts
+ *
+ * @return  "Other error code"   See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev,
+    uint32_t InterruptMask);
+
+/**
+ * @brief Return device interrupt status
+ *
+ * @par Function Description
+ * Returns currently raised interrupts by the device.
+ * User shall be able to activate/deactivate interrupts through
+ * @a VL53L0X_SetGpioConfig()
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                    Device Handle
+ * @param   pInterruptMaskStatus   Pointer to status variable to update
+ * @return  VL53L0X_ERROR_NONE      Success
+ * @return  "Other error code"     See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
+    uint32_t *pInterruptMaskStatus);
+
+/**
+ * @brief Configure ranging interrupt reported to system
+ *
+ * @note This function is not Implemented
+ *
+ * @param   Dev                  Device Handle
+ * @param   InterruptMask         Mask of interrupt to Enable/disable
+ *  (0:interrupt disabled or 1: interrupt enabled)
+ * @return  VL53L0X_ERROR_NOT_IMPLEMENTED   Not implemented
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_EnableInterruptMask(VL53L0X_DEV Dev,
+    uint32_t InterruptMask);
+
+/** @} VL53L0X_interrupt_group */
+
+/** @defgroup VL53L0X_SPADfunctions_group VL53L0X SPAD Functions
+ *  @brief    Functions used for SPAD managements
+ *  @{
+ */
+
+/**
+ * @brief  Set the SPAD Ambient Damper Threshold value
+ *
+ * @par Function Description
+ * This function set the SPAD Ambient Damper Threshold value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   SpadAmbientDamperThreshold    SPAD Ambient Damper Threshold value
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
+    uint16_t SpadAmbientDamperThreshold);
+
+/**
+ * @brief  Get the current SPAD Ambient Damper Threshold value
+ *
+ * @par Function Description
+ * This function get the SPAD Ambient Damper Threshold value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   pSpadAmbientDamperThreshold   Pointer to programmed
+ *                                        SPAD Ambient Damper Threshold value
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
+    uint16_t *pSpadAmbientDamperThreshold);
+
+/**
+ * @brief  Set the SPAD Ambient Damper Factor value
+ *
+ * @par Function Description
+ * This function set the SPAD Ambient Damper Factor value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   SpadAmbientDamperFactor       SPAD Ambient Damper Factor value
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
+    uint16_t SpadAmbientDamperFactor);
+
+/**
+ * @brief  Get the current SPAD Ambient Damper Factor value
+ *
+ * @par Function Description
+ * This function get the SPAD Ambient Damper Factor value
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                           Device Handle
+ * @param   pSpadAmbientDamperFactor      Pointer to programmed SPAD Ambient
+ * Damper Factor value
+ * @return  VL53L0X_ERROR_NONE             Success
+ * @return  "Other error code"            See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
+    uint16_t *pSpadAmbientDamperFactor);
+
+/**
+ * @brief Performs Reference Spad Management
+ *
+ * @par Function Description
+ * The reference SPAD initialization procedure determines the minimum amount
+ * of reference spads to be enables to achieve a target reference signal rate
+ * and should be performed once during initialization.
+ *
+ * @note This function Access to the device
+ *
+ * @note This function change the device mode to
+ * VL53L0X_DEVICEMODE_SINGLE_RANGING
+ *
+ * @param   Dev                          Device Handle
+ * @param   refSpadCount                 Reports ref Spad Count
+ * @param   isApertureSpads              Reports if spads are of type
+ *                                       aperture or non-aperture.
+ *                                       1:=aperture, 0:=Non-Aperture
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_REF_SPAD_INIT   Error in the Ref Spad procedure.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
+    uint32_t *refSpadCount, uint8_t *isApertureSpads);
+
+/**
+ * @brief Applies Reference SPAD configuration
+ *
+ * @par Function Description
+ * This function applies a given number of reference spads, identified as
+ * either Aperture or Non-Aperture.
+ * The requested spad count and type are stored within the device specific
+ * parameters data for access by the host.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   refSpadCount                 Number of ref spads.
+ * @param   isApertureSpads              Defines if spads are of type
+ *                                       aperture or non-aperture.
+ *                                       1:=aperture, 0:=Non-Aperture
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_REF_SPAD_INIT   Error in the in the reference
+ *                                       spad configuration.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_SetReferenceSpads(VL53L0X_DEV Dev,
+    uint32_t refSpadCount, uint8_t isApertureSpads);
+
+/**
+ * @brief Retrieves SPAD configuration
+ *
+ * @par Function Description
+ * This function retrieves the current number of applied reference spads
+ * and also their type : Aperture or Non-Aperture.
+ *
+ * @note This function Access to the device
+ *
+ * @param   Dev                          Device Handle
+ * @param   refSpadCount                 Number ref Spad Count
+ * @param   isApertureSpads              Reports if spads are of type
+ *                                       aperture or non-aperture.
+ *                                       1:=aperture, 0:=Non-Aperture
+ * @return  VL53L0X_ERROR_NONE            Success
+ * @return  VL53L0X_ERROR_REF_SPAD_INIT   Error in the in the reference
+ *                                       spad configuration.
+ * @return  "Other error code"           See ::VL53L0X_Error
+ */
+VL53L0X_API VL53L0X_Error VL53L0X_GetReferenceSpads(VL53L0X_DEV Dev,
+    uint32_t *refSpadCount, uint8_t *isApertureSpads);
+
+/** @} VL53L0X_SPADfunctions_group */
+
+/** @} VL53L0X_cut11_group */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_H_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_calibration.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_calibration.h
new file mode 100644
index 0000000..502575a
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_calibration.h
@@ -0,0 +1,85 @@
+/*******************************************************************************
+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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_core.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_core.h
new file mode 100644
index 0000000..7a805e0
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_ranging.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_ranging.h
new file mode 100644
index 0000000..7030e54
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_ranging.h
@@ -0,0 +1,47 @@
+/*******************************************************************************
+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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_strings.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_strings.h
new file mode 100644
index 0000000..ac99947
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_api_strings.h
@@ -0,0 +1,283 @@
+/*******************************************************************************
+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"
+
+//#include "alld_vl53l0x.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 Overlow 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
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_def.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_def.h
new file mode 100644
index 0000000..1a0fdaf
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_def.h
@@ -0,0 +1,640 @@
+/*******************************************************************************
+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	  2
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X_IMPLEMENTATION_VER_REVISION	  4823
+#define VL53L0X_DEFAULT_MAX_LOOP 2000
+#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; // from -128 to 127
+
+#define VL53L0X_ERROR_NONE		((VL53L0X_Error)	0)
+#define VL53L0X_ERROR_CALIBRATION_WARNING	((VL53L0X_Error) -1) // -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) //-2
+    /*!< Warning parameter passed was clipped to min before to be applied */
+
+#define VL53L0X_ERROR_UNDEFINED				((VL53L0X_Error) -3) //-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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_device.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_device.h
new file mode 100644
index 0000000..796c49b
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_device.h
@@ -0,0 +1,283 @@
+/*******************************************************************************
+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_ */
+
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_interrupt_threshold_settings.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_interrupt_threshold_settings.h
new file mode 100644
index 0000000..fadf859
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_interrupt_threshold_settings.h
@@ -0,0 +1,194 @@
+/*******************************************************************************
+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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_tuning.h b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_tuning.h
new file mode 100644
index 0000000..1575503
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/inc/vl53l0x_tuning.h
@@ -0,0 +1,146 @@
+/*******************************************************************************
+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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api.c b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api.c
new file mode 100644
index 0000000..0cf25fb
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api.c
@@ -0,0 +1,3055 @@
+/*******************************************************************************
+ 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_tuning.h"
+#include "vl53l0x_interrupt_threshold_settings.h"
+#include "vl53l0x_api_core.h"
+#include "vl53l0x_api_calibration.h"
+#include "vl53l0x_api_strings.h"
+
+//debugging
+#include <aos_thread.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__)
+
+#ifdef VL53L0X_LOG_ENABLE
+#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_API, \
+    level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
+#endif
+
+/* Group PAL General Functions */
+
+VL53L0X_Error VL53L0X_GetVersion(VL53L0X_Version_t *pVersion)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    pVersion->major = VL53L0X_IMPLEMENTATION_VER_MAJOR;
+    pVersion->minor = VL53L0X_IMPLEMENTATION_VER_MINOR;
+    pVersion->build = VL53L0X_IMPLEMENTATION_VER_SUB;
+
+    pVersion->revision = VL53L0X_IMPLEMENTATION_VER_REVISION;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetPalSpecVersion(VL53L0X_Version_t *pPalSpecVersion)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    pPalSpecVersion->major = VL53L0X_SPECIFICATION_VER_MAJOR;
+    pPalSpecVersion->minor = VL53L0X_SPECIFICATION_VER_MINOR;
+    pPalSpecVersion->build = VL53L0X_SPECIFICATION_VER_SUB;
+
+    pPalSpecVersion->revision = VL53L0X_SPECIFICATION_VER_REVISION;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetProductRevision(VL53L0X_DEV Dev,
+    uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t revision_id;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_REVISION_ID,
+        &revision_id);
+    *pProductRevisionMajor = 1;
+    *pProductRevisionMinor = (revision_id & 0xF0) >> 4;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+
+}
+
+VL53L0X_Error VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
+    VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_device_info(Dev, pVL53L0X_DeviceInfo);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetDeviceErrorStatus(VL53L0X_DEV Dev,
+    VL53L0X_DeviceError *pDeviceErrorStatus)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t RangeStatus;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
+        &RangeStatus);
+
+    *pDeviceErrorStatus = (VL53L0X_DeviceError)((RangeStatus & 0x78) >> 3);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_GetDeviceErrorString(VL53L0X_DeviceError ErrorCode,
+    char *pDeviceErrorString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_device_error_string(ErrorCode, pDeviceErrorString);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetRangeStatusString(uint8_t RangeStatus,
+    char *pRangeStatusString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_range_status_string(RangeStatus,
+        pRangeStatusString);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetPalErrorString(VL53L0X_Error PalErrorCode,
+    char *pPalErrorString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_pal_error_string(PalErrorCode, pPalErrorString);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetPalStateString(VL53L0X_State PalStateCode,
+    char *pPalStateString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_pal_state_string(PalStateCode, pPalStateString);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetPalState(VL53L0X_DEV Dev, VL53L0X_State *pPalState)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    *pPalState = PALDevDataGet(Dev, PalState);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetPowerMode(VL53L0X_DEV Dev, VL53L0X_PowerModes PowerMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    /* Only level1 of Power mode exists */
+    if ((PowerMode != VL53L0X_POWERMODE_STANDBY_LEVEL1)
+        && (PowerMode != VL53L0X_POWERMODE_IDLE_LEVEL1)) {
+        Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
+    } else if (PowerMode == VL53L0X_POWERMODE_STANDBY_LEVEL1) {
+        /* set the standby level1 of power mode */
+        Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* Set PAL State to standby */
+            PALDevDataSet(Dev, PalState, VL53L0X_STATE_STANDBY);
+            PALDevDataSet(Dev, PowerMode,
+                VL53L0X_POWERMODE_STANDBY_LEVEL1);
+        }
+
+    } else {
+        /* VL53L0X_POWERMODE_IDLE_LEVEL1 */
+        Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_StaticInit(Dev);
+
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, PowerMode,
+                VL53L0X_POWERMODE_IDLE_LEVEL1);
+
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetPowerMode(VL53L0X_DEV Dev, VL53L0X_PowerModes *pPowerMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    /* Only level1 of Power mode exists */
+    Status = VL53L0X_RdByte(Dev, 0x80, &Byte);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (Byte == 1) {
+            PALDevDataSet(Dev, PowerMode,
+                VL53L0X_POWERMODE_IDLE_LEVEL1);
+        } else {
+            PALDevDataSet(Dev, PowerMode,
+                VL53L0X_POWERMODE_STANDBY_LEVEL1);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
+    int32_t OffsetCalibrationDataMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_set_offset_calibration_data_micro_meter(Dev,
+        OffsetCalibrationDataMicroMeter);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
+    int32_t *pOffsetCalibrationDataMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_offset_calibration_data_micro_meter(Dev,
+        pOffsetCalibrationDataMicroMeter);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetLinearityCorrectiveGain(VL53L0X_DEV Dev,
+    int16_t LinearityCorrectiveGain)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    if ((LinearityCorrectiveGain < 0) || (LinearityCorrectiveGain > 1000))
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    else {
+        PALDevDataSet(Dev, LinearityCorrectiveGain,
+            LinearityCorrectiveGain);
+
+        if (LinearityCorrectiveGain != 1000) {
+            /* Disable FW Xtalk */
+            Status = VL53L0X_WrWord(Dev,
+            VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, 0);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetLinearityCorrectiveGain(VL53L0X_DEV Dev,
+    uint16_t *pLinearityCorrectiveGain)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    *pLinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetGroupParamHold(VL53L0X_DEV Dev, uint8_t GroupParamHold)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetUpperLimitMilliMeter(VL53L0X_DEV Dev,
+    uint16_t *pUpperLimitMilliMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetTotalSignalRate(VL53L0X_DEV Dev,
+    FixPoint1616_t *pTotalSignalRate)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
+
+    LOG_FUNCTION_START("");
+
+    LastRangeDataBuffer = PALDevDataGet(Dev, LastRangeMeasure);
+
+    Status = VL53L0X_get_total_signal_rate(
+        Dev, &LastRangeDataBuffer, pTotalSignalRate);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* End Group PAL General Functions */
+
+/* Group PAL Init Functions */
+VL53L0X_Error VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev, uint8_t DeviceAddress)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+
+
+
+
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
+        DeviceAddress); // changed to not DeviceAddress/2
+
+    //added
+    Dev->I2cDevAddr = DeviceAddress;
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_DataInit(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_DeviceParameters_t CurrentParameters;
+    int i;
+    uint8_t StopVariable;
+
+
+    LOG_FUNCTION_START("");
+
+
+
+    /* by default the I2C is running at 1V8 if you want to change it you
+     * need to include this define at compilation level. */
+#ifdef USE_I2C_2V8
+    Status = VL53L0X_UpdateByte(Dev,
+        VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
+        0xFE,
+        0x01);
+#endif
+
+    /* Set I2C standard mode */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, 0x88, 0x00);
+
+    VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone, 0);
+
+#ifdef USE_IQC_STATION
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_apply_offset_adjustment(Dev);
+#endif
+
+    /* Default value is 1000 for Linearity Corrective Gain */
+    PALDevDataSet(Dev, LinearityCorrectiveGain, 1000);
+
+    /* Dmax default Parameter */
+    PALDevDataSet(Dev, DmaxCalRangeMilliMeter, 400);
+    PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
+        (FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
+
+    /* Set Default static parameters
+     *set first temporary values 9.44MHz * 65536 = 618660 */
+    VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz, 618660);
+
+    /* Set Default XTalkCompensationRateMegaCps to 0  */
+    VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps, 0);
+
+    /* Get default parameters */
+    Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* initialize PAL values */
+        CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
+        CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
+        PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
+    }
+
+    /* Sigma estimator variable */
+    PALDevDataSet(Dev, SigmaEstRefArray, 100);
+    PALDevDataSet(Dev, SigmaEstEffPulseWidth, 900);
+    PALDevDataSet(Dev, SigmaEstEffAmbWidth, 500);
+    PALDevDataSet(Dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
+
+    /* Use internal default settings */
+    PALDevDataSet(Dev, UseInternalTuningSettings, 1);
+
+    Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+    Status |= VL53L0X_RdByte(Dev, 0x91, &StopVariable);
+    PALDevDataSet(Dev, StopVariable, StopVariable);
+    Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+    Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+
+    /* Enable all check */
+    for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
+        if (Status == VL53L0X_ERROR_NONE)
+            Status |= VL53L0X_SetLimitCheckEnable(Dev, i, 1);
+        else
+            break;
+
+    }
+
+    /* Disable the following checks */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
+
+    /* Limit default values */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(Dev,
+            VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                (FixPoint1616_t)(18 * 65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                (FixPoint1616_t)(25 * 65536 / 100));
+                /* 0.25 * 65536 */
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+                (FixPoint1616_t)(35 * 65536));
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(Dev,
+            VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                (FixPoint1616_t)(0 * 65536));
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        PALDevDataSet(Dev, SequenceConfig, 0xFF);
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+            0xFF);
+
+        /* Set PAL state to tell that we are waiting for call to
+         * VL53L0X_StaticInit */
+        PALDevDataSet(Dev, PalState, VL53L0X_STATE_WAIT_STATICINIT);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 0);
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetTuningSettingBuffer(VL53L0X_DEV Dev,
+    uint8_t *pTuningSettingBuffer, uint8_t UseInternalTuningSettings)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    if (UseInternalTuningSettings == 1) {
+        /* Force use internal settings */
+        PALDevDataSet(Dev, UseInternalTuningSettings, 1);
+    } else {
+
+        /* check that the first byte is not 0 */
+        if (*pTuningSettingBuffer != 0) {
+            PALDevDataSet(Dev, pTuningSettingsPointer,
+                pTuningSettingBuffer);
+            PALDevDataSet(Dev, UseInternalTuningSettings, 0);
+
+        } else {
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetTuningSettingBuffer(VL53L0X_DEV Dev,
+    uint8_t **ppTuningSettingBuffer, uint8_t *pUseInternalTuningSettings)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    *ppTuningSettingBuffer = PALDevDataGet(Dev, pTuningSettingsPointer);
+    *pUseInternalTuningSettings = PALDevDataGet(Dev,
+        UseInternalTuningSettings);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_StaticInit(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_DeviceParameters_t CurrentParameters = {0};
+    uint8_t *pTuningSettingBuffer;
+    uint16_t tempword = 0;
+    uint8_t tempbyte = 0;
+    uint8_t UseInternalTuningSettings = 0;
+    uint32_t count = 0;
+    uint8_t isApertureSpads = 0;
+    uint32_t refSpadCount = 0;
+    uint8_t ApertureSpads = 0;
+    uint8_t vcselPulsePeriodPCLK;
+    uint32_t seqTimeoutMicroSecs;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_info_from_device(Dev, 1);
+
+    /* set the ref spad from NVM */
+    count	= (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+        ReferenceSpadCount);
+    ApertureSpads = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+        ReferenceSpadType);
+
+    /* NVM value invalid */
+    if ((ApertureSpads > 1) ||
+        ((ApertureSpads == 1) && (count > 32)) ||
+        ((ApertureSpads == 0) && (count > 12)))
+        Status = VL53L0X_perform_ref_spad_management(Dev, &refSpadCount,
+            &isApertureSpads);
+    else
+        Status = VL53L0X_set_reference_spads(Dev, count, ApertureSpads);
+
+
+    /* Initialize tuning settings buffer to prevent compiler warning. */
+    pTuningSettingBuffer = DefaultTuningSettings;
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        UseInternalTuningSettings = PALDevDataGet(Dev,
+            UseInternalTuningSettings);
+
+        if (UseInternalTuningSettings == 0)
+            pTuningSettingBuffer = PALDevDataGet(Dev,
+                pTuningSettingsPointer);
+        else
+            pTuningSettingBuffer = DefaultTuningSettings;
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_load_tuning_settings(Dev, pTuningSettingBuffer);
+
+
+    /* Set interrupt config to new sample ready */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetGpioConfig(Dev, 0, 0,
+        VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
+        VL53L0X_INTERRUPTPOLARITY_LOW);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+        Status |= VL53L0X_RdWord(Dev, 0x84, &tempword);
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz,
+            VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
+    }
+
+    /* After static init, some device parameters may be changed,
+     * so update them */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetFractionEnable(Dev, &tempbyte);
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, RangeFractionalEnable, tempbyte);
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
+
+
+    /* read the sequence config and save it */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_RdByte(Dev,
+        VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, tempbyte);
+
+    }
+
+    /* Disable MSRC and TCC by default */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetSequenceStepEnable(Dev,
+                    VL53L0X_SEQUENCESTEP_TCC, 0);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetSequenceStepEnable(Dev,
+        VL53L0X_SEQUENCESTEP_MSRC, 0);
+
+
+    /* Set PAL State to standby */
+    if (Status == VL53L0X_ERROR_NONE)
+        PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+
+
+
+    /* Store pre-range vcsel period */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetVcselPulsePeriod(
+            Dev,
+            VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+            &vcselPulsePeriodPCLK);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETDEVICESPECIFICPARAMETER(
+                Dev,
+                PreRangeVcselPulsePeriod,
+                vcselPulsePeriodPCLK);
+    }
+
+    /* Store final-range vcsel period */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetVcselPulsePeriod(
+            Dev,
+            VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+            &vcselPulsePeriodPCLK);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETDEVICESPECIFICPARAMETER(
+                Dev,
+                FinalRangeVcselPulsePeriod,
+                vcselPulsePeriodPCLK);
+    }
+
+    /* Store pre-range timeout */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = get_sequence_step_timeout(
+            Dev,
+            VL53L0X_SEQUENCESTEP_PRE_RANGE,
+            &seqTimeoutMicroSecs);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETDEVICESPECIFICPARAMETER(
+            Dev,
+            PreRangeTimeoutMicroSecs,
+            seqTimeoutMicroSecs);
+    }
+
+    /* Store final-range timeout */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = get_sequence_step_timeout(
+            Dev,
+            VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+            &seqTimeoutMicroSecs);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETDEVICESPECIFICPARAMETER(
+            Dev,
+            FinalRangeTimeoutMicroSecs,
+            seqTimeoutMicroSecs);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_ResetDevice(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    /* Set reset bit */
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
+        0x00);
+
+    /* Wait for some time */
+    if (Status == VL53L0X_ERROR_NONE) {
+        do {
+            Status = VL53L0X_RdByte(Dev,
+            VL53L0X_REG_IDENTIFICATION_MODEL_ID, &Byte);
+        } while (Byte != 0x00);
+    }
+
+    //VL53L0X_PollingDelay(Dev); TODO NEED THIS ??
+
+    /* Release reset */
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
+        0x01);
+
+    /* Wait until correct boot-up of the device */
+    if (Status == VL53L0X_ERROR_NONE) {
+        do {
+            Status = VL53L0X_RdByte(Dev,
+            VL53L0X_REG_IDENTIFICATION_MODEL_ID, &Byte);
+        } while (Byte == 0x00);
+    }
+
+    //VL53L0X_PollingDelay(Dev); TODO NEED THIS ??
+
+    /* Set PAL State to VL53L0X_STATE_POWERDOWN */
+    if (Status == VL53L0X_ERROR_NONE)
+        PALDevDataSet(Dev, PalState, VL53L0X_STATE_POWERDOWN);
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+/* End Group PAL Init Functions */
+
+/* Group PAL Parameters Functions */
+VL53L0X_Error VL53L0X_SetDeviceParameters(VL53L0X_DEV Dev,
+    const VL53L0X_DeviceParameters_t *pDeviceParameters)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    int i;
+    LOG_FUNCTION_START("");
+    Status = VL53L0X_SetDeviceMode(Dev, pDeviceParameters->DeviceMode);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetInterMeasurementPeriodMilliSeconds(Dev,
+            pDeviceParameters->InterMeasurementPeriodMilliSeconds);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetXTalkCompensationRateMegaCps(Dev,
+            pDeviceParameters->XTalkCompensationRateMegaCps);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev,
+            pDeviceParameters->RangeOffsetMicroMeters);
+
+
+    for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
+        if (Status == VL53L0X_ERROR_NONE)
+            Status |= VL53L0X_SetLimitCheckEnable(Dev, i,
+                pDeviceParameters->LimitChecksEnable[i]);
+        else
+            break;
+
+        if (Status == VL53L0X_ERROR_NONE)
+            Status |= VL53L0X_SetLimitCheckValue(Dev, i,
+                pDeviceParameters->LimitChecksValue[i]);
+        else
+            break;
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetWrapAroundCheckEnable(Dev,
+            pDeviceParameters->WrapAroundCheckEnable);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
+            pDeviceParameters->MeasurementTimingBudgetMicroSeconds);
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
+    VL53L0X_DeviceParameters_t *pDeviceParameters)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    int i;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_GetDeviceMode(Dev, &(pDeviceParameters->DeviceMode));
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetInterMeasurementPeriodMilliSeconds(Dev,
+        &(pDeviceParameters->InterMeasurementPeriodMilliSeconds));
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        pDeviceParameters->XTalkCompensationEnable = 0;
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetXTalkCompensationRateMegaCps(Dev,
+            &(pDeviceParameters->XTalkCompensationRateMegaCps));
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetOffsetCalibrationDataMicroMeter(Dev,
+            &(pDeviceParameters->RangeOffsetMicroMeters));
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
+            /* get first the values, then the enables.
+             * VL53L0X_GetLimitCheckValue will modify the enable
+             * flags
+             */
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status |= VL53L0X_GetLimitCheckValue(Dev, i,
+                &(pDeviceParameters->LimitChecksValue[i]));
+            } else {
+                break;
+            }
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status |= VL53L0X_GetLimitCheckEnable(Dev, i,
+                &(pDeviceParameters->LimitChecksEnable[i]));
+            } else {
+                break;
+            }
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetWrapAroundCheckEnable(Dev,
+            &(pDeviceParameters->WrapAroundCheckEnable));
+    }
+
+    /* Need to be done at the end as it uses VCSELPulsePeriod */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetMeasurementTimingBudgetMicroSeconds(Dev,
+        &(pDeviceParameters->MeasurementTimingBudgetMicroSeconds));
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetDeviceMode(VL53L0X_DEV Dev, VL53L0X_DeviceModes DeviceMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("%d", (int)DeviceMode);
+
+    switch (DeviceMode) {
+    case VL53L0X_DEVICEMODE_SINGLE_RANGING:
+    case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
+    case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
+    case VL53L0X_DEVICEMODE_GPIO_DRIVE:
+    case VL53L0X_DEVICEMODE_GPIO_OSC:
+        /* Supported modes */
+        VL53L0X_SETPARAMETERFIELD(Dev, DeviceMode, DeviceMode);
+        break;
+    default:
+        /* Unsupported mode */
+        Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes *pDeviceMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    VL53L0X_GETPARAMETERFIELD(Dev, DeviceMode, *pDeviceMode);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetRangeFractionEnable(VL53L0X_DEV Dev,	uint8_t Enable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("%d", (int)Enable);
+
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, Enable);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        PALDevDataSet(Dev, RangeFractionalEnable, Enable);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetFractionEnable(VL53L0X_DEV Dev, uint8_t *pEnabled)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, pEnabled);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        *pEnabled = (*pEnabled & 1);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetHistogramMode(VL53L0X_DEV Dev,
+    VL53L0X_HistogramModes HistogramMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetHistogramMode(VL53L0X_DEV Dev,
+    VL53L0X_HistogramModes *pHistogramMode)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
+    uint32_t MeasurementTimingBudgetMicroSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_set_measurement_timing_budget_micro_seconds(Dev,
+        MeasurementTimingBudgetMicroSeconds);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
+    uint32_t *pMeasurementTimingBudgetMicroSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_measurement_timing_budget_micro_seconds(Dev,
+        pMeasurementTimingBudgetMicroSeconds);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_set_vcsel_pulse_period(Dev, VcselPeriodType,
+        VCSELPulsePeriodPCLK);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_vcsel_pulse_period(Dev, VcselPeriodType,
+        pVCSELPulsePeriodPCLK);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+    uint8_t SequenceConfigNew = 0;
+    uint32_t MeasurementTimingBudgetMicroSeconds;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+        &SequenceConfig);
+
+    SequenceConfigNew = SequenceConfig;
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (SequenceStepEnabled == 1) {
+
+            /* Enable requested sequence step
+             */
+            switch (SequenceStepId) {
+            case VL53L0X_SEQUENCESTEP_TCC:
+                SequenceConfigNew |= 0x10;
+                break;
+            case VL53L0X_SEQUENCESTEP_DSS:
+                SequenceConfigNew |= 0x28;
+                break;
+            case VL53L0X_SEQUENCESTEP_MSRC:
+                SequenceConfigNew |= 0x04;
+                break;
+            case VL53L0X_SEQUENCESTEP_PRE_RANGE:
+                SequenceConfigNew |= 0x40;
+                break;
+            case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
+                SequenceConfigNew |= 0x80;
+                break;
+            default:
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+        } else {
+            /* Disable requested sequence step
+             */
+            switch (SequenceStepId) {
+            case VL53L0X_SEQUENCESTEP_TCC:
+                SequenceConfigNew &= 0xef;
+                break;
+            case VL53L0X_SEQUENCESTEP_DSS:
+                SequenceConfigNew &= 0xd7;
+                break;
+            case VL53L0X_SEQUENCESTEP_MSRC:
+                SequenceConfigNew &= 0xfb;
+                break;
+            case VL53L0X_SEQUENCESTEP_PRE_RANGE:
+                SequenceConfigNew &= 0xbf;
+                break;
+            case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
+                SequenceConfigNew &= 0x7f;
+                break;
+            default:
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+        }
+    }
+
+    if (SequenceConfigNew != SequenceConfig) {
+        /* Apply New Setting */
+        if (Status == VL53L0X_ERROR_NONE) {
+            Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, SequenceConfigNew);
+        }
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, SequenceConfigNew);
+
+
+        /* Recalculate timing budget */
+        if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_GETPARAMETERFIELD(Dev,
+                MeasurementTimingBudgetMicroSeconds,
+                MeasurementTimingBudgetMicroSeconds);
+
+            VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
+                MeasurementTimingBudgetMicroSeconds);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error sequence_step_enabled(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceConfig,
+    uint8_t *pSequenceStepEnabled)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    *pSequenceStepEnabled = 0;
+    LOG_FUNCTION_START("");
+
+    switch (SequenceStepId) {
+    case VL53L0X_SEQUENCESTEP_TCC:
+        *pSequenceStepEnabled = (SequenceConfig & 0x10) >> 4;
+        break;
+    case VL53L0X_SEQUENCESTEP_DSS:
+        *pSequenceStepEnabled = (SequenceConfig & 0x08) >> 3;
+        break;
+    case VL53L0X_SEQUENCESTEP_MSRC:
+        *pSequenceStepEnabled = (SequenceConfig & 0x04) >> 2;
+        break;
+    case VL53L0X_SEQUENCESTEP_PRE_RANGE:
+        *pSequenceStepEnabled = (SequenceConfig & 0x40) >> 6;
+        break;
+    case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
+        *pSequenceStepEnabled = (SequenceConfig & 0x80) >> 7;
+        break;
+    default:
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSequenceStepEnable(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, uint8_t *pSequenceStepEnabled)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+        &SequenceConfig);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev, SequenceStepId,
+            SequenceConfig, pSequenceStepEnabled);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
+    VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+        &SequenceConfig);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev,
+        VL53L0X_SEQUENCESTEP_TCC, SequenceConfig,
+            &pSchedulerSequenceSteps->TccOn);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev,
+        VL53L0X_SEQUENCESTEP_DSS, SequenceConfig,
+            &pSchedulerSequenceSteps->DssOn);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev,
+        VL53L0X_SEQUENCESTEP_MSRC, SequenceConfig,
+            &pSchedulerSequenceSteps->MsrcOn);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev,
+        VL53L0X_SEQUENCESTEP_PRE_RANGE, SequenceConfig,
+            &pSchedulerSequenceSteps->PreRangeOn);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = sequence_step_enabled(Dev,
+        VL53L0X_SEQUENCESTEP_FINAL_RANGE, SequenceConfig,
+            &pSchedulerSequenceSteps->FinalRangeOn);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetNumberOfSequenceSteps(VL53L0X_DEV Dev,
+    uint8_t *pNumberOfSequenceSteps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    *pNumberOfSequenceSteps = VL53L0X_SEQUENCESTEP_NUMBER_OF_CHECKS;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSequenceStepsInfo(VL53L0X_SequenceStepId SequenceStepId,
+    char *pSequenceStepsString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_sequence_steps_info(
+            SequenceStepId,
+            pSequenceStepsString);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetSequenceStepTimeout(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, FixPoint1616_t TimeOutMilliSecs)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_Error Status1 = VL53L0X_ERROR_NONE;
+    uint32_t TimeoutMicroSeconds = ((TimeOutMilliSecs * 1000) + 0x8000)
+        >> 16;
+    uint32_t MeasurementTimingBudgetMicroSeconds;
+    FixPoint1616_t OldTimeOutMicroSeconds;
+
+    LOG_FUNCTION_START("");
+
+    /* Read back the current value in case we need to revert back to this.
+     */
+    Status = get_sequence_step_timeout(Dev, SequenceStepId,
+        &OldTimeOutMicroSeconds);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = set_sequence_step_timeout(Dev, SequenceStepId,
+            TimeoutMicroSeconds);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_GETPARAMETERFIELD(Dev,
+            MeasurementTimingBudgetMicroSeconds,
+            MeasurementTimingBudgetMicroSeconds);
+
+        /* At this point we don't know if the requested value is valid,
+         therefore proceed to update the entire timing budget and
+         if this fails, revert back to the previous value.
+         */
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
+            MeasurementTimingBudgetMicroSeconds);
+
+        if (Status != VL53L0X_ERROR_NONE) {
+            Status1 = set_sequence_step_timeout(Dev, SequenceStepId,
+                OldTimeOutMicroSeconds);
+
+            if (Status1 == VL53L0X_ERROR_NONE) {
+                Status1 =
+                VL53L0X_SetMeasurementTimingBudgetMicroSeconds(
+                    Dev,
+                    MeasurementTimingBudgetMicroSeconds);
+            }
+
+            Status = Status1;
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSequenceStepTimeout(VL53L0X_DEV Dev,
+    VL53L0X_SequenceStepId SequenceStepId, FixPoint1616_t *pTimeOutMilliSecs)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint32_t TimeoutMicroSeconds;
+    LOG_FUNCTION_START("");
+
+    Status = get_sequence_step_timeout(Dev, SequenceStepId,
+        &TimeoutMicroSeconds);
+    if (Status == VL53L0X_ERROR_NONE) {
+        TimeoutMicroSeconds <<= 8;
+        *pTimeOutMilliSecs = (TimeoutMicroSeconds + 500)/1000;
+        *pTimeOutMilliSecs <<= 8;
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
+    uint32_t InterMeasurementPeriodMilliSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t osc_calibrate_val;
+    uint32_t IMPeriodMilliSeconds;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdWord(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
+        &osc_calibrate_val);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (osc_calibrate_val != 0) {
+            IMPeriodMilliSeconds =
+                InterMeasurementPeriodMilliSeconds
+                    * osc_calibrate_val;
+        } else {
+            IMPeriodMilliSeconds =
+                InterMeasurementPeriodMilliSeconds;
+        }
+        Status = VL53L0X_WrDWord(Dev,
+        VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
+            IMPeriodMilliSeconds);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETPARAMETERFIELD(Dev,
+            InterMeasurementPeriodMilliSeconds,
+            InterMeasurementPeriodMilliSeconds);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
+    uint32_t *pInterMeasurementPeriodMilliSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t osc_calibrate_val;
+    uint32_t IMPeriodMilliSeconds;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdWord(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
+        &osc_calibrate_val);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_RdDWord(Dev,
+        VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
+            &IMPeriodMilliSeconds);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (osc_calibrate_val != 0) {
+            *pInterMeasurementPeriodMilliSeconds =
+                IMPeriodMilliSeconds / osc_calibrate_val;
+        }
+        VL53L0X_SETPARAMETERFIELD(Dev,
+            InterMeasurementPeriodMilliSeconds,
+            *pInterMeasurementPeriodMilliSeconds);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetXTalkCompensationEnable(VL53L0X_DEV Dev,
+    uint8_t XTalkCompensationEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    FixPoint1616_t TempFix1616;
+    uint16_t LinearityCorrectiveGain;
+
+    LOG_FUNCTION_START("");
+
+    LinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
+
+    if ((XTalkCompensationEnable == 0)
+        || (LinearityCorrectiveGain != 1000)) {
+        TempFix1616 = 0;
+    } else {
+        VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
+            TempFix1616);
+    }
+
+    /* the following register has a format 3.13 */
+    Status = VL53L0X_WrWord(Dev,
+    VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS,
+        VL53L0X_FIXPOINT1616TOFIXPOINT313(TempFix1616));
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (XTalkCompensationEnable == 0) {
+            VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+                0);
+        } else {
+            VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+                1);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
+    uint8_t *pXTalkCompensationEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Temp8;
+    LOG_FUNCTION_START("");
+
+    VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable, Temp8);
+    *pXTalkCompensationEnable = Temp8;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
+    FixPoint1616_t XTalkCompensationRateMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Temp8;
+    uint16_t LinearityCorrectiveGain;
+    uint16_t data;
+    LOG_FUNCTION_START("");
+
+    VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable, Temp8);
+    LinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
+
+    if (Temp8 == 0) { /* disabled write only internal value */
+        VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
+            XTalkCompensationRateMegaCps);
+    } else {
+        /* the following register has a format 3.13 */
+        if (LinearityCorrectiveGain == 1000) {
+            data = VL53L0X_FIXPOINT1616TOFIXPOINT313(
+                XTalkCompensationRateMegaCps);
+        } else {
+            data = 0;
+        }
+
+        Status = VL53L0X_WrWord(Dev,
+        VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, data);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETPARAMETERFIELD(Dev,
+                XTalkCompensationRateMegaCps,
+                XTalkCompensationRateMegaCps);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
+    FixPoint1616_t *pXTalkCompensationRateMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t Value;
+    FixPoint1616_t TempFix1616;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdWord(Dev,
+    VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&Value);
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (Value == 0) {
+            /* the Xtalk is disabled return value from memory */
+            VL53L0X_GETPARAMETERFIELD(Dev,
+                XTalkCompensationRateMegaCps, TempFix1616);
+            *pXTalkCompensationRateMegaCps = TempFix1616;
+            VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+                0);
+        } else {
+            TempFix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(Value);
+            *pXTalkCompensationRateMegaCps = TempFix1616;
+            VL53L0X_SETPARAMETERFIELD(Dev,
+                XTalkCompensationRateMegaCps, TempFix1616);
+            VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+                1);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetRefCalibration(VL53L0X_DEV Dev, uint8_t VhvSettings,
+    uint8_t PhaseCal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_set_ref_calibration(Dev, VhvSettings, PhaseCal);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
+    uint8_t *pPhaseCal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_ref_calibration(Dev, pVhvSettings, pPhaseCal);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/*
+ * CHECK LIMIT FUNCTIONS
+ */
+
+VL53L0X_Error VL53L0X_GetNumberOfLimitCheck(uint16_t *pNumberOfLimitCheck)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    *pNumberOfLimitCheck = VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetLimitCheckInfo(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    char *pLimitCheckString)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_limit_check_info(Dev, LimitCheckId,
+        pLimitCheckString);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetLimitCheckStatus(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    uint8_t *pLimitCheckStatus)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Temp8;
+
+    LOG_FUNCTION_START("");
+
+    if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    } else {
+
+        VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+            LimitCheckId, Temp8);
+
+        *pLimitCheckStatus = Temp8;
+
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    uint8_t LimitCheckEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    FixPoint1616_t TempFix1616 = 0;
+    uint8_t LimitCheckEnableInt = 0;
+    uint8_t LimitCheckDisable = 0;
+    uint8_t Temp8;
+
+    LOG_FUNCTION_START("");
+
+    if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    } else {
+        if (LimitCheckEnable == 0) {
+            TempFix1616 = 0;
+            LimitCheckEnableInt = 0;
+            LimitCheckDisable = 1;
+
+        } else {
+            VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+                LimitCheckId, TempFix1616);
+            LimitCheckDisable = 0;
+            /* this to be sure to have either 0 or 1 */
+            LimitCheckEnableInt = 1;
+        }
+
+        switch (LimitCheckId) {
+
+        case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                LimitCheckEnableInt);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+
+            Status = VL53L0X_WrWord(Dev,
+            VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+                VL53L0X_FIXPOINT1616TOFIXPOINT97(TempFix1616));
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+                VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+                LimitCheckEnableInt);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                LimitCheckEnableInt);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+
+            Temp8 = (uint8_t)(LimitCheckDisable << 1);
+            Status = VL53L0X_UpdateByte(Dev,
+                VL53L0X_REG_MSRC_CONFIG_CONTROL,
+                0xFE, Temp8);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+
+            Temp8 = (uint8_t)(LimitCheckDisable << 4);
+            Status = VL53L0X_UpdateByte(Dev,
+                VL53L0X_REG_MSRC_CONFIG_CONTROL,
+                0xEF, Temp8);
+
+            break;
+
+
+        default:
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+        }
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (LimitCheckEnable == 0) {
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+                LimitCheckId, 0);
+        } else {
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+                LimitCheckId, 1);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    uint8_t *pLimitCheckEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Temp8;
+
+    LOG_FUNCTION_START("");
+
+    if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+        *pLimitCheckEnable = 0;
+    } else {
+        VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+            LimitCheckId, Temp8);
+        *pLimitCheckEnable = Temp8;
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    FixPoint1616_t LimitCheckValue)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Temp8;
+
+    LOG_FUNCTION_START("");
+
+    VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId,
+        Temp8);
+
+    if (Temp8 == 0) { /* disabled write only internal value */
+        VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+            LimitCheckId, LimitCheckValue);
+    } else {
+
+        switch (LimitCheckId) {
+
+        case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                LimitCheckValue);
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+
+            Status = VL53L0X_WrWord(Dev,
+            VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+                VL53L0X_FIXPOINT1616TOFIXPOINT97(
+                    LimitCheckValue));
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+                VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+                LimitCheckValue);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+
+            /* internal computation: */
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                LimitCheckValue);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+
+            Status = VL53L0X_WrWord(Dev,
+                VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+                VL53L0X_FIXPOINT1616TOFIXPOINT97(
+                    LimitCheckValue));
+
+            break;
+
+        default:
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+        }
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+                LimitCheckId, LimitCheckValue);
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    FixPoint1616_t *pLimitCheckValue)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t EnableZeroValue = 0;
+    uint16_t Temp16;
+    FixPoint1616_t TempFix1616;
+
+    LOG_FUNCTION_START("");
+
+    switch (LimitCheckId) {
+
+    case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+        /* internal computation: */
+        VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+            VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, TempFix1616);
+        EnableZeroValue = 0;
+        break;
+
+    case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+        Status = VL53L0X_RdWord(Dev,
+        VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+            &Temp16);
+        if (Status == VL53L0X_ERROR_NONE)
+            TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
+
+
+        EnableZeroValue = 1;
+        break;
+
+    case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+        /* internal computation: */
+        VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+            VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, TempFix1616);
+        EnableZeroValue = 0;
+        break;
+
+    case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+        /* internal computation: */
+        VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+            VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, TempFix1616);
+        EnableZeroValue = 0;
+        break;
+
+    case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+    case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+        Status = VL53L0X_RdWord(Dev,
+            VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+            &Temp16);
+        if (Status == VL53L0X_ERROR_NONE)
+            TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
+
+
+        EnableZeroValue = 0;
+        break;
+
+    default:
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        if (EnableZeroValue == 1) {
+
+            if (TempFix1616 == 0) {
+                /* disabled: return value from memory */
+                VL53L0X_GETARRAYPARAMETERFIELD(Dev,
+                    LimitChecksValue, LimitCheckId,
+                    TempFix1616);
+                *pLimitCheckValue = TempFix1616;
+                VL53L0X_SETARRAYPARAMETERFIELD(Dev,
+                    LimitChecksEnable, LimitCheckId, 0);
+            } else {
+                *pLimitCheckValue = TempFix1616;
+                VL53L0X_SETARRAYPARAMETERFIELD(Dev,
+                    LimitChecksValue, LimitCheckId,
+                    TempFix1616);
+                VL53L0X_SETARRAYPARAMETERFIELD(Dev,
+                    LimitChecksEnable, LimitCheckId, 1);
+            }
+        } else {
+            *pLimitCheckValue = TempFix1616;
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+
+}
+
+VL53L0X_Error VL53L0X_GetLimitCheckCurrent(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+    FixPoint1616_t *pLimitCheckCurrent)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
+
+    LOG_FUNCTION_START("");
+
+
+
+    if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    } else {
+
+        switch (LimitCheckId) {
+        case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+            /* Need to run a ranging to have the latest values */
+            *pLimitCheckCurrent = PALDevDataGet(Dev, SigmaEstimate);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+            /* Need to run a ranging to have the latest values */
+            LastRangeDataBuffer = PALDevDataGet(Dev,
+                LastRangeMeasure);
+            *pLimitCheckCurrent =
+                LastRangeDataBuffer.SignalRateRtnMegaCps;
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+            /* Need to run a ranging to have the latest values */
+            *pLimitCheckCurrent = PALDevDataGet(Dev,
+                LastSignalRefMcps);
+
+            break;
+
+        case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+            /* Need to run a ranging to have the latest values */
+            LastRangeDataBuffer = PALDevDataGet(Dev,
+                LastRangeMeasure);
+            *pLimitCheckCurrent =
+                LastRangeDataBuffer.SignalRateRtnMegaCps;
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+            /* Need to run a ranging to have the latest values */
+            LastRangeDataBuffer = PALDevDataGet(Dev,
+                LastRangeMeasure);
+            *pLimitCheckCurrent =
+                LastRangeDataBuffer.SignalRateRtnMegaCps;
+
+            break;
+
+        case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+            /* Need to run a ranging to have the latest values */
+            LastRangeDataBuffer = PALDevDataGet(Dev,
+                LastRangeMeasure);
+            *pLimitCheckCurrent =
+                LastRangeDataBuffer.SignalRateRtnMegaCps;
+
+            break;
+
+        default:
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+        }
+    }
+
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+
+}
+
+/*
+ * WRAPAROUND Check
+ */
+VL53L0X_Error VL53L0X_SetWrapAroundCheckEnable(VL53L0X_DEV Dev,
+    uint8_t WrapAroundCheckEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    uint8_t WrapAroundCheckEnableInt;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &Byte);
+    if (WrapAroundCheckEnable == 0) {
+        /* Disable wraparound */
+        Byte = Byte & 0x7F;
+        WrapAroundCheckEnableInt = 0;
+    } else {
+        /*Enable wraparound */
+        Byte = Byte | 0x80;
+        WrapAroundCheckEnableInt = 1;
+    }
+
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, Byte);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        PALDevDataSet(Dev, SequenceConfig, Byte);
+        VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
+            WrapAroundCheckEnableInt);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
+    uint8_t *pWrapAroundCheckEnable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t data;
+
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
+    if (Status == VL53L0X_ERROR_NONE) {
+        PALDevDataSet(Dev, SequenceConfig, data);
+        if (data & (0x01 << 7))
+            *pWrapAroundCheckEnable = 0x01;
+        else
+            *pWrapAroundCheckEnable = 0x00;
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
+            *pWrapAroundCheckEnable);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetDmaxCalParameters(VL53L0X_DEV Dev,
+    uint16_t RangeMilliMeter, FixPoint1616_t SignalRateRtnMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    FixPoint1616_t SignalRateRtnMegaCpsTemp = 0;
+
+    LOG_FUNCTION_START("");
+
+    /* Check if one of input parameter is zero, in that case the
+     * value are get from NVM */
+    if ((RangeMilliMeter == 0) || (SignalRateRtnMegaCps == 0)) {
+        /* NVM parameters */
+        /* Run VL53L0X_get_info_from_device wit option 4 to get
+         * signal rate at 400 mm if the value have been already
+         * get this function will return with no access to device */
+        VL53L0X_get_info_from_device(Dev, 4);
+
+        SignalRateRtnMegaCpsTemp = VL53L0X_GETDEVICESPECIFICPARAMETER(
+            Dev, SignalRateMeasFixed400mm);
+
+        PALDevDataSet(Dev, DmaxCalRangeMilliMeter, 400);
+        PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
+            SignalRateRtnMegaCpsTemp);
+    } else {
+        /* User parameters */
+        PALDevDataSet(Dev, DmaxCalRangeMilliMeter, RangeMilliMeter);
+        PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
+            SignalRateRtnMegaCps);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetDmaxCalParameters(VL53L0X_DEV Dev,
+    uint16_t *pRangeMilliMeter, FixPoint1616_t *pSignalRateRtnMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    *pRangeMilliMeter = PALDevDataGet(Dev, DmaxCalRangeMilliMeter);
+    *pSignalRateRtnMegaCps = PALDevDataGet(Dev,
+        DmaxCalSignalRateRtnMegaCps);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* End Group PAL Parameters Functions */
+
+/* Group PAL Measurement Functions */
+VL53L0X_Error VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_DeviceModes DeviceMode;
+
+    LOG_FUNCTION_START("");
+
+    /* Get Current DeviceMode */
+    Status = VL53L0X_GetDeviceMode(Dev, &DeviceMode);
+
+    /* Start immediately to run a single ranging measurement in case of
+     * single ranging or single histogram */
+    if (Status == VL53L0X_ERROR_NONE
+        && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
+        Status = VL53L0X_StartMeasurement(Dev);
+
+
+    if (Status == VL53L0X_ERROR_NONE
+            && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
+        Status = VL53L0X_measurement_poll_for_completion(Dev);
+
+
+    /* Change PAL State in case of single ranging or single histogram */
+    if (Status == VL53L0X_ERROR_NONE
+        && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
+        PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformSingleHistogramMeasurement(VL53L0X_DEV Dev,
+    VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
+    uint8_t *pPhaseCal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_perform_ref_calibration(Dev, pVhvSettings,
+        pPhaseCal, 1);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformXTalkMeasurement(VL53L0X_DEV Dev,
+    uint32_t TimeoutMs, FixPoint1616_t *pXtalkPerSpad,
+    uint8_t *pAmbientTooHigh)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented on VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformXTalkCalibration(VL53L0X_DEV Dev,
+    FixPoint1616_t XTalkCalDistance,
+    FixPoint1616_t *pXTalkCompensationRateMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_perform_xtalk_calibration(Dev, XTalkCalDistance,
+        pXTalkCompensationRateMegaCps);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformOffsetCalibration(VL53L0X_DEV Dev,
+    FixPoint1616_t CalDistanceMilliMeter, int32_t *pOffsetMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_perform_offset_calibration(Dev, CalDistanceMilliMeter,
+        pOffsetMicroMeter);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_CheckAndLoadInterruptSettings(VL53L0X_DEV Dev,
+    uint8_t StartNotStopFlag)
+{
+    uint8_t InterruptConfig;
+    FixPoint1616_t ThresholdLow;
+    FixPoint1616_t ThresholdHigh;
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+        Pin0GpioFunctionality);
+
+    if ((InterruptConfig ==
+        VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
+        (InterruptConfig ==
+        VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH) ||
+        (InterruptConfig ==
+        VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
+
+        Status = VL53L0X_GetInterruptThresholds(Dev,
+            VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+            &ThresholdLow, &ThresholdHigh);
+
+        if (((ThresholdLow > 255*65536) ||
+            (ThresholdHigh > 255*65536)) &&
+            (Status == VL53L0X_ERROR_NONE)) {
+
+            if (StartNotStopFlag != 0) {
+                Status = VL53L0X_load_tuning_settings(Dev,
+                    InterruptThresholdSettings);
+            } else {
+                Status |= VL53L0X_WrByte(Dev, 0xFF, 0x04);
+                Status |= VL53L0X_WrByte(Dev, 0x70, 0x00);
+                Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+                Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+            }
+
+        }
+
+
+    }
+
+    return Status;
+
+}
+
+
+VL53L0X_Error VL53L0X_StartMeasurement(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_DeviceModes DeviceMode;
+    uint8_t Byte;
+    uint8_t StartStopByte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
+    uint32_t LoopNb;
+    LOG_FUNCTION_START("");
+
+    /* Get Current DeviceMode */
+    VL53L0X_GetDeviceMode(Dev, &DeviceMode);
+
+    Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
+    Status = VL53L0X_WrByte(Dev, 0x91, PALDevDataGet(Dev, StopVariable));
+    Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+    Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
+
+    switch (DeviceMode) {
+    case VL53L0X_DEVICEMODE_SINGLE_RANGING:
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START, 0x01);
+
+        Byte = StartStopByte;
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* Wait until start bit has been cleared */
+            LoopNb = 0;
+            do {
+                if (LoopNb > 0)
+                    Status = VL53L0X_RdByte(Dev,
+                    VL53L0X_REG_SYSRANGE_START, &Byte);
+                LoopNb = LoopNb + 1;
+            } while (((Byte & StartStopByte) == StartStopByte)
+                && (Status == VL53L0X_ERROR_NONE)
+                && (LoopNb < VL53L0X_DEFAULT_MAX_LOOP));
+
+            if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP)
+                Status = VL53L0X_ERROR_TIME_OUT;
+
+        }
+
+        break;
+    case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
+        /* Back-to-back mode */
+
+        /* Check if need to apply interrupt settings */
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
+
+        Status = VL53L0X_WrByte(Dev,
+        VL53L0X_REG_SYSRANGE_START,
+        VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* Set PAL State to Running */
+            PALDevDataSet(Dev, PalState, VL53L0X_STATE_RUNNING);
+        }
+        break;
+    case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
+        /* Continuous mode */
+        /* Check if need to apply interrupt settings */
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
+
+        Status = VL53L0X_WrByte(Dev,
+        VL53L0X_REG_SYSRANGE_START,
+        VL53L0X_REG_SYSRANGE_MODE_TIMED);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* Set PAL State to Running */
+            PALDevDataSet(Dev, PalState, VL53L0X_STATE_RUNNING);
+        }
+        break;
+    default:
+        /* Selected mode not supported */
+        Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
+    }
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_StopMeasurement(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START,
+    VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
+    Status = VL53L0X_WrByte(Dev, 0x91, 0x00);
+    Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* Set PAL State to Idle */
+        PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+    }
+
+    /* Check if need to apply interrupt settings */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 0);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
+    uint8_t *pMeasurementDataReady)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SysRangeStatusRegister;
+    uint8_t InterruptConfig;
+    uint32_t InterruptMask;
+    LOG_FUNCTION_START("");
+
+    InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+        Pin0GpioFunctionality);
+
+    if (InterruptConfig ==
+        VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
+        Status = VL53L0X_GetInterruptMaskStatus(Dev, &InterruptMask);
+        if (InterruptMask ==
+        VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY)
+            *pMeasurementDataReady = 1;
+        else
+            *pMeasurementDataReady = 0;
+    } else {
+        Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
+            &SysRangeStatusRegister);
+        if (Status == VL53L0X_ERROR_NONE) {
+            if (SysRangeStatusRegister & 0x01)
+                *pMeasurementDataReady = 1;
+            else
+                *pMeasurementDataReady = 0;
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_WaitDeviceReadyForNewMeasurement(VL53L0X_DEV Dev,
+    uint32_t MaxLoop)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented for VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t DeviceRangeStatus;
+    uint8_t RangeFractionalEnable;
+    uint8_t PalRangeStatus;
+    uint8_t XTalkCompensationEnable;
+    uint16_t AmbientRate;
+    FixPoint1616_t SignalRate;
+    uint16_t XTalkCompensationRateMegaCps;
+    uint16_t EffectiveSpadRtnCount;
+    uint16_t tmpuint16;
+    uint16_t XtalkRangeMilliMeter;
+    uint16_t LinearityCorrectiveGain;
+    uint8_t localBuffer[12];
+    VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
+
+    LOG_FUNCTION_START("");
+
+    /*
+     * use multi read even if some registers are not useful, result will
+     * be more efficient
+     * start reading at 0x14 dec20
+     * end reading at 0x21 dec33 total 14 bytes to read
+     */
+    Status = VL53L0X_ReadMulti(Dev, 0x14, localBuffer, 12);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        pRangingMeasurementData->ZoneId = 0; /* Only one zone */
+        pRangingMeasurementData->TimeStamp = 0; /* Not Implemented */
+
+        tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11], localBuffer[10]);
+        /* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
+         *(format 11.2) else no fractional
+         */
+
+        pRangingMeasurementData->MeasurementTimeUsec = 0;
+
+        SignalRate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
+            VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
+        /* peak_signal_count_rate_rtn_mcps */
+        pRangingMeasurementData->SignalRateRtnMegaCps = SignalRate;
+
+        AmbientRate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
+        pRangingMeasurementData->AmbientRateRtnMegaCps =
+            VL53L0X_FIXPOINT97TOFIXPOINT1616(AmbientRate);
+
+        EffectiveSpadRtnCount = VL53L0X_MAKEUINT16(localBuffer[3],
+            localBuffer[2]);
+        /* EffectiveSpadRtnCount is 8.8 format */
+        pRangingMeasurementData->EffectiveSpadRtnCount =
+            EffectiveSpadRtnCount;
+
+        DeviceRangeStatus = localBuffer[0];
+
+        /* Get Linearity Corrective Gain */
+        LinearityCorrectiveGain = PALDevDataGet(Dev,
+            LinearityCorrectiveGain);
+
+        /* Get ranging configuration */
+        RangeFractionalEnable = PALDevDataGet(Dev,
+            RangeFractionalEnable);
+
+        if (LinearityCorrectiveGain != 1000) {
+
+            tmpuint16 = (uint16_t)((LinearityCorrectiveGain
+                * tmpuint16 + 500) / 1000);
+
+            /* Implement Xtalk */
+            VL53L0X_GETPARAMETERFIELD(Dev,
+                XTalkCompensationRateMegaCps,
+                XTalkCompensationRateMegaCps);
+            VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+                XTalkCompensationEnable);
+
+            if (XTalkCompensationEnable) {
+
+                if ((SignalRate
+                    - ((XTalkCompensationRateMegaCps
+                    * EffectiveSpadRtnCount) >> 8))
+                    <= 0) {
+                    if (RangeFractionalEnable)
+                        XtalkRangeMilliMeter = 8888;
+                    else
+                        XtalkRangeMilliMeter = 8888
+                            << 2;
+                } else {
+                    XtalkRangeMilliMeter =
+                    (tmpuint16 * SignalRate)
+                        / (SignalRate
+                        - ((XTalkCompensationRateMegaCps
+                        * EffectiveSpadRtnCount)
+                        >> 8));
+                }
+
+                tmpuint16 = XtalkRangeMilliMeter;
+            }
+
+        }
+
+        if (RangeFractionalEnable) {
+            pRangingMeasurementData->RangeMilliMeter =
+                (uint16_t)((tmpuint16) >> 2);
+            pRangingMeasurementData->RangeFractionalPart =
+                (uint8_t)((tmpuint16 & 0x03) << 6);
+        } else {
+            pRangingMeasurementData->RangeMilliMeter = tmpuint16;
+            pRangingMeasurementData->RangeFractionalPart = 0;
+        }
+
+        /*
+         * For a standard definition of RangeStatus, this should
+         * return 0 in case of good result after a ranging
+         * The range status depends on the device so call a device
+         * specific function to obtain the right Status.
+         */
+        Status |= VL53L0X_get_pal_range_status(Dev, DeviceRangeStatus,
+            SignalRate, EffectiveSpadRtnCount,
+            pRangingMeasurementData, &PalRangeStatus);
+
+        if (Status == VL53L0X_ERROR_NONE)
+            pRangingMeasurementData->RangeStatus = PalRangeStatus;
+
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* Copy last read data into Dev buffer */
+        LastRangeDataBuffer = PALDevDataGet(Dev, LastRangeMeasure);
+
+        LastRangeDataBuffer.RangeMilliMeter =
+            pRangingMeasurementData->RangeMilliMeter;
+        LastRangeDataBuffer.RangeFractionalPart =
+            pRangingMeasurementData->RangeFractionalPart;
+        LastRangeDataBuffer.RangeDMaxMilliMeter =
+            pRangingMeasurementData->RangeDMaxMilliMeter;
+        LastRangeDataBuffer.MeasurementTimeUsec =
+            pRangingMeasurementData->MeasurementTimeUsec;
+        LastRangeDataBuffer.SignalRateRtnMegaCps =
+            pRangingMeasurementData->SignalRateRtnMegaCps;
+        LastRangeDataBuffer.AmbientRateRtnMegaCps =
+            pRangingMeasurementData->AmbientRateRtnMegaCps;
+        LastRangeDataBuffer.EffectiveSpadRtnCount =
+            pRangingMeasurementData->EffectiveSpadRtnCount;
+        LastRangeDataBuffer.RangeStatus =
+            pRangingMeasurementData->RangeStatus;
+
+        PALDevDataSet(Dev, LastRangeMeasure, LastRangeDataBuffer);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetMeasurementRefSignal(VL53L0X_DEV Dev,
+    FixPoint1616_t *pMeasurementRefSignal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SignalRefClipLimitCheckEnable = 0;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_GetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+            &SignalRefClipLimitCheckEnable);
+    if (SignalRefClipLimitCheckEnable != 0) {
+        *pMeasurementRefSignal = PALDevDataGet(Dev, LastSignalRefMcps);
+    } else {
+        Status = VL53L0X_ERROR_INVALID_COMMAND;
+    }
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetHistogramMeasurementData(VL53L0X_DEV Dev,
+    VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    /* This function will do a complete single ranging
+     * Here we fix the mode! */
+    Status = VL53L0X_SetDeviceMode(Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_PerformSingleMeasurement(Dev);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetRangingMeasurementData(Dev,
+            pRangingMeasurementData);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_ClearInterruptMask(Dev, 0);
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t NumberOfROIZones)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    if (NumberOfROIZones != 1)
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t *pNumberOfROIZones)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    *pNumberOfROIZones = 1;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetMaxNumberOfROIZones(VL53L0X_DEV Dev,
+    uint8_t *pMaxNumberOfROIZones)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    *pMaxNumberOfROIZones = 1;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* End Group PAL Measurement Functions */
+
+VL53L0X_Error VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
+    VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
+    VL53L0X_InterruptPolarity Polarity)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t data;
+
+    LOG_FUNCTION_START("");
+
+    if (Pin != 0) {
+        Status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
+    } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
+        if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
+            data = 0x10;
+        else
+            data = 1;
+
+        Status = VL53L0X_WrByte(Dev,
+        VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
+
+    } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_OSC) {
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0x85, 0x02);
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x04);
+        Status |= VL53L0X_WrByte(Dev, 0xcd, 0x00);
+        Status |= VL53L0X_WrByte(Dev, 0xcc, 0x11);
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x07);
+        Status |= VL53L0X_WrByte(Dev, 0xbe, 0x00);
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x06);
+        Status |= VL53L0X_WrByte(Dev, 0xcc, 0x09);
+
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+
+    } else {
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            switch (Functionality) {
+            case VL53L0X_GPIOFUNCTIONALITY_OFF:
+                data = 0x00;
+                break;
+            case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
+                data = 0x01;
+                break;
+            case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
+                data = 0x02;
+                break;
+            case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
+                data = 0x03;
+                break;
+            case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
+                data = 0x04;
+                break;
+            default:
+                Status =
+                VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
+            }
+        }
+
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
+                data = 0;
+            else
+                data = (uint8_t)(1 << 4);
+
+            Status = VL53L0X_UpdateByte(Dev,
+            VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
+        }
+
+        if (Status == VL53L0X_ERROR_NONE)
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                Pin0GpioFunctionality, Functionality);
+
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_ClearInterruptMask(Dev, 0);
+
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
+    VL53L0X_DeviceModes *pDeviceMode,
+    VL53L0X_GpioFunctionality *pFunctionality,
+    VL53L0X_InterruptPolarity *pPolarity)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_GpioFunctionality GpioFunctionality;
+    uint8_t data;
+
+    LOG_FUNCTION_START("");
+
+    /* pDeviceMode not managed by Ewok it return the current mode */
+
+    Status = VL53L0X_GetDeviceMode(Dev, pDeviceMode);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (Pin != 0) {
+            Status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
+        } else {
+            Status = VL53L0X_RdByte(Dev,
+            VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, &data);
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        switch (data & 0x07) {
+        case 0x00:
+            GpioFunctionality = VL53L0X_GPIOFUNCTIONALITY_OFF;
+            break;
+        case 0x01:
+            GpioFunctionality =
+            VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW;
+            break;
+        case 0x02:
+            GpioFunctionality =
+            VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH;
+            break;
+        case 0x03:
+            GpioFunctionality =
+            VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT;
+            break;
+        case 0x04:
+            GpioFunctionality =
+            VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY;
+            break;
+        default:
+            Status = VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_RdByte(Dev, VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,
+            &data);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if ((data & (uint8_t)(1 << 4)) == 0)
+            *pPolarity = VL53L0X_INTERRUPTPOLARITY_LOW;
+        else
+            *pPolarity = VL53L0X_INTERRUPTPOLARITY_HIGH;
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        *pFunctionality = GpioFunctionality;
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, Pin0GpioFunctionality,
+            GpioFunctionality);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetInterruptThresholds(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes DeviceMode, FixPoint1616_t ThresholdLow,
+    FixPoint1616_t ThresholdHigh)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t Threshold16;
+    LOG_FUNCTION_START("");
+
+    /* no dependency on DeviceMode for Ewok */
+    /* Need to divide by 2 because the FW will apply a x2 */
+    Threshold16 = (uint16_t)((ThresholdLow >> 17) & 0x00fff);
+    Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, Threshold16);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* Need to divide by 2 because the FW will apply a x2 */
+        Threshold16 = (uint16_t)((ThresholdHigh >> 17) & 0x00fff);
+        Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+            Threshold16);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
+    VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
+    FixPoint1616_t *pThresholdHigh)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t Threshold16;
+    LOG_FUNCTION_START("");
+
+    /* no dependency on DeviceMode for Ewok */
+
+    Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &Threshold16);
+    /* Need to multiply by 2 because the FW will apply a x2 */
+    *pThresholdLow = (FixPoint1616_t)((0x00fff & Threshold16) << 17);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+            &Threshold16);
+        /* Need to multiply by 2 because the FW will apply a x2 */
+        *pThresholdHigh =
+            (FixPoint1616_t)((0x00fff & Threshold16) << 17);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
+    uint32_t *pStopStatus)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte = 0;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_RdByte(Dev, 0x04, &Byte);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x0);
+
+    *pStopStatus = Byte;
+
+    if (Byte == 0) {
+        Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+        Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
+        Status = VL53L0X_WrByte(Dev, 0x91,
+            PALDevDataGet(Dev, StopVariable));
+        Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+        Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* Group PAL Interrupt Functions */
+VL53L0X_Error VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t LoopCount;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    /* clear bit 0 range interrupt, bit 1 error interrupt */
+    LoopCount = 0;
+    do {
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
+        Status |= VL53L0X_WrByte(Dev,
+            VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
+        Status |= VL53L0X_RdByte(Dev,
+            VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
+        LoopCount++;
+    } while (((Byte & 0x07) != 0x00)
+            && (LoopCount < 3)
+            && (Status == VL53L0X_ERROR_NONE));
+
+
+    if (LoopCount >= 3)
+        Status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
+    uint32_t *pInterruptMaskStatus)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
+    *pInterruptMaskStatus = Byte & 0x07;
+
+    if (Byte & 0x18)
+        Status = VL53L0X_ERROR_RANGE_ERROR;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_EnableInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+    LOG_FUNCTION_START("");
+
+    /* not implemented for VL53L0X */
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* End Group PAL Interrupt Functions */
+
+/* Group SPAD functions */
+
+VL53L0X_Error VL53L0X_SetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
+    uint16_t SpadAmbientDamperThreshold)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_WrWord(Dev, 0x40, SpadAmbientDamperThreshold);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
+    uint16_t *pSpadAmbientDamperThreshold)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_RdWord(Dev, 0x40, pSpadAmbientDamperThreshold);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_SetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
+    uint16_t SpadAmbientDamperFactor)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    Byte = (uint8_t)(SpadAmbientDamperFactor & 0x00FF);
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0x42, Byte);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
+    uint16_t *pSpadAmbientDamperFactor)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t Byte;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_RdByte(Dev, 0x42, &Byte);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+    *pSpadAmbientDamperFactor = (uint16_t)Byte;
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+/* END Group SPAD functions */
+
+/*****************************************************************************
+ * Internal functions
+ *****************************************************************************/
+
+VL53L0X_Error VL53L0X_SetReferenceSpads(VL53L0X_DEV Dev, uint32_t count,
+    uint8_t isApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_set_reference_spads(Dev, count, isApertureSpads);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_GetReferenceSpads(VL53L0X_DEV Dev, uint32_t *pSpadCount,
+    uint8_t *pIsApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_get_reference_spads(Dev, pSpadCount, pIsApertureSpads);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
+    uint32_t *refSpadCount, uint8_t *isApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    LOG_FUNCTION_START("");
+
+    Status = VL53L0X_perform_ref_spad_management(Dev, refSpadCount,
+        isApertureSpads);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_calibration.c b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_calibration.c
new file mode 100644
index 0000000..a4b02ff
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_calibration.c
@@ -0,0 +1,1276 @@
+/*******************************************************************************
+ 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"
+#include "vl53l0x_api_calibration.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__)
+
+#define REF_ARRAY_SPAD_0  0
+#define REF_ARRAY_SPAD_5  5
+#define REF_ARRAY_SPAD_10 10
+
+uint32_t refArrayQuadrants[4] = {REF_ARRAY_SPAD_10, REF_ARRAY_SPAD_5,
+        REF_ARRAY_SPAD_0, REF_ARRAY_SPAD_5 };
+
+VL53L0X_Error VL53L0X_perform_xtalk_calibration(VL53L0X_DEV Dev,
+            FixPoint1616_t XTalkCalDistance,
+            FixPoint1616_t *pXTalkCompensationRateMegaCps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t sum_ranging = 0;
+    uint16_t sum_spads = 0;
+    FixPoint1616_t sum_signalRate = 0;
+    FixPoint1616_t total_count = 0;
+    uint8_t xtalk_meas = 0;
+    VL53L0X_RangingMeasurementData_t RangingMeasurementData;
+    FixPoint1616_t xTalkStoredMeanSignalRate;
+    FixPoint1616_t xTalkStoredMeanRange;
+    FixPoint1616_t xTalkStoredMeanRtnSpads;
+    uint32_t signalXTalkTotalPerSpad;
+    uint32_t xTalkStoredMeanRtnSpadsAsInt;
+    uint32_t xTalkCalDistanceAsInt;
+    FixPoint1616_t XTalkCompensationRateMegaCps;
+
+    if (XTalkCalDistance <= 0)
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+    /* Disable the XTalk compensation */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetXTalkCompensationEnable(Dev, 0);
+
+    /* Disable the RIT */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+    }
+
+    /* Perform 50 measurements and compute the averages */
+    if (Status == VL53L0X_ERROR_NONE) {
+        sum_ranging = 0;
+        sum_spads = 0;
+        sum_signalRate = 0;
+        total_count = 0;
+        for (xtalk_meas = 0; xtalk_meas < 50; xtalk_meas++) {
+            Status = VL53L0X_PerformSingleRangingMeasurement(Dev,
+                &RangingMeasurementData);
+
+            if (Status != VL53L0X_ERROR_NONE)
+                break;
+
+            /* The range is valid when RangeStatus = 0 */
+            if (RangingMeasurementData.RangeStatus == 0) {
+                sum_ranging = sum_ranging +
+                    RangingMeasurementData.RangeMilliMeter;
+                sum_signalRate = sum_signalRate +
+                RangingMeasurementData.SignalRateRtnMegaCps;
+                sum_spads = sum_spads +
+                RangingMeasurementData.EffectiveSpadRtnCount
+                    / 256;
+                total_count = total_count + 1;
+            }
+        }
+
+        /* no valid values found */
+        if (total_count == 0)
+            Status = VL53L0X_ERROR_RANGE_ERROR;
+
+    }
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* FixPoint1616_t / uint16_t = FixPoint1616_t */
+        xTalkStoredMeanSignalRate = sum_signalRate / total_count;
+        xTalkStoredMeanRange = (FixPoint1616_t)((uint32_t)(
+            sum_ranging << 16) / total_count);
+        xTalkStoredMeanRtnSpads = (FixPoint1616_t)((uint32_t)(
+            sum_spads << 16) / total_count);
+
+        /* Round Mean Spads to Whole Number.
+         * Typically the calculated mean SPAD count is a whole number
+         * or very close to a whole
+         * number, therefore any truncation will not result in a
+         * significant loss in accuracy.
+         * Also, for a grey target at a typical distance of around
+         * 400mm, around 220 SPADs will
+         * be enabled, therefore, any truncation will result in a loss
+         * of accuracy of less than
+         * 0.5%.
+         */
+        xTalkStoredMeanRtnSpadsAsInt = (xTalkStoredMeanRtnSpads +
+            0x8000) >> 16;
+
+        /* Round Cal Distance to Whole Number.
+         * Note that the cal distance is in mm, therefore no resolution
+         * is lost.*/
+         xTalkCalDistanceAsInt = (XTalkCalDistance + 0x8000) >> 16;
+
+        if (xTalkStoredMeanRtnSpadsAsInt == 0 ||
+           xTalkCalDistanceAsInt == 0 ||
+           xTalkStoredMeanRange >= XTalkCalDistance) {
+            XTalkCompensationRateMegaCps = 0;
+        } else {
+            /* Round Cal Distance to Whole Number.
+               Note that the cal distance is in mm, therefore no
+               resolution is lost.*/
+            xTalkCalDistanceAsInt = (XTalkCalDistance +
+                0x8000) >> 16;
+
+            /* Apply division by mean spad count early in the
+             * calculation to keep the numbers small.
+             * This ensures we can maintain a 32bit calculation.
+             * Fixed1616 / int := Fixed1616 */
+            signalXTalkTotalPerSpad = (xTalkStoredMeanSignalRate) /
+                xTalkStoredMeanRtnSpadsAsInt;
+
+            /* Complete the calculation for total Signal XTalk per
+             * SPAD
+             * Fixed1616 * (Fixed1616 - Fixed1616/int) :=
+             * (2^16 * Fixed1616)
+             */
+            signalXTalkTotalPerSpad *= ((1 << 16) -
+                (xTalkStoredMeanRange / xTalkCalDistanceAsInt));
+
+            /* Round from 2^16 * Fixed1616, to Fixed1616. */
+            XTalkCompensationRateMegaCps = (signalXTalkTotalPerSpad
+                + 0x8000) >> 16;
+        }
+
+        *pXTalkCompensationRateMegaCps = XTalkCompensationRateMegaCps;
+
+        /* Enable the XTalk compensation */
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_SetXTalkCompensationEnable(Dev, 1);
+
+        /* Enable the XTalk compensation */
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_SetXTalkCompensationRateMegaCps(Dev,
+                    XTalkCompensationRateMegaCps);
+
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_perform_offset_calibration(VL53L0X_DEV Dev,
+            FixPoint1616_t CalDistanceMilliMeter,
+            int32_t *pOffsetMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t sum_ranging = 0;
+    FixPoint1616_t total_count = 0;
+    VL53L0X_RangingMeasurementData_t RangingMeasurementData;
+    FixPoint1616_t StoredMeanRange;
+    uint32_t StoredMeanRangeAsInt;
+    uint32_t CalDistanceAsInt_mm;
+    uint8_t SequenceStepEnabled;
+    int meas = 0;
+
+    if (CalDistanceMilliMeter <= 0)
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev, 0);
+
+
+    /* Get the value of the TCC */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_GetSequenceStepEnable(Dev,
+                VL53L0X_SEQUENCESTEP_TCC, &SequenceStepEnabled);
+
+
+    /* Disable the TCC */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetSequenceStepEnable(Dev,
+                VL53L0X_SEQUENCESTEP_TCC, 0);
+
+
+    /* Disable the RIT */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_SetLimitCheckEnable(Dev,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+
+    /* Perform 50 measurements and compute the averages */
+    if (Status == VL53L0X_ERROR_NONE) {
+        sum_ranging = 0;
+        total_count = 0;
+        for (meas = 0; meas < 50; meas++) {
+            Status = VL53L0X_PerformSingleRangingMeasurement(Dev,
+                    &RangingMeasurementData);
+
+            if (Status != VL53L0X_ERROR_NONE)
+                break;
+
+            /* The range is valid when RangeStatus = 0 */
+            if (RangingMeasurementData.RangeStatus == 0) {
+                sum_ranging = sum_ranging +
+                    RangingMeasurementData.RangeMilliMeter;
+                total_count = total_count + 1;
+            }
+        }
+
+        /* no valid values found */
+        if (total_count == 0)
+            Status = VL53L0X_ERROR_RANGE_ERROR;
+    }
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* FixPoint1616_t / uint16_t = FixPoint1616_t */
+        StoredMeanRange = (FixPoint1616_t)((uint32_t)(sum_ranging << 16)
+            / total_count);
+
+        StoredMeanRangeAsInt = (StoredMeanRange + 0x8000) >> 16;
+
+        /* Round Cal Distance to Whole Number.
+         * Note that the cal distance is in mm, therefore no resolution
+         * is lost.*/
+         CalDistanceAsInt_mm = (CalDistanceMilliMeter + 0x8000) >> 16;
+
+         *pOffsetMicroMeter = (CalDistanceAsInt_mm -
+                 StoredMeanRangeAsInt) * 1000;
+
+        /* Apply the calculated offset */
+        if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETPARAMETERFIELD(Dev, RangeOffsetMicroMeters,
+                    *pOffsetMicroMeter);
+            Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev,
+                    *pOffsetMicroMeter);
+        }
+
+    }
+
+    /* Restore the TCC */
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (SequenceStepEnabled != 0)
+            Status = VL53L0X_SetSequenceStepEnable(Dev,
+                    VL53L0X_SEQUENCESTEP_TCC, 1);
+    }
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
+        int32_t OffsetCalibrationDataMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    int32_t cMaxOffsetMicroMeter = 511000;
+    int32_t cMinOffsetMicroMeter = -512000;
+    int16_t cOffsetRange = 4096;
+    uint32_t encodedOffsetVal;
+
+    LOG_FUNCTION_START("");
+
+    if (OffsetCalibrationDataMicroMeter > cMaxOffsetMicroMeter)
+        OffsetCalibrationDataMicroMeter = cMaxOffsetMicroMeter;
+    else if (OffsetCalibrationDataMicroMeter < cMinOffsetMicroMeter)
+        OffsetCalibrationDataMicroMeter = cMinOffsetMicroMeter;
+
+    /* The offset register is 10.2 format and units are mm
+     * therefore conversion is applied by a division of
+     * 250.
+     */
+    if (OffsetCalibrationDataMicroMeter >= 0) {
+        encodedOffsetVal =
+            OffsetCalibrationDataMicroMeter/250;
+    } else {
+        encodedOffsetVal =
+            cOffsetRange +
+            OffsetCalibrationDataMicroMeter/250;
+    }
+
+    Status = VL53L0X_WrWord(Dev,
+        VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+        encodedOffsetVal);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
+        int32_t *pOffsetCalibrationDataMicroMeter)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint16_t RangeOffsetRegister;
+    int16_t cMaxOffset = 2047;
+    int16_t cOffsetRange = 4096;
+
+    /* Note that offset has 10.2 format */
+
+    Status = VL53L0X_RdWord(Dev,
+                VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+                &RangeOffsetRegister);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        RangeOffsetRegister = (RangeOffsetRegister & 0x0fff);
+
+        /* Apply 12 bit 2's compliment conversion */
+        if (RangeOffsetRegister > cMaxOffset)
+            *pOffsetCalibrationDataMicroMeter =
+                (int16_t)(RangeOffsetRegister - cOffsetRange)
+                    * 250;
+        else
+            *pOffsetCalibrationDataMicroMeter =
+                (int16_t)RangeOffsetRegister * 250;
+
+    }
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    int32_t CorrectedOffsetMicroMeters;
+    int32_t CurrentOffsetMicroMeters;
+
+    /* if we run on this function we can read all the NVM info
+     * used by the API */
+    Status = VL53L0X_get_info_from_device(Dev, 7);
+
+    /* Read back current device offset */
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_GetOffsetCalibrationDataMicroMeter(Dev,
+                    &CurrentOffsetMicroMeters);
+    }
+
+    /* Apply Offset Adjustment derived from 400mm measurements */
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        /* Store initial device offset */
+        PALDevDataSet(Dev, Part2PartOffsetNVMMicroMeter,
+            CurrentOffsetMicroMeters);
+
+        CorrectedOffsetMicroMeters = CurrentOffsetMicroMeters +
+            (int32_t)PALDevDataGet(Dev,
+                Part2PartOffsetAdjustmentNVMMicroMeter);
+
+        Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev,
+                    CorrectedOffsetMicroMeters);
+
+        /* store current, adjusted offset */
+        if (Status == VL53L0X_ERROR_NONE) {
+            VL53L0X_SETPARAMETERFIELD(Dev, RangeOffsetMicroMeters,
+                    CorrectedOffsetMicroMeters);
+        }
+    }
+
+    return Status;
+}
+
+void get_next_good_spad(uint8_t goodSpadArray[], uint32_t size,
+            uint32_t curr, int32_t *next)
+{
+    uint32_t startIndex;
+    uint32_t fineOffset;
+    uint32_t cSpadsPerByte = 8;
+    uint32_t coarseIndex;
+    uint32_t fineIndex;
+    uint8_t dataByte;
+    uint8_t success = 0;
+
+    /*
+     * Starting with the current good spad, loop through the array to find
+     * the next. i.e. the next bit set in the sequence.
+     *
+     * The coarse index is the byte index of the array and the fine index is
+     * the index of the bit within each byte.
+     */
+
+    *next = -1;
+
+    startIndex = curr / cSpadsPerByte;
+    fineOffset = curr % cSpadsPerByte;
+
+    for (coarseIndex = startIndex; ((coarseIndex < size) && !success);
+                coarseIndex++) {
+        fineIndex = 0;
+        dataByte = goodSpadArray[coarseIndex];
+
+        if (coarseIndex == startIndex) {
+            /* locate the bit position of the provided current
+             * spad bit before iterating */
+            dataByte >>= fineOffset;
+            fineIndex = fineOffset;
+        }
+
+        while (fineIndex < cSpadsPerByte) {
+            if ((dataByte & 0x1) == 1) {
+                success = 1;
+                *next = coarseIndex * cSpadsPerByte + fineIndex;
+                break;
+            }
+            dataByte >>= 1;
+            fineIndex++;
+        }
+    }
+}
+
+
+uint8_t is_aperture(uint32_t spadIndex)
+{
+    /*
+     * This function reports if a given spad index is an aperture SPAD by
+     * deriving the quadrant.
+     */
+    uint32_t quadrant;
+    uint8_t isAperture = 1;
+    quadrant = spadIndex >> 6;
+    if (refArrayQuadrants[quadrant] == REF_ARRAY_SPAD_0)
+        isAperture = 0;
+
+    return isAperture;
+}
+
+
+VL53L0X_Error enable_spad_bit(uint8_t spadArray[], uint32_t size,
+    uint32_t spadIndex)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    uint32_t cSpadsPerByte = 8;
+    uint32_t coarseIndex;
+    uint32_t fineIndex;
+
+    coarseIndex = spadIndex / cSpadsPerByte;
+    fineIndex = spadIndex % cSpadsPerByte;
+    if (coarseIndex >= size)
+        status = VL53L0X_ERROR_REF_SPAD_INIT;
+    else
+        spadArray[coarseIndex] |= (1 << fineIndex);
+
+    return status;
+}
+
+VL53L0X_Error count_enabled_spads(uint8_t spadArray[],
+        uint32_t byteCount, uint32_t maxSpads,
+        uint32_t *pTotalSpadsEnabled, uint8_t *pIsAperture)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    uint32_t cSpadsPerByte = 8;
+    uint32_t lastByte;
+    uint32_t lastBit;
+    uint32_t byteIndex = 0;
+    uint32_t bitIndex = 0;
+    uint8_t tempByte;
+    uint8_t spadTypeIdentified = 0;
+
+    /* The entire array will not be used for spads, therefore the last
+     * byte and last bit is determined from the max spads value.
+     */
+
+    lastByte = maxSpads / cSpadsPerByte;
+    lastBit = maxSpads % cSpadsPerByte;
+
+    /* Check that the max spads value does not exceed the array bounds. */
+    if (lastByte >= byteCount)
+        status = VL53L0X_ERROR_REF_SPAD_INIT;
+
+    *pTotalSpadsEnabled = 0;
+
+    /* Count the bits enabled in the whole bytes */
+    for (byteIndex = 0; byteIndex <= (lastByte - 1); byteIndex++) {
+        tempByte = spadArray[byteIndex];
+
+        for (bitIndex = 0; bitIndex <= cSpadsPerByte; bitIndex++) {
+            if ((tempByte & 0x01) == 1) {
+                (*pTotalSpadsEnabled)++;
+
+                if (!spadTypeIdentified) {
+                    *pIsAperture = 1;
+                    if ((byteIndex < 2) && (bitIndex < 4))
+                            *pIsAperture = 0;
+                    spadTypeIdentified = 1;
+                }
+            }
+            tempByte >>= 1;
+        }
+    }
+
+    /* Count the number of bits enabled in the last byte accounting
+     * for the fact that not all bits in the byte may be used.
+     */
+    tempByte = spadArray[lastByte];
+
+    for (bitIndex = 0; bitIndex <= lastBit; bitIndex++) {
+        if ((tempByte & 0x01) == 1)
+            (*pTotalSpadsEnabled)++;
+    }
+
+    return status;
+}
+
+VL53L0X_Error set_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray)
+{
+    VL53L0X_Error status = VL53L0X_WriteMulti(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
+                refSpadArray, 6);
+    return status;
+}
+
+VL53L0X_Error get_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray)
+{
+    VL53L0X_Error status = VL53L0X_ReadMulti(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
+                refSpadArray,
+                6);
+    return status;
+}
+
+VL53L0X_Error enable_ref_spads(VL53L0X_DEV Dev,
+                uint8_t apertureSpads,
+                uint8_t goodSpadArray[],
+                uint8_t spadArray[],
+                uint32_t size,
+                uint32_t start,
+                uint32_t offset,
+                uint32_t spadCount,
+                uint32_t *lastSpad)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    uint32_t index;
+    uint32_t i;
+    int32_t nextGoodSpad = offset;
+    uint32_t currentSpad;
+    uint8_t checkSpadArray[6];
+
+    /*
+     * This function takes in a spad array which may or may not have SPADS
+     * already enabled and appends from a given offset a requested number
+     * of new SPAD enables. The 'good spad map' is applied to
+     * determine the next SPADs to enable.
+     *
+     * This function applies to only aperture or only non-aperture spads.
+     * Checks are performed to ensure this.
+     */
+
+    currentSpad = offset;
+    for (index = 0; index < spadCount; index++) {
+        get_next_good_spad(goodSpadArray, size, currentSpad,
+            &nextGoodSpad);
+
+        if (nextGoodSpad == -1) {
+            status = VL53L0X_ERROR_REF_SPAD_INIT;
+            break;
+        }
+
+        /* Confirm that the next good SPAD is non-aperture */
+        if (is_aperture(start + nextGoodSpad) != apertureSpads) {
+            /* if we can't get the required number of good aperture
+             * spads from the current quadrant then this is an error
+             */
+            status = VL53L0X_ERROR_REF_SPAD_INIT;
+            break;
+        }
+        currentSpad = (uint32_t)nextGoodSpad;
+        enable_spad_bit(spadArray, size, currentSpad);
+        currentSpad++;
+    }
+    *lastSpad = currentSpad;
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = set_ref_spad_map(Dev, spadArray);
+
+
+    if (status == VL53L0X_ERROR_NONE) {
+        status = get_ref_spad_map(Dev, checkSpadArray);
+
+        i = 0;
+
+        /* Compare spad maps. If not equal report error. */
+        while (i < size) {
+            if (spadArray[i] != checkSpadArray[i]) {
+                status = VL53L0X_ERROR_REF_SPAD_INIT;
+                break;
+            }
+            i++;
+        }
+    }
+    return status;
+}
+
+
+VL53L0X_Error perform_ref_signal_measurement(VL53L0X_DEV Dev,
+        uint16_t *refSignalRate)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    VL53L0X_RangingMeasurementData_t rangingMeasurementData;
+
+    uint8_t SequenceConfig = 0;
+
+    /* store the value of the sequence config,
+     * this will be reset before the end of the function
+     */
+
+    SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+
+    /*
+     * This function performs a reference signal rate measurement.
+     */
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_PerformSingleRangingMeasurement(Dev,
+                &rangingMeasurementData);
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_RdWord(Dev,
+            VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+            refSignalRate);
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    if (status == VL53L0X_ERROR_NONE) {
+        /* restore the previous Sequence Config */
+        status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+                SequenceConfig);
+        if (status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+    }
+
+    return status;
+}
+
+VL53L0X_Error VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
+                uint32_t *refSpadCount,
+                uint8_t *isApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t lastSpadArray[6];
+    uint8_t startSelect = 0xB4;
+    uint32_t minimumSpadCount = 3;
+    uint32_t maxSpadCount = 44;
+    uint32_t currentSpadIndex = 0;
+    uint32_t lastSpadIndex = 0;
+    int32_t nextGoodSpad = 0;
+    uint16_t targetRefRate = 0x0A00; /* 20 MCPS in 9:7 format */
+    uint16_t peakSignalRateRef;
+    uint32_t needAptSpads = 0;
+    uint32_t index = 0;
+    uint32_t spadArraySize = 6;
+    uint32_t signalRateDiff = 0;
+    uint32_t lastSignalRateDiff = 0;
+    uint8_t complete = 0;
+    uint8_t VhvSettings = 0;
+    uint8_t PhaseCal = 0;
+    uint32_t refSpadCount_int = 0;
+    uint8_t	 isApertureSpads_int = 0;
+
+    /*
+     * The reference SPAD initialization procedure determines the minimum
+     * amount of reference spads to be enables to achieve a target reference
+     * signal rate and should be performed once during initialization.
+     *
+     * Either aperture or non-aperture spads are applied but never both.
+     * Firstly non-aperture spads are set, begining with 5 spads, and
+     * increased one spad at a time until the closest measurement to the
+     * target rate is achieved.
+     *
+     * If the target rate is exceeded when 5 non-aperture spads are enabled,
+     * initialization is performed instead with aperture spads.
+     *
+     * When setting spads, a 'Good Spad Map' is applied.
+     *
+     * This procedure operates within a SPAD window of interest of a maximum
+     * 44 spads.
+     * The start point is currently fixed to 180, which lies towards the end
+     * of the non-aperture quadrant and runs in to the adjacent aperture
+     * quadrant.
+     */
+
+
+    targetRefRate = PALDevDataGet(Dev, targetRefRate);
+
+    /*
+     * Initialize Spad arrays.
+     * Currently the good spad map is initialised to 'All good'.
+     * This is a short term implementation. The good spad map will be
+     * provided as an input.
+     * Note that there are 6 bytes. Only the first 44 bits will be used to
+     * represent spads.
+     */
+    for (index = 0; index < spadArraySize; index++)
+        Dev->Data.SpadData.RefSpadEnables[index] = 0;
+
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
+            startSelect);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
+
+    /* Perform ref calibration */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_perform_ref_calibration(Dev, &VhvSettings,
+            &PhaseCal, 0);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* Enable Minimum NON-APERTURE Spads */
+        currentSpadIndex = 0;
+        lastSpadIndex = currentSpadIndex;
+        needAptSpads = 0;
+        Status = enable_ref_spads(Dev,
+                    needAptSpads,
+                    Dev->Data.SpadData.RefGoodSpadMap,
+                    Dev->Data.SpadData.RefSpadEnables,
+                    spadArraySize,
+                    startSelect,
+                    currentSpadIndex,
+                    minimumSpadCount,
+                    &lastSpadIndex);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        currentSpadIndex = lastSpadIndex;
+
+        Status = perform_ref_signal_measurement(Dev,
+            &peakSignalRateRef);
+        if ((Status == VL53L0X_ERROR_NONE) &&
+            (peakSignalRateRef > targetRefRate)) {
+            /* Signal rate measurement too high,
+             * switch to APERTURE SPADs */
+
+            for (index = 0; index < spadArraySize; index++)
+                Dev->Data.SpadData.RefSpadEnables[index] = 0;
+
+
+            /* Increment to the first APERTURE spad */
+            while ((is_aperture(startSelect + currentSpadIndex)
+                == 0) && (currentSpadIndex < maxSpadCount)) {
+                currentSpadIndex++;
+            }
+
+            needAptSpads = 1;
+
+            Status = enable_ref_spads(Dev,
+                    needAptSpads,
+                    Dev->Data.SpadData.RefGoodSpadMap,
+                    Dev->Data.SpadData.RefSpadEnables,
+                    spadArraySize,
+                    startSelect,
+                    currentSpadIndex,
+                    minimumSpadCount,
+                    &lastSpadIndex);
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                currentSpadIndex = lastSpadIndex;
+                Status = perform_ref_signal_measurement(Dev,
+                        &peakSignalRateRef);
+
+                if ((Status == VL53L0X_ERROR_NONE) &&
+                    (peakSignalRateRef > targetRefRate)) {
+                    /* Signal rate still too high after
+                     * setting the minimum number of
+                     * APERTURE spads. Can do no more
+                     * therefore set the min number of
+                     * aperture spads as the result.
+                     */
+                    isApertureSpads_int = 1;
+                    refSpadCount_int = minimumSpadCount;
+                }
+            }
+        } else {
+            needAptSpads = 0;
+        }
+    }
+
+    if ((Status == VL53L0X_ERROR_NONE) &&
+        (peakSignalRateRef < targetRefRate)) {
+        /* At this point, the minimum number of either aperture
+         * or non-aperture spads have been set. Proceed to add
+         * spads and perform measurements until the target
+         * reference is reached.
+         */
+        isApertureSpads_int = needAptSpads;
+        refSpadCount_int	= minimumSpadCount;
+
+        memcpy(lastSpadArray, Dev->Data.SpadData.RefSpadEnables,
+                spadArraySize);
+        lastSignalRateDiff = abs(peakSignalRateRef -
+            targetRefRate);
+        complete = 0;
+
+        while (!complete) {
+            get_next_good_spad(
+                Dev->Data.SpadData.RefGoodSpadMap,
+                spadArraySize, currentSpadIndex,
+                &nextGoodSpad);
+
+            if (nextGoodSpad == -1) {
+                Status = VL53L0X_ERROR_REF_SPAD_INIT;
+                break;
+            }
+
+            /* Cannot combine Aperture and Non-Aperture spads, so
+             * ensure the current spad is of the correct type.
+             */
+            if (is_aperture((uint32_t)startSelect + nextGoodSpad) !=
+                    needAptSpads) {
+                /* At this point we have enabled the maximum
+                 * number of Aperture spads.
+                 */
+                complete = 1;
+                break;
+            }
+
+            (refSpadCount_int)++;
+
+            currentSpadIndex = nextGoodSpad;
+            Status = enable_spad_bit(
+                    Dev->Data.SpadData.RefSpadEnables,
+                    spadArraySize, currentSpadIndex);
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                currentSpadIndex++;
+                /* Proceed to apply the additional spad and
+                 * perform measurement. */
+                Status = set_ref_spad_map(Dev,
+                    Dev->Data.SpadData.RefSpadEnables);
+            }
+
+            if (Status != VL53L0X_ERROR_NONE)
+                break;
+
+            Status = perform_ref_signal_measurement(Dev,
+                    &peakSignalRateRef);
+
+            if (Status != VL53L0X_ERROR_NONE)
+                break;
+
+            signalRateDiff = abs(peakSignalRateRef - targetRefRate);
+
+            if (peakSignalRateRef > targetRefRate) {
+                /* Select the spad map that provides the
+                 * measurement closest to the target rate,
+                 * either above or below it.
+                 */
+                if (signalRateDiff > lastSignalRateDiff) {
+                    /* Previous spad map produced a closer
+                     * measurement, so choose this. */
+                    Status = set_ref_spad_map(Dev,
+                            lastSpadArray);
+                    memcpy(
+                    Dev->Data.SpadData.RefSpadEnables,
+                    lastSpadArray, spadArraySize);
+
+                    (refSpadCount_int)--;
+                }
+                complete = 1;
+            } else {
+                /* Continue to add spads */
+                lastSignalRateDiff = signalRateDiff;
+                memcpy(lastSpadArray,
+                    Dev->Data.SpadData.RefSpadEnables,
+                    spadArraySize);
+            }
+
+        } /* while */
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        *refSpadCount = refSpadCount_int;
+        *isApertureSpads = isApertureSpads_int;
+
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 1);
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadCount, (uint8_t)(*refSpadCount));
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadType, *isApertureSpads);
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_set_reference_spads(VL53L0X_DEV Dev,
+                 uint32_t count, uint8_t isApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint32_t currentSpadIndex = 0;
+    uint8_t startSelect = 0xB4;
+    uint32_t spadArraySize = 6;
+    uint32_t maxSpadCount = 44;
+    uint32_t lastSpadIndex;
+    uint32_t index;
+
+    /*
+     * This function applies a requested number of reference spads, either
+     * aperture or
+     * non-aperture, as requested.
+     * The good spad map will be applied.
+     */
+
+    Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev,
+            VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
+            startSelect);
+
+    for (index = 0; index < spadArraySize; index++)
+        Dev->Data.SpadData.RefSpadEnables[index] = 0;
+
+    if (isApertureSpads) {
+        /* Increment to the first APERTURE spad */
+        while ((is_aperture(startSelect + currentSpadIndex) == 0) &&
+              (currentSpadIndex < maxSpadCount)) {
+            currentSpadIndex++;
+        }
+    }
+    Status = enable_ref_spads(Dev,
+                isApertureSpads,
+                Dev->Data.SpadData.RefGoodSpadMap,
+                Dev->Data.SpadData.RefSpadEnables,
+                spadArraySize,
+                startSelect,
+                currentSpadIndex,
+                count,
+                &lastSpadIndex);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 1);
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadCount, (uint8_t)(count));
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadType, isApertureSpads);
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_reference_spads(VL53L0X_DEV Dev,
+            uint32_t *pSpadCount, uint8_t *pIsApertureSpads)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t refSpadsInitialised;
+    uint8_t refSpadArray[6];
+    uint32_t cMaxSpadCount = 44;
+    uint32_t cSpadArraySize = 6;
+    uint32_t spadsEnabled;
+    uint8_t isApertureSpads = 0;
+
+    refSpadsInitialised = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+                    RefSpadsInitialised);
+
+    if (refSpadsInitialised == 1) {
+
+        *pSpadCount = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadCount);
+        *pIsApertureSpads = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+            ReferenceSpadType);
+    } else {
+
+        /* obtain spad info from device.*/
+        Status = get_ref_spad_map(Dev, refSpadArray);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* count enabled spads within spad map array and
+             * determine if Aperture or Non-Aperture.
+             */
+            Status = count_enabled_spads(refSpadArray,
+                            cSpadArraySize,
+                            cMaxSpadCount,
+                            &spadsEnabled,
+                            &isApertureSpads);
+
+            if (Status == VL53L0X_ERROR_NONE) {
+
+                *pSpadCount = spadsEnabled;
+                *pIsApertureSpads = isApertureSpads;
+
+                VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    RefSpadsInitialised, 1);
+                VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    ReferenceSpadCount,
+                    (uint8_t)spadsEnabled);
+                VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    ReferenceSpadType, isApertureSpads);
+            }
+        }
+    }
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_perform_single_ref_calibration(VL53L0X_DEV Dev,
+        uint8_t vhv_init_byte)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START,
+                VL53L0X_REG_SYSRANGE_MODE_START_STOP |
+                vhv_init_byte);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_measurement_poll_for_completion(Dev);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_ClearInterruptMask(Dev, 0);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START, 0x00);
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_ref_calibration_io(VL53L0X_DEV Dev, uint8_t read_not_write,
+    uint8_t VhvSettings, uint8_t PhaseCal,
+    uint8_t *pVhvSettings, uint8_t *pPhaseCal,
+    const uint8_t vhv_enable, const uint8_t phase_enable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t PhaseCalint = 0;
+
+    /* Read VHV from device */
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    if (read_not_write) {
+        if (vhv_enable)
+            Status |= VL53L0X_RdByte(Dev, 0xCB, pVhvSettings);
+        if (phase_enable)
+            Status |= VL53L0X_RdByte(Dev, 0xEE, &PhaseCalint);
+    } else {
+        if (vhv_enable)
+            Status |= VL53L0X_WrByte(Dev, 0xCB, VhvSettings);
+        if (phase_enable)
+            Status |= VL53L0X_UpdateByte(Dev, 0xEE, 0x80, PhaseCal);
+    }
+
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
+    Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+    *pPhaseCal = (uint8_t)(PhaseCalint&0xEF);
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_perform_vhv_calibration(VL53L0X_DEV Dev,
+    uint8_t *pVhvSettings, const uint8_t get_data_enable,
+    const uint8_t restore_config)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+    uint8_t VhvSettings = 0;
+    uint8_t PhaseCal = 0;
+    uint8_t PhaseCalInt = 0;
+
+    /* store the value of the sequence config,
+     * this will be reset before the end of the function
+     */
+
+    if (restore_config)
+        SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+
+    /* Run VHV */
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_perform_single_ref_calibration(Dev, 0x40);
+
+    /* Read VHV from device */
+    if ((Status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
+        Status = VL53L0X_ref_calibration_io(Dev, 1,
+            VhvSettings, PhaseCal, /* Not used here */
+            pVhvSettings, &PhaseCalInt,
+            1, 0);
+    } else
+        *pVhvSettings = 0;
+
+
+    if ((Status == VL53L0X_ERROR_NONE) && restore_config) {
+        /* restore the previous Sequence Config */
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+                SequenceConfig);
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+
+    }
+
+    return Status;
+}
+
+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 Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+    uint8_t VhvSettings = 0;
+    uint8_t PhaseCal = 0;
+    uint8_t VhvSettingsint;
+
+    /* store the value of the sequence config,
+     * this will be reset before the end of the function
+     */
+
+    if (restore_config)
+        SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+
+    /* Run PhaseCal */
+    Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_perform_single_ref_calibration(Dev, 0x0);
+
+    /* Read PhaseCal from device */
+    if ((Status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
+        Status = VL53L0X_ref_calibration_io(Dev, 1,
+            VhvSettings, PhaseCal, /* Not used here */
+            &VhvSettingsint, pPhaseCal,
+            0, 1);
+    } else
+        *pPhaseCal = 0;
+
+
+    if ((Status == VL53L0X_ERROR_NONE) && restore_config) {
+        /* restore the previous Sequence Config */
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+                SequenceConfig);
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
+    uint8_t *pVhvSettings, uint8_t *pPhaseCal, uint8_t get_data_enable)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t SequenceConfig = 0;
+
+    /* store the value of the sequence config,
+     * this will be reset before the end of the function
+     */
+
+    SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+
+    /* In the following function we don't save the config to optimize
+     * writes on device. Config is saved and restored only once. */
+    Status = VL53L0X_perform_vhv_calibration(
+            Dev, pVhvSettings, get_data_enable, 0);
+
+
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_perform_phase_calibration(
+            Dev, pPhaseCal, get_data_enable, 0);
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        /* restore the previous Sequence Config */
+        Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+                SequenceConfig);
+        if (Status == VL53L0X_ERROR_NONE)
+            PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_set_ref_calibration(VL53L0X_DEV Dev,
+        uint8_t VhvSettings, uint8_t PhaseCal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t pVhvSettings;
+    uint8_t pPhaseCal;
+
+    Status = VL53L0X_ref_calibration_io(Dev, 0,
+        VhvSettings, PhaseCal,
+        &pVhvSettings, &pPhaseCal,
+        1, 1);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_ref_calibration(VL53L0X_DEV Dev,
+        uint8_t *pVhvSettings, uint8_t *pPhaseCal)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t VhvSettings = 0;
+    uint8_t PhaseCal = 0;
+
+    Status = VL53L0X_ref_calibration_io(Dev, 1,
+        VhvSettings, PhaseCal,
+        pVhvSettings, pPhaseCal,
+        1, 1);
+
+    return Status;
+}
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_core.c b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_core.c
new file mode 100644
index 0000000..d6c67fe
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_core.c
@@ -0,0 +1,2242 @@
+/*******************************************************************************
+ 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"
+#include "vl53l0x_api_calibration.h"
+//#include "periphAL.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_reverse_bytes(uint8_t *data, uint32_t size)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t tempData;
+    uint32_t mirrorIndex;
+    uint32_t middle = size/2;
+    uint32_t index;
+
+    for (index = 0; index < middle; index++) {
+        mirrorIndex		 = size - index - 1;
+        tempData		 = data[index];
+        data[index]		 = data[mirrorIndex];
+        data[mirrorIndex] = tempData;
+    }
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t NewDataReady = 0;
+    uint32_t LoopNb;
+
+    LOG_FUNCTION_START("");
+
+    LoopNb = 0;
+
+    do {
+        Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDataReady);
+        if (Status != 0)
+            break; /* the error is set */
+
+        if (NewDataReady == 1)
+            break; /* done note that status == 0 */
+
+        LoopNb++;
+        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
+            Status = VL53L0X_ERROR_TIME_OUT;
+            break;
+        }
+
+        // sleep for 1 millisec
+        usleep(1000);
+
+    } while (1);
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+
+uint8_t VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg)
+{
+    /*!
+     * Converts the encoded VCSEL period register value into the real
+     * period in PLL clocks
+     */
+
+    uint8_t vcsel_period_pclks = 0;
+
+    vcsel_period_pclks = (vcsel_period_reg + 1) << 1;
+
+    return vcsel_period_pclks;
+}
+
+uint8_t VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks)
+{
+    /*!
+     * Converts the encoded VCSEL period register value into the real period
+     * in PLL clocks
+     */
+
+    uint8_t vcsel_period_reg = 0;
+
+    vcsel_period_reg = (vcsel_period_pclks >> 1) - 1;
+
+    return vcsel_period_reg;
+}
+
+
+uint32_t VL53L0X_isqrt(uint32_t num)
+{
+    /*
+     * Implements an integer square root
+     *
+     * From: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
+     */
+
+    uint32_t  res = 0;
+    uint32_t  bit = 1 << 30;
+    /* The second-to-top bit is set:
+     *	1 << 14 for 16-bits, 1 << 30 for 32 bits */
+
+     /* "bit" starts at the highest power of four <= the argument. */
+    while (bit > num)
+        bit >>= 2;
+
+
+    while (bit != 0) {
+        if (num >= res + bit) {
+            num -= res + bit;
+            res = (res >> 1) + bit;
+        } else
+            res >>= 1;
+
+        bit >>= 2;
+    }
+
+    return res;
+}
+
+
+uint32_t VL53L0X_quadrature_sum(uint32_t a, uint32_t b)
+{
+    /*
+     * Implements a quadrature sum
+     *
+     * rea = sqrt(a^2 + b^2)
+     *
+     * Trap overflow case max input value is 65535 (16-bit value)
+     * as internal calc are 32-bit wide
+     *
+     * If overflow then seta output to maximum
+     */
+    uint32_t  res = 0;
+
+    if (a > 65535 || b > 65535)
+        res = 65535;
+    else
+        res = VL53L0X_isqrt(a * a + b * b);
+
+    return res;
+}
+
+
+VL53L0X_Error VL53L0X_device_read_strobe(VL53L0X_DEV Dev)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t strobe;
+    uint32_t LoopNb;
+    LOG_FUNCTION_START("");
+
+    Status |= VL53L0X_WrByte(Dev, 0x83, 0x00);
+
+    /* polling
+     * use timeout to avoid deadlock*/
+    if (Status == VL53L0X_ERROR_NONE) {
+        LoopNb = 0;
+        do {
+            Status = VL53L0X_RdByte(Dev, 0x83, &strobe);
+            if ((strobe != 0x00) || Status != VL53L0X_ERROR_NONE)
+                    break;
+
+            LoopNb = LoopNb + 1;
+        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
+
+        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP)
+            Status = VL53L0X_ERROR_TIME_OUT;
+
+    }
+
+    Status |= VL53L0X_WrByte(Dev, 0x83, 0x01);
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+
+}
+
+VL53L0X_Error VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option)
+{
+
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t byte;
+    uint32_t TmpDWord;
+    uint8_t ModuleId;
+    uint8_t Revision;
+    uint8_t ReferenceSpadCount = 0;
+    uint8_t ReferenceSpadType = 0;
+    uint32_t PartUIDUpper = 0;
+    uint32_t PartUIDLower = 0;
+    uint32_t OffsetFixed1104_mm = 0;
+    int16_t OffsetMicroMeters = 0;
+    uint32_t DistMeasTgtFixed1104_mm = 400 << 4;
+    uint32_t DistMeasFixed1104_400_mm = 0;
+    uint32_t SignalRateMeasFixed1104_400_mm = 0;
+    char ProductId[19];
+    char *ProductId_tmp;
+    uint8_t ReadDataFromDeviceDone;
+    FixPoint1616_t SignalRateMeasFixed400mmFix = 0;
+    uint8_t NvmRefGoodSpadMap[VL53L0X_REF_SPAD_BUFFER_SIZE];
+    int i;
+
+
+    LOG_FUNCTION_START("");
+
+    ReadDataFromDeviceDone = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+            ReadDataFromDeviceDone);
+
+    /* This access is done only once after that a GetDeviceInfo or
+     * datainit is done*/
+    if (ReadDataFromDeviceDone != 7) {
+
+        Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x06);
+        Status |= VL53L0X_RdByte(Dev, 0x83, &byte);
+        Status |= VL53L0X_WrByte(Dev, 0x83, byte|4);
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x07);
+        Status |= VL53L0X_WrByte(Dev, 0x81, 0x01);
+
+        //Status |= VL53L0X_PollingDelay(Dev); TODO NEED THIS ??
+
+        Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
+
+        if (((option & 1) == 1) &&
+            ((ReadDataFromDeviceDone & 1) == 0)) {
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x6b);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            ReferenceSpadCount = (uint8_t)((TmpDWord >> 8) & 0x07f);
+            ReferenceSpadType  = (uint8_t)((TmpDWord >> 15) & 0x01);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x24);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+
+            NvmRefGoodSpadMap[0] = (uint8_t)((TmpDWord >> 24)
+                & 0xff);
+            NvmRefGoodSpadMap[1] = (uint8_t)((TmpDWord >> 16)
+                & 0xff);
+            NvmRefGoodSpadMap[2] = (uint8_t)((TmpDWord >> 8)
+                & 0xff);
+            NvmRefGoodSpadMap[3] = (uint8_t)(TmpDWord & 0xff);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x25);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            NvmRefGoodSpadMap[4] = (uint8_t)((TmpDWord >> 24)
+                & 0xff);
+            NvmRefGoodSpadMap[5] = (uint8_t)((TmpDWord >> 16)
+                & 0xff);
+        }
+
+        if (((option & 2) == 2) &&
+            ((ReadDataFromDeviceDone & 2) == 0)) {
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x02);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdByte(Dev, 0x90, &ModuleId);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x7B);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdByte(Dev, 0x90, &Revision);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x77);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            ProductId[0] = (char)((TmpDWord >> 25) & 0x07f);
+            ProductId[1] = (char)((TmpDWord >> 18) & 0x07f);
+            ProductId[2] = (char)((TmpDWord >> 11) & 0x07f);
+            ProductId[3] = (char)((TmpDWord >> 4) & 0x07f);
+
+            byte = (uint8_t)((TmpDWord & 0x00f) << 3);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x78);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            ProductId[4] = (char)(byte +
+                    ((TmpDWord >> 29) & 0x07f));
+            ProductId[5] = (char)((TmpDWord >> 22) & 0x07f);
+            ProductId[6] = (char)((TmpDWord >> 15) & 0x07f);
+            ProductId[7] = (char)((TmpDWord >> 8) & 0x07f);
+            ProductId[8] = (char)((TmpDWord >> 1) & 0x07f);
+
+            byte = (uint8_t)((TmpDWord & 0x001) << 6);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x79);
+
+            Status |= VL53L0X_device_read_strobe(Dev);
+
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            ProductId[9] = (char)(byte +
+                    ((TmpDWord >> 26) & 0x07f));
+            ProductId[10] = (char)((TmpDWord >> 19) & 0x07f);
+            ProductId[11] = (char)((TmpDWord >> 12) & 0x07f);
+            ProductId[12] = (char)((TmpDWord >> 5) & 0x07f);
+
+            byte = (uint8_t)((TmpDWord & 0x01f) << 2);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x7A);
+
+            Status |= VL53L0X_device_read_strobe(Dev);
+
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            ProductId[13] = (char)(byte +
+                    ((TmpDWord >> 30) & 0x07f));
+            ProductId[14] = (char)((TmpDWord >> 23) & 0x07f);
+            ProductId[15] = (char)((TmpDWord >> 16) & 0x07f);
+            ProductId[16] = (char)((TmpDWord >> 9) & 0x07f);
+            ProductId[17] = (char)((TmpDWord >> 2) & 0x07f);
+            ProductId[18] = '\0';
+
+        }
+
+        if (((option & 4) == 4) &&
+            ((ReadDataFromDeviceDone & 4) == 0)) {
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x7B);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &PartUIDUpper);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x7C);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &PartUIDLower);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x73);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            SignalRateMeasFixed1104_400_mm = (TmpDWord &
+                0x0000000ff) << 8;
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x74);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            SignalRateMeasFixed1104_400_mm |= ((TmpDWord &
+                0xff000000) >> 24);
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x75);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            DistMeasFixed1104_400_mm = (TmpDWord & 0x0000000ff)
+                            << 8;
+
+            Status |= VL53L0X_WrByte(Dev, 0x94, 0x76);
+            Status |= VL53L0X_device_read_strobe(Dev);
+            Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
+
+            DistMeasFixed1104_400_mm |= ((TmpDWord & 0xff000000)
+                            >> 24);
+        }
+
+        Status |= VL53L0X_WrByte(Dev, 0x81, 0x00);
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x06);
+        Status |= VL53L0X_RdByte(Dev, 0x83, &byte);
+        Status |= VL53L0X_WrByte(Dev, 0x83, byte&0xfb);
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
+        Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
+
+        Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+        Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+    }
+
+    if ((Status == VL53L0X_ERROR_NONE) &&
+        (ReadDataFromDeviceDone != 7)) {
+        /* Assign to variable if status is ok */
+        if (((option & 1) == 1) &&
+            ((ReadDataFromDeviceDone & 1) == 0)) {
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                ReferenceSpadCount, ReferenceSpadCount);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                ReferenceSpadType, ReferenceSpadType);
+
+            for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
+                Dev->Data.SpadData.RefGoodSpadMap[i] =
+                    NvmRefGoodSpadMap[i];
+            }
+        }
+
+        if (((option & 2) == 2) &&
+            ((ReadDataFromDeviceDone & 2) == 0)) {
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    ModuleId, ModuleId);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    Revision, Revision);
+
+            ProductId_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+                    ProductId);
+            VL53L0X_COPYSTRING(ProductId_tmp, ProductId);
+
+        }
+
+        if (((option & 4) == 4) &&
+            ((ReadDataFromDeviceDone & 4) == 0)) {
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                        PartUIDUpper, PartUIDUpper);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                        PartUIDLower, PartUIDLower);
+
+            SignalRateMeasFixed400mmFix =
+                VL53L0X_FIXPOINT97TOFIXPOINT1616(
+                    SignalRateMeasFixed1104_400_mm);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                SignalRateMeasFixed400mm,
+                SignalRateMeasFixed400mmFix);
+
+            OffsetMicroMeters = 0;
+            if (DistMeasFixed1104_400_mm != 0) {
+                    OffsetFixed1104_mm =
+                        DistMeasFixed1104_400_mm -
+                        DistMeasTgtFixed1104_mm;
+                    OffsetMicroMeters = (OffsetFixed1104_mm
+                        * 1000) >> 4;
+                    OffsetMicroMeters *= -1;
+            }
+
+            PALDevDataSet(Dev,
+                Part2PartOffsetAdjustmentNVMMicroMeter,
+                OffsetMicroMeters);
+        }
+        byte = (uint8_t)(ReadDataFromDeviceDone|option);
+        VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone,
+                byte);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+
+uint32_t VL53L0X_calc_macro_period_ps(VL53L0X_DEV Dev, uint8_t vcsel_period_pclks)
+{
+    uint64_t PLL_period_ps;
+    uint32_t macro_period_vclks;
+    uint32_t macro_period_ps;
+
+    LOG_FUNCTION_START("");
+
+    /* The above calculation will produce rounding errors,
+       therefore set fixed value
+    */
+    PLL_period_ps = 1655;
+
+    macro_period_vclks = 2304;
+    macro_period_ps = (uint32_t)(macro_period_vclks
+            * vcsel_period_pclks * PLL_period_ps);
+
+    LOG_FUNCTION_END("");
+    return macro_period_ps;
+}
+
+uint16_t VL53L0X_encode_timeout(uint32_t timeout_macro_clks)
+{
+    /*!
+     * Encode timeout in macro periods in (LSByte * 2^MSByte) + 1 format
+     */
+
+    uint16_t encoded_timeout = 0;
+    uint32_t ls_byte = 0;
+    uint16_t ms_byte = 0;
+
+    if (timeout_macro_clks > 0) {
+        ls_byte = timeout_macro_clks - 1;
+
+        while ((ls_byte & 0xFFFFFF00) > 0) {
+            ls_byte = ls_byte >> 1;
+            ms_byte++;
+        }
+
+        encoded_timeout = (ms_byte << 8)
+                + (uint16_t) (ls_byte & 0x000000FF);
+    }
+
+    return encoded_timeout;
+
+}
+
+uint32_t VL53L0X_decode_timeout(uint16_t encoded_timeout)
+{
+    /*!
+     * Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
+     */
+
+    uint32_t timeout_macro_clks = 0;
+
+    timeout_macro_clks = ((uint32_t) (encoded_timeout & 0x00FF)
+            << (uint32_t) ((encoded_timeout & 0xFF00) >> 8)) + 1;
+
+    return timeout_macro_clks;
+}
+
+
+/* To convert ms into register value */
+uint32_t VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev,
+        uint32_t timeout_period_us,
+        uint8_t vcsel_period_pclks)
+{
+    uint32_t macro_period_ps;
+    uint32_t macro_period_ns;
+    uint32_t timeout_period_mclks = 0;
+
+    macro_period_ps = VL53L0X_calc_macro_period_ps(Dev, vcsel_period_pclks);
+    macro_period_ns = (macro_period_ps + 500) / 1000;
+
+    timeout_period_mclks =
+        (uint32_t) (((timeout_period_us * 1000)
+        + (macro_period_ns / 2)) / macro_period_ns);
+
+    return timeout_period_mclks;
+}
+
+/* To convert register value into us */
+uint32_t VL53L0X_calc_timeout_us(VL53L0X_DEV Dev,
+        uint16_t timeout_period_mclks,
+        uint8_t vcsel_period_pclks)
+{
+    uint32_t macro_period_ps;
+    uint32_t macro_period_ns;
+    uint32_t actual_timeout_period_us = 0;
+
+    macro_period_ps = VL53L0X_calc_macro_period_ps(Dev, vcsel_period_pclks);
+    macro_period_ns = (macro_period_ps + 500) / 1000;
+
+    actual_timeout_period_us =
+        ((timeout_period_mclks * macro_period_ns) + 500) / 1000;
+
+    return actual_timeout_period_us;
+}
+
+
+VL53L0X_Error get_sequence_step_timeout(VL53L0X_DEV Dev,
+                VL53L0X_SequenceStepId SequenceStepId,
+                uint32_t *pTimeOutMicroSecs)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t CurrentVCSELPulsePeriodPClk;
+    uint8_t EncodedTimeOutByte = 0;
+    uint32_t TimeoutMicroSeconds = 0;
+    uint16_t PreRangeEncodedTimeOut = 0;
+    uint16_t MsrcTimeOutMClks;
+    uint16_t PreRangeTimeOutMClks;
+    uint16_t FinalRangeTimeOutMClks = 0;
+    uint16_t FinalRangeEncodedTimeOut;
+    VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
+
+    if ((SequenceStepId == VL53L0X_SEQUENCESTEP_TCC)	 ||
+        (SequenceStepId == VL53L0X_SEQUENCESTEP_DSS)	 ||
+        (SequenceStepId == VL53L0X_SEQUENCESTEP_MSRC)) {
+
+        Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                    VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                    &CurrentVCSELPulsePeriodPClk);
+        if (Status == VL53L0X_ERROR_NONE) {
+            Status = VL53L0X_RdByte(Dev,
+                    VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
+                    &EncodedTimeOutByte);
+        }
+        MsrcTimeOutMClks = VL53L0X_decode_timeout(EncodedTimeOutByte);
+
+        TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
+                        MsrcTimeOutMClks,
+                        CurrentVCSELPulsePeriodPClk);
+    } else if (SequenceStepId == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
+        /* Retrieve PRE-RANGE VCSEL Period */
+        Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                        VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                        &CurrentVCSELPulsePeriodPClk);
+
+        /* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
+        if (Status == VL53L0X_ERROR_NONE) {
+
+            /* Retrieve PRE-RANGE VCSEL Period */
+            Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                    VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                    &CurrentVCSELPulsePeriodPClk);
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status = VL53L0X_RdWord(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+                &PreRangeEncodedTimeOut);
+            }
+
+            PreRangeTimeOutMClks = VL53L0X_decode_timeout(
+                    PreRangeEncodedTimeOut);
+
+            TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
+                    PreRangeTimeOutMClks,
+                    CurrentVCSELPulsePeriodPClk);
+        }
+    } else if (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
+
+        VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
+        PreRangeTimeOutMClks = 0;
+
+        if (SchedulerSequenceSteps.PreRangeOn) {
+            /* Retrieve PRE-RANGE VCSEL Period */
+            Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                &CurrentVCSELPulsePeriodPClk);
+
+            /* Retrieve PRE-RANGE Timeout in Macro periods
+             * (MCLKS) */
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status = VL53L0X_RdWord(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+                &PreRangeEncodedTimeOut);
+                PreRangeTimeOutMClks = VL53L0X_decode_timeout(
+                        PreRangeEncodedTimeOut);
+            }
+        }
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            /* Retrieve FINAL-RANGE VCSEL Period */
+            Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                    VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+                    &CurrentVCSELPulsePeriodPClk);
+        }
+
+        /* Retrieve FINAL-RANGE Timeout in Macro periods (MCLKS) */
+        if (Status == VL53L0X_ERROR_NONE) {
+            Status = VL53L0X_RdWord(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+                &FinalRangeEncodedTimeOut);
+            FinalRangeTimeOutMClks = VL53L0X_decode_timeout(
+                    FinalRangeEncodedTimeOut);
+        }
+
+        FinalRangeTimeOutMClks -= PreRangeTimeOutMClks;
+        TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
+                        FinalRangeTimeOutMClks,
+                        CurrentVCSELPulsePeriodPClk);
+    }
+
+    *pTimeOutMicroSecs = TimeoutMicroSeconds;
+
+    return Status;
+}
+
+
+VL53L0X_Error set_sequence_step_timeout(VL53L0X_DEV Dev,
+                    VL53L0X_SequenceStepId SequenceStepId,
+                    uint32_t TimeOutMicroSecs)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t CurrentVCSELPulsePeriodPClk;
+    uint8_t MsrcEncodedTimeOut;
+    uint16_t PreRangeEncodedTimeOut;
+    uint16_t PreRangeTimeOutMClks;
+    uint16_t MsrcRangeTimeOutMClks;
+    uint32_t FinalRangeTimeOutMClks;
+    uint16_t FinalRangeEncodedTimeOut;
+    VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
+
+    if ((SequenceStepId == VL53L0X_SEQUENCESTEP_TCC)	 ||
+        (SequenceStepId == VL53L0X_SEQUENCESTEP_DSS)	 ||
+        (SequenceStepId == VL53L0X_SEQUENCESTEP_MSRC)) {
+
+        Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                    VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                    &CurrentVCSELPulsePeriodPClk);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            MsrcRangeTimeOutMClks = VL53L0X_calc_timeout_mclks(Dev,
+                    TimeOutMicroSecs,
+                    (uint8_t)CurrentVCSELPulsePeriodPClk);
+
+            if (MsrcRangeTimeOutMClks > 256)
+                MsrcEncodedTimeOut = 255;
+            else
+                MsrcEncodedTimeOut =
+                    (uint8_t)MsrcRangeTimeOutMClks - 1;
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                LastEncodedTimeout,
+                MsrcEncodedTimeOut);
+        }
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
+                MsrcEncodedTimeOut);
+        }
+    } else {
+
+        if (SequenceStepId == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                        VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                        &CurrentVCSELPulsePeriodPClk);
+                PreRangeTimeOutMClks =
+                    VL53L0X_calc_timeout_mclks(Dev,
+                    TimeOutMicroSecs,
+                    (uint8_t)CurrentVCSELPulsePeriodPClk);
+                PreRangeEncodedTimeOut = VL53L0X_encode_timeout(
+                    PreRangeTimeOutMClks);
+
+                VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+                    LastEncodedTimeout,
+                    PreRangeEncodedTimeOut);
+            }
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                Status = VL53L0X_WrWord(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+                PreRangeEncodedTimeOut);
+            }
+
+            if (Status == VL53L0X_ERROR_NONE) {
+                VL53L0X_SETDEVICESPECIFICPARAMETER(
+                    Dev,
+                    PreRangeTimeoutMicroSecs,
+                    TimeOutMicroSecs);
+            }
+        } else if (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.
+             */
+
+            VL53L0X_GetSequenceStepEnables(Dev,
+                    &SchedulerSequenceSteps);
+            PreRangeTimeOutMClks = 0;
+            if (SchedulerSequenceSteps.PreRangeOn) {
+
+                /* Retrieve PRE-RANGE VCSEL Period */
+                Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                    VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+                    &CurrentVCSELPulsePeriodPClk);
+
+                /* Retrieve PRE-RANGE Timeout in Macro periods
+                 * (MCLKS) */
+                if (Status == VL53L0X_ERROR_NONE) {
+                    Status = VL53L0X_RdWord(Dev, 0x51,
+                        &PreRangeEncodedTimeOut);
+                    PreRangeTimeOutMClks =
+                        VL53L0X_decode_timeout(
+                            PreRangeEncodedTimeOut);
+                }
+            }
+
+            /* Calculate FINAL RANGE Timeout in Macro Periods
+             * (MCLKS) and add PRE-RANGE value
+             */
+            if (Status == VL53L0X_ERROR_NONE) {
+
+                Status = VL53L0X_GetVcselPulsePeriod(Dev,
+                        VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+                        &CurrentVCSELPulsePeriodPClk);
+            }
+            if (Status == VL53L0X_ERROR_NONE) {
+
+                FinalRangeTimeOutMClks =
+                    VL53L0X_calc_timeout_mclks(Dev,
+                    TimeOutMicroSecs,
+                    (uint8_t) CurrentVCSELPulsePeriodPClk);
+
+                FinalRangeTimeOutMClks += PreRangeTimeOutMClks;
+
+                FinalRangeEncodedTimeOut =
+                VL53L0X_encode_timeout(FinalRangeTimeOutMClks);
+
+                if (Status == VL53L0X_ERROR_NONE) {
+                    Status = VL53L0X_WrWord(Dev, 0x71,
+                    FinalRangeEncodedTimeOut);
+                }
+
+                if (Status == VL53L0X_ERROR_NONE) {
+                    VL53L0X_SETDEVICESPECIFICPARAMETER(
+                        Dev,
+                        FinalRangeTimeoutMicroSecs,
+                        TimeOutMicroSecs);
+                }
+            }
+        } else
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+
+    }
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t vcsel_period_reg;
+    uint8_t MinPreVcselPeriodPCLK = 12;
+    uint8_t MaxPreVcselPeriodPCLK = 18;
+    uint8_t MinFinalVcselPeriodPCLK = 8;
+    uint8_t MaxFinalVcselPeriodPCLK = 14;
+    uint32_t MeasurementTimingBudgetMicroSeconds;
+    uint32_t FinalRangeTimeoutMicroSeconds;
+    uint32_t PreRangeTimeoutMicroSeconds;
+    uint32_t MsrcTimeoutMicroSeconds;
+    uint8_t PhaseCalInt = 0;
+
+    /* Check if valid clock period requested */
+
+    if ((VCSELPulsePeriodPCLK % 2) != 0) {
+        /* Value must be an even number */
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
+        (VCSELPulsePeriodPCLK < MinPreVcselPeriodPCLK ||
+        VCSELPulsePeriodPCLK > MaxPreVcselPeriodPCLK)) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
+        (VCSELPulsePeriodPCLK < MinFinalVcselPeriodPCLK ||
+         VCSELPulsePeriodPCLK > MaxFinalVcselPeriodPCLK)) {
+
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    }
+
+    /* Apply specific settings for the requested clock period */
+
+    if (Status != VL53L0X_ERROR_NONE)
+        return Status;
+
+
+    if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
+
+        /* Set phase check limits */
+        if (VCSELPulsePeriodPCLK == 12) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x18);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+        } else if (VCSELPulsePeriodPCLK == 14) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x30);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+        } else if (VCSELPulsePeriodPCLK == 16) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x40);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+        } else if (VCSELPulsePeriodPCLK == 18) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x50);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+        }
+    } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_FINAL_RANGE) {
+
+        if (VCSELPulsePeriodPCLK == 8) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x10);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
+
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_LIM,
+                0x30);
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        } else if (VCSELPulsePeriodPCLK == 10) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x28);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
+
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_LIM,
+                0x20);
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        } else if (VCSELPulsePeriodPCLK == 12) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x38);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
+
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_LIM,
+                0x20);
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        } else if (VCSELPulsePeriodPCLK == 14) {
+
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+                0x048);
+            Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+                0x08);
+
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
+
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
+            Status |= VL53L0X_WrByte(Dev,
+                VL53L0X_REG_ALGO_PHASECAL_LIM,
+                0x20);
+            Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+        }
+    }
+
+
+    /* Re-calculate and apply timeouts, in macro periods */
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        vcsel_period_reg = VL53L0X_encode_vcsel_period((uint8_t)
+            VCSELPulsePeriodPCLK);
+
+        /* 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.
+        */
+        switch (VcselPeriodType) {
+        case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
+            Status = get_sequence_step_timeout(Dev,
+                VL53L0X_SEQUENCESTEP_PRE_RANGE,
+                &PreRangeTimeoutMicroSeconds);
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = get_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_MSRC,
+                    &MsrcTimeoutMicroSeconds);
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
+                    vcsel_period_reg);
+
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = set_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_PRE_RANGE,
+                    PreRangeTimeoutMicroSeconds);
+
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = set_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_MSRC,
+                    MsrcTimeoutMicroSeconds);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(
+                Dev,
+                PreRangeVcselPulsePeriod,
+                VCSELPulsePeriodPCLK);
+            break;
+        case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
+            Status = get_sequence_step_timeout(Dev,
+                VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+                &FinalRangeTimeoutMicroSeconds);
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = VL53L0X_WrByte(Dev,
+                VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+                    vcsel_period_reg);
+
+
+            if (Status == VL53L0X_ERROR_NONE)
+                Status = set_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+                    FinalRangeTimeoutMicroSeconds);
+
+            VL53L0X_SETDEVICESPECIFICPARAMETER(
+                Dev,
+                FinalRangeVcselPulsePeriod,
+                VCSELPulsePeriodPCLK);
+            break;
+        default:
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+        }
+    }
+
+    /* Finally, the timing budget must be re-applied */
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_GETPARAMETERFIELD(Dev,
+            MeasurementTimingBudgetMicroSeconds,
+            MeasurementTimingBudgetMicroSeconds);
+
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
+                MeasurementTimingBudgetMicroSeconds);
+    }
+
+    /* Perform the phase calibration. This is needed after changing on
+     * vcsel period.
+     * get_data_enable = 0, restore_config = 1 */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status = VL53L0X_perform_phase_calibration(
+            Dev, &PhaseCalInt, 0, 1);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
+    VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t vcsel_period_reg;
+
+    switch (VcselPeriodType) {
+    case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
+        Status = VL53L0X_RdByte(Dev,
+            VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
+            &vcsel_period_reg);
+    break;
+    case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
+        Status = VL53L0X_RdByte(Dev,
+            VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+            &vcsel_period_reg);
+    break;
+    default:
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    }
+
+    if (Status == VL53L0X_ERROR_NONE)
+        *pVCSELPulsePeriodPCLK =
+            VL53L0X_decode_vcsel_period(vcsel_period_reg);
+
+    return Status;
+}
+
+
+
+VL53L0X_Error VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
+        uint32_t MeasurementTimingBudgetMicroSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint32_t FinalRangeTimingBudgetMicroSeconds;
+    VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
+    uint32_t MsrcDccTccTimeoutMicroSeconds	= 2000;
+    uint32_t StartOverheadMicroSeconds		= 1910;
+    uint32_t EndOverheadMicroSeconds		= 960;
+    uint32_t MsrcOverheadMicroSeconds		= 660;
+    uint32_t TccOverheadMicroSeconds		= 590;
+    uint32_t DssOverheadMicroSeconds		= 690;
+    uint32_t PreRangeOverheadMicroSeconds	= 660;
+    uint32_t FinalRangeOverheadMicroSeconds = 550;
+    uint32_t PreRangeTimeoutMicroSeconds	= 0;
+    uint32_t cMinTimingBudgetMicroSeconds	= 20000;
+    uint32_t SubTimeout = 0;
+
+    LOG_FUNCTION_START("");
+
+    if (MeasurementTimingBudgetMicroSeconds
+            < cMinTimingBudgetMicroSeconds) {
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+        return Status;
+    }
+
+    FinalRangeTimingBudgetMicroSeconds =
+        MeasurementTimingBudgetMicroSeconds -
+        (StartOverheadMicroSeconds + EndOverheadMicroSeconds);
+
+    Status = VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
+
+    if (Status == VL53L0X_ERROR_NONE &&
+        (SchedulerSequenceSteps.TccOn  ||
+        SchedulerSequenceSteps.MsrcOn ||
+        SchedulerSequenceSteps.DssOn)) {
+
+        /* TCC, MSRC and DSS all share the same timeout */
+        Status = get_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_MSRC,
+                    &MsrcDccTccTimeoutMicroSeconds);
+
+        /* Subtract the TCC, MSRC and DSS timeouts if they are
+         * enabled. */
+
+        if (Status != VL53L0X_ERROR_NONE)
+            return Status;
+
+        /* TCC */
+        if (SchedulerSequenceSteps.TccOn) {
+
+            SubTimeout = MsrcDccTccTimeoutMicroSeconds
+                + TccOverheadMicroSeconds;
+
+            if (SubTimeout <
+                FinalRangeTimingBudgetMicroSeconds) {
+                FinalRangeTimingBudgetMicroSeconds -=
+                            SubTimeout;
+            } else {
+                /* Requested timeout too big. */
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+        }
+
+        if (Status != VL53L0X_ERROR_NONE) {
+            LOG_FUNCTION_END(Status);
+            return Status;
+        }
+
+        /* DSS */
+        if (SchedulerSequenceSteps.DssOn) {
+
+            SubTimeout = 2 * (MsrcDccTccTimeoutMicroSeconds +
+                DssOverheadMicroSeconds);
+
+            if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
+                FinalRangeTimingBudgetMicroSeconds
+                            -= SubTimeout;
+            } else {
+                /* Requested timeout too big. */
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+        } else if (SchedulerSequenceSteps.MsrcOn) {
+            /* MSRC */
+            SubTimeout = MsrcDccTccTimeoutMicroSeconds +
+                        MsrcOverheadMicroSeconds;
+
+            if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
+                FinalRangeTimingBudgetMicroSeconds
+                            -= SubTimeout;
+            } else {
+                /* Requested timeout too big. */
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+        }
+
+    }
+
+    if (Status != VL53L0X_ERROR_NONE) {
+        LOG_FUNCTION_END(Status);
+        return Status;
+    }
+
+    if (SchedulerSequenceSteps.PreRangeOn) {
+
+        /* Subtract the Pre-range timeout if enabled. */
+
+        Status = get_sequence_step_timeout(Dev,
+                VL53L0X_SEQUENCESTEP_PRE_RANGE,
+                &PreRangeTimeoutMicroSeconds);
+
+        SubTimeout = PreRangeTimeoutMicroSeconds +
+                PreRangeOverheadMicroSeconds;
+
+        if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
+            FinalRangeTimingBudgetMicroSeconds -= SubTimeout;
+        } else {
+            /* Requested timeout too big. */
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+        }
+    }
+
+
+    if (Status == VL53L0X_ERROR_NONE &&
+        SchedulerSequenceSteps.FinalRangeOn) {
+
+        FinalRangeTimingBudgetMicroSeconds -=
+                FinalRangeOverheadMicroSeconds;
+
+        /* Final Range Timeout
+         * 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.
+         */
+        Status = set_sequence_step_timeout(Dev,
+            VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+            FinalRangeTimingBudgetMicroSeconds);
+
+        VL53L0X_SETPARAMETERFIELD(Dev,
+            MeasurementTimingBudgetMicroSeconds,
+            MeasurementTimingBudgetMicroSeconds);
+    }
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
+        uint32_t *pMeasurementTimingBudgetMicroSeconds)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
+    uint32_t FinalRangeTimeoutMicroSeconds;
+    uint32_t MsrcDccTccTimeoutMicroSeconds	= 2000;
+    uint32_t StartOverheadMicroSeconds		= 1910;
+    uint32_t EndOverheadMicroSeconds		= 960;
+    uint32_t MsrcOverheadMicroSeconds		= 660;
+    uint32_t TccOverheadMicroSeconds		= 590;
+    uint32_t DssOverheadMicroSeconds		= 690;
+    uint32_t PreRangeOverheadMicroSeconds	= 660;
+    uint32_t FinalRangeOverheadMicroSeconds = 550;
+    uint32_t PreRangeTimeoutMicroSeconds	= 0;
+
+    LOG_FUNCTION_START("");
+
+    /* Start and end overhead times always present */
+    *pMeasurementTimingBudgetMicroSeconds
+        = StartOverheadMicroSeconds + EndOverheadMicroSeconds;
+
+    Status = VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
+
+    if (Status != VL53L0X_ERROR_NONE) {
+        LOG_FUNCTION_END(Status);
+        return Status;
+    }
+
+
+    if (SchedulerSequenceSteps.TccOn  ||
+        SchedulerSequenceSteps.MsrcOn ||
+        SchedulerSequenceSteps.DssOn) {
+
+        Status = get_sequence_step_timeout(Dev,
+                VL53L0X_SEQUENCESTEP_MSRC,
+                &MsrcDccTccTimeoutMicroSeconds);
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            if (SchedulerSequenceSteps.TccOn) {
+                *pMeasurementTimingBudgetMicroSeconds +=
+                    MsrcDccTccTimeoutMicroSeconds +
+                    TccOverheadMicroSeconds;
+            }
+
+            if (SchedulerSequenceSteps.DssOn) {
+                *pMeasurementTimingBudgetMicroSeconds +=
+                2 * (MsrcDccTccTimeoutMicroSeconds +
+                    DssOverheadMicroSeconds);
+            } else if (SchedulerSequenceSteps.MsrcOn) {
+                *pMeasurementTimingBudgetMicroSeconds +=
+                    MsrcDccTccTimeoutMicroSeconds +
+                    MsrcOverheadMicroSeconds;
+            }
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (SchedulerSequenceSteps.PreRangeOn) {
+            Status = get_sequence_step_timeout(Dev,
+                VL53L0X_SEQUENCESTEP_PRE_RANGE,
+                &PreRangeTimeoutMicroSeconds);
+            *pMeasurementTimingBudgetMicroSeconds +=
+                PreRangeTimeoutMicroSeconds +
+                PreRangeOverheadMicroSeconds;
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (SchedulerSequenceSteps.FinalRangeOn) {
+            Status = get_sequence_step_timeout(Dev,
+                    VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+                    &FinalRangeTimeoutMicroSeconds);
+            *pMeasurementTimingBudgetMicroSeconds +=
+                (FinalRangeTimeoutMicroSeconds +
+                FinalRangeOverheadMicroSeconds);
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        VL53L0X_SETPARAMETERFIELD(Dev,
+            MeasurementTimingBudgetMicroSeconds,
+            *pMeasurementTimingBudgetMicroSeconds);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+
+
+VL53L0X_Error VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
+        uint8_t *pTuningSettingBuffer)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    int i;
+    int Index;
+    uint8_t msb;
+    uint8_t lsb;
+    uint8_t SelectParam;
+    uint8_t NumberOfWrites;
+    uint8_t Address;
+    uint8_t localBuffer[4]; /* max */
+    uint16_t Temp16;
+
+    LOG_FUNCTION_START("");
+
+    Index = 0;
+
+    while ((*(pTuningSettingBuffer + Index) != 0) &&
+            (Status == VL53L0X_ERROR_NONE)) {
+        NumberOfWrites = *(pTuningSettingBuffer + Index);
+        Index++;
+        if (NumberOfWrites == 0xFF) {
+            /* internal parameters */
+            SelectParam = *(pTuningSettingBuffer + Index);
+            Index++;
+            switch (SelectParam) {
+            case 0: /* uint16_t SigmaEstRefArray -> 2 bytes */
+                msb = *(pTuningSettingBuffer + Index);
+                Index++;
+                lsb = *(pTuningSettingBuffer + Index);
+                Index++;
+                Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+                PALDevDataSet(Dev, SigmaEstRefArray, Temp16);
+                break;
+            case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
+                msb = *(pTuningSettingBuffer + Index);
+                Index++;
+                lsb = *(pTuningSettingBuffer + Index);
+                Index++;
+                Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+                PALDevDataSet(Dev, SigmaEstEffPulseWidth,
+                    Temp16);
+                break;
+            case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
+                msb = *(pTuningSettingBuffer + Index);
+                Index++;
+                lsb = *(pTuningSettingBuffer + Index);
+                Index++;
+                Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+                PALDevDataSet(Dev, SigmaEstEffAmbWidth, Temp16);
+                break;
+            case 3: /* uint16_t targetRefRate -> 2 bytes */
+                msb = *(pTuningSettingBuffer + Index);
+                Index++;
+                lsb = *(pTuningSettingBuffer + Index);
+                Index++;
+                Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+                PALDevDataSet(Dev, targetRefRate, Temp16);
+                break;
+            default: /* invalid parameter */
+                Status = VL53L0X_ERROR_INVALID_PARAMS;
+            }
+
+        } else if (NumberOfWrites <= 4) {
+            Address = *(pTuningSettingBuffer + Index);
+            Index++;
+
+            for (i = 0; i < NumberOfWrites; i++) {
+                localBuffer[i] = *(pTuningSettingBuffer +
+                            Index);
+                Index++;
+            }
+
+            Status = VL53L0X_WriteMulti(Dev, Address, localBuffer,
+                    NumberOfWrites);
+
+        } else {
+            Status = VL53L0X_ERROR_INVALID_PARAMS;
+        }
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_total_xtalk_rate(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *ptotal_xtalk_rate_mcps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    uint8_t xtalkCompEnable;
+    FixPoint1616_t totalXtalkMegaCps;
+    FixPoint1616_t xtalkPerSpadMegaCps;
+
+    *ptotal_xtalk_rate_mcps = 0;
+
+    Status = VL53L0X_GetXTalkCompensationEnable(Dev, &xtalkCompEnable);
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        if (xtalkCompEnable) {
+
+            VL53L0X_GETPARAMETERFIELD(
+                Dev,
+                XTalkCompensationRateMegaCps,
+                xtalkPerSpadMegaCps);
+
+            /* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
+            totalXtalkMegaCps =
+                pRangingMeasurementData->EffectiveSpadRtnCount *
+                xtalkPerSpadMegaCps;
+
+            /* FixPoint0824 >> 8 = FixPoint1616 */
+            *ptotal_xtalk_rate_mcps =
+                (totalXtalkMegaCps + 0x80) >> 8;
+        }
+    }
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_get_total_signal_rate(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *ptotal_signal_rate_mcps)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    FixPoint1616_t totalXtalkMegaCps;
+
+    LOG_FUNCTION_START("");
+
+    *ptotal_signal_rate_mcps =
+        pRangingMeasurementData->SignalRateRtnMegaCps;
+
+    Status = VL53L0X_get_total_xtalk_rate(
+        Dev, pRangingMeasurementData, &totalXtalkMegaCps);
+
+    if (Status == VL53L0X_ERROR_NONE)
+        *ptotal_signal_rate_mcps += totalXtalkMegaCps;
+
+    return Status;
+}
+
+VL53L0X_Error VL53L0X_calc_dmax(
+    VL53L0X_DEV Dev,
+    FixPoint1616_t totalSignalRate_mcps,
+    FixPoint1616_t totalCorrSignalRate_mcps,
+    FixPoint1616_t pwMult,
+    uint32_t sigmaEstimateP1,
+    FixPoint1616_t sigmaEstimateP2,
+    uint32_t peakVcselDuration_us,
+    uint32_t *pdmax_mm)
+{
+    const uint32_t cSigmaLimit		= 18;
+    const FixPoint1616_t cSignalLimit	= 0x4000; /* 0.25 */
+    const FixPoint1616_t cSigmaEstRef	= 0x00000042; /* 0.001 */
+    const uint32_t cAmbEffWidthSigmaEst_ns = 6;
+    const uint32_t cAmbEffWidthDMax_ns	   = 7;
+    uint32_t dmaxCalRange_mm;
+    FixPoint1616_t dmaxCalSignalRateRtn_mcps;
+    FixPoint1616_t minSignalNeeded;
+    FixPoint1616_t minSignalNeeded_p1;
+    FixPoint1616_t minSignalNeeded_p2;
+    FixPoint1616_t minSignalNeeded_p3;
+    FixPoint1616_t minSignalNeeded_p4;
+    FixPoint1616_t sigmaLimitTmp;
+    FixPoint1616_t sigmaEstSqTmp;
+    FixPoint1616_t signalLimitTmp;
+    FixPoint1616_t SignalAt0mm;
+    FixPoint1616_t dmaxDark;
+    FixPoint1616_t dmaxAmbient;
+    FixPoint1616_t dmaxDarkTmp;
+    FixPoint1616_t sigmaEstP2Tmp;
+    uint32_t signalRateTemp_mcps;
+
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+    LOG_FUNCTION_START("");
+
+    dmaxCalRange_mm =
+        PALDevDataGet(Dev, DmaxCalRangeMilliMeter);
+
+    dmaxCalSignalRateRtn_mcps =
+        PALDevDataGet(Dev, DmaxCalSignalRateRtnMegaCps);
+
+    /* uint32 * FixPoint1616 = FixPoint1616 */
+    SignalAt0mm = dmaxCalRange_mm * dmaxCalSignalRateRtn_mcps;
+
+    /* FixPoint1616 >> 8 = FixPoint2408 */
+    SignalAt0mm = (SignalAt0mm + 0x80) >> 8;
+    SignalAt0mm *= dmaxCalRange_mm;
+
+    minSignalNeeded_p1 = 0;
+    if (totalCorrSignalRate_mcps > 0) {
+
+        /* Shift by 10 bits to increase resolution prior to the
+         * division */
+        signalRateTemp_mcps = totalSignalRate_mcps << 10;
+
+        /* Add rounding value prior to division */
+        minSignalNeeded_p1 = signalRateTemp_mcps +
+            (totalCorrSignalRate_mcps/2);
+
+        /* FixPoint0626/FixPoint1616 = FixPoint2210 */
+        minSignalNeeded_p1 /= totalCorrSignalRate_mcps;
+
+        /* Apply a factored version of the speed of light.
+         Correction to be applied at the end */
+        minSignalNeeded_p1 *= 3;
+
+        /* FixPoint2210 * FixPoint2210 = FixPoint1220 */
+        minSignalNeeded_p1 *= minSignalNeeded_p1;
+
+        /* FixPoint1220 >> 16 = FixPoint2804 */
+        minSignalNeeded_p1 = (minSignalNeeded_p1 + 0x8000) >> 16;
+    }
+
+    minSignalNeeded_p2 = pwMult * sigmaEstimateP1;
+
+    /* FixPoint1616 >> 16 =	 uint32 */
+    minSignalNeeded_p2 = (minSignalNeeded_p2 + 0x8000) >> 16;
+
+    /* uint32 * uint32	=  uint32 */
+    minSignalNeeded_p2 *= minSignalNeeded_p2;
+
+    /* Check sigmaEstimateP2
+     * If this value is too high there is not enough signal rate
+     * to calculate dmax value so set a suitable value to ensure
+     * a very small dmax.
+     */
+    sigmaEstP2Tmp = (sigmaEstimateP2 + 0x8000) >> 16;
+    sigmaEstP2Tmp = (sigmaEstP2Tmp + cAmbEffWidthSigmaEst_ns/2)/
+        cAmbEffWidthSigmaEst_ns;
+    sigmaEstP2Tmp *= cAmbEffWidthDMax_ns;
+
+    if (sigmaEstP2Tmp > 0xffff) {
+        minSignalNeeded_p3 = 0xfff00000;
+    } else {
+
+        /* DMAX uses a different ambient width from sigma, so apply
+         * correction.
+         * Perform division before multiplication to prevent overflow.
+         */
+        sigmaEstimateP2 = (sigmaEstimateP2 + cAmbEffWidthSigmaEst_ns/2)/
+            cAmbEffWidthSigmaEst_ns;
+        sigmaEstimateP2 *= cAmbEffWidthDMax_ns;
+
+        /* FixPoint1616 >> 16 = uint32 */
+        minSignalNeeded_p3 = (sigmaEstimateP2 + 0x8000) >> 16;
+
+        minSignalNeeded_p3 *= minSignalNeeded_p3;
+
+    }
+
+    /* FixPoint1814 / uint32 = FixPoint1814 */
+    sigmaLimitTmp = ((cSigmaLimit << 14) + 500) / 1000;
+
+    /* FixPoint1814 * FixPoint1814 = FixPoint3628 := FixPoint0428 */
+    sigmaLimitTmp *= sigmaLimitTmp;
+
+    /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
+    sigmaEstSqTmp = cSigmaEstRef * cSigmaEstRef;
+
+    /* FixPoint3232 >> 4 = FixPoint0428 */
+    sigmaEstSqTmp = (sigmaEstSqTmp + 0x08) >> 4;
+
+    /* FixPoint0428 - FixPoint0428	= FixPoint0428 */
+    sigmaLimitTmp -=  sigmaEstSqTmp;
+
+    /* uint32_t * FixPoint0428 = FixPoint0428 */
+    minSignalNeeded_p4 = 4 * 12 * sigmaLimitTmp;
+
+    /* FixPoint0428 >> 14 = FixPoint1814 */
+    minSignalNeeded_p4 = (minSignalNeeded_p4 + 0x2000) >> 14;
+
+    /* uint32 + uint32 = uint32 */
+    minSignalNeeded = (minSignalNeeded_p2 + minSignalNeeded_p3);
+
+    /* uint32 / uint32 = uint32 */
+    minSignalNeeded += (peakVcselDuration_us/2);
+    minSignalNeeded /= peakVcselDuration_us;
+
+    /* uint32 << 14 = FixPoint1814 */
+    minSignalNeeded <<= 14;
+
+    /* FixPoint1814 / FixPoint1814 = uint32 */
+    minSignalNeeded += (minSignalNeeded_p4/2);
+    minSignalNeeded /= minSignalNeeded_p4;
+
+    /* FixPoint3200 * FixPoint2804 := FixPoint2804*/
+    minSignalNeeded *= minSignalNeeded_p1;
+
+    /* Apply correction by dividing by 1000000.
+     * This assumes 10E16 on the numerator of the equation
+     * and 10E-22 on the denominator.
+     * We do this because 32bit fix point calculation can't
+     * handle the larger and smaller elements of this equation,
+     * i.e. speed of light and pulse widths.
+     */
+    minSignalNeeded = (minSignalNeeded + 500) / 1000;
+    minSignalNeeded <<= 4;
+
+    minSignalNeeded = (minSignalNeeded + 500) / 1000;
+
+    /* FixPoint1616 >> 8 = FixPoint2408 */
+    signalLimitTmp = (cSignalLimit + 0x80) >> 8;
+
+    /* FixPoint2408/FixPoint2408 = uint32 */
+    if (signalLimitTmp != 0)
+        dmaxDarkTmp = (SignalAt0mm + (signalLimitTmp / 2))
+            / signalLimitTmp;
+    else
+        dmaxDarkTmp = 0;
+
+    dmaxDark = VL53L0X_isqrt(dmaxDarkTmp);
+
+    /* FixPoint2408/FixPoint2408 = uint32 */
+    if (minSignalNeeded != 0)
+        dmaxAmbient = (SignalAt0mm + minSignalNeeded/2)
+            / minSignalNeeded;
+    else
+        dmaxAmbient = 0;
+
+    dmaxAmbient = VL53L0X_isqrt(dmaxAmbient);
+
+    *pdmax_mm = dmaxDark;
+    if (dmaxDark > dmaxAmbient)
+        *pdmax_mm = dmaxAmbient;
+
+    LOG_FUNCTION_END(Status);
+
+    return Status;
+}
+
+
+VL53L0X_Error VL53L0X_calc_sigma_estimate(VL53L0X_DEV Dev,
+    VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+    FixPoint1616_t *pSigmaEstimate,
+    uint32_t *pDmax_mm)
+{
+    /* Expressed in 100ths of a ns, i.e. centi-ns */
+    const uint32_t cPulseEffectiveWidth_centi_ns   = 800;
+    /* Expressed in 100ths of a ns, i.e. centi-ns */
+    const uint32_t cAmbientEffectiveWidth_centi_ns = 600;
+    const FixPoint1616_t cDfltFinalRangeIntegrationTimeMilliSecs	= 0x00190000; /* 25ms */
+    const uint32_t cVcselPulseWidth_ps	= 4700; /* pico secs */
+    const FixPoint1616_t cSigmaEstMax	= 0x028F87AE;
+    const FixPoint1616_t cSigmaEstRtnMax	= 0xF000;
+    const FixPoint1616_t cAmbToSignalRatioMax = 0xF0000000/
+        cAmbientEffectiveWidth_centi_ns;
+    /* Time Of Flight per mm (6.6 pico secs) */
+    const FixPoint1616_t cTOF_per_mm_ps		= 0x0006999A;
+    const uint32_t c16BitRoundingParam		= 0x00008000;
+    const FixPoint1616_t cMaxXTalk_kcps		= 0x00320000;
+    const uint32_t cPllPeriod_ps			= 1655;
+
+    uint32_t vcselTotalEventsRtn;
+    uint32_t finalRangeTimeoutMicroSecs;
+    uint32_t preRangeTimeoutMicroSecs;
+    uint32_t finalRangeIntegrationTimeMilliSecs;
+    FixPoint1616_t sigmaEstimateP1;
+    FixPoint1616_t sigmaEstimateP2;
+    FixPoint1616_t sigmaEstimateP3;
+    FixPoint1616_t deltaT_ps;
+    FixPoint1616_t pwMult;
+    FixPoint1616_t sigmaEstRtn;
+    FixPoint1616_t sigmaEstimate;
+    FixPoint1616_t xTalkCorrection;
+    FixPoint1616_t ambientRate_kcps;
+    FixPoint1616_t peakSignalRate_kcps;
+    FixPoint1616_t xTalkCompRate_mcps;
+    uint32_t xTalkCompRate_kcps;
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    FixPoint1616_t diff1_mcps;
+    FixPoint1616_t diff2_mcps;
+    FixPoint1616_t sqr1;
+    FixPoint1616_t sqr2;
+    FixPoint1616_t sqrSum;
+    FixPoint1616_t sqrtResult_centi_ns;
+    FixPoint1616_t sqrtResult;
+    FixPoint1616_t totalSignalRate_mcps;
+    FixPoint1616_t correctedSignalRate_mcps;
+    FixPoint1616_t sigmaEstRef;
+    uint32_t vcselWidth;
+    uint32_t finalRangeMacroPCLKS;
+    uint32_t preRangeMacroPCLKS;
+    uint32_t peakVcselDuration_us;
+    uint8_t finalRangeVcselPCLKS;
+    uint8_t preRangeVcselPCLKS;
+    /*! \addtogroup calc_sigma_estimate
+     * @{
+     *
+     * Estimates the range sigma
+     */
+
+    LOG_FUNCTION_START("");
+
+    VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
+            xTalkCompRate_mcps);
+
+    /*
+     * We work in kcps rather than mcps as this helps keep within the
+     * confines of the 32 Fix1616 type.
+     */
+
+    ambientRate_kcps =
+        (pRangingMeasurementData->AmbientRateRtnMegaCps * 1000) >> 16;
+
+    correctedSignalRate_mcps =
+        pRangingMeasurementData->SignalRateRtnMegaCps;
+
+
+    Status = VL53L0X_get_total_signal_rate(
+        Dev, pRangingMeasurementData, &totalSignalRate_mcps);
+    Status = VL53L0X_get_total_xtalk_rate(
+        Dev, pRangingMeasurementData, &xTalkCompRate_mcps);
+
+
+    /* Signal rate measurement provided by device is the
+     * peak signal rate, not average.
+     */
+    peakSignalRate_kcps = (totalSignalRate_mcps * 1000);
+    peakSignalRate_kcps = (peakSignalRate_kcps + 0x8000) >> 16;
+
+    xTalkCompRate_kcps = xTalkCompRate_mcps * 1000;
+
+    if (xTalkCompRate_kcps > cMaxXTalk_kcps)
+        xTalkCompRate_kcps = cMaxXTalk_kcps;
+
+    if (Status == VL53L0X_ERROR_NONE) {
+
+        /* Calculate final range macro periods */
+        finalRangeTimeoutMicroSecs = VL53L0X_GETDEVICESPECIFICPARAMETER(
+            Dev, FinalRangeTimeoutMicroSecs);
+
+        finalRangeVcselPCLKS = VL53L0X_GETDEVICESPECIFICPARAMETER(
+            Dev, FinalRangeVcselPulsePeriod);
+
+        finalRangeMacroPCLKS = VL53L0X_calc_timeout_mclks(
+            Dev, finalRangeTimeoutMicroSecs, finalRangeVcselPCLKS);
+
+        /* Calculate pre-range macro periods */
+        preRangeTimeoutMicroSecs = VL53L0X_GETDEVICESPECIFICPARAMETER(
+            Dev, PreRangeTimeoutMicroSecs);
+
+        preRangeVcselPCLKS = VL53L0X_GETDEVICESPECIFICPARAMETER(
+            Dev, PreRangeVcselPulsePeriod);
+
+        preRangeMacroPCLKS = VL53L0X_calc_timeout_mclks(
+            Dev, preRangeTimeoutMicroSecs, preRangeVcselPCLKS);
+
+        vcselWidth = 3;
+        if (finalRangeVcselPCLKS == 8)
+            vcselWidth = 2;
+
+
+        peakVcselDuration_us = vcselWidth * 2048 *
+            (preRangeMacroPCLKS + finalRangeMacroPCLKS);
+        peakVcselDuration_us = (peakVcselDuration_us + 500)/1000;
+        peakVcselDuration_us *= cPllPeriod_ps;
+        peakVcselDuration_us = (peakVcselDuration_us + 500)/1000;
+
+        /* Fix1616 >> 8 = Fix2408 */
+        totalSignalRate_mcps = (totalSignalRate_mcps + 0x80) >> 8;
+
+        /* Fix2408 * uint32 = Fix2408 */
+        vcselTotalEventsRtn = totalSignalRate_mcps *
+            peakVcselDuration_us;
+
+        /* Fix2408 >> 8 = uint32 */
+        vcselTotalEventsRtn = (vcselTotalEventsRtn + 0x80) >> 8;
+
+        /* Fix2408 << 8 = Fix1616 = */
+        totalSignalRate_mcps <<= 8;
+    }
+
+    if (Status != VL53L0X_ERROR_NONE) {
+        LOG_FUNCTION_END(Status);
+        return Status;
+    }
+
+    if (peakSignalRate_kcps == 0) {
+        *pSigmaEstimate = cSigmaEstMax;
+        PALDevDataSet(Dev, SigmaEstimate, cSigmaEstMax);
+        *pDmax_mm = 0;
+    } else {
+        if (vcselTotalEventsRtn < 1)
+            vcselTotalEventsRtn = 1;
+
+        sigmaEstimateP1 = cPulseEffectiveWidth_centi_ns;
+
+        /* ((FixPoint1616 << 16)* uint32)/uint32 = FixPoint1616 */
+        sigmaEstimateP2 = (ambientRate_kcps << 16)/peakSignalRate_kcps;
+        if (sigmaEstimateP2 > cAmbToSignalRatioMax) {
+            /* Clip to prevent overflow. Will ensure safe
+             * max result. */
+            sigmaEstimateP2 = cAmbToSignalRatioMax;
+        }
+        sigmaEstimateP2 *= cAmbientEffectiveWidth_centi_ns;
+
+        sigmaEstimateP3 = 2 * VL53L0X_isqrt(vcselTotalEventsRtn * 12);
+
+        /* uint32 * FixPoint1616 = FixPoint1616 */
+        deltaT_ps = pRangingMeasurementData->RangeMilliMeter *
+                    cTOF_per_mm_ps;
+
+        /*
+         * vcselRate - xtalkCompRate
+         * (uint32 << 16) - FixPoint1616 = FixPoint1616.
+         * Divide result by 1000 to convert to mcps.
+         * 500 is added to ensure rounding when integer division
+         * truncates.
+         */
+        diff1_mcps = (((peakSignalRate_kcps << 16) -
+            2 * xTalkCompRate_kcps) + 500)/1000;
+
+        /* vcselRate + xtalkCompRate */
+        diff2_mcps = ((peakSignalRate_kcps << 16) + 500)/1000;
+
+        /* Shift by 8 bits to increase resolution prior to the
+         * division */
+        diff1_mcps <<= 8;
+
+        /* FixPoint0824/FixPoint1616 = FixPoint2408 */
+        xTalkCorrection	 = abs(diff1_mcps/diff2_mcps);
+
+        /* FixPoint2408 << 8 = FixPoint1616 */
+        xTalkCorrection <<= 8;
+
+        if(pRangingMeasurementData->RangeStatus != 0){
+            pwMult = 1 << 16;
+        } else {
+            /* FixPoint1616/uint32 = FixPoint1616 */
+            pwMult = deltaT_ps/cVcselPulseWidth_ps; /* smaller than 1.0f */
+
+            /*
+             * FixPoint1616 * FixPoint1616 = FixPoint3232, however both
+             * values are small enough such that32 bits will not be
+             * exceeded.
+             */
+            pwMult *= ((1 << 16) - xTalkCorrection);
+
+            /* (FixPoint3232 >> 16) = FixPoint1616 */
+            pwMult =  (pwMult + c16BitRoundingParam) >> 16;
+
+            /* FixPoint1616 + FixPoint1616 = FixPoint1616 */
+            pwMult += (1 << 16);
+
+            /*
+             * At this point the value will be 1.xx, therefore if we square
+             * the value this will exceed 32 bits. To address this perform
+             * a single shift to the right before the multiplication.
+             */
+            pwMult >>= 1;
+            /* FixPoint1715 * FixPoint1715 = FixPoint3430 */
+            pwMult = pwMult * pwMult;
+
+            /* (FixPoint3430 >> 14) = Fix1616 */
+            pwMult >>= 14;
+        }
+
+        /* FixPoint1616 * uint32 = FixPoint1616 */
+        sqr1 = pwMult * sigmaEstimateP1;
+
+        /* (FixPoint1616 >> 16) = FixPoint3200 */
+        sqr1 = (sqr1 + 0x8000) >> 16;
+
+        /* FixPoint3200 * FixPoint3200 = FixPoint6400 */
+        sqr1 *= sqr1;
+
+        sqr2 = sigmaEstimateP2;
+
+        /* (FixPoint1616 >> 16) = FixPoint3200 */
+        sqr2 = (sqr2 + 0x8000) >> 16;
+
+        /* FixPoint3200 * FixPoint3200 = FixPoint6400 */
+        sqr2 *= sqr2;
+
+        /* FixPoint64000 + FixPoint6400 = FixPoint6400 */
+        sqrSum = sqr1 + sqr2;
+
+        /* SQRT(FixPoin6400) = FixPoint3200 */
+        sqrtResult_centi_ns = VL53L0X_isqrt(sqrSum);
+
+        /* (FixPoint3200 << 16) = FixPoint1616 */
+        sqrtResult_centi_ns <<= 16;
+
+        /*
+         * Note that the Speed Of Light is expressed in um per 1E-10
+         * seconds (2997) Therefore to get mm/ns we have to divide by
+         * 10000
+         */
+        sigmaEstRtn = (((sqrtResult_centi_ns+50)/100) /
+                sigmaEstimateP3);
+        sigmaEstRtn		 *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
+
+        /* Add 5000 before dividing by 10000 to ensure rounding. */
+        sigmaEstRtn		 += 5000;
+        sigmaEstRtn		 /= 10000;
+
+        if (sigmaEstRtn > cSigmaEstRtnMax) {
+            /* Clip to prevent overflow. Will ensure safe
+             * max result. */
+            sigmaEstRtn = cSigmaEstRtnMax;
+        }
+        finalRangeIntegrationTimeMilliSecs =
+            (finalRangeTimeoutMicroSecs + preRangeTimeoutMicroSecs + 500)/1000;
+
+        /* sigmaEstRef = 1mm * 25ms/final range integration time (inc pre-range)
+         * sqrt(FixPoint1616/int) = FixPoint2408)
+         */
+        sigmaEstRef =
+            VL53L0X_isqrt((cDfltFinalRangeIntegrationTimeMilliSecs +
+                finalRangeIntegrationTimeMilliSecs/2)/
+                finalRangeIntegrationTimeMilliSecs);
+
+        /* FixPoint2408 << 8 = FixPoint1616 */
+        sigmaEstRef <<= 8;
+        sigmaEstRef = (sigmaEstRef + 500)/1000;
+
+        /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
+        sqr1 = sigmaEstRtn * sigmaEstRtn;
+        /* FixPoint1616 * FixPoint1616 = FixPoint3232 */
+        sqr2 = sigmaEstRef * sigmaEstRef;
+
+        /* sqrt(FixPoint3232) = FixPoint1616 */
+        sqrtResult = VL53L0X_isqrt((sqr1 + sqr2));
+        /*
+         * Note that the Shift by 4 bits increases resolution prior to
+         * the sqrt, therefore the result must be shifted by 2 bits to
+         * the right to revert back to the FixPoint1616 format.
+         */
+
+        sigmaEstimate	 = 1000 * sqrtResult;
+
+        if ((peakSignalRate_kcps < 1) || (vcselTotalEventsRtn < 1) ||
+                (sigmaEstimate > cSigmaEstMax)) {
+                sigmaEstimate = cSigmaEstMax;
+        }
+
+        *pSigmaEstimate = (uint32_t)(sigmaEstimate);
+        PALDevDataSet(Dev, SigmaEstimate, *pSigmaEstimate);
+        Status = VL53L0X_calc_dmax(
+            Dev,
+            totalSignalRate_mcps,
+            correctedSignalRate_mcps,
+            pwMult,
+            sigmaEstimateP1,
+            sigmaEstimateP2,
+            peakVcselDuration_us,
+            pDmax_mm);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+}
+
+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)
+{
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t NoneFlag;
+    uint8_t SigmaLimitflag = 0;
+    uint8_t SignalRefClipflag = 0;
+    uint8_t RangeIgnoreThresholdflag = 0;
+    uint8_t SigmaLimitCheckEnable = 0;
+    uint8_t SignalRateFinalRangeLimitCheckEnable = 0;
+    uint8_t SignalRefClipLimitCheckEnable = 0;
+    uint8_t RangeIgnoreThresholdLimitCheckEnable = 0;
+    FixPoint1616_t SigmaEstimate;
+    FixPoint1616_t SigmaLimitValue;
+    FixPoint1616_t SignalRefClipValue;
+    FixPoint1616_t RangeIgnoreThresholdValue;
+    FixPoint1616_t SignalRatePerSpad;
+    uint8_t DeviceRangeStatusInternal = 0;
+    uint16_t tmpWord = 0;
+    uint8_t Temp8;
+    uint32_t Dmax_mm = 0;
+    FixPoint1616_t LastSignalRefMcps;
+
+    LOG_FUNCTION_START("");
+
+
+    /*
+     * VL53L0X has a good ranging when the value of the
+     * DeviceRangeStatus = 11. This function will replace the value 0 with
+     * the value 11 in the DeviceRangeStatus.
+     * In addition, the SigmaEstimator is not included in the VL53L0X
+     * DeviceRangeStatus, this will be added in the PalRangeStatus.
+     */
+
+    DeviceRangeStatusInternal = ((DeviceRangeStatus & 0x78) >> 3);
+
+    if (DeviceRangeStatusInternal == 0 ||
+        DeviceRangeStatusInternal == 5 ||
+        DeviceRangeStatusInternal == 7 ||
+        DeviceRangeStatusInternal == 12 ||
+        DeviceRangeStatusInternal == 13 ||
+        DeviceRangeStatusInternal == 14 ||
+        DeviceRangeStatusInternal == 15
+            ) {
+        NoneFlag = 1;
+    } else {
+        NoneFlag = 0;
+    }
+
+    /*
+     * Check if Sigma limit is enabled, if yes then do comparison with limit
+     * value and put the result back into pPalRangeStatus.
+     */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status =  VL53L0X_GetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+            &SigmaLimitCheckEnable);
+
+    if ((SigmaLimitCheckEnable != 0) && (Status == VL53L0X_ERROR_NONE)) {
+        /*
+        * compute the Sigma and check with limit
+        */
+        Status = VL53L0X_calc_sigma_estimate(
+            Dev,
+            pRangingMeasurementData,
+            &SigmaEstimate,
+            &Dmax_mm);
+        if (Status == VL53L0X_ERROR_NONE)
+            pRangingMeasurementData->RangeDMaxMilliMeter = Dmax_mm;
+
+        if (Status == VL53L0X_ERROR_NONE) {
+            Status = VL53L0X_GetLimitCheckValue(Dev,
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                &SigmaLimitValue);
+
+            if ((SigmaLimitValue > 0) &&
+                (SigmaEstimate > SigmaLimitValue))
+                    /* Limit Fail */
+                    SigmaLimitflag = 1;
+        }
+    }
+
+    /*
+     * Check if Signal ref clip limit is enabled, if yes then do comparison
+     * with limit value and put the result back into pPalRangeStatus.
+     */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status =  VL53L0X_GetLimitCheckEnable(Dev,
+                VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+                &SignalRefClipLimitCheckEnable);
+
+    if ((SignalRefClipLimitCheckEnable != 0) &&
+            (Status == VL53L0X_ERROR_NONE)) {
+
+        Status = VL53L0X_GetLimitCheckValue(Dev,
+                VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+                &SignalRefClipValue);
+
+        /* Read LastSignalRefMcps from device */
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_RdWord(Dev,
+                VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+                &tmpWord);
+
+        if (Status == VL53L0X_ERROR_NONE)
+            Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+
+        LastSignalRefMcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmpWord);
+        PALDevDataSet(Dev, LastSignalRefMcps, LastSignalRefMcps);
+
+        if ((SignalRefClipValue > 0) &&
+                (LastSignalRefMcps > SignalRefClipValue)) {
+            /* Limit Fail */
+            SignalRefClipflag = 1;
+        }
+    }
+
+    /*
+     * Check if Signal ref clip limit is enabled, if yes then do comparison
+     * with limit value and put the result back into pPalRangeStatus.
+     * EffectiveSpadRtnCount has a format 8.8
+     * If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
+     */
+    if (Status == VL53L0X_ERROR_NONE)
+        Status =  VL53L0X_GetLimitCheckEnable(Dev,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                &RangeIgnoreThresholdLimitCheckEnable);
+
+    if ((RangeIgnoreThresholdLimitCheckEnable != 0) &&
+            (Status == VL53L0X_ERROR_NONE)) {
+
+        /* Compute the signal rate per spad */
+        if (EffectiveSpadRtnCount == 0) {
+            SignalRatePerSpad = 0;
+        } else {
+            SignalRatePerSpad = (FixPoint1616_t)((256 * SignalRate)
+                / EffectiveSpadRtnCount);
+        }
+
+        Status = VL53L0X_GetLimitCheckValue(Dev,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                &RangeIgnoreThresholdValue);
+
+        if ((RangeIgnoreThresholdValue > 0) &&
+            (SignalRatePerSpad < RangeIgnoreThresholdValue)) {
+            /* Limit Fail add 2^6 to range status */
+            RangeIgnoreThresholdflag = 1;
+        }
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if (NoneFlag == 1) {
+            *pPalRangeStatus = 255;	 /* NONE */
+        } else if (DeviceRangeStatusInternal == 1 ||
+                    DeviceRangeStatusInternal == 2 ||
+                    DeviceRangeStatusInternal == 3) {
+            *pPalRangeStatus = 5; /* HW fail */
+        } else if (DeviceRangeStatusInternal == 6 ||
+                    DeviceRangeStatusInternal == 9) {
+            *pPalRangeStatus = 4;  /* Phase fail */
+        } else if (DeviceRangeStatusInternal == 8 ||
+                    DeviceRangeStatusInternal == 10 ||
+                    SignalRefClipflag == 1) {
+            *pPalRangeStatus = 3;  /* Min range */
+        } else if (DeviceRangeStatusInternal == 4 ||
+                    RangeIgnoreThresholdflag == 1) {
+            *pPalRangeStatus = 2;  /* Signal Fail */
+        } else if (SigmaLimitflag == 1) {
+            *pPalRangeStatus = 1;  /* Sigma	 Fail */
+        } else {
+            *pPalRangeStatus = 0; /* Range Valid */
+        }
+    }
+
+    /* DMAX only relevant during range error */
+    if (*pPalRangeStatus == 0)
+        pRangingMeasurementData->RangeDMaxMilliMeter = 0;
+
+    /* fill the Limit Check Status */
+
+    Status =  VL53L0X_GetLimitCheckEnable(Dev,
+            VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+            &SignalRateFinalRangeLimitCheckEnable);
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        if ((SigmaLimitCheckEnable == 0) || (SigmaLimitflag == 1))
+            Temp8 = 1;
+        else
+            Temp8 = 0;
+        VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, Temp8);
+
+        if ((DeviceRangeStatusInternal == 4) ||
+                (SignalRateFinalRangeLimitCheckEnable == 0))
+            Temp8 = 1;
+        else
+            Temp8 = 0;
+        VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                Temp8);
+
+        if ((SignalRefClipLimitCheckEnable == 0) ||
+                    (SignalRefClipflag == 1))
+            Temp8 = 1;
+        else
+            Temp8 = 0;
+
+        VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+                VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, Temp8);
+
+        if ((RangeIgnoreThresholdLimitCheckEnable == 0) ||
+                (RangeIgnoreThresholdflag == 1))
+            Temp8 = 1;
+        else
+            Temp8 = 0;
+
+        VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                Temp8);
+    }
+
+    LOG_FUNCTION_END(Status);
+    return Status;
+
+}
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_ranging.c b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_ranging.c
new file mode 100644
index 0000000..57c9d42
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_ranging.c
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ 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__)
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_strings.c b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_strings.c
new file mode 100644
index 0000000..8499a1d
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/core/src/vl53l0x_api_strings.c
@@ -0,0 +1,462 @@
+/*******************************************************************************
+ 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"
+#include "vl53l0x_api_strings.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;
+}
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_i2c_platform.h b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_i2c_platform.h
new file mode 100644
index 0000000..1da14a2
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_i2c_platform.h
@@ -0,0 +1,372 @@
+/*
+ * COPYRIGHT (C) STMicroelectronics 2014. All rights reserved.
+ *
+ * This software is the confidential and proprietary information of
+ * STMicroelectronics ("Confidential Information").  You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with STMicroelectronics
+ *
+ * Programming Golden Rule: Keep it Simple!
+ *
+ */
+
+/**
+ * @file   VL53L0X_platform.h
+ * @brief  Function prototype definitions for Ewok Platform layer.
+ *
+ */
+
+//MUST WRITE OWN
+
+#ifndef _VL53L0X_I2C_PLATFORM_H_
+#define _VL53L0X_I2C_PLATFORM_H_
+
+#include <amiro-lld.h>
+#include <periphAL.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "vl53l0x_def.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Include uint8_t, unit16_t  etc definitions
+
+#include <stdint.h>
+#include <stdarg.h>
+
+
+/**
+ *  @brief Typedef defining .\n
+ * The developer shoud modify this to suit the platform being deployed.
+ *
+ */
+
+// enum  {TRUE = true, FALSE = false};
+
+/**
+ * @brief Typedef defining 8 bit unsigned char type.\n
+ * The developer shoud modify this to suit the platform being deployed.
+ *
+ */
+
+#ifndef bool_t
+typedef unsigned char bool_t;
+#endif
+
+
+#define	   I2C                0x01
+#define	   SPI                0x00
+
+#define    COMMS_BUFFER_SIZE    64  // MUST be the same size as the SV task buffer
+
+#define    BYTES_PER_WORD        2
+#define    BYTES_PER_DWORD       4
+
+#define    VL53L0X_MAX_STRING_LENGTH_PLT       256
+
+/**
+ * @brief  Initialise platform comms.
+ *
+ * @param  comms_type      - selects between I2C and SPI
+ * @param  comms_speed_khz - unsigned short containing the I2C speed in kHz
+ *
+ * @return status - status 0 = ok, 1 = error
+ *
+ */
+
+
+
+
+
+
+
+int32_t VL53L0X_write_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t reg, uint8_t *pdata, int32_t count, apalTime_t timeout);
+
+
+/**
+ * @brief  Reads the requested number of bytes from the device
+ *
+ * Wrapper for SystemVerilog Read Multi task
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t buffer[COMMS_BUFFER_SIZE];
+ *
+ * int status = status  = VL53L0X_read_multi(DEVICE_ID, buffer, 2)
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  pdata - pointer to the uint8_t buffer to store read data
+ * @param  count - number of uint8_t's to read
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t *pdata, size_t count, apalTime_t timeout);
+
+
+/**
+ * @brief  Writes a single byte to the device
+ *
+ * Wrapper for SystemVerilog Write Byte task
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t page_number = MAIN_SELECT_PAGE;
+ *
+ * int status = VL53L0X_write_byte(PAGE_SELECT, page_number);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uint8_t data value to write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t data, apalTime_t timeout);
+
+
+/**
+ * @brief  Writes a single word (16-bit unsigned) to the device
+ *
+ * Manages the big-endian nature of the device (first byte written is the MS byte).
+ * Uses SystemVerilog Write Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint16_t nvm_ctrl_pulse_width = 0x0004;
+ *
+ * int status = VL53L0X_write_word(NVM_CTRL__PULSE_WIDTH_MSB, nvm_ctrl_pulse_width);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uin16_t data value write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t data, apalTime_t timeout);
+
+
+/**
+ * @brief  Writes a single dword (32-bit unsigned) to the device
+ *
+ * Manages the big-endian nature of the device (first byte written is the MS byte).
+ * Uses SystemVerilog Write Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint32_t nvm_data = 0x0004;
+ *
+ * int status = VL53L0X_write_dword(NVM_CTRL__DATAIN_MMM, nvm_data);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uint32_t data value to write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t data, apalTime_t timeout);
+
+
+
+/**
+ * @brief  Reads a single byte from the device
+ *
+ * Uses SystemVerilog Read Byte task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t device_status = 0;
+ *
+ * int status = VL53L0X_read_byte(STATUS, &device_status);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index  - uint8_t register index value
+ * @param  pdata  - pointer to uint8_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t *pdata, apalTime_t timeout);
+
+
+/**
+ * @brief  Reads a single word (16-bit unsigned) from the device
+ *
+ * Manages the big-endian nature of the device (first byte read is the MS byte).
+ * Uses SystemVerilog Read Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint16_t timeout = 0;
+ *
+ * int status = VL53L0X_read_word(TIMEOUT_OVERALL_PERIODS_MSB, &timeout);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index  - uint8_t register index value
+ * @param  pdata  - pointer to uint16_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t *pdata, apalTime_t timeout);
+
+
+/**
+ * @brief  Reads a single dword (32-bit unsigned) from the device
+ *
+ * Manages the big-endian nature of the device (first byte read is the MS byte).
+ * Uses SystemVerilog Read Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint32_t range_1 = 0;
+ *
+ * int status = VL53L0X_read_dword(RANGE_1_MMM, &range_1);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  pdata - pointer to uint32_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t *pdata, apalTime_t timeout);
+
+
+/**
+ * @brief  Implements a programmable wait in us
+ *
+ * Wrapper for SystemVerilog Wait in micro seconds task
+ *
+ * @param  wait_us - integer wait in micro seconds
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_platform_wait_us(int32_t wait_us);
+
+
+/**
+ * @brief  Implements a programmable wait in ms
+ *
+ * Wrapper for SystemVerilog Wait in milli seconds task
+ *
+ * @param  wait_ms - integer wait in milli seconds
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_wait_ms(int32_t wait_ms);
+
+
+/**
+ * @brief Set GPIO value
+ *
+ * @param  level  - input  level - either 0 or 1
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_set_gpio(uint8_t  level);
+
+
+/**
+ * @brief Get GPIO value
+ *
+ * @param  plevel - uint8_t pointer to store GPIO level (0 or 1)
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_get_gpio(uint8_t *plevel);
+
+/**
+ * @brief Release force on GPIO
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_release_gpio(void);
+
+
+/**
+* @brief Get the frequency of the timer used for ranging results time stamps
+*
+* @param[out] ptimer_freq_hz : pointer for timer frequency
+*
+* @return status : 0 = ok, 1 = error
+*
+*/
+
+int32_t VL53L0X_get_timer_frequency(int32_t *ptimer_freq_hz);
+
+/**
+* @brief Get the timer value in units of timer_freq_hz (see VL53L0X_get_timestamp_frequency())
+*
+* @param[out] ptimer_count : pointer for timer count value
+*
+* @return status : 0 = ok, 1 = error
+*
+*/
+
+int32_t VL53L0X_get_timer_value(int32_t *ptimer_count);
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_VL53L0X_I2C_PLATFORM_H_
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_platform.h b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_platform.h
new file mode 100644
index 0000000..e60b027
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_platform.h
@@ -0,0 +1,250 @@
+/*******************************************************************************
+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 <periphALtypes.h>
+//#include <periphAL.h>
+#include <amiro-lld.h>
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform_log.h"
+#include "vl53l0x_i2c_platform.h"
+
+//#include "alld_vl53l0x.h"
+//#include "vl53l0x_api_strings.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file vl53l0x_platform.h
+ *
+ * @brief All end user OS/platform/application porting
+ */
+
+/**
+ * @defgroup VL53L0X_platform_group VL53L0X Platform Functions
+ * @brief    VL53L0X Platform Functions
+ *  @{
+ */
+
+/**
+ * @struct  VL53L0X_Dev_t
+ * @brief    Generic PAL device type that does link between API and platform abstraction layer
+ *
+ */
+typedef struct {
+    apalI2CDriver_t* i2cd;              /*!< @brief The I2C Driver.     */
+    apalTime_t timeout;                 /*!< timeout for chibios I2C interactions */
+    VL53L0X_DevData_t Data;               /*!< embed ST Ewok Dev  data as "Data"*/
+
+    /*!< user specific field */
+    uint16_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           */
+
+} 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_ */
+
+
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_platform_log.h b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_platform_log.h
new file mode 100644
index 0000000..8876f67
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/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 vl53l0x_platform_log.h
+ *
+ * @brief platform log function definition
+ */
+
+// id include error in linker TODO
+//#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_ */
+
+
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_types.h b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/vl53l0x_types.h
new file mode 100644
index 0000000..0f842c2
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/inc/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  vl53l0x_types.h
+ * @brief VL53L0X types definition
+ */
+
+#ifndef VL53L0X_TYPES_H_
+#define VL53L0X_TYPES_H_
+
+/** @defgroup porting_type  Basic type definition
+ *  @ingroup  VL53L0X_platform_group
+ *
+ *  @brief  file vl53l0x_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 <stdint.h>
+#include <stddef.h>
+
+#ifndef NULL
+#error "Error NULL definition should be done. Please add required include "
+#endif
+
+
+#if ! 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 addapt 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_ */
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_i2c_platform.c b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_i2c_platform.c
new file mode 100644
index 0000000..1e1a67d
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_i2c_platform.c
@@ -0,0 +1,353 @@
+
+
+/*!
+ * \file   VL53L0X_platform.c
+ * \brief  Code function defintions for Doppler Testchip Platform Layer
+ *
+ */
+
+
+#include <stdio.h>    // sprintf(), vsnprintf(), printf()
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+
+
+#include "vl53l0x_i2c_platform.h"
+#include "vl53l0x_def.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+//#include "SERIAL_COMMS.h"
+//#include "comms_platform.h"
+
+#include "vl53l0x_platform_log.h"
+
+//#include <aos_thread.h>
+
+
+
+#ifdef VL53L0X_LOG_ENABLE
+#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_PLATFORM, level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
+#define trace_i2c(...) trace_print_module_function(TRACE_MODULE_NONE, TRACE_LEVEL_NONE, TRACE_FUNCTION_I2C, ##__VA_ARGS__)
+#endif
+
+//char  debug_string[VL53L0X_MAX_STRING_LENGTH_PLT];
+
+uint8_t cached_page = 0;
+
+#define MIN_COMMS_VERSION_MAJOR     1
+#define MIN_COMMS_VERSION_MINOR     8
+#define MIN_COMMS_VERSION_BUILD     1
+#define MIN_COMMS_VERSION_REVISION  0
+
+
+#define MAX_STR_SIZE 255
+#define MAX_MSG_SIZE 100
+#define MAX_DEVICES 4
+#define STATUS_OK              0x00
+#define STATUS_FAIL            0x01
+
+
+static unsigned char _dataBytes[MAX_MSG_SIZE];
+
+bool_t _check_min_version(void)
+{
+    return TRUE;
+}
+
+
+uint8_t txbuf[10];
+
+
+/**
+ * @brief VL53L0X_write_multi
+ * @param address
+ * @param reg   register to write to
+ * @param pdata
+ * @param count
+ * @return int32_t because the vl53l0x has more error messages than the chibiOS
+ */
+int32_t VL53L0X_write_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t reg, uint8_t *pdata, int32_t count, apalTime_t timeout)
+{
+
+
+    int32_t status = APAL_STATUS_OK;
+    #ifdef VL53L0X_LOG_ENABLE
+        int32_t i = 0;
+        char value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];
+        char *pvalue_as_str;
+    #endif
+
+
+    /* For multi writes, the serial comms dll requires multiples 4 bytes or
+     * anything less than 4 bytes. So if an irregular size is required, the
+     * message is broken up into two writes.
+     *
+     *
+     * with the apalI2CMasterTransmit it is possible to write ore than one think -> TODO!
+     */
+
+    #ifdef VL53L0X_LOG_ENABLE
+
+        pvalue_as_str =  value_as_str;
+
+        for(i = 0 ; i < count ; i++)
+        {
+            sprintf(pvalue_as_str,"%02X", *(pdata+i));
+
+            pvalue_as_str += 2;
+        }
+        trace_i2c("Write reg : 0x%04X, Val : 0x%s\n", reg, value_as_str);
+    #endif
+
+
+    if(status == APAL_STATUS_OK)
+    {
+        //max is 6 + 1 and allcoate the max space of 7 ... TODO
+        int i = 0;
+        txbuf[0] = reg;
+        for (i = 0; i < (int)count; i++){
+            txbuf[i+1] = pdata[i];
+        }
+
+        if (timeout == 0){
+            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, TIME_INFINITE);
+        }else{
+            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, timeout);
+        }
+    }
+
+    //convet error status to vl53l0x-api
+    if (status != APAL_STATUS_OK)
+    {
+        status = VL53L0X_ERROR_NONE;
+        //SERIAL_COMMS_Get_Error_Text(debug_string);
+        apalDbgAssert(status != STATUS_OK);
+    }
+
+    return status;
+}
+
+
+
+
+/**
+ * @brief VL53L0X_read_multi
+ * @param address
+ * @param index address from register
+ * @param pdata
+ * @param count likly 6
+ * @return
+ */
+int32_t VL53L0X_read_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t* pdata, size_t count, apalTime_t timeout)
+{
+
+    apalDbgAssert(i2cd != NULL);
+
+    int32_t status = STATUS_OK;
+//    #ifdef VL53L0X_LOG_ENABLE
+//        int32_t      i = 0;
+//        char   value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];
+//        char *pvalue_as_str;
+//    #endif
+
+    if(status == STATUS_OK)
+    {
+
+//        status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);
+        if (timeout == 0){
+            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, TIME_INFINITE);
+        }else{
+            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);
+        }
+
+    }
+
+
+//    #ifdef VL53L0X_LOG_ENABLE
+
+//        // Build  value as string;
+//        pvalue_as_str =  value_as_str;
+
+//        for(i = 0 ; i < count ; i++)
+//        {
+//            sprintf(pvalue_as_str, "%02X", *(pdata+i));
+//            pvalue_as_str += 2;
+//        }
+
+//        //trace_i2c("Read  reg : 0x%04X, Val : 0x%s\n", index, value_as_str);
+//    #endif
+
+
+    return status;
+}
+
+
+
+/**
+ * @brief VL53L0X_write_byte
+ * @param address
+ * @param index
+ * @param data
+ * @return
+ */
+int32_t VL53L0X_write_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t data, apalTime_t timeout)
+{
+
+    int32_t status = STATUS_OK;
+    const size_t cbyte_count = 1;
+
+    #ifdef VL53L0X_LOG_ENABLE
+        trace_print(TRACE_LEVEL_INFO,"Write reg : 0x%02X, Val : 0x%02X\n", index, data);
+    #endif
+
+
+    status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&data, cbyte_count, timeout);
+
+
+
+    return status;
+
+}
+
+
+/**
+ * @brief VL53L0X_write_word
+ * @param address
+ * @param index
+ * @param data
+ * @return
+ */
+int32_t VL53L0X_write_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t data, apalTime_t timeout)
+{
+    int32_t status = STATUS_OK;
+
+    uint8_t  buffer[BYTES_PER_WORD];
+
+    // Split 16-bit word into MS and LS uint8_t
+    buffer[0] = (uint8_t)(data >> 8);
+    buffer[1] = (uint8_t)(data &  0x00FF);
+
+    if(index%2 == 1)
+    {
+        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0],1, timeout);
+        status = VL53L0X_write_multi(i2cd, address, index + 1, (uint8_t*) &buffer[1],1, timeout);
+        // serial comms cannot handle word writes to non 2-byte aligned registers.
+    }
+    else
+    {
+        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0], BYTES_PER_WORD, timeout);
+    }
+
+    return status;
+
+}
+
+
+
+
+
+/**
+ * @brief VL53L0X_write_dword
+ * @param address
+ * @param index
+ * @param data
+ * @return
+ */
+int32_t VL53L0X_write_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t data, apalTime_t timeout)
+{
+    int32_t status = STATUS_OK;
+    uint8_t  buffer[BYTES_PER_DWORD];
+
+    // Split 32-bit word into MS ... LS bytes
+    buffer[0] = (uint8_t) (data >> 24);
+    buffer[1] = (uint8_t)((data &  0x00FF0000) >> 16);
+    buffer[2] = (uint8_t)((data &  0x0000FF00) >> 8);
+    buffer[3] = (uint8_t) (data &  0x000000FF);
+
+    status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)buffer[0], BYTES_PER_DWORD, timeout);
+
+    return status;
+
+}
+
+
+
+/**
+ * @brief VL53L0X_read_byte
+ * @param address
+ * @param index
+ * @param pdata
+ * @return
+ */
+int32_t VL53L0X_read_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t *pdata, apalTime_t timeout)
+{
+    int32_t status = STATUS_OK;
+    size_t cbyte_count = 1;
+
+    status = VL53L0X_read_multi(i2cd, address, index, pdata, cbyte_count, timeout);
+
+    #ifdef VL53L0X_LOG_ENABLE
+        trace_print(TRACE_LEVEL_INFO,"Read reg : 0x%02X, Val : 0x%02X\n", index, *pdata);
+    #endif
+
+    return status;
+
+}
+
+
+
+
+/**
+ * @brief VL53L0X_read_word
+ * @param address
+ * @param index
+ * @param pdata
+ * @return
+ */
+int32_t VL53L0X_read_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t *pdata ,apalTime_t timeout)
+{
+    int32_t  status = STATUS_OK;
+    uint8_t  buffer[BYTES_PER_WORD];
+
+    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_WORD, timeout);
+    *pdata = ((uint16_t)buffer[0]<<8) + (uint16_t)buffer[1];
+
+    return status;
+
+}
+
+
+
+
+/**
+ * @brief VL53L0X_read_dword
+ * @param address
+ * @param index
+ * @param pdata
+ * @return
+ */
+int32_t VL53L0X_read_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t *pdata, apalTime_t timeout)
+{
+    int32_t status = STATUS_OK;
+    uint8_t  buffer[BYTES_PER_DWORD];
+
+    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_DWORD, timeout);
+    *pdata = ((uint32_t)buffer[0]<<24) + ((uint32_t)buffer[1]<<16) + ((uint32_t)buffer[2]<<8) + (uint32_t)buffer[3];
+
+    return status;
+
+}
+
+
+
+
+
+
+
+
+
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform.c b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform.c
new file mode 100644
index 0000000..d17fb1e
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform.c
@@ -0,0 +1,278 @@
+/*******************************************************************************
+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_i2c_platform.h"
+//#include "vl53l0x_api.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;
+    uint16_t deviceAddress;
+
+    if (count>=VL53L0X_MAX_I2C_XFER_SIZE){
+        Status = VL53L0X_ERROR_INVALID_PARAMS;
+    }
+
+    deviceAddress = Dev->I2cDevAddr;
+
+    status_int = VL53L0X_write_multi(Dev->i2cd, deviceAddress, index, pdata, count, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, pdata, count, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, &data, Dev->timeout);
+
+    if (status_int != 0)
+        Status = VL53L0X_ERROR_CONTROL_INTERFACE;
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        data = (data & AndData) | OrData;
+        status_int = VL53L0X_write_byte(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+        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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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(Dev->i2cd, deviceAddress, index, data, Dev->timeout);
+
+    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;
+    LOG_FUNCTION_START("");
+
+    //const DWORD cTimeout_ms = 1;
+    //const uint16  cTimeout_ms = 1;
+    // 1000 microseconds == 1 milliesecound
+     usleep(1000);
+
+     //    HANDLE hEvent = CreateEvent(0, TRUE, FALSE, 0);
+//    if(hEvent != NULL)
+//    {
+//        WaitForSingleObject(hEvent,cTimeout_ms);
+//    }
+
+    LOG_FUNCTION_END(status);
+    return status;
+}
diff --git a/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform_log.c b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform_log.c
new file mode 100644
index 0000000..eba3093
--- /dev/null
+++ b/include/VL53L0X/v1/Api_vl53l0x/platform/src/vl53l0x_platform_log.c
@@ -0,0 +1,106 @@
+/*
+ * COPYRIGHT (C) STMicroelectronics 2015. All rights reserved.
+ *
+ * This software is the confidential and proprietary information of
+ * STMicroelectronics ("Confidential Information").  You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with STMicroelectronics
+ *
+ * Programming Golden Rule: Keep it Simple!
+ *
+ */
+
+/*!
+ * \file   VL53L0X_platform_log.c
+ * \brief  Code function defintions for Ewok Platform Layer
+ *
+ */
+
+
+
+#include <stdio.h>    // sprintf(), vsnprintf(), printf()
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+#include "vl53l0x_i2c_platform.h"
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform_log.h"
+
+#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_PLATFORM, level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
+//#define trace_i2c(...) trace_print_module_function(TRACE_MODULE_NONE, TRACE_LEVEL_NONE, TRACE_FUNCTION_I2C, ##__VA_ARGS__)
+
+//#define trace_i2c(ftm,...) apalDbgPrintf(ftm, ##__VA_ARGS__)
+
+char  debug_string[VL53L0X_MAX_STRING_LENGTH_PLT];
+
+
+char * _trace_filename = NULL;
+FILE *_tracefile = NULL;
+
+uint32_t _trace_level = TRACE_LEVEL_WARNING;
+uint32_t _trace_modules = TRACE_MODULE_NONE;
+uint32_t _trace_functions = TRACE_FUNCTION_NONE;
+
+
+int32_t VL53L0X_trace_config(char *filename, uint32_t modules, uint32_t level, uint32_t functions)
+{
+    int STATUS = 0;
+
+    if ((_trace_filename != NULL) && (_trace_filename != filename))
+    {
+        if ( _tracefile != NULL )
+        {
+            fclose(_tracefile);
+            _tracefile = NULL;
+        }
+        free(_trace_filename);
+        _trace_filename = NULL;
+    }
+
+    if ((filename != NULL) && (_tracefile == NULL))
+    {
+        _tracefile = fopen(filename, "w+");
+
+        //TODO: Add time and header banner to the log file to indicate we've just opened a new log session
+
+        if ( _tracefile != NULL )
+        {
+            _trace_filename = (char*)malloc((strlen(filename) + 1) * sizeof(char));
+            strcpy(_trace_filename, filename);
+        } else
+            STATUS = 1;
+    }
+
+    _trace_functions = functions;
+    _trace_level = level;
+    _trace_modules = modules;
+
+    return STATUS;
+}
+
+// error if enabled_log us enabled
+void trace_print_module_function(uint32_t module, uint32_t level, uint32_t function, const char *format, ...)
+{
+    if ( ((level <=_trace_level) && ((module & _trace_modules) > 0))
+        || ((function & _trace_functions) > 0) )
+    {
+        va_list arg_list;
+        char message[VL53L0X_MAX_STRING_LENGTH_PLT];
+
+        va_start(arg_list, format);
+        vsnprintf(message, VL53L0X_MAX_STRING_LENGTH_PLT, format, arg_list);
+
+        va_end(arg_list);
+
+        //apalDbgPrintf(message);
+
+//        if (_tracefile != NULL)
+//            fprintf(_tracefile, message);
+//        else
+//            printf(message);
+    }
+}
+
diff --git a/include/VL53L0X/v1/alld_VL53L0X_v1.h b/include/VL53L0X/v1/alld_VL53L0X_v1.h
new file mode 100644
index 0000000..6ed238c
--- /dev/null
+++ b/include/VL53L0X/v1/alld_VL53L0X_v1.h
@@ -0,0 +1,230 @@
+/*
+AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
+Copyright (C) 2016..2019  Thomas Schöpping et al.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+/**
+ * @file    alld_VL53L0X_v1.h
+ * @brief   Proximity Sensor macros and structures.
+ *
+ * @addtogroup lld_proximity
+ * @{
+ */
+
+#ifndef AMIROLLD_VL53L0X_V1_H
+#define AMIROLLD_VL53L0X_V1_H
+
+
+#include <stdbool.h>
+
+#include <string.h>
+//debugging
+//#include <aos_thread.h>
+
+
+#include <stdint.h>
+#include <stdarg.h>
+#include "chprintf.h"
+
+
+//includes api st vl53l0x
+#include <vl53l0x_api.h>
+//#include "vl53l0x_platform.h"
+
+
+#if (defined(AMIROLLD_CFG_VL53L0X) && (AMIROLLD_CFG_VL53L0X == 1)) || defined(__DOXYGEN__)
+
+/******************************************************************************/
+/* CONSTANTS                                                                  */
+/******************************************************************************/
+
+/**
+ * @brief Fixed slave address to access the VL53L0X via I2C.
+ *
+ * VCNL4020 had 0010011 = 13h == 0x13u
+ * VL53L0X  has 0101001 = 29h == 0x29u and the last bit is read(0x53)/write(0x52)
+ *
+ */
+#define VL53L0X_LLD_I2C_ADDR           0x29u
+
+/**
+ * @brief Maximum frequency for I2C communication.
+ *
+ * VL53L0X has 400 kHz
+ *
+ */
+#define VL53L0X_LLD_I2C_MAXFREQUENCY   200000
+
+/**
+ * @brief A falling edge indicates an interrupt.
+ *
+ * VL53L0X has an interrupt on a falling or rising edge, it can be set.
+ *
+ */
+#define VL53L0X_LLD_INT_EDGE           APAL_GPIO_EDGE_FALLING
+
+
+/**
+ *@brief use the 2.8V mode for the VL53L0X Sensor
+ */
+#define USE_I2C_2V8
+
+
+/**
+ * @brief Adresses of all registers of the VL53L0X.
+ */
+
+
+/******************************************************************************/
+/* SETTINGS                                                                   */
+/******************************************************************************/
+
+/******************************************************************************/
+/* CHECKS                                                                     */
+/******************************************************************************/
+
+/******************************************************************************/
+/* DATA STRUCTURES AND TYPES                                                  */
+/******************************************************************************/
+
+/**
+ * @brief The VL53L0X driver struct, the apalI2CDriver_t I2C Driver is inside the VL53L0X_Dev_t structur.
+ */
+typedef struct {
+  VL53L0X_Dev_t vl53l0x_dev;
+} VL53L0XDriver;
+
+
+/**
+ * @brief Adresses for the several I/O registers of the VCNL4020.
+ */
+typedef enum {
+    VL53L0X_REG_SYSRANGE_START_API = VL53L0X_REG_SYSRANGE_START,
+    VL53L0X_REG_SYSRANGE_MODE_MASK_API = VL53L0X_REG_SYSRANGE_MODE_MASK,
+    VL53L0X_REG_SYSRANGE_MODE_START_STOP_API = VL53L0X_REG_SYSRANGE_MODE_START_STOP,
+    VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT_API = VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT,
+    VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK_API = VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK,
+    VL53L0X_REG_SYSRANGE_MODE_TIMED_API = VL53L0X_REG_SYSRANGE_MODE_TIMED,                                      //0x04,
+    VL53L0X_REG_SYSRANGE_MODE_HISTOGRAM_API= VL53L0X_REG_SYSRANGE_MODE_HISTOGRAM,                               // 0x08,
+    VL53L0X_REG_SYSTEM_THRESH_HIGH_API = VL53L0X_REG_SYSTEM_THRESH_HIGH,                                        // 0x000C,
+    VL53L0X_REG_SYSTEM_THRESH_LOW_API = VL53L0X_REG_SYSTEM_THRESH_LOW,                                          // 0x000E,
+    VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG_API = VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,                                // 0x0001,
+    VL53L0X_REG_SYSTEM_RANGE_CONFIG_API = VL53L0X_REG_SYSTEM_RANGE_CONFIG,                                      // 0x0009,
+    VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD_API = VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,                // 0x0004,
+    VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO_API = VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO,                    // 0x000A,
+    VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED_API = VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED,                // 0x00,
+    VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_LOW_API = VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_LOW,              // 0x01,
+    VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH_API = VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH,            // 0x02,
+    VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW_API = VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW,      //0x03,
+    VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY_API = VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,// 0x04,
+    VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH_API = VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,                              // 0x0084,
+    VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR_API = VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR,                                // 0x000B,
+    VL53L0X_REG_RESULT_INTERRUPT_STATUS_API = VL53L0X_REG_RESULT_INTERRUPT_STATUS,                              // 0x0013,
+    VL53L0X_REG_RESULT_RANGE_STATUS_API = VL53L0X_REG_RESULT_RANGE_STATUS,                                      // 0x0014,
+    VL53L0X_REG_RESULT_CORE_PAGE_API = VL53L0X_REG_RESULT_CORE_PAGE,                                            // 1,
+    VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN_API = VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN,  // 0x00BC,
+    VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_RTN_API = VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_RTN,    // 0x00C0,
+    VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF_API = VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF,  // 0x00D0,
+    VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_REF_API = VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_REF,    // 0x00D4,
+    VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF_API = VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,                      // 0x00B6,
+    VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM_API = VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,          // 0x0028,
+    VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS_API = VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,                            // 0x008a,
+    VL53L0X_REG_MSRC_CONFIG_CONTROL_API = VL53L0X_REG_MSRC_CONFIG_CONTROL,                                      // 0x0060,
+    VL53L0X_REG_PRE_RANGE_CONFIG_MIN_SNR_API = VL53L0X_REG_PRE_RANGE_CONFIG_MIN_SNR,                            // 0X0027,
+    VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW_API = VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,            // 0x0056,
+    VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH_API = VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,          // 0x0057,
+    VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT_API = VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,        // 0x0064,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_SNR_API = VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_SNR,                        // 0X0067,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW_API = VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,        // 0x0047,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH_API = VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,      // 0x0048,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT_API = VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,  // 0x0044,
+    VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_HI_API = VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_HI,            // 0X0061,
+    VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_LO_API = VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_LO,            // 0X0062,
+    VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD_API = VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,                  // 0x0050,
+    VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI_API = VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,        // 0x0051,
+    VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO_API = VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO,        // 0x0052,
+    VL53L0X_REG_SYSTEM_HISTOGRAM_BIN_API = VL53L0X_REG_SYSTEM_HISTOGRAM_BIN,                                    // 0x0081,
+    VL53L0X_REG_HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT_API = VL53L0X_REG_HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT,  // 0x0033,
+    VL53L0X_REG_HISTOGRAM_CONFIG_READOUT_CTRL_API = VL53L0X_REG_HISTOGRAM_CONFIG_READOUT_CTRL,                  // 0x0055,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD_API = VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,              // 0x0070,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI_API = VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,    // 0x0071,
+    VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO_API = VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO,    // 0x0072,
+    VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS_API = VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS,  // 0x0020,
+    VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP_API = VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,                        // 0x0046,
+    VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N_API = VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,                      // 0x00bf,
+    VL53L0X_REG_IDENTIFICATION_MODEL_ID_API = VL53L0X_REG_IDENTIFICATION_MODEL_ID,                              // 0x00c0,
+    VL53L0X_REG_IDENTIFICATION_REVISION_ID_API = VL53L0X_REG_IDENTIFICATION_REVISION_ID,                        // 0x00c2,
+    VL53L0X_REG_OSC_CALIBRATE_VAL_API = VL53L0X_REG_OSC_CALIBRATE_VAL,                                          // 0x00f8,
+    VL53L0X_SIGMA_ESTIMATE_MAX_VALUE_API = VL53L0X_SIGMA_ESTIMATE_MAX_VALUE,                                    // 65535,
+    VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH_API = VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH,                          // 0x032,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,            // 0x0B0,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_1_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_1,            // 0x0B1,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_2_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_2,            // 0x0B2,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_3_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_3,            // 0x0B3,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_4_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_4,            // 0x0B4,
+    VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_5_API = VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_5,            // 0x0B5,
+    VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT_API = VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,          // 0xB6,
+    VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD_API = VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD,      // 0x4E,
+    VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET_API = VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET,            // 0x4F,
+    VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE_API = VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE,            // 0x80,
+    VL53L0X_SPEED_OF_LIGHT_IN_AIR_API = VL53L0X_SPEED_OF_LIGHT_IN_AIR,                                          // 2997,
+    VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV_API = VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,          // 0x0089,
+    VL53L0X_REG_ALGO_PHASECAL_LIM_API = VL53L0X_REG_ALGO_PHASECAL_LIM,                                          // 0x0030,
+    VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT_API = VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT,                    // 0x0030,
+} vl53l0x_lld_regaddr_t;
+
+
+/******************************************************************************/
+/* MACROS                                                                     */
+/******************************************************************************/
+
+/******************************************************************************/
+/* EXTERN DECLARATIONS                                                        */
+/******************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    apalExitStatus_t vl53l0x_lld_init(VL53L0XDriver* vl53l0x);
+    apalExitStatus_t vl53l0x_lld_set_mode(VL53L0XDriver* vl53l0x, VL53L0X_DeviceModes mode, VL53L0X_GpioFunctionality interrupt,
+                                          FixPoint1616_t low, FixPoint1616_t high);
+    apalExitStatus_t vl53l0x_lld_start_measurement(VL53L0XDriver* vl53l0x);
+    apalExitStatus_t vl53l0x_lld_stop_measurement(VL53L0XDriver* vl53l0x);
+    apalExitStatus_t vl53l0x_lld_CheckRangingDataReady(VL53L0XDriver* vl53l0x, uint8_t *pMeasurementDataReady);
+    apalExitStatus_t vl53l0x_lld_getRangingData(VL53L0XDriver* vl53l0x, VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
+    apalExitStatus_t vl53l0x_lld_set_address(VL53L0XDriver* vl53l0x, uint8_t new_address);
+    apalExitStatus_t vl53l0x_lld_perform_mesaurement(VL53L0XDriver* vl53l0x, uint16_t* data);
+    VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/******************************************************************************/
+/* INLINE FUNCTIONS                                                           */
+/******************************************************************************/
+
+#endif /* defined(AMIROLLD_CFG_VL53L0X) */
+
+#endif /* AMIROLLD_VL53L0X_V1_H */
+
+/** @} */
+
+
+
diff --git a/source/VL53L0X/v1/alld_VL53L0X_v1.c b/source/VL53L0X/v1/alld_VL53L0X_v1.c
new file mode 100644
index 0000000..871934d
--- /dev/null
+++ b/source/VL53L0X/v1/alld_VL53L0X_v1.c
@@ -0,0 +1,677 @@
+/*
+AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
+Copyright (C) 2016..2018  Thomas Schöpping et al.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    alld_vl53l0x.c
+ * @brief   Proximity Sensor function implementations.
+ *
+ * @addtogroup lld_proximity
+ * @{
+ */
+
+
+#include <alld_VL53L0X.h>
+//#include <string.h>
+//debugging
+//#include <aos_thread.h>
+
+
+#if (defined(AMIROLLD_CFG_VL53L0X) && (AMIROLLD_CFG_VL53L0X == 1)) || defined(__DOXYGEN__)
+
+
+
+/******************************************************************************/
+/* LOCAL DEFINITIONS                                                          */
+/******************************************************************************/
+
+/******************************************************************************/
+/* EXPORTED VARIABLES                                                         */
+/******************************************************************************/
+
+/******************************************************************************/
+/* LOCAL TYPES                                                                */
+/******************************************************************************/
+
+/******************************************************************************/
+/* LOCAL VARIABLES                                                            */
+/******************************************************************************/
+
+/******************************************************************************/
+/* LOCAL FUNCTIONS                                                            */
+/******************************************************************************/
+
+/******************************************************************************/
+/* EXPORTED FUNCTIONS                                                         */
+/******************************************************************************/
+
+/* general single register access */
+
+
+void print_pal_error(VL53L0X_Error Status){
+    char buf[VL53L0X_MAX_STRING_LENGTH];
+    VL53L0X_GetPalErrorString(Status, buf);
+    chprintf((BaseSequentialStream*)&SD1,"\t\tAPI Status: %i : %s\n", Status, buf);
+}
+
+
+
+void print_range_status(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);
+    chprintf((BaseSequentialStream*)&SD1,"Range Status: %i : %s\n", RangeStatus, buf);
+
+}
+
+
+/**
+ * @brief vl53l0x_lld_init useses the Vl53L0X functions so init the sensor. This function are VL53L0X_DataInit (performs the device initialization)
+ * and VL53L0X_StaticInit (allows to load device settings specific for a given use case). These two function need 40 ms to perform.
+ *
+ * @param[in] vl53l0x
+ * @return
+ */
+
+
+apalExitStatus_t vl53l0x_lld_init(VL53L0XDriver* vl53l0x)
+{
+
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+    VL53L0X_DeviceInfo_t DeviceInfo;
+
+
+    if(status == VL53L0X_ERROR_NONE)
+        {
+            chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_DataInit\n");
+            status = VL53L0X_DataInit(&(vl53l0x->vl53l0x_dev)); // Data initialization
+            print_pal_error(status);
+        }
+
+
+    if(status == VL53L0X_ERROR_NONE)
+       {
+           status = VL53L0X_GetDeviceInfo(&(vl53l0x->vl53l0x_dev), &DeviceInfo);
+           if(status == VL53L0X_ERROR_NONE)
+           {
+               chprintf((BaseSequentialStream*)&SD1,"VL53L0X_GetDeviceInfo:\n");
+               chprintf((BaseSequentialStream*)&SD1,"\tDevice Name : %s\n", DeviceInfo.Name);
+               chprintf((BaseSequentialStream*)&SD1,"\tDevice Type : %s\n", DeviceInfo.Type);
+               chprintf((BaseSequentialStream*)&SD1,"\tDevice ID : %s\n", DeviceInfo.ProductId);
+               chprintf((BaseSequentialStream*)&SD1,"\tProductRevisionMajor : %d\n", DeviceInfo.ProductRevisionMajor);
+           chprintf((BaseSequentialStream*)&SD1,"\tProductRevisionMinor : %d\n", DeviceInfo.ProductRevisionMinor);
+
+           if ((DeviceInfo.ProductRevisionMinor != 1) && (DeviceInfo.ProductRevisionMinor != 1)) {
+               chprintf((BaseSequentialStream*)&SD1,"Error expected cut 1.1 but found cut %d.%d\n",
+                          DeviceInfo.ProductRevisionMajor, DeviceInfo.ProductRevisionMinor);
+                   status = VL53L0X_ERROR_NOT_SUPPORTED;
+               }
+           }
+           print_pal_error(status);
+    }
+
+
+    /* static init and tests*/
+    uint32_t refSpadCount;
+    uint8_t isApertureSpads;
+    uint8_t VhvSettings;
+    uint8_t PhaseCal;
+
+    if(status == VL53L0X_ERROR_NONE)
+    {
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_StaticInit\n");
+        status = VL53L0X_StaticInit(&(vl53l0x->vl53l0x_dev)); // Device Initialization
+       print_pal_error(status);
+    }
+
+
+    /* START Load calibration data*/
+
+
+    // need to be done after VL53L0X_StaticInit and before VL53L0X_PerformRefCalibration. In order to optimize the
+    // dynamic of the system, the reference SPADs have to be calibrated
+    // there are three different possibilities to set the Parameter
+    /*
+            - calibration has not been performed -> VL53L0X_PerformRefSpadManagement
+            - Host has not programmed the number and type of SPADs -> VL53L0X_SetReferenceSpads
+            - get the number and type of reference SPADs programmed into the device NVM -> VL53L0X_GetReferenceSpads
+
+     */
+    if(status == VL53L0X_ERROR_NONE)
+    {
+        // only test
+       status = VL53L0X_GetReferenceSpads(&(vl53l0x->vl53l0x_dev), &refSpadCount, &isApertureSpads);
+       chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_GetReferenceSpads with refSpadCount:%lu and isApertureSpads:%u \n", refSpadCount, isApertureSpads);
+
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_PerformRefSpadManagement\n");
+        status |= VL53L0X_PerformRefSpadManagement(&(vl53l0x->vl53l0x_dev),
+                &refSpadCount, &isApertureSpads); // Device Initialization
+        chprintf((BaseSequentialStream*)&SD1,"\trefSpadCount = %d, isApertureSpads = %d\n", refSpadCount, isApertureSpads);
+        print_pal_error(status);
+        if(status == -6){
+            status  = VL53L0X_ERROR_NONE;
+        }
+    }
+
+
+
+
+    // calibration of two parameters (VHV and phase cal) which are temperature dependent,  it should be
+    // performed again when temperature varies more than 8degC compared to the initial calibration temperature
+    // if the user has previously performed a calibration and stored the two parameters in the Host memory we can use VL53L0X_SetRefCalibration
+    if(status == VL53L0X_ERROR_NONE)
+    {
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_PerformRefCalibration\n");
+        status = VL53L0X_PerformRefCalibration(&(vl53l0x->vl53l0x_dev),
+                &VhvSettings, &PhaseCal); // Device Initialization
+        print_pal_error(status);
+        if(status == -6){
+            status  = VL53L0X_ERROR_NONE;
+        }
+    }
+
+
+    //Offset is get via VL53L0X_GetDeviceParameters in VL53L0X_DataInit
+    //VL53L0X_SetOffsetCalibrationDataMicroMeter();
+
+    // ross-talk correction is set in VL53L0X_DataInit to 0.
+    // the Host will have to program the cross-talk correction factor and enable the cross-talk correction
+
+    /* End Load calibration data*/
+
+
+
+    // Enable/Disable Sigma and Signal check
+    // why are no values set?? with VL53L0X_SetLimitCheckValue
+    if (status == VL53L0X_ERROR_NONE) {
+        status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+    }
+
+    // why are no values seet?? with VL53L0X_SetLimitCheckValue
+    if (status == VL53L0X_ERROR_NONE) {
+        status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+    }
+
+
+
+    // Signal rate minimum threshold. Measurements with signal rates below this value are ignored.
+    //This ensures that false measurements are not made due to reflection from the housing.
+    if (status == VL53L0X_ERROR_NONE) {
+        status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 1);
+    }
+
+    if (status == VL53L0X_ERROR_NONE) {
+        status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+                (FixPoint1616_t)(1.5*0.023*65536));
+    }
+    /* end static init and some tests */
+
+
+    return status;
+
+
+}
+
+
+/**
+ * @brief vl53l0x_lld_set_mode set one of the thre possible modes.
+ * @param vl53l0x[in]
+ * @param mode[in] one of the VL53L0X_DeviceModes, VL53L0X_DEVICEMODE_SINGLE_RANGING == 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING == 1,
+ *                  VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING == 3
+ * @param interrupt[in] set one of the different interrupt modes: VL53L0X_GPIOFUNCTIONALITY_OFF == 0 no interrupt,
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW == 1 Level Low (value < thresh_low),
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH == 2 Level High (value > thresh_high),
+ *                      VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT == 3 value < thresh_low OR value > thresh_high,
+ *                      VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY == 4 New Sample Ready.
+ *                      The Interruptpolarity is set to low, an interrupt is created if HIGH changes to LOW.
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_set_mode(VL53L0XDriver* vl53l0x, VL53L0X_DeviceModes mode, VL53L0X_GpioFunctionality interrupt,
+                                      FixPoint1616_t low, FixPoint1616_t high)
+{
+
+    uint32_t ThresholdLow;
+    uint32_t ThresholdHigh;
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+    if(status == VL53L0X_ERROR_NONE)
+    {
+
+        // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_SetDeviceMode\n");
+        status = VL53L0X_SetDeviceMode(&(vl53l0x->vl53l0x_dev), mode); // Setup in single ranging mode
+        print_pal_error(status);
+    }
+
+
+    if(status == VL53L0X_ERROR_NONE)
+    {
+        // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_SetGpioConfig\n");
+        status = VL53L0X_SetGpioConfig(&(vl53l0x->vl53l0x_dev), 0, mode, interrupt, VL53L0X_INTERRUPTPOLARITY_LOW);
+        print_pal_error(status);
+    }
+
+
+    if(status == VL53L0X_ERROR_NONE && interrupt != VL53L0X_GPIOFUNCTIONALITY_OFF)
+    {
+
+        // multiplication with 65536 is imported, no clue why!
+        // in single ranging high and low must be below 255, otherwise there will be no interrupt. In the other two modes the ranging is a few ms slower!
+        if(mode == VL53L0X_DEVICEMODE_SINGLE_RANGING && (low > 254 || high > 254)){
+            chprintf((BaseSequentialStream*)&SD1,"Device mode is VL53L0X_DEVICEMODE_SINGLE_RANGING and therefore we get no Interrupt if the interrupt "
+                                                 "threshold is bigger than 254 mm\n");
+        }
+
+        ThresholdLow = low * 65536;
+        ThresholdHigh = high * 65536;
+
+
+
+        // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
+        chprintf((BaseSequentialStream*)&SD1,"Call of VL53L0X_SetInterruptThresholds\n");
+        status = VL53L0X_SetInterruptThresholds(&(vl53l0x->vl53l0x_dev),interrupt,ThresholdLow ,ThresholdHigh);
+        print_pal_error(status);
+    }
+
+    return status;
+
+
+
+
+    /*High Accurancy
+
+    // Enable/Disable Sigma and Signal check
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                (FixPoint1616_t)(0.25*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                (FixPoint1616_t)(18*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&(vl53l0x->vl53l0x_dev),
+                200000);
+    }
+
+    */
+
+    /*High Speed
+
+    // Enable/Disable Sigma and Signal check
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                (FixPoint1616_t)(0.25*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                (FixPoint1616_t)(32*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&(vl53l0x->vl53l0x_dev),
+                30000);
+    }
+
+
+    */
+
+    /*Long Range
+
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckEnable(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+                (FixPoint1616_t)(0.1*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetLimitCheckValue(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+                (FixPoint1616_t)(60*65536));
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(&(vl53l0x->vl53l0x_dev),
+                33000);
+    }
+
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetVcselPulsePeriod(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_VCSEL_PERIOD_PRE_RANGE, 18);
+    }
+    if (Status == VL53L0X_ERROR_NONE) {
+        Status = VL53L0X_SetVcselPulsePeriod(&(vl53l0x->vl53l0x_dev),
+                VL53L0X_VCSEL_PERIOD_FINAL_RANGE, 14);
+    }
+
+    */
+
+
+}
+
+/**
+ * @brief vl53l0x_lld_start_measurement, use this method for interrupt mode. You must call vl53l0x_lld_set_mode beforehand.
+ * @param vl53l0x
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_start_measurement(VL53L0XDriver* vl53l0x)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    status = VL53L0X_StartMeasurement(&(vl53l0x->vl53l0x_dev));
+
+    if(status == VL53L0X_ERROR_NONE)
+    {
+        // no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
+        chprintf((BaseSequentialStream*)&SD1,"Successful startet measurement\n");
+        print_pal_error(status);
+    }else{
+        chprintf((BaseSequentialStream*)&SD1,"Error in startet measurement\n");
+        print_pal_error(status);
+    }
+
+    return status;
+
+}
+
+
+
+apalExitStatus_t vl53l0x_lld_stop_measurement(VL53L0XDriver* vl53l0x)
+{
+
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    status = VL53L0X_StopMeasurement(&(vl53l0x->vl53l0x_dev));
+
+    return status;
+}
+
+/**
+ * @brief vl53l0x_lld_perform_mesaurement with delay and not interrupts ! No need to call vl53l0x_lld_set_mode.
+ *
+ * write 16 Byte to 80, FF, 00, 91, 00, FF 80, 00
+ *  -> read 00 and get 00 back
+ * listen on 13 till we get 44 back
+ * write the data from sensor 14 -> 12 B , 12 single BYTES_PER_DWORD
+ * clear things: 0B -> 01 and 0B -> 00
+ *
+ * @param vl53l0x
+ * @param data
+ * @param timeout
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_perform_mesaurement(VL53L0XDriver* vl53l0x, uint16_t* data)
+{
+    //the information of the measurement is saved in although in vl53l0x->vl53l0x_dev.Data.LastRangeMeasure, but only after VL53L0X_PerformSingleRangingMeasurement
+    // is called
+    VL53L0X_RangingMeasurementData_t    RangingMeasurementData;
+    VL53L0X_RangingMeasurementData_t   *pRangingMeasurementData    = &RangingMeasurementData;
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+    status = VL53L0X_PerformSingleMeasurement(&(vl53l0x->vl53l0x_dev));
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_GetRangingMeasurementData(&(vl53l0x->vl53l0x_dev),
+            pRangingMeasurementData);
+
+
+    if (status == VL53L0X_ERROR_NONE)
+        status = VL53L0X_ClearInterruptMask(&(vl53l0x->vl53l0x_dev), 0);
+
+
+
+    data[0] = RangingMeasurementData.RangeMilliMeter;
+    //chprintf((BaseSequentialStream*)&SD1, "Measured distance: %i\n\n", RangingMeasurementData.RangeMilliMeter);
+
+
+    //TODO write millimeter to data
+    //data = &RangingMeasurementData.RangeMilliMeter;
+
+    return status;
+}
+
+/**
+ * @brief vl53l0x_lld_CheckRangingDataReady custom method, because in api was a strange phenonom
+ * @param vl53l0x[in]
+ * @param pMeasurementDataReady[in]
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_CheckRangingDataReady(VL53L0XDriver* vl53l0x, uint8_t *pMeasurementDataReady)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+    uint8_t sysRangeStatusRegister;
+    uint8_t interruptConfig;
+    uint32_t interruptMask;
+    //LOG_FUNCTION_START("");
+   interruptConfig = vl53l0x->vl53l0x_dev.Data.DeviceSpecificParameters.Pin0GpioFunctionality;
+    if (interruptConfig !=
+        VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED) {
+        status = VL53L0X_GetInterruptMaskStatus(&(vl53l0x->vl53l0x_dev), &interruptMask);
+        if (interruptMask == interruptConfig)
+            *pMeasurementDataReady = 1;
+        else
+            *pMeasurementDataReady = 0;
+
+    } else {
+        status = VL53L0X_RdByte(&(vl53l0x->vl53l0x_dev), VL53L0X_REG_RESULT_RANGE_STATUS,
+            &sysRangeStatusRegister);
+        if (status == VL53L0X_ERROR_NONE) {
+            if (sysRangeStatusRegister & 0x01)
+                *pMeasurementDataReady = 1;
+            else
+                *pMeasurementDataReady = 0;
+        }
+    }
+
+    //LOG_FUNCTION_END(status);
+    return status;
+}
+
+/**
+ * @brief vl53l0x_lld_getRangingData
+ * @param vl53l0x
+ * @param pRangingMeasurementData
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_getRangingData(VL53L0XDriver* vl53l0x, VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
+{
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    status = VL53L0X_GetRangingMeasurementData(&(vl53l0x->vl53l0x_dev),
+        pRangingMeasurementData);
+
+    status |= VL53L0X_ClearInterruptMask(&(vl53l0x->vl53l0x_dev), 0);
+
+    return status;
+}
+
+
+
+/**
+ * @brief vl53l0x_lld_set_address
+ * @param vl53l0x
+ * @param new_address
+ * @return
+ */
+apalExitStatus_t vl53l0x_lld_set_address(VL53L0XDriver* vl53l0x, uint8_t new_address)
+{
+
+    VL53L0X_Error status = VL53L0X_ERROR_NONE;
+    status = VL53L0X_SetDeviceAddress(&(vl53l0x->vl53l0x_dev), new_address );
+    return status;
+}
+
+
+/*
+
+
+  examples for continous getting examples without interrupt
+
+
+
+
+    uint32_t measurement;
+    uint32_t no_of_measurements = 32;
+
+    uint16_t* pResults = (uint16_t*)malloc(sizeof(uint16_t) * no_of_measurements);
+
+    for(measurement=0; measurement<no_of_measurements; measurement++)
+    {
+
+        Status = WaitMeasurementDataReady(&(vl53l0x->vl53l0x_dev));
+
+        if(Status == VL53L0X_ERROR_NONE)
+        {
+            Status = VL53L0X_GetRangingMeasurementData(&(vl53l0x->vl53l0x_dev), pRangingMeasurementData);
+
+            *(pResults + measurement) = pRangingMeasurementData->RangeMilliMeter;
+            printf("In loop measurement %ld: %d\n", measurement, pRangingMeasurementData->RangeMilliMeter);
+
+            // Clear the interrupt
+            VL53L0X_ClearInterruptMask(&(vl53l0x->vl53l0x_dev), VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+            usleep(20);
+            //VL53L0X_PollingDelay(&(vl53l0x->vl53l0x_dev);
+        } else {
+            break;
+        }
+    }
+
+    if(Status == VL53L0X_ERROR_NONE)
+    {
+        for(measurement=0; measurement<no_of_measurements; measurement++)
+        {
+            printf("measurement %ld: %d\n", measurement, *(pResults + measurement));
+        }
+    }
+    data = &pResults[0];
+
+    free(pResults);
+
+
+
+    example for measurement with interrupt single
+
+
+    example for measurement with interrupt continious
+
+*/
+
+
+/**
+ * @brief WaitMeasurementDataReady.
+ * @param Dev
+ * @return
+ */
+VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev) {
+    VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+    uint8_t NewDatReady=0;
+    uint32_t LoopNb;
+
+    // Wait until it finished
+    // use timeout to avoid deadlock
+    if (Status == VL53L0X_ERROR_NONE) {
+        LoopNb = 0;
+        do {
+            Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDatReady);
+            if ((NewDatReady == 0x01) || Status != VL53L0X_ERROR_NONE) {
+                break;
+            }
+            LoopNb = LoopNb + 1;
+            // sleep for 50 ms
+            usleep(50);
+        } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
+
+        if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
+            Status = VL53L0X_ERROR_TIME_OUT;
+        }
+    }
+
+    return Status;
+}
+
+
+//#define VL53L0X_POLLINGDELAY_LOOPNB  250
+//int32_t VL53L0X_PollingDelay(VL53L0X_DEV Dev){
+//    int32_t status = VL53L0X_ERROR_NONE;
+//    //LOG_FUNCTION_START("");
+
+////    const DWORD cTimeout_ms = 1;
+//    usleep(1000);
+
+////    HANDLE hEvent = CreateEvent(0, TRUE, FALSE, 0);
+////    if(hEvent != NULL)
+////    {
+////        WaitForSingleObject(hEvent,cTimeout_ms);
+////    }
+
+//    //LOG_FUNCTION_END(status);
+//    return status;
+//}
+
+
+/*============================================================================*/
+/* threshold register access                                                  */
+/*============================================================================*/
+
+
+#endif /* defined(AMIROLLD_CFG_VL53L0X) && (AMIROLLD_CFG_VL53L0X == 1) */
+
+/** @} */
+
+
+
+
