AMiRo-OS

#include <alld_VL53L1X.h>

//#include "vl53l1_platform.h"

#include <vl53l1_api.h>

// #include "vl53l1_platform_log.h"

// #include "stm32xxx_hal.h"

#include <string.h>

apalExitStatus_t hello_world(void){

    return APAL_STATUS_OK;

}

/**

 * @brief Set the GPIO1 to a specific state.

 * @param[in]   ledp        The LED driver object.

 * @param[in]   led_state   The state to set the LED to.

 * @return                  An indicator whether the call was successful.

 */

apalExitStatus_t vl53l1x_GPIO1_set(const VL53L1XDriver* const vlx, const gpio_lld_state_t state)

{

  apalDbgAssert(vlx != NULL);

  return apalControlGpioSet(vlx->xshut, (state == GPIO_LLD_STATE_ON) ? APAL_GPIO_ON : APAL_GPIO_OFF);

}

// #define I2C_TIME_OUT_BASE   10

// #define I2C_TIME_OUT_BYTE   1

// #ifdef VL53L1_LOG_ENABLE

// #define trace_print(level, ...) VL53L1_trace_print_module_function(VL53L1_TRACE_MODULE_PLATFORM, level, VL53L1_TRACE_FUNCTION_NONE, ##__VA_ARGS__)

// #define trace_i2c(...) VL53L1_trace_print_module_function(VL53L1_TRACE_MODULE_NONE, VL53L1_TRACE_LEVEL_NONE, VL53L1_TRACE_FUNCTION_I2C, ##__VA_ARGS__)

// #endif

// #ifndef HAL_I2C_MODULE_ENABLED

// #warning "HAL I2C module must be enable "

// #endif

//extern I2C_HandleTypeDef hi2c1;

//#define VL53L0X_pI2cHandle    (&hi2c1)

/* when not customized by application define dummy one */

// #ifndef VL53L1_GetI2cBus

/** This macro can be overloaded by user to enforce i2c sharing in RTOS context

 */

// #   define VL53L1_GetI2cBus(...) (void)0

// #endif

// #ifndef VL53L1_PutI2cBus

/** This macro can be overloaded by user to enforce i2c sharing in RTOS context

 */

// #   define VL53L1_PutI2cBus(...) (void)0

// #endif

#define I2C_TIME_OUT_BASE   10

#define I2C_TIME_OUT_BYTE   1

uint8_t _I2CBuffer[256] = { 0 };

uint8_t rx_buf[256];

uint8_t tx_buf[256];

int _I2CWrite(VL53L1_DEV Dev, uint8_t *pdata, uint32_t count) {

    int status = 0;

    int i2c_time_out = 1000 * (I2C_TIME_OUT_BASE + count * I2C_TIME_OUT_BYTE);

    apalExitStatus_t status2 = apalI2CMasterTransmit(Dev->vl53l1x.i2cd, Dev->vl53l1x.addr, pdata, count, rx_buf, 0, 100);

    return status;

}

int _I2CRead(VL53L1_DEV Dev, uint8_t *pdata, uint32_t count) {

   int status = 0;

//   apalI2CMasterReceive(Dev->vl53l1x->i2cd, Dev->vl53l1x->addr, uint8_t* const rxbuf, const size_t rxbytes, const apalTime_t timeout)

   return status;

}

// TODO: Needs to be defined

VL53L1_Error VL53L1_WriteMulti(VL53L1_DEV Dev, uint16_t index, uint8_t *pdata, uint32_t count) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

// the ranging_sensor_comms.dll will take care of the page selection

VL53L1_Error VL53L1_ReadMulti(VL53L1_DEV Dev, uint16_t index, uint8_t *pdata, uint32_t count) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_WrByte(VL53L1_DEV Dev, uint16_t index, uint8_t data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    // printf("Starting to write byte: %X\n", data);

     int32_t status_int;

    _I2CBuffer[0] = index>>8;

    _I2CBuffer[1] = index&0xFF;

    _I2CBuffer[2] = data;

    _I2CWrite(Dev, _I2CBuffer, 3);

    return Status;

}

