Revision 13:3f1b341901dd, committed 2021-06-11

Comitter:

Charles MacNeill

Date:

Fri Jun 11 17:08:27 2021 +0100

Parent:

12:0fd8afb7f950

Commit message:

changing case of vl53l1cb.* so it works in linux

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/inc/VL53L1CB.h	Fri Jun 11 17:08:27 2021 +0100
@@ -0,0 +1,699 @@
+/*******************************************************************************
+ * @file    vl53l1x_class.h
+ * @author  JS
+ * @version V0.0.1
+ * @date    15-January-2019
+ * @brief   Header file for VL53L1 sensor component
+ ******************************************************************************
+ Copyright © 2019, 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 __VL53L1X_CLASS_H
+#define __VL53L1X_CLASS_H
+
+
+
+/* Includes ------------------------------------------------------------------*/
+
+#include "mbed.h"
+#include "PinNames.h"
+
+#include "RangeSensor.h"
+#include "Stmpe1600.h"
+
+#include "vl53l1_error_codes.h"
+#include "vl53l1_platform_user_data.h"
+
+//#include "DevI2C.h"
+#include "ToF_I2C.h"
+/**********************************************************/
+#include "vl53l1_def.h"
+/***********************************************************/
+
+
+#define VL53L1CB_IMPLEMENTATION_VER_MAJOR       1
+#define VL53L1CB_IMPLEMENTATION_VER_MINOR       0
+#define VL53L1CB_IMPLEMENTATION_VER_SUB         1
+#define VL53L1CB_IMPLEMENTATION_VER_REVISION  0000
+
+typedef int8_t VL53L1CB_ERROR;
+
+//#define SOFT_RESET                                          0x0000
+#define VL53L1CB_I2C_SLAVE__DEVICE_ADDRESS                    0x0001
+#define VL53L1CB_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND        0x0008
+#define ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS      0x0016
+#define ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS  0x0018
+#define ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS  0x001A
+#define ALGO__PART_TO_PART_RANGE_OFFSET_MM                  0x001E
+#define MM_CONFIG__INNER_OFFSET_MM                          0x0020
+#define MM_CONFIG__OUTER_OFFSET_MM                          0x0022
+#define GPIO_HV_MUX__CTRL                                   0x0030
+#define GPIO__TIO_HV_STATUS                                 0x0031
+#define SYSTEM__INTERRUPT_CONFIG_GPIO                       0x0046
+#define PHASECAL_CONFIG__TIMEOUT_MACROP                     0x004B
+#define RANGE_CONFIG__TIMEOUT_MACROP_A_HI                   0x005E
+#define RANGE_CONFIG__VCSEL_PERIOD_A                        0x0060
+#define RANGE_CONFIG__VCSEL_PERIOD_B                        0x0063
+#define RANGE_CONFIG__TIMEOUT_MACROP_B_HI                   0x0061
+#define RANGE_CONFIG__TIMEOUT_MACROP_B_LO                   0x0062
+#define RANGE_CONFIG__SIGMA_THRESH                          0x0064
+#define RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS         0x0066
+#define RANGE_CONFIG__VALID_PHASE_HIGH                      0x0069
+#define SYSTEM__THRESH_HIGH                                 0x0072
+#define SYSTEM__THRESH_LOW                                  0x0074
+#define SD_CONFIG__WOI_SD0                                  0x0078
+#define SD_CONFIG__INITIAL_PHASE_SD0                        0x007A
+#define ROI_CONFIG__USER_ROI_CENTRE_SPAD                    0x007F
+#define ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE       0x0080
+#define SYSTEM__SEQUENCE_CONFIG                             0x0081
+#define SYSTEM__INTERRUPT_CLEAR                             0x0086
+#define SYSTEM__MODE_START                                  0x0087
+#define RESULT__AMBIENT_COUNT_RATE_MCPS_SD                  0x0090
+#define VL53L1CB_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0               0x0096
+#define VL53L1CB_FIRMWARE__SYSTEM_STATUS                      0x00E5
+
+
+
+#define VL53L1CB_DEFAULT_DEVICE_ADDRESS                      0x52
+
+#define VL53L1CB_REG_IDENTIFICATION_MODEL_ID                 0x010F
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/**
+ *  @brief defines SW Version
+ */
+//typedef struct {
+ //   uint8_t      major;    /*!< major number */
+//    uint8_t      minor;    /*!< minor number */
+//    uint8_t      build;    /*!< build number */
+//    uint32_t     revision; /*!< revision number */
+//} VL53L1X_Version_t;
+
+
+/* Classes -------------------------------------------------------------------*/
+/** Class representing a VL53L1CB sensor component
+ */
+class VL53L1CB : public RangeSensor
+{
+ 
+
+ 
+ public:
+ 
+ 
+ #define VL53L1DevStructGetLLDriverHandle(Dev) (&Dev->Data.LLData)
+    /** Constructor
+     * @param[in] &i2c device I2C to be used for communication
+     * @param[in] &pin_gpio1 pin Mbed InterruptIn PinName to be used as component GPIO_1 INT
+     * @param[in] DevAddr device address, 0x52 by default
+     */
+/*
+    VL53L1CB(ToF_DevI2C *i2c, DigitalOut *pin, PinName pin_gpio1, uint8_t dev_addr = VL53L1CB_DEFAULT_DEVICE_ADDRESS) 
+    : RangeSensor(), dev_i2c(i2c), _gpio0(pin)
+    {
+        MyDevice.i2c_slave_address=dev_addr;
+        Device = &MyDevice;
+               
+        _expgpio0 = NULL;
+        if (pin_gpio1 != NC) {
+            _gpio1Int = new InterruptIn(pin_gpio1);
+        } else {
+            _gpio1Int = NULL;
+        }
+    }
+*/
+    
+    /** Constructor 2 (STMPE1600DigiOut)
+     * @param[in] i2c device I2C to be used for communication
+     * @param[in] &pin Gpio Expander STMPE1600DigiOut pin to be used as component GPIO_0 CE
+     * @param[in] pin_gpio1 pin Mbed InterruptIn PinName to be used as component GPIO_1 INT
+     * @param[in] device address, 0x29 by default
+     */
+    VL53L1CB(ToF_DevI2C *i2c, Stmpe1600DigiOut *pin, PinName pin_gpio1,
+            uint8_t dev_addr = VL53L1CB_DEFAULT_DEVICE_ADDRESS) 
+            : dev_i2c(i2c), _expgpio0(pin)
+    {
+        MyDevice.i2c_slave_address=dev_addr;
+        Device = &MyDevice;
+               
+        _gpio0 = NULL;
+        if (pin_gpio1 != NC) {
+            _gpio1Int = new InterruptIn(pin_gpio1);
+        } else {
+            _gpio1Int = NULL;
+        }
+    }    
+    
+   /** Destructor
+    */
+    virtual ~VL53L1CB()
+    {        
+        if (_gpio1Int != NULL) {
+            delete _gpio1Int;
+        }
+    }
+    
+        
+    
+    VL53L1_DEV getDevicePtr() { return Device; }
+
+    
+    /* warning: VL53L1CB class inherits from GenericSensor, RangeSensor and LightSensor, that haven`t a destructor.
+       The warning should request to introduce a virtual destructor to make sure to delete the object */
+
+    /*** Interface Methods ***/
+    /*** High level API ***/
+    /**
+     * @brief       PowerOn the sensor
+     * @return      void
+     */
+    /* turns on the sensor */
+    virtual void VL53L1CB_On(void)
+    {
+        printf("VL53L1CB_On\r\n");
+        if (_gpio0) {
+            *_gpio0 = 1;
+        } else {
+            if (_expgpio0) {
+                *_expgpio0 = 1;
+            }
+        }
+#if (MBED_VERSION  > 60300) 
+    thread_sleep_for(100);
+#else
+    wait_ms(100);  // NEEDS A DELAY BETWEEN SENSORS
+#endif
+    }
+
+    /**
+     * @brief       PowerOff the sensor
+     * @return      void
+     */
+    /* turns off the sensor */
+    virtual void VL53L1CB_Off(void)
+    {
+        printf("VL53L1_Off\r\n");
+        if (_gpio0) {
+            *_gpio0 = 0;
+        } else {
+            if (_expgpio0) {
+                *_expgpio0 = 0;
+            }
+        }
+#if (MBED_VERSION  > 60300) 
+    thread_sleep_for(100);
+#else
+    wait_ms(100);  // NEEDS A DELAY BETWEEN SENSORS
+#endif
+    }
+    
+    int is_present()
+    {
+        int status;
+        uint8_t id = 0;
+
+        status = read_id(&id);
+        if (status) {
+            printf("Failed to read ID device. Device not present!\n\r");
+        }
+        return status;
+    }
+
+    /**
+     * @brief       Initialize the sensor with default values
+     * @return      0 on Success
+     */
+     
+     VL53L1CB_ERROR InitSensor(uint8_t address){
+        VL53L1CB_ERROR status = 0;
+        uint8_t sensorState = 0;
+        VL53L1CB_Off();
+        VL53L1CB_On();
+        status = VL53L1CB_SetI2CAddress(address);
+        if(!status){
+            status = VL53L1CB_SensorInit();
+        }      
+     
+        while(!status && !sensorState) {
+            status = VL53L1CB_BootState(&sensorState);
+
+#if (MBED_VERSION  > 60300) 
+        thread_sleep_for(2);
+#else
+        wait_ms(2);  // NEEDS A DELAY BETWEEN SENSORS
+#endif
+        }           
+        return status;
+     }
+
+
+
+/**
+ *
+ * @brief One time device initialization
+ * @param void
+ * @return     0 on success,  @a #CALIBRATION_WARNING if failed
+ */
+    virtual int init(void *init)
+    {
+         return VL53L1CB_SensorInit();
+         return 0;
+    }
+
+
+    /**
+     * @brief       Initialize the sensor with default values
+     * @return      "0" on success
+     */
+    int init_sensor(uint8_t new_addr);
+
+    /* Read function of the ID device */
+    virtual int read_id(uint8_t *id){
+        int status = 0;
+        uint16_t rl_id = 0;
+    
+        uint8_t ExpanderData[2];
+    
+        ExpanderData[0] = 0;
+        ExpanderData[1] = 0;
+        rl_id = 0;
+        dev_i2c->ToF_i2c_read(&ExpanderData[0], Device->i2c_slave_address, VL53L1CB_REG_IDENTIFICATION_MODEL_ID, 2);
+    
+        rl_id = (ExpanderData[0] << 8) + ExpanderData[1];
+        printf("Model ID is: %d (%X)  \r\n",rl_id, rl_id);
+    
+        uint8_t tmp = 0;
+        ExpanderData[0] = VL53L1CB_FIRMWARE__SYSTEM_STATUS >> 8;
+        ExpanderData[1] = VL53L1CB_FIRMWARE__SYSTEM_STATUS & 0x0FF;
+        dev_i2c->ToF_i2c_read(&tmp, Device->i2c_slave_address, VL53L1CB_FIRMWARE__SYSTEM_STATUS, 1);
+
+        printf("Firmware system is: %d\r\n",tmp);
+    
+        if (rl_id == 0xEACC) {
+            printf("Device is present %d:\r\n", rl_id);
+            return status;
+        }
+        return -1;
+    }
+
+
+    /**
+     * @brief       Interrupt handling func to be called by user after an INT is occurred
+     * @param[out]  Data pointer to the distance to read data in to
+     * @return      0 on Success
+     */
+    int handle_irq(uint16_t *distance);
+
+    /**
+     * @brief       Start the measure indicated by operating mode
+     * @param[in]   fptr specifies call back function must be !NULL in case of interrupt measure
+     * @return      0 on Success
+     */
+    int start_measurement(void (*fptr)(void));
+    /**
+     * @brief       Stop the currently running measure indicate by operating_mode
+     * @return      0 on Success
+     */
+    int stop_measurement();
+    /**
+     * @brief       Get results for the measure
+     * @param[out]  Data pointer to the distance_data to read data in to
+     * @return      0 on Success
+     */
+    int get_measurement(uint16_t *distance);
+    /**
+     * @brief       Enable interrupt measure IRQ
+     * @return      0 on Success
+     */
+    void enable_interrupt_measure_detection_irq(void)
+    {
+        if (_gpio1Int != NULL)
+            _gpio1Int->enable_irq();
+    }
+
+    /**
+     * @brief       Disable interrupt measure IRQ
+     * @return      0 on Success
+     */
+    void disable_interrupt_measure_detection_irq(void)
+    {
+        if (_gpio1Int != NULL)
+            _gpio1Int->disable_irq();
+    }
+    /**
+     * @brief       Attach a function to call when an interrupt is detected, i.e. measurement is ready
+     * @param[in]   fptr pointer to call back function to be called whenever an interrupt occours
+     * @return      0 on Success
+     */
+    void attach_interrupt_measure_detection_irq(void (*fptr)(void))
+    {
+        if (_gpio1Int != NULL)
+            _gpio1Int->rise(fptr);
+    }
+
+/**
+ * @brief Get ranging result and only that
+ * @param pRange_mm  Pointer to range distance
+ * @return           0 on success
+ */
+    virtual int get_distance(uint32_t *piData)
+    {
+    int status;
+    uint16_t distance;
+    status = VL53L1CB_GetDistance(&distance);
+    *piData = (uint32_t) distance;
+    return status;
+    }
+
+
+/* VL53L1X_api.h functions */
+
+
+
+    /**
+     * @brief This function returns the SW driver version
+     */
+    VL53L1CB_ERROR VL53L1CB_GetSWVersion(VL53L1_Version_t *pVersion);
+
+    /**
+     * @brief This function sets the sensor I2C address used in case multiple devices application, default address 0x52
+     */
+    VL53L1CB_ERROR VL53L1CB_SetI2CAddress(uint8_t new_address);
+
+    /**
+     * @brief This function loads the 135 bytes default values to initialize the sensor.
+     * @param dev Device address
+     * @return 0:success, != 0:failed
+     */
+    VL53L1CB_ERROR VL53L1CB_SensorInit();
+
+    /**
+     * @brief This function clears the interrupt, to be called after a ranging data reading
+     * to arm the interrupt for the next data ready event.
+     */
+    VL53L1CB_ERROR VL53L1CB_ClearInterrupt();
+
+
+    /**
+     * @brief This function returns the current interrupt polarity\n
+     * 1=active high (default), 0=active low
+     */
+    VL53L1CB_ERROR VL53L1CB_GetInterruptPolarity(uint8_t *pIntPol);
+
+    /**
+     * @brief This function starts the ranging distance operation\n
+     * The ranging operation is continuous. The clear interrupt has to be done after each get data to allow the interrupt to raise when the next data is ready\n
+     * 1=active high (default), 0=active low, use SetInterruptPolarity() to change the interrupt polarity if required.
+     */
+    VL53L1CB_ERROR VL53L1CB_StartRanging();
+
+    /**
+     * @brief This function stops the ranging.
+     */
+    VL53L1CB_ERROR VL53L1CB_StopRanging();
+
+
+
+    /**
+     * @brief This function returns the boot state of the device (1:booted, 0:not booted)
+     */
+    VL53L1CB_ERROR VL53L1CB_BootState(uint8_t *state);
+
+    /**
+     * @brief This function returns the sensor id, sensor Id must be 0xEEAC
+     */
+  //  VL53L1CB_ERROR VL53L1X_GetSensorId(uint16_t *id);
+
+    /**
+     * @brief This function returns the distance measured by the sensor in mm
+     */
+    VL53L1CB_ERROR VL53L1CB_GetDistance(uint16_t *distance);
+
+
+    
+    
+    /**************************************************************************/
+    VL53L1CB_ERROR VL53L1CB_WaitDeviceBooted(VL53L1_DEV Dev);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetCalibrationData(VL53L1_CalibrationData_t  *pCalibrationData);
+        
+    
+    
+    VL53L1_GPIO_Interrupt_Mode ConvertModeToLLD(VL53L1CB_ERROR *pStatus,
+        VL53L1_ThresholdMode CrossMode);
+      
+    VL53L1CB_ERROR VL53L1CB_GetVersion(VL53L1_Version_t *pVersion);
+    
+    VL53L1CB_ERROR VL53L1CB_GetProductRevision(
+    uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetDeviceInfo(
+    VL53L1_DeviceInfo_t *pVL53L1_DeviceInfo);
+    
+    VL53L1CB_ERROR VL53L1CB_GetUID( uint64_t *pUid);
+    
+    VL53L1CB_ERROR VL53L1CB_GetRangeStatusString(uint8_t RangeStatus,
+    char *pRangeStatusString);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetPalErrorString(VL53L1CB_ERROR PalErrorCode,
+    char *pPalErrorString);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetPalStateString(VL53L1_State PalStateCode,
+    char *pPalStateString);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetPalState(VL53L1_DEV Dev, VL53L1_State *pPalState);
+    
+    VL53L1CB_ERROR VL53L1CB_DataInit();
+    
+    VL53L1CB_ERROR VL53L1CB_StaticInit();
+        
+    VL53L1CB_ERROR VL53L1CB_ClearInterruptAndStartMeasurement();
+    
+    VL53L1CB_ERROR VL53L1CB_GetRangingMeasurementData(
+        VL53L1_RangingMeasurementData_t *pRangingMeasurementData);
+
+    VL53L1CB_ERROR VL53L1CB_GetMultiRangingData(
+        VL53L1_MultiRangingData_t *pMultiRangingData);   
+        
+    VL53L1CB_ERROR VL53L1CB_GetAdditionalData(
+                VL53L1_AdditionalData_t *pAdditionalData);
+                
+    VL53L1CB_ERROR VL53L1CB_SetTuningParameter(
+        uint16_t TuningParameterId, int32_t TuningParameterValue);
+        
+    VL53L1CB_ERROR VL53L1CB_GetTuningParameter(
+        uint16_t TuningParameterId, int32_t *pTuningParameterValue);
+  
+    VL53L1CB_ERROR VL53L1CB_SetXTalkCompensationEnable(
+         uint8_t XTalkCompensationEnable);
+         
+         
+    VL53L1CB_ERROR VL53L1CB_GetXTalkCompensationEnable(
+            uint8_t *pXTalkCompensationEnable);
+                       
+    VL53L1CB_ERROR VL53L1CB_PerformXTalkCalibration(
+    uint8_t CalibrationOption);
+    
+    VL53L1CB_ERROR VL53L1CB_SetOffsetCalibrationMode(
+            VL53L1_OffsetCalibrationModes OffsetCalibrationMode);
+            
+
+    VL53L1CB_ERROR VL53L1CB_SetOffsetCorrectionMode(
+            VL53L1_OffsetCorrectionModes OffsetCorrectionMode);
+        
+    VL53L1CB_ERROR VL53L1CB_PerformOffsetCalibration(
+            int32_t CalDistanceMilliMeter, FixPoint1616_t CalReflectancePercent);
+            
+    VL53L1CB_ERROR VL53L1CB_PerformOffsetSimpleCalibration(
+             int32_t CalDistanceMilliMeter);
+    
+    VL53L1CB_ERROR VL53L1CB_PerformOffsetZeroDistanceCalibration();
+    
+    VL53L1CB_ERROR VL53L1CB_SetCalibrationData(
+        VL53L1_CalibrationData_t *pCalibrationData);
+        
+    VL53L1CB_ERROR VL53L1CB_SetZoneCalibrationData(
+        VL53L1_ZoneCalibrationData_t *pZoneCalibrationData);
+        
+    VL53L1CB_ERROR VL53L1CB_GetZoneCalibrationData(
+        VL53L1_ZoneCalibrationData_t  *pZoneCalibrationData);
+        
+    VL53L1CB_ERROR VL53L1CB_GetOpticalCenter(
+        FixPoint1616_t *pOpticalCenterX,
+        FixPoint1616_t *pOpticalCenterY);
+        
+    VL53L1CB_ERROR VL53L1CB_SetThresholdConfig(VL53L1_DetectionConfig_t *pConfig);
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetLimitCheckStatus( uint16_t LimitCheckId,
+                                              uint8_t *pLimitCheckStatus);    
+                                              
+        
+    VL53L1CB_ERROR VL53L1CB_SetLimitCheckEnable( uint16_t LimitCheckId,
+                                             uint8_t LimitCheckEnable);
+        
+    VL53L1CB_ERROR VL53L1CB_GetLimitCheckEnable(uint16_t LimitCheckId,
+                                             uint8_t *pLimitCheckEnable);
+    
+    VL53L1CB_ERROR VL53L1CB_GetThresholdConfig(VL53L1_DetectionConfig_t *pConfig);
+        
+        
+    VL53L1CB_ERROR VL53L1CB_PerformOffsetPerVcselCalibration(int32_t CalDistanceMilliMeter);
+  
+    VL53L1CB_ERROR VL53L1CB_GetNumberOfLimitCheck(uint16_t *pNumberOfLimitCheck);      
+    
+    VL53L1CB_ERROR VL53L1CB_GetLimitCheckInfo(uint16_t LimitCheckId,
+                                           char *pLimitCheckString);       
+        
+    VL53L1CB_ERROR VL53L1CB_SetPresetMode(VL53L1_PresetModes PresetMode);
+        
+    VL53L1CB_ERROR VL53L1CB_GetPresetMode( VL53L1_PresetModes *pPresetMode);
+                                    
+    VL53L1CB_ERROR VL53L1CB_SetDistanceMode( VL53L1_DistanceModes DistanceMode);
+                                                                                    
+    VL53L1CB_ERROR VL53L1CB_GetDistanceMode(VL53L1_DistanceModes *pDistanceMode);
+                                             
+    VL53L1CB_ERROR VL53L1CB_SetOutputMode(VL53L1_OutputModes OutputMode);
+                                           
+    VL53L1CB_ERROR VL53L1CB_GetOutputMode(VL53L1_OutputModes *pOutputMode);
+                                        
+    VL53L1CB_ERROR VL53L1CB_SetMeasurementTimingBudgetMicroSeconds(uint32_t MeasurementTimingBudgetMicroSeconds);
+                                    
+    VL53L1CB_ERROR VL53L1CB_SetInterMeasurementPeriodMilliSeconds(uint32_t InterMeasurementPeriodMilliSeconds);
+                                   
+    
+    VL53L1CB_ERROR VL53L1CB_GetInterMeasurementPeriodMilliSeconds(
+            uint32_t *pInterMeasurementPeriodMilliSeconds);
+        
+        
+    VL53L1CB_ERROR VL53L1CB_SetDmaxReflectance( FixPoint1616_t DmaxReflectance);
+                                                
+    VL53L1CB_ERROR VL53L1CB_GetDmaxReflectance(FixPoint1616_t *pDmaxReflectance);
+                                                
+                                                
+    VL53L1CB_ERROR VL53L1CB_GetDmaxMode( VL53L1_DeviceDmaxModes *pDmaxMode);    
+                                    
+    VL53L1CB_ERROR VL53L1CB_GetMeasurementTimingBudgetMicroSeconds(
+                                 uint32_t *pMeasurementTimingBudgetMicroSeconds);  
+                                 
+    VL53L1CB_ERROR VL53L1CB_SetDmaxMode(VL53L1_DeviceDmaxModes DmaxMode);    
+                                     
+    VL53L1CB_ERROR VL53L1CB_SetLimitCheckValue( uint16_t LimitCheckId,
+                                            FixPoint1616_t LimitCheckValue);
+                                            
+    VL53L1CB_ERROR VL53L1CB_GetLimitCheckValue(uint16_t LimitCheckId,
+                                            FixPoint1616_t *pLimitCheckValue);   
+                                            
+    VL53L1CB_ERROR VL53L1CB_GetLimitCheckCurrent( uint16_t LimitCheckId,
+                                              FixPoint1616_t *pLimitCheckCurrent);   
+                                            
+    VL53L1CB_ERROR VL53L1CB_GetMaxNumberOfROI( uint8_t *pMaxNumberOfROI);    
+                                           
+    VL53L1CB_ERROR VL53L1CB_SetROI(VL53L1_RoiConfig_t *pRoiConfig);
+                                
+    VL53L1CB_ERROR VL53L1CB_GetROI(VL53L1_RoiConfig_t *pRoiConfig);
+                                 
+    VL53L1CB_ERROR VL53L1CB_GetNumberOfSequenceSteps(uint8_t *pNumberOfSequenceSteps);          
+    
+    VL53L1CB_ERROR VL53L1CB_GetSequenceStepsInfo(VL53L1_SequenceStepId SequenceStepId,
+                                              char *pSequenceStepsString);   
+                                              
+                                              
+    VL53L1CB_ERROR VL53L1CB_SetSequenceStepEnable(VL53L1_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled);    
+        
+        
+    VL53L1CB_ERROR VL53L1CB_GetSequenceStepEnable(VL53L1_SequenceStepId SequenceStepId, uint8_t *pSequenceStepEnabled); 
+           
+    
+    VL53L1CB_ERROR VL53L1CB_StartMeasurement();
+    
+    VL53L1CB_ERROR VL53L1CB_StopMeasurement();
+    
+    
+    VL53L1CB_ERROR VL53L1CB_GetMeasurementDataReady(uint8_t *pMeasurementDataReady); 
+                                                 
+    VL53L1CB_ERROR VL53L1CB_WaitMeasurementDataReady();        
+    
+    VL53L1CB_ERROR VL53L1CB_SmudgeCorrectionEnable(VL53L1_SmudgeCorrectionModes Mode);                                                                                                                                                    
+    /***************************************************************************/
+    
+
+    /* Write and read functions from I2C */
+
+    VL53L1CB_ERROR VL53L1CB_WrByte(VL53L1_DEV dev, uint16_t index, uint8_t data);
+    VL53L1CB_ERROR VL53L1CB_WrWord(VL53L1_DEV dev, uint16_t index, uint16_t data);
+    VL53L1CB_ERROR VL53L1CB_WrDWord(VL53L1_DEV dev, uint16_t index, uint32_t data);
+    VL53L1CB_ERROR VL53L1CB_RdByte(VL53L1_DEV dev, uint16_t index, uint8_t *data);
+    VL53L1CB_ERROR VL53L1CB_RdWord(VL53L1_DEV dev, uint16_t index, uint16_t *data);
+    VL53L1CB_ERROR VL53L1CB_RdDWord(VL53L1_DEV dev, uint16_t index, uint32_t *data);
+    VL53L1CB_ERROR VL53L1CB_UpdateByte(VL53L1_DEV dev, uint16_t index, uint8_t AndData, uint8_t OrData);
+
+    VL53L1CB_ERROR VL53L1CB_WriteMulti(VL53L1_DEV Dev, uint16_t index, uint8_t *pdata, uint32_t count);
+    VL53L1CB_ERROR VL53L1CB_ReadMulti(VL53L1_DEV Dev, uint16_t index, uint8_t *pdata, uint32_t count);
+
+    VL53L1CB_ERROR VL53L1CB_I2CWrite(uint8_t dev, uint16_t index, uint8_t *data, uint16_t number_of_bytes);
+    VL53L1CB_ERROR VL53L1CB_I2CRead(uint8_t dev, uint16_t index, uint8_t *data, uint16_t number_of_bytes);
+    VL53L1CB_ERROR VL53L1CB_GetTickCount(uint32_t *ptick_count_ms);
+    VL53L1CB_ERROR VL53L1CB_WaitUs(VL53L1_Dev_t *pdev, int32_t wait_us);
+    VL53L1CB_ERROR VL53L1CB_WaitMs(VL53L1_Dev_t *pdev, int32_t wait_ms);
+    
+    VL53L1CB_ERROR VL53L1CB_WaitValueMaskEx(VL53L1_Dev_t *pdev, uint32_t timeout_ms, uint16_t index, uint8_t value, uint8_t mask, uint32_t poll_delay_ms);
+    VL53L1CB_ERROR VL53L1CB_SetDeviceAddress(VL53L1_DEV Dev, uint8_t DeviceAddress);
+    
+    // from vl53l1_api_debug.c
+
+    VL53L1CB_ERROR VL53L1CB_get_additional_data(
+        VL53L1_DEV                       Dev,
+        VL53L1_additional_data_t        *pdata);
+
+
+ protected:
+
+    /* IO Device */
+    ToF_DevI2C *dev_i2c;
+    
+    /* Digital out pin */
+    DigitalOut *_gpio0;
+    /* GPIO expander */
+    Stmpe1600DigiOut *_expgpio0;
+    /* Measure detection IRQ */
+    InterruptIn *_gpio1Int;
+ 
+    ///* Digital out pin */
+    /* Device data */
+    VL53L1_Dev_t MyDevice;
+    VL53L1_DEV Device;
+};
+
+
+#endif /* _VL53L1X_CLASS_H_ */
\ No newline at end of file