VL53L1_Error VL53L1_WrWord(VL53L1_DEV Dev, uint16_t index, uint16_t data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_WrDWord(VL53L1_DEV Dev, uint16_t index, uint32_t data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_UpdateByte(VL53L1_DEV Dev, uint16_t index, uint8_t AndData, uint8_t OrData) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_RdByte(VL53L1_DEV Dev, uint16_t index, uint8_t *data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    uint8_t indx[2] = { index >> 8, index & 0xFF };

    apalExitStatus_t status2 = apalI2CMasterTransmit(Dev->vl53l1x.i2cd, Dev->vl53l1x.addr, indx, 2, data, 1, 0);

    return Status;

}

VL53L1_Error VL53L1_RdWord(VL53L1_DEV Dev, uint16_t index, uint16_t *data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_RdDWord(VL53L1_DEV Dev, uint16_t index, uint32_t *data) {

    VL53L1_Error Status = VL53L1_ERROR_NONE;

    return Status;

}

VL53L1_Error VL53L1_GetTickCount(

	uint32_t *ptick_count_ms)

{

	VL53L1_Error status  = VL53L1_ERROR_NONE;

	return status;

}

//#define trace_print(level, ...) \

//	_LOG_TRACE_PRINT(VL53L1_TRACE_MODULE_PLATFORM, \

//	level, VL53L1_TRACE_FUNCTION_NONE, ##__VA_ARGS__)

//#define trace_i2c(...) \

//	_LOG_TRACE_PRINT(VL53L1_TRACE_MODULE_NONE, \

//	VL53L1_TRACE_LEVEL_NONE, VL53L1_TRACE_FUNCTION_I2C, ##__VA_ARGS__)

VL53L1_Error VL53L1_GetTimerFrequency(int32_t *ptimer_freq_hz)

{

	VL53L1_Error status  = VL53L1_ERROR_NONE;

	return status;

}

VL53L1_Error VL53L1_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms){

	VL53L1_Error status  = VL53L1_ERROR_NONE;

	return status;

}

VL53L1_Error VL53L1_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us){

	VL53L1_Error status  = VL53L1_ERROR_NONE;

	return status;

}

VL53L1_Error VL53L1_WaitValueMaskEx(

	VL53L1_Dev_t *pdev,

	uint32_t      timeout_ms,

	uint16_t      index,

	uint8_t       value,

	uint8_t       mask,

	uint32_t      poll_delay_ms)

{

	VL53L1_Error status  = VL53L1_ERROR_NONE;

	return status;

}

/**

 * @file    alld_VL53L1X.h

 * @brief   Touch sensor macros and structures.

 *

 * @addtogroup lld_touch

 * @{

 */

#ifndef AMIROLLD_VL53L1X_H

#define AMIROLLD_VL53L1X_H

#include <amiro-lld.h>

#include <alld_VL53L1X_types.h>

#include <vl53l1_api.h>

/******************************************************************************/

/* CONSTANTS                                                                  */

/******************************************************************************/

// 400kHz

#define VL53L1X_LLD_I2C_MAXFREQUENCY 400000

/* Default I2C address */

/* #define VL53L1X_LLD_I2C_ADDR_DEFAULT      0x52 */

#define VL53L1X_LLD_I2C_ADDR_DEFAULT           0x29

#define VL53L1X_LLD_BOOTDURATION     1200

/******************************************************************************/

/* SETTINGS                                                                   */

/******************************************************************************/

/******************************************************************************/

/* CHECKS                                                                     */

/******************************************************************************/

/******************************************************************************/

/* DATA STRUCTURES AND TYPES                                                  */

/******************************************************************************/

/**

 * @brief The state of the GPIOs.

 */

typedef enum {

  GPIO_LLD_STATE_OFF = 0x00,   /**< 'on' state of the LED */

  GPIO_LLD_STATE_ON  = 0x01,   /**< 'off' state of the LED */

} gpio_lld_state_t;

/******************************************************************************/

/* MACROS                                                                     */

/******************************************************************************/

/******************************************************************************/

/* EXTERN DECLARATIONS                                                        */

/******************************************************************************/

#ifdef __cplusplus

extern "C" {

#endif

  apalExitStatus_t hello_world(void);

  apalExitStatus_t vl53l1x_GPIO1_set(const VL53L1XDriver* const vlx, const gpio_lld_state_t state);

#ifdef __cplusplus

}

#endif

/******************************************************************************/

/* INLINE FUNCTIONS                                                           */

/******************************************************************************/

#endif /* AMIROLLD_VL53L1X_H */

################################################################################

# 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 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 General Public License for more details.                                 #

#                                                                              #

# You should have received a copy of the GNU General Public License            #

# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #

#                                                                              #

# This research/work was supported by the Cluster of Excellence Cognitive      #

# Interaction Technology 'CITEC' (EXC 277) at Bielefeld University, which is   #

# funded by the German Research Foundation (DFG).                              #

################################################################################

# path to this directory

AMIROLLD_ST_VL53L1X := $(dir $(lastword $(MAKEFILE_LIST)))

# include paths

AMIROLLD_INC += $(AMIROLLD_ST_VL53L1X) \

				$(AMIROLLD_ST_VL53L1X)/api/core \

				$(AMIROLLD_ST_VL53L1X)/api/platform \

# $(info    AMIROLLD_INC is $(AMIROLLD_INC))

# C source files

AMIROLLD_CSRC += $(AMIROLLD_ST_VL53L1X)alld_VL53L1X.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api_calibration.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api_core.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api_debug.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api_preset_modes.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api_strings.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_api.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_core_support.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_core.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_error_strings.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_register_funcs.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_silicon_core.c \

				 $(AMIROLLD_ST_VL53L1X)api/core/vl53l1_wait.c \

# $(info    AMIROLLD_CSRC is $(AMIROLLD_CSRC))

#ifndef AMIROLLD_VL53L1X_TYPES_H

#define AMIROLLD_VL53L1X_TYPES_H

#include <amiro-lld.h>

/**

 * @brief The VL53L1X driver struct

 */

typedef struct {

  apalI2CDriver_t* i2cd;

  apalI2Caddr_t addr;       /**< @brief The I2C Driver.     */

  const apalControlGpio_t* gpio1;

  const apalControlGpio_t* xshut;

} VL53L1XDriver;

#endif

/*

* Copyright (c) 2017, STMicroelectronics - All Rights Reserved

*

* This file is part of VL53L1 Core and is dual licensed,

* either 'STMicroelectronics

* Proprietary license'

* or 'BSD 3-clause "New" or "Revised" License' , at your option.

*

********************************************************************************

*

* 'STMicroelectronics Proprietary license'

*

********************************************************************************

*

* License terms: STMicroelectronics Proprietary in accordance with licensing

* terms at www.st.com/sla0081

*

* STMicroelectronics confidential

* Reproduction and Communication of this document is strictly prohibited unless

* specifically authorized in writing by STMicroelectronics.

*

*

********************************************************************************

*

* Alternatively, VL53L1 Core may be distributed under the terms of

* 'BSD 3-clause "New" or "Revised" License', in which case the following

* provisions apply instead of the ones mentioned above :

*

********************************************************************************

*

* License terms: BSD 3-clause "New" or "Revised" License.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* 1. Redistributions of source code must retain the above copyright notice, this

* list of conditions and the following disclaimer.

*

* 2. 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.

*

* 3. Neither the name of the copyright holder 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 AND FITNESS FOR A PARTICULAR PURPOSE ARE

* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS 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 "vl53l1_api.h"

#include "vl53l1_api_strings.h"

#include "vl53l1_register_settings.h"

#include "vl53l1_register_funcs.h"

#include "vl53l1_core.h"

#include "vl53l1_api_calibration.h"

#include "vl53l1_wait.h"

#include "vl53l1_preset_setup.h"

#include "vl53l1_api_debug.h"

#include "vl53l1_api_core.h"

/* Check for minimum user zone requested by Xtalk calibration */

/* no need for VL53L1_MAX_USER_ZONES check, set 5 to pass the test */

#define ZONE_CHECK 5

#if ZONE_CHECK < 5

#error Must define at least 5 zones in MAX_USER_ZONES constant

#endif

#ifdef VL53L1_NOCALIB

#define OFFSET_CALIB_EMPTY

#endif

#ifndef VL53L1_NOCALIB

#define OFFSET_CALIB

#endif

#define LOG_FUNCTION_START(fmt, ...) \

	_LOG_FUNCTION_START(VL53L1_TRACE_MODULE_API, fmt, ##__VA_ARGS__)

#define LOG_FUNCTION_END(status, ...) \

	_LOG_FUNCTION_END(VL53L1_TRACE_MODULE_API, status, ##__VA_ARGS__)

#define LOG_FUNCTION_END_FMT(status, fmt, ...) \

	_LOG_FUNCTION_END_FMT(VL53L1_TRACE_MODULE_API, status, \

			fmt, ##__VA_ARGS__)

#ifdef VL53L1_LOG_ENABLE

#define trace_print(level, ...) trace_print_module_function(\

		VL53L1_TRACE_MODULE_API, level, VL53L1_TRACE_FUNCTION_NONE, \

		##__VA_ARGS__)

#endif

#ifndef MIN

#define MIN(v1, v2) ((v1) < (v2) ? (v1) : (v2))

#endif

#ifndef MAX

#define MAX(v1, v2) ((v1) < (v2) ? (v2) : (v1))

#endif

#define DMAX_REFLECTANCE_IDX 2

/* Use Dmax index 2 because it's the 50% reflectance case by default */

/* Following LOWPOWER_AUTO figures have been measured observing vcsel

 * emissions on an actual device

 */

#define LOWPOWER_AUTO_VHV_LOOP_DURATION_US 245

#define LOWPOWER_AUTO_OVERHEAD_BEFORE_A_RANGING 1448

#define LOWPOWER_AUTO_OVERHEAD_BETWEEN_A_B_RANGING 2100

#define FDA_MAX_TIMING_BUDGET_US 550000

/* Maximum timing budget allowed codex #456189*/

/* local static utilities functions */

/* Bare Driver Tuning parameter table indexed with VL53L1_Tuning_t */

static int32_t BDTable[VL53L1_TUNING_MAX_TUNABLE_KEY] = {

		TUNING_VERSION,

		TUNING_PROXY_MIN,

		TUNING_SINGLE_TARGET_XTALK_TARGET_DISTANCE_MM,

		TUNING_SINGLE_TARGET_XTALK_SAMPLE_NUMBER,

		TUNING_MIN_AMBIENT_DMAX_VALID,

		TUNING_MAX_SIMPLE_OFFSET_CALIBRATION_SAMPLE_NUMBER,

		TUNING_XTALK_FULL_ROI_TARGET_DISTANCE_MM,

		TUNING_SIMPLE_OFFSET_CALIBRATION_REPEAT

};

#define VL53L1_NVM_POWER_UP_DELAY_US             50

#define VL53L1_NVM_READ_TRIGGER_DELAY_US          5

static VL53L1_Error VL53L1_nvm_enable(

	VL53L1_DEV      Dev,

	uint16_t        nvm_ctrl_pulse_width,

	int32_t         nvm_power_up_delay_us)

{

	/*

	 * Sequence below enables NVM for reading

	 *

	 *  - Enable power force

	 *  - Disable firmware

	 *  - Power up NVM

	 *  - Wait for 50us while the NVM powers up

	 *  - Configure for reading and set the pulse width (16-bit)

	 */

	VL53L1_Error status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	/* Disable Firmware */

	if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/

		status = VL53L1_disable_firmware(Dev);

	/* Enable Power Force  */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_enable_powerforce(Dev);

	/* Wait the required time for the regulators, bandgap,

	 * oscillator to wake up and settle

	 */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WaitUs(

					Dev,

					VL53L1_ENABLE_POWERFORCE_SETTLING_TIME_US);

	/*  Power up NVM */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WrByte(

					Dev,

					VL53L1_RANGING_CORE__NVM_CTRL__PDN,

					0x01);

	/* Enable NVM Clock */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WrByte(

					Dev,

					VL53L1_RANGING_CORE__CLK_CTRL1,

					0x05);

	/* Wait the required time for NVM to power up*/

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WaitUs(

					Dev,

					nvm_power_up_delay_us);

	/* Select read mode and set control pulse width */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WrByte(

					Dev,

					VL53L1_RANGING_CORE__NVM_CTRL__MODE,

					0x01);

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WrWord(

					Dev,

					VL53L1_RANGING_CORE__NVM_CTRL__PULSE_WIDTH_MSB,

					nvm_ctrl_pulse_width);

	LOG_FUNCTION_END(status);

	return status;

}

static VL53L1_Error VL53L1_nvm_read(

	VL53L1_DEV    Dev,

	uint8_t       start_address,

	uint8_t       count,

	uint8_t      *pdata)

{

	/*

	 * Sequence per 32-bit NVM read access:

	 *

	 * - Set up the 5-bit (0-127) NVM Address

	 * - Trigger the read of the NVM data by toggling NVM_CTRL__READN

	 * - Read the NVM data - 4 bytes wide read/write interface

	 * - Increment data byte pointer by 4 ready for the next loop

	 */

	VL53L1_Error status   = VL53L1_ERROR_NONE;

	uint8_t      nvm_addr = 0;

	LOG_FUNCTION_START("");

	for (nvm_addr = start_address; nvm_addr < (start_address+count) ; nvm_addr++) {

		/* Step 1 : set address */

		if (status == VL53L1_ERROR_NONE)

			status = VL53L1_WrByte(

						Dev,

						VL53L1_RANGING_CORE__NVM_CTRL__ADDR,

						nvm_addr);

		/* Step 2 : trigger reading of data */

		if (status == VL53L1_ERROR_NONE)

			status = VL53L1_WrByte(

						Dev,

						VL53L1_RANGING_CORE__NVM_CTRL__READN,

						0x00);

		/* Step 3 : wait the required time */

		if (status == VL53L1_ERROR_NONE)

			status = VL53L1_WaitUs(

						Dev,

						VL53L1_NVM_READ_TRIGGER_DELAY_US);

		if (status == VL53L1_ERROR_NONE)

			status = VL53L1_WrByte(

						Dev,

						VL53L1_RANGING_CORE__NVM_CTRL__READN,

						0x01);

		/* Step 3 : read 4-byte wide data register */

		if (status == VL53L1_ERROR_NONE)

			status = VL53L1_ReadMulti(

						Dev,

						VL53L1_RANGING_CORE__NVM_CTRL__DATAOUT_MMM,

						pdata,

						4);

		/* Step 4 : increment byte buffer pointer */

		pdata = pdata + 4;

	}

	LOG_FUNCTION_END(status);

	return status;

}

static VL53L1_Error VL53L1_nvm_disable(

	VL53L1_DEV    Dev)

{

	/*

	 * Power down NVM (OTP) to extend lifetime

	 */

	VL53L1_Error status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/

		status = VL53L1_WrByte(

					Dev,

					VL53L1_RANGING_CORE__NVM_CTRL__READN,

					0x01);

	/* Power down NVM */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_WrByte(

					Dev,

					VL53L1_RANGING_CORE__NVM_CTRL__PDN,

					0x00);

	/* Keep power force enabled */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_disable_powerforce(Dev);

	/* (Re)Enable Firmware */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_enable_firmware(Dev);

	LOG_FUNCTION_END(status);

	return status;

}

static VL53L1_Error VL53L1_read_nvm_raw_data(

	VL53L1_DEV     Dev,

	uint8_t        start_address,

	uint8_t        count,

	uint8_t       *pnvm_raw_data)

{

	/*

	 * Reads ALL 512 bytes of NVM data

	 */

	VL53L1_Error status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	/*

	 *   Enable NVM and set control pulse width

	 */

	if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/

		status = VL53L1_nvm_enable(

					Dev,

					0x0004,

					VL53L1_NVM_POWER_UP_DELAY_US);

	/*

	 *  Read the raw NVM data

	 *        - currently all of 128 * 4 bytes = 512 bytes are read

	 */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_nvm_read(

			Dev,

			start_address,

			count,

			pnvm_raw_data);

	/*

	 *   Disable NVM

	 */

	if (status == VL53L1_ERROR_NONE)

		status = VL53L1_nvm_disable(Dev);

	LOG_FUNCTION_END(status);

	return status;

}

static VL53L1_Error SingleTargetXTalkCalibration(VL53L1_DEV Dev)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint32_t sum_ranging = 0;

	uint32_t sum_spads = 0;

	FixPoint1616_t sum_signalRate = 0;

	FixPoint1616_t total_count = 0;

	uint8_t xtalk_meas = 0;

	uint8_t xtalk_measmax =

		BDTable[VL53L1_TUNING_SINGLE_TARGET_XTALK_SAMPLE_NUMBER];

	VL53L1_RangingMeasurementData_t RMData;

	FixPoint1616_t xTalkStoredMeanSignalRate;

	FixPoint1616_t xTalkStoredMeanRange;

	FixPoint1616_t xTalkStoredMeanRtnSpads;

	uint32_t xTalkStoredMeanRtnSpadsAsInt;

	uint32_t xTalkCalDistanceAsInt;

	FixPoint1616_t XTalkCompensationRateMegaCps;

	uint32_t signalXTalkTotalPerSpad;

	VL53L1_PresetModes PresetMode;

	VL53L1_CalibrationData_t  CalibrationData;

	VL53L1_CustomerNvmManaged_t *pC;

	LOG_FUNCTION_START("");

	/* check if the following are selected

	 * VL53L1_PRESETMODE_AUTONOMOUS,

	 * VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS

	 * VL53L1_PRESETMODE_LITE_RANGING

	 */

	PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode);

	if ((PresetMode != VL53L1_PRESETMODE_AUTONOMOUS) &&

		(PresetMode != VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS) &&

		(PresetMode != VL53L1_PRESETMODE_LITE_RANGING)) {

		Status = VL53L1_ERROR_MODE_NOT_SUPPORTED;

		goto ENDFUNC;

	}

	/* disable crosstalk calibration */

	Status = VL53L1_disable_xtalk_compensation(Dev);

	CHECK_ERROR_GO_ENDFUNC;

	Status = VL53L1_StartMeasurement(Dev);

	CHECK_ERROR_GO_ENDFUNC;

	sum_ranging = 0;

	sum_spads = 0;

	sum_signalRate = 0;

	total_count = 0;

	for (xtalk_meas = 0; xtalk_meas < xtalk_measmax; xtalk_meas++) {

		VL53L1_WaitMeasurementDataReady(Dev);

		VL53L1_GetRangingMeasurementData(Dev, &RMData);

		VL53L1_ClearInterruptAndStartMeasurement(Dev);

		if (RMData.RangeStatus == VL53L1_RANGESTATUS_RANGE_VALID) {

			sum_ranging += RMData.RangeMilliMeter;

			sum_signalRate += RMData.SignalRateRtnMegaCps;

			sum_spads += RMData.EffectiveSpadRtnCount / 256;

			total_count++;

		}

	}

	Status = VL53L1_StopMeasurement(Dev);

	if (total_count > 0) {

		/* FixPoint1616_t / uint16_t = FixPoint1616_t */

		xTalkStoredMeanSignalRate = sum_signalRate / total_count;

		xTalkStoredMeanRange = (FixPoint1616_t)(sum_ranging << 16);

		xTalkStoredMeanRange /= total_count;

		xTalkStoredMeanRtnSpads = (FixPoint1616_t)(sum_spads << 16);

		xTalkStoredMeanRtnSpads /= 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 = ((uint32_t)BDTable[

			VL53L1_TUNING_SINGLE_TARGET_XTALK_TARGET_DISTANCE_MM]);

		if (xTalkStoredMeanRtnSpadsAsInt == 0 ||

		xTalkCalDistanceAsInt == 0 ||

		xTalkStoredMeanRange >= (xTalkCalDistanceAsInt << 16)) {

			XTalkCompensationRateMegaCps = 0;

		} else {

			/* 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 *= (((uint32_t)1 << 16) -

				(xTalkStoredMeanRange / xTalkCalDistanceAsInt));

			/* Round from 2^16 * Fixed1616, to Fixed1616. */

			XTalkCompensationRateMegaCps = (signalXTalkTotalPerSpad

				+ 0x8000) >> 16;

		}

		Status = VL53L1_GetCalibrationData(Dev, &CalibrationData);

		CHECK_ERROR_GO_ENDFUNC;

		pC = &CalibrationData.customer;

		pC->algo__crosstalk_compensation_plane_offset_kcps =

			(uint32_t)(1000 * ((XTalkCompensationRateMegaCps  +

				((uint32_t)1<<6)) >> (16-9)));

		Status = VL53L1_SetCalibrationData(Dev, &CalibrationData);

		CHECK_ERROR_GO_ENDFUNC;

		Status = VL53L1_enable_xtalk_compensation(Dev);

	} else

		/* return error because no valid data found */

		Status = VL53L1_ERROR_XTALK_EXTRACTION_NO_SAMPLE_FAIL;

ENDFUNC:

	LOG_FUNCTION_END(Status);

	return Status;

}

/* Check Rectangle in user's coordinate system:

 *	15	TL(x,y) o-----*

 *   ^			|     |

 *   |			*-----o BR(x,y)

 *   0------------------------- >15

 *   check Rectangle definition conforms to the (0,15,15) coordinate system

 *   with a minimum of 4x4 size

 */

static VL53L1_Error CheckValidRectRoi(VL53L1_UserRoi_t ROI)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	/* Negative check are not necessary because value is unsigned */

	if ((ROI.TopLeftX > 15) || (ROI.TopLeftY > 15) ||

		(ROI.BotRightX > 15) || (ROI.BotRightY > 15))

		Status = VL53L1_ERROR_INVALID_PARAMS;

	if ((ROI.TopLeftX > ROI.BotRightX) || (ROI.TopLeftY < ROI.BotRightY))

		Status = VL53L1_ERROR_INVALID_PARAMS;

	LOG_FUNCTION_END(Status);

	return Status;

}

static VL53L1_GPIO_Interrupt_Mode ConvertModeToLLD(VL53L1_Error *pStatus,

		VL53L1_ThresholdMode CrossMode)

{

	VL53L1_GPIO_Interrupt_Mode Mode;

	switch (CrossMode) {

	case VL53L1_THRESHOLD_CROSSED_LOW:

		Mode = VL53L1_GPIOINTMODE_LEVEL_LOW;

		break;

	case VL53L1_THRESHOLD_CROSSED_HIGH:

		Mode = VL53L1_GPIOINTMODE_LEVEL_HIGH;

		break;

	case VL53L1_THRESHOLD_OUT_OF_WINDOW:

		Mode = VL53L1_GPIOINTMODE_OUT_OF_WINDOW;

		break;

	case VL53L1_THRESHOLD_IN_WINDOW:

		Mode = VL53L1_GPIOINTMODE_IN_WINDOW;

		break;

	default:

		/* define Mode to avoid warning but actual value doesn't mind */

		Mode = VL53L1_GPIOINTMODE_LEVEL_HIGH;

		*pStatus = VL53L1_ERROR_INVALID_PARAMS;

	}

	return Mode;

}

static VL53L1_ThresholdMode ConvertModeFromLLD(VL53L1_Error *pStatus,

		VL53L1_GPIO_Interrupt_Mode CrossMode)

{

	VL53L1_ThresholdMode Mode;

	switch (CrossMode) {

	case VL53L1_GPIOINTMODE_LEVEL_LOW:

		Mode = VL53L1_THRESHOLD_CROSSED_LOW;

		break;

	case VL53L1_GPIOINTMODE_LEVEL_HIGH:

		Mode = VL53L1_THRESHOLD_CROSSED_HIGH;

		break;

	case VL53L1_GPIOINTMODE_OUT_OF_WINDOW:

		Mode = VL53L1_THRESHOLD_OUT_OF_WINDOW;

		break;

	case VL53L1_GPIOINTMODE_IN_WINDOW:

		Mode = VL53L1_THRESHOLD_IN_WINDOW;

		break;

	default:

		/* define Mode to avoid warning but actual value doesn't mind */

		Mode = VL53L1_THRESHOLD_CROSSED_HIGH;

		*pStatus = VL53L1_ERROR_UNDEFINED;

	}

	return Mode;

}

/* Group PAL General Functions */

VL53L1_Error VL53L1_GetVersion(VL53L1_Version_t *pVersion)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	pVersion->major = VL53L1_IMPLEMENTATION_VER_MAJOR;

	pVersion->minor = VL53L1_IMPLEMENTATION_VER_MINOR;

	pVersion->build = VL53L1_IMPLEMENTATION_VER_SUB;

	pVersion->revision = VL53L1_IMPLEMENTATION_VER_REVISION;

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetProductRevision(VL53L1_DEV Dev,

	uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t revision_id;

	VL53L1_LLDriverData_t   *pLLData;

	LOG_FUNCTION_START("");

	pLLData =  VL53L1DevStructGetLLDriverHandle(Dev);

	revision_id = pLLData->nvm_copy_data.identification__revision_id;

	*pProductRevisionMajor = 1;

	*pProductRevisionMinor = (revision_id & 0xF0) >> 4;

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetDeviceInfo(VL53L1_DEV Dev,

	VL53L1_DeviceInfo_t *pVL53L1_DeviceInfo)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t revision_id;

	VL53L1_LLDriverData_t   *pLLData;

	LOG_FUNCTION_START("");

	pLLData =  VL53L1DevStructGetLLDriverHandle(Dev);

	strncpy(pVL53L1_DeviceInfo->ProductId, "",

			VL53L1_DEVINFO_STRLEN-1);

	pVL53L1_DeviceInfo->ProductType =

			pLLData->nvm_copy_data.identification__module_type;

	revision_id = pLLData->nvm_copy_data.identification__revision_id;

	pVL53L1_DeviceInfo->ProductRevisionMajor = 1;

	pVL53L1_DeviceInfo->ProductRevisionMinor = (revision_id & 0xF0) >> 4;

#ifndef VL53L1_USE_EMPTY_STRING

	if (pVL53L1_DeviceInfo->ProductRevisionMinor == 0)

		strncpy(pVL53L1_DeviceInfo->Name,

				VL53L1_STRING_DEVICE_INFO_NAME0,

				VL53L1_DEVINFO_STRLEN-1);

	else

		strncpy(pVL53L1_DeviceInfo->Name,

				VL53L1_STRING_DEVICE_INFO_NAME1,

				VL53L1_DEVINFO_STRLEN-1);

	strncpy(pVL53L1_DeviceInfo->Type,

			VL53L1_STRING_DEVICE_INFO_TYPE,

			VL53L1_DEVINFO_STRLEN-1);

#else

	pVL53L1_DeviceInfo->Name[0] = 0;

	pVL53L1_DeviceInfo->Type[0] = 0;

#endif

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetRangeStatusString(uint8_t RangeStatus,

	char *pRangeStatusString)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	Status = VL53L1_get_range_status_string(RangeStatus,

		pRangeStatusString);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetPalErrorString(VL53L1_Error PalErrorCode,

	char *pPalErrorString)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	Status = VL53L1_get_pal_error_string(PalErrorCode, pPalErrorString);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetPalStateString(VL53L1_State PalStateCode,

	char *pPalStateString)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	Status = VL53L1_get_pal_state_string(PalStateCode, pPalStateString);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetPalState(VL53L1_DEV Dev, VL53L1_State *pPalState)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	*pPalState = VL53L1DevDataGet(Dev, PalState);

	LOG_FUNCTION_END(Status);

	return Status;

}

/* End Group PAL General Functions */

/* Group PAL Init Functions */

VL53L1_Error VL53L1_SetDeviceAddress(VL53L1_DEV Dev, uint8_t DeviceAddress)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	Status = VL53L1_WrByte(Dev, VL53L1_I2C_SLAVE__DEVICE_ADDRESS,

			DeviceAddress / 2);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_DataInit(VL53L1_DEV Dev)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t i;

	LOG_FUNCTION_START("");

	/* 2V8 power mode selection codex 447463 */

#ifdef USE_I2C_2V8

	Status = VL53L1_RdByte(Dev, VL53L1_PAD_I2C_HV__EXTSUP_CONFIG, &i);

	if (Status == VL53L1_ERROR_NONE) {

		i = (i & 0xfe) | 0x01;

		Status = VL53L1_WrByte(Dev, VL53L1_PAD_I2C_HV__EXTSUP_CONFIG,

				i);

	}

#endif

	if (Status == VL53L1_ERROR_NONE)

		Status = VL53L1_data_init(Dev, 1);

	if (Status == VL53L1_ERROR_NONE) {

		VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_WAIT_STATICINIT);

		VL53L1DevDataSet(Dev, CurrentParameters.PresetMode,

				VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS);

	}

	/* Enable all check */

	for (i = 0; i < VL53L1_CHECKENABLE_NUMBER_OF_CHECKS; i++) {

		if (Status == VL53L1_ERROR_NONE)

			Status |= VL53L1_SetLimitCheckEnable(Dev, i, 1);

		else

			break;

	}

	/* Limit default values */

	if (Status == VL53L1_ERROR_NONE) {

		Status = VL53L1_SetLimitCheckValue(Dev,

			VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE,

				(FixPoint1616_t)(18 * 65536));

	}

	if (Status == VL53L1_ERROR_NONE) {

		Status = VL53L1_SetLimitCheckValue(Dev,

			VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,

				(FixPoint1616_t)(25 * 65536 / 100));

				/* 0.25 * 65536 */

	}

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_StaticInit(VL53L1_DEV Dev)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t  measurement_mode;

	LOG_FUNCTION_START("");

	VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_IDLE);

	measurement_mode  = VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK;

	VL53L1DevDataSet(Dev, LLData.measurement_mode, measurement_mode);

	VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode,

			VL53L1_DISTANCEMODE_LONG);

	VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode,

			VL53L1_DISTANCEMODE_LONG);

	VL53L1DevDataSet(Dev, CurrentParameters.DistanceMode,

			VL53L1_DISTANCEMODE_LONG);

	/* ticket 472728 fix */

	Status = VL53L1_SetPresetMode(Dev,

			VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS);

	/* end of ticket 472728 fix */

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_WaitDeviceBooted(VL53L1_DEV Dev)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	Status = VL53L1_poll_for_boot_completion(Dev,

			VL53L1_BOOT_COMPLETION_POLLING_TIMEOUT_MS);

	LOG_FUNCTION_END(Status);

	return Status;

}

/* End Group PAL Init Functions */

/* Group PAL Parameters Functions */

static VL53L1_Error ComputeDevicePresetMode(

		VL53L1_PresetModes PresetMode,

		VL53L1_DistanceModes DistanceMode,

		VL53L1_DevicePresetModes *pDevicePresetMode)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t DistIdx;

	VL53L1_DevicePresetModes LightModes[3] = {

		VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_SHORT_RANGE,

		VL53L1_DEVICEPRESETMODE_STANDARD_RANGING,

		VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_LONG_RANGE};

	VL53L1_DevicePresetModes TimedModes[3] = {

		VL53L1_DEVICEPRESETMODE_TIMED_RANGING_SHORT_RANGE,

		VL53L1_DEVICEPRESETMODE_TIMED_RANGING,

		VL53L1_DEVICEPRESETMODE_TIMED_RANGING_LONG_RANGE};

	VL53L1_DevicePresetModes LowPowerTimedModes[3] = {

		VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_SHORT_RANGE,

		VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_MEDIUM_RANGE,

		VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_LONG_RANGE};

	*pDevicePresetMode = VL53L1_DEVICEPRESETMODE_STANDARD_RANGING;

	switch (DistanceMode) {

	case VL53L1_DISTANCEMODE_SHORT:

		DistIdx = 0;

		break;

	case VL53L1_DISTANCEMODE_MEDIUM:

		DistIdx = 1;

		break;

	default:

		DistIdx = 2;

	}

	switch (PresetMode) {

	case VL53L1_PRESETMODE_LITE_RANGING:

		*pDevicePresetMode = LightModes[DistIdx];

		break;

	case VL53L1_PRESETMODE_AUTONOMOUS:

		*pDevicePresetMode = TimedModes[DistIdx];

		break;

	case VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS:

		*pDevicePresetMode = LowPowerTimedModes[DistIdx];

		break;

	default:

		/* Unsupported mode */

		Status = VL53L1_ERROR_MODE_NOT_SUPPORTED;

	}

	return Status;

}

static VL53L1_Error SetPresetMode(VL53L1_DEV Dev,

		VL53L1_PresetModes PresetMode,

		VL53L1_DistanceModes DistanceMode,

		uint32_t inter_measurement_period_ms)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	VL53L1_DevicePresetModes   device_preset_mode;

	uint8_t measurement_mode;

	uint16_t dss_config__target_total_rate_mcps;

	uint32_t phasecal_config_timeout_us;

	uint32_t mm_config_timeout_us;

	uint32_t lld_range_config_timeout_us;

	LOG_FUNCTION_START("%d", (int)PresetMode);

	if ((PresetMode == VL53L1_PRESETMODE_AUTONOMOUS) ||

		(PresetMode == VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS))

		measurement_mode  = VL53L1_DEVICEMEASUREMENTMODE_TIMED;

	else

		measurement_mode  = VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK;

	Status = ComputeDevicePresetMode(PresetMode, DistanceMode,

			&device_preset_mode);

	if (Status == VL53L1_ERROR_NONE)

		Status =  VL53L1_get_preset_mode_timing_cfg(Dev,

				device_preset_mode,

				&dss_config__target_total_rate_mcps,

				&phasecal_config_timeout_us,

				&mm_config_timeout_us,

				&lld_range_config_timeout_us);

	if (Status == VL53L1_ERROR_NONE)

		Status = VL53L1_set_preset_mode(

				Dev,

				device_preset_mode,

				dss_config__target_total_rate_mcps,

				phasecal_config_timeout_us,

				mm_config_timeout_us,

				lld_range_config_timeout_us,

				inter_measurement_period_ms);

	if (Status == VL53L1_ERROR_NONE)

		VL53L1DevDataSet(Dev, LLData.measurement_mode, measurement_mode);

	if (Status == VL53L1_ERROR_NONE)

		VL53L1DevDataSet(Dev, CurrentParameters.PresetMode, PresetMode);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_SetPresetMode(VL53L1_DEV Dev, VL53L1_PresetModes PresetMode)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	VL53L1_DistanceModes DistanceMode = VL53L1_DISTANCEMODE_LONG;

	LOG_FUNCTION_START("%d", (int)PresetMode);

	Status = SetPresetMode(Dev,

			PresetMode,

			DistanceMode,

			1000);

	if (Status == VL53L1_ERROR_NONE) {

		VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode,

				DistanceMode);

		VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode,

				DistanceMode);

		if ((PresetMode == VL53L1_PRESETMODE_LITE_RANGING) ||

			(PresetMode == VL53L1_PRESETMODE_AUTONOMOUS) ||

			(PresetMode == VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS))

			Status = VL53L1_SetMeasurementTimingBudgetMicroSeconds(

				Dev, 41000);

		else

			/* Set default timing budget to 30Hz (33.33 ms)*/

			Status = VL53L1_SetMeasurementTimingBudgetMicroSeconds(

				Dev, 33333);

	}

	if (Status == VL53L1_ERROR_NONE) {

		/* Set default intermeasurement period to 1000 ms */

		Status = VL53L1_SetInterMeasurementPeriodMilliSeconds(Dev,

				1000);

	}

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetPresetMode(VL53L1_DEV Dev,

	VL53L1_PresetModes *pPresetMode)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	*pPresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_SetDistanceMode(VL53L1_DEV Dev,

		VL53L1_DistanceModes DistanceMode)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	VL53L1_PresetModes PresetMode;

	VL53L1_DistanceModes InternalDistanceMode;

	uint32_t inter_measurement_period_ms;

	uint32_t TimingBudget;

	uint32_t MmTimeoutUs;

	uint32_t PhaseCalTimeoutUs;

	VL53L1_user_zone_t user_zone;

	LOG_FUNCTION_START("%d", (int)DistanceMode);

	PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode);

	/* when the distance mode is valid:

	 * Manual Mode: all modes

	 * AUTO AUTO_LITE : LITE_RANGING, RANGING

	 */

	if ((DistanceMode != VL53L1_DISTANCEMODE_SHORT) &&

		(DistanceMode != VL53L1_DISTANCEMODE_MEDIUM) &&

		(DistanceMode != VL53L1_DISTANCEMODE_LONG))

		return VL53L1_ERROR_INVALID_PARAMS;

	/* The internal distance mode is limited to Short, Medium or

	 * long only

	*/

	if (Status == VL53L1_ERROR_NONE) {

		if ((DistanceMode == VL53L1_DISTANCEMODE_SHORT) ||

			(DistanceMode == VL53L1_DISTANCEMODE_MEDIUM))

			InternalDistanceMode = DistanceMode;

		else /* (DistanceMode == VL53L1_DISTANCEMODE_LONG) */

			InternalDistanceMode = VL53L1_DISTANCEMODE_LONG;

	}

	if (Status == VL53L1_ERROR_NONE)

		Status = VL53L1_get_user_zone(Dev, &user_zone);

	inter_measurement_period_ms =  VL53L1DevDataGet(Dev,

				LLData.inter_measurement_period_ms);

	if (Status == VL53L1_ERROR_NONE)

		Status = VL53L1_get_timeouts_us(Dev, &PhaseCalTimeoutUs,

			&MmTimeoutUs, &TimingBudget);

	if (Status == VL53L1_ERROR_NONE)

		Status = SetPresetMode(Dev,

				PresetMode,

				InternalDistanceMode,

				inter_measurement_period_ms);

	if (Status == VL53L1_ERROR_NONE) {

		VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode,

				InternalDistanceMode);

		VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode,

				InternalDistanceMode);

		VL53L1DevDataSet(Dev, CurrentParameters.DistanceMode,

				DistanceMode);

	}

	if (Status == VL53L1_ERROR_NONE) {

		Status = VL53L1_set_timeouts_us(Dev, PhaseCalTimeoutUs,

			MmTimeoutUs, TimingBudget);

		if (Status == VL53L1_ERROR_NONE)

			VL53L1DevDataSet(Dev, LLData.range_config_timeout_us,

				TimingBudget);

	}

	if (Status == VL53L1_ERROR_NONE)

		Status = VL53L1_set_user_zone(Dev, &user_zone);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_GetDistanceMode(VL53L1_DEV Dev,

	VL53L1_DistanceModes *pDistanceMode)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	LOG_FUNCTION_START("");

	*pDistanceMode = VL53L1DevDataGet(Dev, CurrentParameters.DistanceMode);

	LOG_FUNCTION_END(Status);

	return Status;

}

VL53L1_Error VL53L1_SetMeasurementTimingBudgetMicroSeconds(VL53L1_DEV Dev,

	uint32_t MeasurementTimingBudgetMicroSeconds)

{

	VL53L1_Error Status = VL53L1_ERROR_NONE;

	uint8_t Mm1Enabled;

	uint8_t Mm2Enabled;

	uint32_t TimingGuard;

	uint32_t divisor;

	uint32_t TimingBudget;

	uint32_t MmTimeoutUs;

	VL53L1_PresetModes PresetMode;

	uint32_t PhaseCalTimeoutUs;

	uint32_t vhv;

	int32_t vhv_loops;

	uint32_t FDAMaxTimingBudgetUs = FDA_MAX_TIMING_BUDGET_US;

	LOG_FUNCTION_START("");

	/* Timing budget is limited to 10 seconds */

	if (MeasurementTimingBudgetMicroSeconds > 10000000)

		Status = VL53L1_ERROR_INVALID_PARAMS;