Code petit robot

Dependencies:   VL6180x X_NUCLEO_COMMON X_NUCLEO_IHM01A1 mbed

Fork of 1-DoorCloser by Robotique FIP

Files at this revision

API Documentation at this revision

Comitter:
julientiron
Date:
Sat Apr 02 10:07:34 2016 +0000
Parent:
0:1cb50d31c3b5
Commit message:
ll

Changed in this revision

VL6180X/GenericSensor.h Show diff for this revision Revisions of this file
VL6180X/LightSensor.h Show diff for this revision Revisions of this file
VL6180X/RangeSensor.h Show diff for this revision Revisions of this file
VL6180X/vl6180x_cfg.h Show diff for this revision Revisions of this file
VL6180X/vl6180x_class.cpp Show diff for this revision Revisions of this file
VL6180X/vl6180x_class.h Show diff for this revision Revisions of this file
VL6180X/vl6180x_def.h Show diff for this revision Revisions of this file
VL6180X/vl6180x_platform.h Show diff for this revision Revisions of this file
VL6180X/vl6180x_types.h Show diff for this revision Revisions of this file
VL6180X_bis/GenericSensor.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/LightSensor.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/RangeSensor.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_cfg.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_class.cpp Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_class.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_def.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_platform.h Show annotated file Show diff for this revision Revisions of this file
VL6180X_bis/vl6180x_types.h Show annotated file Show diff for this revision Revisions of this file
VL6180x.lib Show annotated file Show diff for this revision Revisions of this file
X_NUCLEO_IHM01A1.lib Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
--- a/VL6180X/GenericSensor.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-/**
- ******************************************************************************
- * @file    GenericSensor.h
- * @author  AST / EST 
- * @version V0.0.1
- * @date    13-April-2015
- * @brief   This file contains the abstract class describing in general
- *          the interfaces of a generic sensor
- ******************************************************************************
- * @attention
- *
- * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * 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 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 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.
- *
- ******************************************************************************
- */
-
-/* Define to prevent from recursive inclusion --------------------------------*/
-#ifndef __GENERIC_SENSOR_CLASS_H
-#define __GENERIC_SENSOR_CLASS_H
-
-/* Includes ------------------------------------------------------------------*/
-#include <stdint.h>
-
-/* Classes  ------------------------------------------------------------------*/
-/** An abstract class for Generic sensors
- */
-class GenericSensor
-{
- public:
-    /**
-     * @brief       Initialization of sensor
-     * @param[out]  ptr Pointer to device specific initalization structure
-     * @return      0 in case of success, an error code otherwise
-     */
-    virtual int Init() = 0;
-
-    /**
-     * @brief       Get ID of sensor
-     * @param[out]  id Pointer to where to store the ID to
-     * @return      0 in case of success, an error code otherwise
-     */
-    virtual int ReadID() = 0;
-};
-
-#endif /* __GENERIC_SENSOR_CLASS_H */
--- a/VL6180X/LightSensor.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-/**
- ******************************************************************************
- * @file    LightSensor.h
- * @author  AST / EST
- * @version V0.0.1
- * @date    13-April-2015
- * @brief   This file contains the abstract class describing in general
- *          the interfaces of an ambient light sensor (ALS)
- ******************************************************************************
- * @attention
- *
- * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * 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 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 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.
- *
- ******************************************************************************
- */
-
-/* Define to prevent from recursive inclusion --------------------------------*/
-#ifndef __LIGHT_SENSOR_CLASS_H
-#define __LIGHT_SENSOR_CLASS_H
-
-/* Includes ------------------------------------------------------------------*/
-#include "GenericSensor.h"
-
-/* Classes  ------------------------------------------------------------------*/
-/** An abstract class for ambient light sensors
- */
-class LightSensor : public GenericSensor
-{
- public:
-    /**
-     * @brief       Get current light [lux]
-     * @param[out]  piData Pointer to where to store light to
-     * @return      0 in case of success, an error code otherwise
-     */
-    virtual int GetLight(uint32_t *piData) = 0;
-};
-
-#endif /* __LIGHT_SENSOR_CLASS_H */
--- a/VL6180X/RangeSensor.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,60 +0,0 @@
-/**
- ******************************************************************************
- * @file    RangeSensor.h
- * @author  AST / EST
- * @version V0.0.1
- * @date    13-April-2015
- * @brief   This file contains the abstract class describing in general
- *          the interfaces of a range sensor
- ******************************************************************************
- * @attention
- *
- * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * 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 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 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.
- *
- ******************************************************************************
- */
-
-/* Define to prevent from recursive inclusion --------------------------------*/
-#ifndef __RANGE_SENSOR_CLASS_H
-#define __RANGE_SENSOR_CLASS_H
-
-/* Includes ------------------------------------------------------------------*/
-#include "GenericSensor.h"
-
-/* Classes  ------------------------------------------------------------------*/
-/** An abstract class for range sensors
- */
-class RangeSensor : public GenericSensor
-{
- public:
-    /**
-     * @brief       Get current range [mm]
-     * @param[out]  piData Pointer to where to store range to
-     * @return      0 in case of success, an error code otherwise
-     */
-    virtual int GetRange(int32_t *piData) = 0;
-};
-
-#endif /* __RANGE_SENSOR_CLASS_H */
--- a/VL6180X/vl6180x_cfg.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,129 +0,0 @@
-/*******************************************************************************
-Copyright © 2014, 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.
-********************************************************************************/
-/*
- * $Date: 2015-01-08 14:35:34 +0100 (Thu, 08 Jan 2015) $
- * $Revision: 2042 $
- */
- 
-/**
- * @file VL6180x_cfg.h
- *
- * Proximity and ALS configuration
- */
-
-#ifndef VL6180x_CFG_H_
-#define VL6180x_CFG_H_
-
-/** @defgroup api_config Configuration
- *  @brief API static configuration
- */
-
-
-
-/** @ingroup api_config
- * @{*/
-
-
-/**
- * @def VL6180x_UPSCALE_SUPPORT
- * @brief Configure up-scale capabilities and default up-scale factor for ranging operations
- * 
- * @li 1 : Fixed scaling by 1 (no up-scaling support)
- * @li 2 : Fixed scaling by 2
- * @li 3 : Fixed scaling by 3
- * @li  -1 -2 -3 : Run time programmable through @a VL6180x_UpscaleSetScaling(). Default scaling factore is -VL6180x_UPSCALE_SUPPORT \n
- */
-//#define VL6180x_UPSCALE_SUPPORT -1
-
-/**
- * @def VL6180x_ALS_SUPPORT
- * @brief Enable ALS support
- *
- * Set to 0 if ALS is not used in application. This can help reducing code size if it is a concern.
- */
-#define VL6180x_ALS_SUPPORT      1
-
-/**
- * @def VL6180x_HAVE_DMAX_RANGING
- * @brief Enable DMax calculation for ranging applications.
- *  
- * When set to 1, __Dmax__ is returned by API typically when  @a VL6180x_RangePollMeasurement() high level
- * function is called (this is returned in @a VL6180x_RangeData_t structure).
- * __Dmax__ is an estimation of the maximum distance (in mm) the product can report a valid distance of a 17% target for 
- * the current ambient light conditions (__Dmax__ decreases when ambient light increases). __Dmax__ should be used only
- * when the product is not able to return a valid distance (no object or object is too far from the ranging sensor).
- * Typically, this is done by checking the __errorStatus__ field of the @a VL6180x_RangeData_t structure returned by 
- * the @a VL6180x_RangePollMeasurement() function.
- * You may refer to ::RangeError_u to get full list of supported error codes.
- * @warning Dmax is estimated for a 17% grey target. If the real target has a reflectance lower than 17%, report Dmax could be over-estimated 
- */
-#define VL6180x_HAVE_DMAX_RANGING   1
-
-/**
- * @def VL6180x_WRAP_AROUND_FILTER_SUPPORT
- * @brief Enable wrap around filter (WAF) feature
- *  
- * In specific conditions, when targeting a mirror or a very reflective metal, a __wrap around__ effect can occur internally to the
- * ranging product which results in returning a wrong distance (under-estimated). Goal of the WAF is to detect this wrap arround effect
- * and to filter it by returning a non-valid distance : __errorStatus__ set to 16 (see ::RangeError_u)
- * @warning Wrap-around filter can not be used when device is running in continuous mode 
- * 
- * @li 0 : Filter is not supported, no filtering code is included in API
- * @li 1 : Filter is supported and active by default
- * @li -1 : Filter is supported but is not active by default @a VL6180x_FilterSetState() can turn it on and off at any time
- */
-#define VL6180x_WRAP_AROUND_FILTER_SUPPORT   1
-
-/**
- * @def VL6180x_EXTENDED_RANGE
- * @brief Enable extended ranging support
- *
- * Device that do not formally support extended ranging should only be used with a scaling factor of 1.
- * Correct operation with scaling factor other than 1 (>200mm ) is not granted by ST.
- */
-//#define VL6180x_EXTENDED_RANGE 0
-
-#define EXTENDED_RANGE_50CM     0
-//#define EXTENDED_RANGE_50CM     1
-
-#if EXTENDED_RANGE_50CM
-#define VL6180x_UPSCALE_SUPPORT -3
-#define VL6180x_EXTENDED_RANGE  1
-#else
-#define VL6180x_UPSCALE_SUPPORT -1
-#define VL6180x_EXTENDED_RANGE  0
-#endif
-
-#if (VL6180x_EXTENDED_RANGE) && (VL6180x_ALS_SUPPORT)
-#warning "Als support should be OFF for extended range"
-#endif
-
-#endif
-/** @} */ // end of api_config
-
-/* VL6180x_CFG_H_ */
--- a/VL6180X/vl6180x_class.cpp	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,3634 +0,0 @@
-/**
- ******************************************************************************
- * @file    vl6180x_class.cpp
- * @author  AST / EST
- * @version V0.0.1
- * @date    14-April-2015
- * @brief   Implementation file for the HTS221 driver class
- ******************************************************************************
- * @attention
- *
- * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * 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 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 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.
- *
- ******************************************************************************
-*/
- 
-/* Includes */
-#include "vl6180x_class.h"
- 
- 
-#ifndef  VL6180x_RANGE_STATUS_ERRSTRING
-#warning "VL6180x_RANGE_STATUS_ERRSTRING not defined ?"
-/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
-   or update your vl6180x_platform.h file */
-/**
- * force VL6180x_RANGE_STATUS_ERRSTRING to not supported when not part of any cfg file
- */
-#define VL6180x_RANGE_STATUS_ERRSTRING  0
-#endif
- 
-#ifndef  VL6180X_SAFE_POLLING_ENTER
-#warning "VL6180X_SAFE_POLLING_ENTER not defined, likely old vl6180x_cfg.h file ?"
-/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
-   or update your vl6180x_platform.h file */
-/**
- * force VL6180X_SAFE_POLLING_ENTER to off when not in cfg file
- */
-#define VL6180X_SAFE_POLLING_ENTER 0 /* off by default as in api 2.0 */
-#endif
- 
-#ifndef VL6180X_LOG_ENABLE
-/**
- * Force VL6180X_LOG_ENABLE to none as default
- */
-#define VL6180X_LOG_ENABLE  0
-#endif
-
-#ifdef MY_LOG 
-Serial pc(USBTX, USBRX);
-#endif 
- 
-#if VL6180x_RANGE_STATUS_ERRSTRING
-/**@def VL6180x_HAVE_RANGE_STATUS_ERRSTRING
- * @brief is defined when @a #VL6180x_RANGE_STATUS_ERRSTRING is enable
- */
-#define  VL6180x_HAVE_RANGE_STATUS_ERRSTRING
-#endif
- 
- 
-/** @brief Get API version as "hex integer" 0xMMnnss
- */
-#define VL6180x_ApiRevInt  ((VL6180x_API_REV_MAJOR<<24)+(VL6180x_API_REV_MINOR<<16)+VL6180x_API_REV_SUB)
- 
-/** Get API version as string for exe "2.1.12" "
- */
-#define VL6180x_ApiRevStr  VL6180X_STR(VL6180x_API_REV_MAJOR) "." VL6180X_STR(VL6180x_API_REV_MINOR) "." VL6180X_STR(VL6180x_API_REV_SUB)
- 
-/** @defgroup api_init Init functions
- *  @brief    API init functions
- *  @ingroup api_hl
- *  @{  
- */
- 
- 
-/****************** define for i2c configuration *******************************/
- 
-#define TEMP_BUF_SIZE   32
- 
-#define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
-/**
- * @brief Clear All interrupt causes (als+range+error)
- *
- * @param dev    The device
- * @return  0    On success
- */
-#define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
-/**
- * @brief  Clear ALS interrupt
- *
- * @param dev    The device
- * @return  0    On success
- */
- #define VL6180x_AlsClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ALS)
-/**
- * @brief Clear range interrupt
- *
- * @param dev    The device
- * @return  0    On success
- */
-#define VL6180x_RangeClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_RANGING)
- 
-/******************************************************************************/
-/******************************* file api.c ***********************************/
- 
-#define VL6180x_9to7Conv(x) (x)
- 
-/* TODO when set all "cached" value with "default init" are updated after init from register read back */
-#define REFRESH_CACHED_DATA_AFTER_INIT  1
- 
- 
-#define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
- 
- 
-/** default value ECE factor Molecular */
-#define DEF_ECE_FACTOR_M    85
-/** default value ECE factor Denominator */
-#define DEF_ECE_FACTOR_D    100
-/** default value ALS integration time */
-#define DEF_INT_PEFRIOD     100
-/** default value ALS gain */
-#define DEF_ALS_GAIN        1
-/** default value ALS scaler */
-#define DEF_ALS_SCALER      1
-/** default value for DMAX Enbale */
-#define DEF_DMAX_ENABLE     1
-/** default ambient tuning factor %x1000 */
-#define DEF_AMBIENT_TUNING  80
- 
-#if VL6180x_SINGLE_DEVICE_DRIVER
-extern  struct VL6180xDevData_t SingleVL6180xDevData;
-#define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field)
-#define VL6180xDevDataSet(dev, field, data) SingleVL6180xDevData.field=(data)
-#endif
- 
-#define LUXRES_FIX_PREC 8
-#define GAIN_FIX_PREC    8  /* ! if not sme as LUX_PREC then :( adjust GetLux */
-#define AN_GAIN_MULT    (1<<GAIN_FIX_PREC)
- 
- 
-//int32_t _GetAveTotalTime(VL6180xDev_t dev);
-//int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev);
- 
-/**
- * ScalerLookUP scaling factor-1 to register #RANGE_SCALER lookup
- */
-static const uint16_t ScalerLookUP[]      ROMABLE_DATA ={ 253, 127,  84}; /* lookup table for scaling->scalar 1x2x 3x */
-/**
- * scaling factor to Upper limit look up
- */
-static const uint16_t UpperLimitLookUP[]  ROMABLE_DATA ={ 185, 370,  580}; /* lookup table for scaling->limit  1x2x3x */
-/**
- * Als Code gain to fix point gain lookup
- */
-static const uint16_t AlsGainLookUp[8]    ROMABLE_DATA = {
-        (uint16_t)(20.0f * AN_GAIN_MULT),
-        (uint16_t)(10.0f * AN_GAIN_MULT),
-        (uint16_t)(5.0f  * AN_GAIN_MULT),
-        (uint16_t)(2.5f  * AN_GAIN_MULT),
-        (uint16_t)(1.67f * AN_GAIN_MULT),
-        (uint16_t)(1.25f * AN_GAIN_MULT),
-        (uint16_t)(1.0f  * AN_GAIN_MULT),
-        (uint16_t)(40.0f * AN_GAIN_MULT),
-};
- 
- 
-#if VL6180x_RANGE_STATUS_ERRSTRING
-const char * ROMABLE_DATA VL6180x_RangeStatusErrString[]={
-       "No Error",
-       "VCSEL Continuity Test",
-       "VCSEL Watchdog Test",
-       "VCSEL Watchdog",
-       "PLL1 Lock",
-       "PLL2 Lock",
-       "Early Convergence Estimate",
-       "Max Convergence",
-       "No Target Ignore",
-       "Not used 9",
-       "Not used 10",
-       "Max Signal To Noise Ratio",
-       "Raw Ranging Algo Underflow",
-       "Raw Ranging Algo Overflow",
-       "Ranging Algo Underflow",
-       "Ranging Algo Overflow",
- 
-       "Filtered by post processing"
-};
- 
-const char * VL6180x_RangeGetStatusErrString(uint8_t RangeErrCode){
-    if( RangeErrCode  > sizeof(VL6180x_RangeStatusErrString)/sizeof(VL6180x_RangeStatusErrString[0]) )
-        return NULL;
-    return  VL6180x_RangeStatusErrString[RangeErrCode];
-}
-#endif
- 
-#if VL6180x_UPSCALE_SUPPORT == 1
-    #define _GetUpscale(dev, ... )  1
-    #define _SetUpscale(...) -1
-    #define DEF_UPSCALE 1
-#elif VL6180x_UPSCALE_SUPPORT == 2
-    #define _GetUpscale(dev, ... )  2
-    #define _SetUpscale(...)
-    #define DEF_UPSCALE 2
-#elif  VL6180x_UPSCALE_SUPPORT == 3
-    #define _GetUpscale(dev, ... )  3
-    #define _SetUpscale(...)
-    #define DEF_UPSCALE 3
-#else
-    #define DEF_UPSCALE (-(VL6180x_UPSCALE_SUPPORT))
-    #define _GetUpscale(dev, ... ) VL6180xDevDataGet(dev, UpscaleFactor)
-    #define _SetUpscale(dev, Scaling ) VL6180xDevDataSet(dev, UpscaleFactor, Scaling)
-#endif
- 
- 
-#if VL6180x_SINGLE_DEVICE_DRIVER
-/**
- * the unique driver data  When single device driver is active
- */
-struct VL6180xDevData_t VL6180x_DEV_DATA_ATTR  SingleVL6180xDevData={
-        .EceFactorM        = DEF_ECE_FACTOR_M,
-        .EceFactorD        = DEF_ECE_FACTOR_D,
-#ifdef VL6180x_HAVE_UPSCALE_DATA
-        .UpscaleFactor     = DEF_UPSCALE,
-#endif
-#ifdef VL6180x_HAVE_ALS_DATA
-        .IntegrationPeriod = DEF_INT_PEFRIOD,
-        .AlsGainCode       = DEF_ALS_GAIN,
-        .AlsScaler         = DEF_ALS_SCALER,
-#endif
-#ifdef VL6180x_HAVE_DMAX_RANGING
-        .DMaxEnable =   DEF_DMAX_ENABLE,
-#endif
-};
-#endif /* VL6180x_SINGLE_DEVICE_DRIVER */
- 
-#define Fix7_2_KCPs(x) ((((uint32_t)(x))*1000)>>7)
- 
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-static int _filter_Init(VL6180xDev_t dev);
-    #define _IsWrapArroundActive(dev) VL6180xDevDataGet(dev,WrapAroundFilterActive)
-#else
-    #define _IsWrapArroundActive(dev) 0
-#endif
- 
- 
-#if VL6180x_HAVE_DMAX_RANGING
-   void _DMax_OneTimeInit(VL6180xDev_t dev);
-//   static int _DMax_InitData(VL6180xDev_t dev);
-   static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange);
-    #define _IsDMaxActive(dev) VL6180xDevDataGet(dev,DMaxEnable)
-#else
-    #define _DMax_InitData(...) 0 /* success */
-    #define _DMax_OneTimeInit(...) (void)0
-    #define _IsDMaxActive(...) 0
-#endif
- 
-//static int VL6180x_RangeStaticInit(VL6180xDev_t dev);
-//static int  VL6180x_UpscaleStaticInit(VL6180xDev_t dev);
- 
-int VL6180X::VL6180x_WaitDeviceBooted(VL6180xDev_t dev){
-    uint8_t FreshOutReset;
-    int status;
-    LOG_FUNCTION_START("");
-    do{
-        status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
-    }
-    while( FreshOutReset!=1 && status==0);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_InitData(VL6180xDev_t dev){
-    int status, dmax_status ;
-    int8_t offset;
-    uint8_t FreshOutReset;
-    uint32_t CalValue;
-    uint16_t u16;
-    uint32_t XTalkCompRate_KCps;
- 
-    LOG_FUNCTION_START("");
- 
-    VL6180xDevDataSet(dev, EceFactorM , DEF_ECE_FACTOR_M);
-    VL6180xDevDataSet(dev, EceFactorD , DEF_ECE_FACTOR_D);
- 
-#ifdef VL6180x_HAVE_UPSCALE_DATA
-    VL6180xDevDataSet(dev, UpscaleFactor ,  DEF_UPSCALE);
-#endif
- 
-#ifdef VL6180x_HAVE_ALS_DATA
-    VL6180xDevDataSet(dev, IntegrationPeriod, DEF_INT_PEFRIOD);
-    VL6180xDevDataSet(dev, AlsGainCode, DEF_ALS_GAIN);
-    VL6180xDevDataSet(dev, AlsScaler, DEF_ALS_SCALER);
-#endif
- 
-#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
-    VL6180xDevDataSet(dev, WrapAroundFilterActive, (VL6180x_WRAP_AROUND_FILTER_SUPPORT >0));
-    VL6180xDevDataSet(dev, DMaxEnable, DEF_DMAX_ENABLE);
-#endif
- 
-    _DMax_OneTimeInit(dev);
-    do{
- 
-        /* backup offset initial value from nvm these must be done prior any over call that use offset */
-        status = VL6180X::VL6180x_RdByte(dev,SYSRANGE_PART_TO_PART_RANGE_OFFSET, (uint8_t*)&offset);
-        if( status ){
-            VL6180x_ErrLog("SYSRANGE_PART_TO_PART_RANGE_OFFSET rd fail");
-            break;
-        }
-        VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
- 
-        status=VL6180x_RdDWord( dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &CalValue);
-        if( status ){
-            VL6180x_ErrLog("Part2PartAmbNVM rd fail");
-            break;
-        }
-        if( (CalValue&0xFFFF0000) == 0 ){
-            CalValue=0x00CE03F8;
-        }
-        VL6180xDevDataSet(dev, Part2PartAmbNVM, CalValue);
- 
-        status = VL6180x_RdWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE ,&u16);
-        if( status){
-            VL6180x_ErrLog("SYSRANGE_CROSSTALK_COMPENSATION_RATE rd fail ");
-            break;
-        }
-        XTalkCompRate_KCps = Fix7_2_KCPs(u16);
-        VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
- 
-        dmax_status = _DMax_InitData(dev);
-        if( dmax_status < 0 ){
-            VL6180x_ErrLog("DMax init failure");
-            break;
-        }
- 
-        /* Read or wait for fresh out of reset  */
-        status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
-        if( status )  {
-            VL6180x_ErrLog("SYSTEM_FRESH_OUT_OF_RESET rd fail");
-            break;
-        }
-        if( FreshOutReset!= 1 || dmax_status )
-            status = CALIBRATION_WARNING;
- 
-    }
-    while(0);
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int8_t VL6180X::VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev)
-{
-    int8_t offset;
-    LOG_FUNCTION_START("");
-    offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM);
-    LOG_FUNCTION_END( offset );
-    return offset;
-}
- 
-void VL6180X::VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset)
-{
-    LOG_FUNCTION_START("%d", offset);
-    VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
-    LOG_FUNCTION_END(0);
-}
- 
-int VL6180X::VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate)
-{
-    int status;
-    LOG_FUNCTION_START("%d", Rate);
-    status = VL6180x_WrWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE, Rate);
-    if( status ==0 ){
-        uint32_t XTalkCompRate_KCps;
-        XTalkCompRate_KCps = Fix7_2_KCPs(Rate);
-        VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
-        /* update dmax whenever xtalk rate changes */
-        status = _DMax_InitData(dev);
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddress){
-    int status;
-    LOG_FUNCTION_START("");
- 
-    status = VL6180x_WrByte(dev, I2C_SLAVE_DEVICE_ADDRESS, NewAddress);
-    if( status ){
-        VL6180x_ErrLog("new i2c addr Wr fail");
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-uint16_t VL6180X::VL6180x_GetUpperLimit(VL6180xDev_t dev) {
-    uint16_t limit;
-    int scaling;
- 
-    LOG_FUNCTION_START("");
- 
-    scaling = _GetUpscale(dev);
-    /* FIXME we do assume here _GetUpscale is valid if  user call us prior to init we may overflow the LUT  mem area */
-    limit = UpperLimitLookUP[scaling - 1];
- 
-    LOG_FUNCTION_END((int )limit);
-    return limit;
-}
- 
- 
- 
-int VL6180X::VL6180x_StaticInit(VL6180xDev_t dev){
-    int status=0, init_status;
-    LOG_FUNCTION_START("");
- 
-    /* TODO doc When using configurable scaling but using 1x as start condition
-     * load tunning upscale  or not ??? */
-    if( _GetUpscale(dev) == 1 && !(VL6180x_UPSCALE_SUPPORT<0))
-        init_status=VL6180x_RangeStaticInit(dev);
-    else
-        init_status=VL6180x_UpscaleStaticInit(dev);
- 
-    if( init_status <0 ){
-        VL6180x_ErrLog("StaticInit fail");
-        goto error;
-    }
-    else if(init_status > 0){
-        VL6180x_ErrLog("StaticInit warning");
-    }
- 
-#if REFRESH_CACHED_DATA_AFTER_INIT
-    /* update cached value after tuning applied */
-    do{
-#ifdef  VL6180x_HAVE_ALS_DATA
-        uint8_t data;
-        status=  VL6180x_RdByte(dev, FW_ALS_RESULT_SCALER, &data);
-        if( status ) break;
-        VL6180xDevDataSet(dev, AlsScaler, data);
- 
-        status=  VL6180x_RdByte(dev, SYSALS_ANALOGUE_GAIN, &data);
-        if( status ) break;
-        VL6180x_AlsSetAnalogueGain(dev, data);
-#endif
-    }
-    while(0);
-#endif /* REFRESH_CACHED_DATA_AFTER_INIT */
-    if( status < 0 ){
-        VL6180x_ErrLog("StaticInit fail");
-    }
-    if( !status && init_status){
-        status = init_status;
-    }
-error:
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold)
-{
-    int status;
-    uint8_t value;
- 
-    LOG_FUNCTION_START("%d", Hold);
-    if( Hold )
-        value = 1;
-    else
-        value = 0;
-    status = VL6180x_WrByte(dev, SYSTEM_GROUPED_PARAMETER_HOLD, value);
- 
-    LOG_FUNCTION_END(status);
-    return status;
- 
-}
- 
-int VL6180X::VL6180x_Prepare(VL6180xDev_t dev)
-{
-    int status;
-    LOG_FUNCTION_START("");
- 
-    do{
-        status=VL6180x_StaticInit(dev);
-        if( status<0) break;
- 
-        /* set range InterruptMode to new sample */
-        status=VL6180x_RangeConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_DISABLED );
-        if( status)
-            break;
- 
-        /* set default threshold */
-        status=VL6180x_RangeSetRawThresholds(dev, 10, 200);
-        if( status ){
-            VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
-            break;
-        }
-#if VL6180x_ALS_SUPPORT
-        status =VL6180x_AlsSetIntegrationPeriod(dev, 100);
-        if( status ) break;
-        status = VL6180x_AlsSetInterMeasurementPeriod(dev,  200);
-        if( status ) break;
-        status = VL6180x_AlsSetAnalogueGain(dev,  0);
-        if( status ) break;
-        status = VL6180x_AlsSetThresholds(dev, 0, 0xFFFF);
-        if( status ) break;
-        /* set Als InterruptMode to new sample */
-        status=VL6180x_AlsConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if( status ) {
-            VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail");
-            break;
-        }
-#endif
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-        _filter_Init(dev);
-#endif
-        /* make sure to reset any left previous condition that can hangs first poll */
-        status=VL6180x_ClearAllInterrupt(dev);
-    }
-    while(0);
-    LOG_FUNCTION_END(status);
- 
-    return status;
-}
- 
-#if VL6180x_ALS_SUPPORT
-int VL6180X::VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux)
-{
-    int status;
-    uint16_t RawAls;
-    uint32_t luxValue = 0;
-    uint32_t IntPeriod;
-    uint32_t AlsAnGain;
-    uint32_t GainFix;
-    uint32_t AlsScaler;
- 
-#if LUXRES_FIX_PREC !=  GAIN_FIX_PREC
-#error "LUXRES_FIX_PREC != GAIN_FIX_PREC  review these code to be correct"
-#endif
-    const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
- 
-    LOG_FUNCTION_START("%p", pLux);
- 
-    status = VL6180x_RdWord( dev, RESULT_ALS_VAL, &RawAls);
-    if( !status){
-        /* wer are yet here at no fix point */
-        IntPeriod=VL6180xDevDataGet(dev, IntegrationPeriod);
-        AlsScaler=VL6180xDevDataGet(dev, AlsScaler);
-        IntPeriod++; /* what stored is real time  ms -1 and it can be 0 for or 0 or 1ms */
-        luxValue = (uint32_t)RawAls * LuxResxIntIme; /* max # 16+8bits + 6bit (0.56*100)  */
-        luxValue /= IntPeriod;                         /* max # 16+8bits + 6bit 16+8+1 to 9 bit */
-        /* between  29 - 21 bit */
-        AlsAnGain = VL6180xDevDataGet(dev, AlsGainCode);
-        GainFix = AlsGainLookUp[AlsAnGain];
-        luxValue = luxValue / (AlsScaler * GainFix);
-        *pLux=luxValue;
-    }
- 
-    LOG_FUNCTION_END_FMT(status, "%x",(int)*pLux);
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData)
-{
-    int status;
-    uint8_t ErrStatus;
- 
-    LOG_FUNCTION_START("%p", pAlsData);
- 
-    status = VL6180x_AlsGetLux(dev, &pAlsData->lux);
-    if( !status ){
-        status = VL6180x_RdByte(dev, RESULT_ALS_STATUS, & ErrStatus);
-        pAlsData->errorStatus = ErrStatus>>4;
-    }
-    LOG_FUNCTION_END_FMT(status,"%d %d", (int)pAlsData->lux,  (int)pAlsData->errorStatus);
- 
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData) {
-    int status;
-    int ClrStatus;
-    uint8_t IntStatus;
- 
-    LOG_FUNCTION_START("%p", pAlsData);
-#if VL6180X_SAFE_POLLING_ENTER
-    /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
-    status=VL6180x_AlsClearInterrupt(dev);
-    if(status){
-        VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-        goto over;
-    }
-#endif
- 
-    status=VL6180x_AlsSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
-    if( status){
-        VL6180x_ErrLog("VL6180x_AlsSetSystemMode fail");
-        goto over;
-    }
- 
-    /* poll for new sample ready */
-    while (1 ) {
-        status = VL6180x_AlsGetInterruptStatus(dev, &IntStatus);
-        if (status) {
-            break;
-        }
-        if (IntStatus == RES_INT_STAT_GPIO_NEW_SAMPLE_READY) {
-            break; /* break on new data (status is 0)  */
-        }
-        wait_ms(10);
-    };
- 
-    if (!status) {
-        status = VL6180x_AlsGetMeasurement(dev, pAlsData);
-    }
- 
-    ClrStatus = VL6180x_AlsClearInterrupt(dev);
-    if (ClrStatus) {
-        VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-        if (!status) {
-            status = ClrStatus; /* leave previous if already on error */
-        }
-    }
-over:
-    LOG_FUNCTION_END(status);
- 
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
-    int status;
-    uint8_t IntStatus;
-    LOG_FUNCTION_START("%p", pIntStatus);
- 
-    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
-    *pIntStatus= (IntStatus>>3)&0x07;
- 
-    LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
-    int status;
-    int  n;
-    uint8_t u8;
-    LOG_FUNCTION_START("%d", (int)MaxLoop);
-    if( MaxLoop<1){
-          status=INVALID_PARAMS;
-     }
-    else{
-        for( n=0; n < MaxLoop ; n++){
-            status=VL6180x_RdByte(dev, RESULT_ALS_STATUS, &u8);
-            if( status)
-                break;
-            u8 = u8 & ALS_DEVICE_READY_MASK;
-            if( u8 )
-                break;
- 
-        }
-        if( !status && !u8 ){
-            status = TIME_OUT;
-        }
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode)
-{
-    int status;
-    LOG_FUNCTION_START("%d", (int)mode);
-    /* FIXME if we are called back to back real fast we are not checking
-     * if previous mode "set" got absorbed => bit 0 must be 0 so that wr 1 work */
-    if( mode <= 3){
-        status=VL6180x_WrByte(dev, SYSALS_START, mode);
-    }
-    else{
-        status = INVALID_PARAMS;
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
-{
-    int status;
- 
-    if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
-        status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_ALS_MASK), (ConfigGpioInt<<3));
-    }
-    else{
-        VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
-        status = INVALID_PARAMS;
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
- 
-int VL6180X::VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high) { 
-    int status;
-
-    LOG_FUNCTION_START("%d %d", (int )low, (int)high);
-
-    status = VL6180x_WrWord(dev, SYSALS_THRESH_LOW, low);
-    if(!status ){
-        status = VL6180x_WrWord(dev, SYSALS_THRESH_HIGH, high);
-    }
-
-    LOG_FUNCTION_END(status) ;
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain) {
-    int status;
-    uint8_t GainTotal;
- 
-    LOG_FUNCTION_START("%d", (int )gain);
-    gain&=~0x40;
-    if (gain > 7) {
-        gain = 7;
-    }
-    GainTotal = gain|0x40;
- 
-    status = VL6180x_WrByte(dev, SYSALS_ANALOGUE_GAIN, GainTotal);
-    if( !status){
-        VL6180xDevDataSet(dev, AlsGainCode, gain);
-    }
- 
-    LOG_FUNCTION_END_FMT(status, "%d %d", (int ) gain, (int )GainTotal);
-    return status;
-}
- 
-int VL6180X::VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev,  uint16_t intermeasurement_period_ms)
-{
-    int status;
- 
-    LOG_FUNCTION_START("%d",(int)intermeasurement_period_ms);
-        /* clipping: range is 0-2550ms */
-        if (intermeasurement_period_ms >= 255 *10)
-                intermeasurement_period_ms = 255 *10;
-    status=VL6180x_WrByte(dev, SYSALS_INTERMEASUREMENT_PERIOD, (uint8_t)(intermeasurement_period_ms/10));
- 
-    LOG_FUNCTION_END_FMT(status, "%d", (int) intermeasurement_period_ms);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms)
-{
-    int status;
-    uint16_t SetIntegrationPeriod;
- 
-    LOG_FUNCTION_START("%d", (int)period_ms);
- 
-    if( period_ms>=1 )
-        SetIntegrationPeriod = period_ms - 1;
-    else
-        SetIntegrationPeriod = period_ms;
- 
-    if (SetIntegrationPeriod > 464) {
-        SetIntegrationPeriod = 464;
-    }
-    else if (SetIntegrationPeriod == 255)   {
-        SetIntegrationPeriod++; /* can't write 255 since this causes the device to lock out.*/
-    }
- 
-    status =VL6180x_WrWord(dev, SYSALS_INTEGRATION_PERIOD, SetIntegrationPeriod);
-    if( !status ){
-        VL6180xDevDataSet(dev, IntegrationPeriod, SetIntegrationPeriod) ;
-    }
-    LOG_FUNCTION_END_FMT(status, "%d", (int)SetIntegrationPeriod);
-    return status;
-}
- 
-#endif /* HAVE_ALS_SUPPORT */
- 
- 
-int VL6180X::VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
-{
-    int status;
-    int ClrStatus;
-    IntrStatus_t IntStatus;
- 
-    LOG_FUNCTION_START("");
-    /* start single range measurement */
- 
- 
-#if VL6180X_SAFE_POLLING_ENTER
-    /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
-    status=VL6180x_RangeClearInterrupt(dev);
-    if(status){
-        VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-        goto done;
-    }
-#endif
-    /* //![single_shot_snipet] */
-    status=VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
-    if( status ){
-        VL6180x_ErrLog("VL6180x_RangeSetSystemMode fail");
-        goto done;
-    }
- 
-    /* poll for new sample ready */
-    while(1 ){
-        status=VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
-        if( status ){
-            break;
-        }
-        if( IntStatus.status.Error !=0 ){
-          VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
-          status = RANGE_ERROR;
-          break;
-        }
-        else
-        if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
-            break;
-        }
-        wait_ms(10);
-    }
- /* //![single_shot_snipet] */
- 
-    if ( !status ){
-        status = VL6180x_RangeGetMeasurement(dev, pRangeData);
-    }
- 
-    /*  clear range interrupt source */
-    ClrStatus = VL6180x_RangeClearInterrupt(dev);
-    if( ClrStatus ){
-        VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-        /*  leave initial status if already in error  */
-        if( !status ){
-            status=ClrStatus;
-        }
-    }
-done:
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
- 
-int VL6180X::VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
-{
-    int status;
-    uint16_t RawRate;
-    uint8_t RawStatus;
- 
-    LOG_FUNCTION_START("");
- 
-    status = VL6180x_RangeGetResult(dev, &pRangeData->range_mm);
-    if( !status ){
-        status = VL6180x_RdWord(dev,RESULT_RANGE_SIGNAL_RATE, &RawRate );
-        if( !status ){
-            pRangeData->signalRate_mcps = VL6180x_9to7Conv(RawRate);
-            status = VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &RawStatus);
-            if( !status ){
-                pRangeData->errorStatus = RawStatus >>4;
-            }
-            else{
-                VL6180x_ErrLog("Rd RESULT_RANGE_STATUS fail");
-            }
-    #if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
-            status = _GetRateResult(dev, pRangeData);
-            if( status )
-                goto error;
-    #endif
-    #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-            /* if enabled run filter */
-            if( _IsWrapArroundActive(dev) ){
-                status=_filter_GetResult(dev, pRangeData);
-                if( !status){
-                    /* patch the range status and measure if it is filtered */
-                    if( pRangeData->range_mm != pRangeData->FilteredData.range_mm) {
-                        pRangeData->errorStatus=RangingFiltered;
-                        pRangeData->range_mm = pRangeData->FilteredData.range_mm;
-                    }
-                }
-            }
-    #endif
- 
-#if VL6180x_HAVE_DMAX_RANGING
-            if(_IsDMaxActive(dev) ){
-                _DMax_Compute(dev, pRangeData);
-            }
-#endif
-        }
-        else{
-            VL6180x_ErrLog("Rd RESULT_RANGE_SIGNAL_RATE fail");
-        }
-    }
-    else{
-        VL6180x_ErrLog("VL6180x_GetRangeResult fail");
-    }
-error:
-    LOG_FUNCTION_END_FMT(status, "%d %d %d", (int)pRangeData->range_mm, (int)pRangeData->signalRate_mcps,  (int)pRangeData->errorStatus) ;
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
-{
-    int status;
-    IntrStatus_t IntStatus;
- 
-    LOG_FUNCTION_START();
- 
-    status = VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
-    if( status ==0 ){
-        if( IntStatus.status.Error !=0 ){
-            VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
-            status = RANGE_ERROR;
-        }
-        else
-        if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
-           status = VL6180x_RangeGetMeasurement(dev,pRangeData );
-           if( status == 0){
-               /*  clear range interrupt source */
-               status = VL6180x_RangeClearInterrupt(dev);
-               if( status ){
-                   VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-               }
-           }
-        }
-        else{
-            status = NOT_READY;
-        }
-    }
-    else{
-        VL6180x_ErrLog("fail to get interrupt status");
-    }
-    LOG_FUNCTION_END(status) ;
-    return status;
-}
- 
-int VL6180X::VL6180x_FilterSetState(VL6180xDev_t dev, int state){
-    int status;
-    LOG_FUNCTION_START("%d", state);
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-    VL6180xDevDataSet(dev,WrapAroundFilterActive, state);
-    status = 0;
-#else
-    status =  NOT_SUPPORTED;
-#endif
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_FilterGetState(VL6180xDev_t dev){
-    int status;
-    LOG_FUNCTION_START("");
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-    status = VL6180xDevDataGet(dev,WrapAroundFilterActive);
-#else
-    status = 0;
-#endif
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm) {
-    int status;
-    uint8_t RawRange;
-    int32_t Upscale;
- 
-    LOG_FUNCTION_START("%p",pRange_mm);
- 
-    status = VL6180x_RdByte(dev, RESULT_RANGE_VAL, &RawRange);
-    if( !status ){
-         Upscale = _GetUpscale(dev);
-        *pRange_mm= Upscale*(int32_t)RawRange;
-    }
-    LOG_FUNCTION_END_FMT(status, "%d", (int)*pRange_mm);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high)
-{
-    int status;
-    LOG_FUNCTION_START("%d %d", (int) low, (int)high);
-    /* TODO we can optimize here grouping high/low in a word but that's cpu endianness dependent */
-    status=VL6180x_WrByte(dev, SYSRANGE_THRESH_HIGH,high);
-    if( !status){
-        status=VL6180x_WrByte(dev, SYSRANGE_THRESH_LOW, low);
-    }
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int UseSafeParamHold)
-{
-    int status;
-    int scale;
-    LOG_FUNCTION_START("%d %d", (int) low, (int)high);
-    scale=_GetUpscale(dev,UpscaleFactor);
-    if( low>scale*255 || high >scale*255){
-        status = INVALID_PARAMS;
-    }
-    else{
-        do{
-            if( UseSafeParamHold ){
-                status=VL6180x_SetGroupParamHold(dev, 1);
-                if( status )
-                    break;
-            }
-            status=VL6180x_RangeSetRawThresholds(dev, (uint8_t)(low/scale), (uint8_t)(high/scale));
-            if( status ){
-                VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
-            }
-            if( UseSafeParamHold ){
-                int HoldStatus;
-                /* tryt to unset param hold vene if previous fail */
-                HoldStatus=VL6180x_SetGroupParamHold(dev, 0);
-                if( !status)
-                    status=HoldStatus;
-            }
-        }
-        while(0);
-    }
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high)
-{
-    int status;
-    uint8_t RawLow, RawHigh;
-    int scale;
- 
-    LOG_FUNCTION_START("%p %p", low , high);
- 
-    scale=_GetUpscale(dev,UpscaleFactor);
-    do{
-        if( high != NULL ){
-            status=VL6180x_RdByte(dev, SYSRANGE_THRESH_HIGH,&RawHigh);
-            if( status ){
-                VL6180x_ErrLog("rd SYSRANGE_THRESH_HIGH fail");
-                break;
-            }
-            *high=(uint16_t)RawHigh*scale;
-        }
-        if( low != NULL ) {
-            status=VL6180x_RdByte(dev, SYSRANGE_THRESH_LOW, &RawLow);
-            if( status ){
-                VL6180x_ErrLog("rd SYSRANGE_THRESH_LOW fail");
-                break;
-            }
-            *low=(uint16_t)RawLow*scale;
-        }
-    }
-    while(0);
-    LOG_FUNCTION_END_FMT(status, "%d %d",(int)*low ,(int)*high);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
-    int status;
-    uint8_t IntStatus;
-    LOG_FUNCTION_START("%p", pIntStatus);
-    /* FIXME we are grouping "error" with over status the user must check implicitly for it
-     * not just new sample or over status , that will nevr show up in case of error*/
-    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
-    *pIntStatus= IntStatus&0xC7;
- 
-    LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *IntStatus)
-{
-    int status;
-    LOG_FUNCTION_START("%p" , IntStatus);
-    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, IntStatus);
-    LOG_FUNCTION_END_FMT(status, "%d", (int)*IntStatus);
-    return status;
-}
- 
-int VL6180X::VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear )
-{
-    int status;
-    LOG_FUNCTION_START("%d" ,(int)IntClear);
-    if( IntClear <= 7 ){
-        status=VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CLEAR, IntClear);
-    }
-    else{
-        status = INVALID_PARAMS;
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeStaticInit(VL6180xDev_t dev)
-{
-    int status;
-    LOG_FUNCTION_START("");
- 
-    /* REGISTER_TUNING_SR03_270514_CustomerView.txt */
-    VL6180x_WrByte( dev, 0x0207, 0x01);
-    VL6180x_WrByte( dev, 0x0208, 0x01);
-    VL6180x_WrByte( dev, 0x0096, 0x00);
-    VL6180x_WrByte( dev, 0x0097, 0xfd);
-    VL6180x_WrByte( dev, 0x00e3, 0x00);
-    VL6180x_WrByte( dev, 0x00e4, 0x04);
-    VL6180x_WrByte( dev, 0x00e5, 0x02);
-    VL6180x_WrByte( dev, 0x00e6, 0x01);
-    VL6180x_WrByte( dev, 0x00e7, 0x03);
-    VL6180x_WrByte( dev, 0x00f5, 0x02);
-    VL6180x_WrByte( dev, 0x00d9, 0x05);
-    VL6180x_WrByte( dev, 0x00db, 0xce);
-    VL6180x_WrByte( dev, 0x00dc, 0x03);
-    VL6180x_WrByte( dev, 0x00dd, 0xf8);
-    VL6180x_WrByte( dev, 0x009f, 0x00);
-    VL6180x_WrByte( dev, 0x00a3, 0x3c);
-    VL6180x_WrByte( dev, 0x00b7, 0x00);
-    VL6180x_WrByte( dev, 0x00bb, 0x3c);
-    VL6180x_WrByte( dev, 0x00b2, 0x09);
-    VL6180x_WrByte( dev, 0x00ca, 0x09);
-    VL6180x_WrByte( dev, 0x0198, 0x01);
-    VL6180x_WrByte( dev, 0x01b0, 0x17);
-    VL6180x_WrByte( dev, 0x01ad, 0x00);
-    VL6180x_WrByte( dev, 0x00ff, 0x05);
-    VL6180x_WrByte( dev, 0x0100, 0x05);
-    VL6180x_WrByte( dev, 0x0199, 0x05);
-    VL6180x_WrByte( dev, 0x01a6, 0x1b);
-    VL6180x_WrByte( dev, 0x01ac, 0x3e);
-    VL6180x_WrByte( dev, 0x01a7, 0x1f);
-    VL6180x_WrByte( dev, 0x0030, 0x00);
- 
-    /* Recommended : Public registers - See data sheet for more detail */
-    VL6180x_WrByte( dev, SYSTEM_MODE_GPIO1, 0x10); /* Enables polling for New Sample ready when measurement completes */
-    VL6180x_WrByte( dev, READOUT_AVERAGING_SAMPLE_PERIOD, 0x30); /* Set the averaging sample period (compromise between lower noise and increased execution time) */
-    VL6180x_WrByte( dev, SYSALS_ANALOGUE_GAIN, 0x46); /* Sets the light and dark gain (upper nibble). Dark gain should not be changed.*/
-    VL6180x_WrByte( dev, SYSRANGE_VHV_REPEAT_RATE, 0xFF); /* sets the # of range measurements after which auto calibration of system is performed */
-    VL6180x_WrByte( dev, SYSALS_INTEGRATION_PERIOD, 0x63); /* Set ALS integration time to 100ms */
-    VL6180x_WrByte( dev, SYSRANGE_VHV_RECALIBRATE, 0x01); /* perform a single temperature calibration of the ranging sensor */
- 
-    /* Optional: Public registers - See data sheet for more detail */
-    VL6180x_WrByte( dev, SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09); /* Set default ranging inter-measurement period to 100ms */
-    VL6180x_WrByte( dev, SYSALS_INTERMEASUREMENT_PERIOD, 0x31); /* Set default ALS inter-measurement period to 500ms */
-    VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24); /* Configures interrupt on New sample ready */
- 
- 
-    status=VL6180x_RangeSetMaxConvergenceTime(dev, 50); /*  Calculate ece value on initialization (use max conv) */
-    LOG_FUNCTION_END(status);
- 
-    return status;
-}
- 
-#if VL6180x_UPSCALE_SUPPORT != 1
- 
-int VL6180X::_UpscaleInitPatch0(VL6180xDev_t dev){
-    int status;
-    uint32_t CalValue=0;
-    CalValue= VL6180xDevDataGet(dev, Part2PartAmbNVM);
-    status=VL6180x_WrDWord( dev, 0xDA, CalValue);
-    return status;
-}
- 
-/* only include up-scaling register setting when up-scale support is configured in */
-int VL6180X::VL6180x_UpscaleRegInit(VL6180xDev_t dev)
-{
-    /*  apply REGISTER_TUNING_ER02_100614_CustomerView.txt */
-    VL6180x_WrByte( dev, 0x0207, 0x01);
-    VL6180x_WrByte( dev, 0x0208, 0x01);
-    VL6180x_WrByte( dev, 0x0096, 0x00);
-    VL6180x_WrByte( dev, 0x0097, 0x54);
-    VL6180x_WrByte( dev, 0x00e3, 0x00);
-    VL6180x_WrByte( dev, 0x00e4, 0x04);
-    VL6180x_WrByte( dev, 0x00e5, 0x02);
-    VL6180x_WrByte( dev, 0x00e6, 0x01);
-    VL6180x_WrByte( dev, 0x00e7, 0x03);
-    VL6180x_WrByte( dev, 0x00f5, 0x02);
-    VL6180x_WrByte( dev, 0x00d9, 0x05);
- 
-    _UpscaleInitPatch0(dev);
- 
-    VL6180x_WrByte( dev, 0x009f, 0x00);
-    VL6180x_WrByte( dev, 0x00a3, 0x28);
-    VL6180x_WrByte( dev, 0x00b7, 0x00);
-    VL6180x_WrByte( dev, 0x00bb, 0x28);
-    VL6180x_WrByte( dev, 0x00b2, 0x09);
-    VL6180x_WrByte( dev, 0x00ca, 0x09);
-    VL6180x_WrByte( dev, 0x0198, 0x01);
-    VL6180x_WrByte( dev, 0x01b0, 0x17);
-    VL6180x_WrByte( dev, 0x01ad, 0x00);
-    VL6180x_WrByte( dev, 0x00ff, 0x05);
-    VL6180x_WrByte( dev, 0x0100, 0x05);
-    VL6180x_WrByte( dev, 0x0199, 0x05);
-    VL6180x_WrByte( dev, 0x01a6, 0x1b);
-    VL6180x_WrByte( dev, 0x01ac, 0x3e);
-    VL6180x_WrByte( dev, 0x01a7, 0x1f);
-    VL6180x_WrByte( dev, 0x0030, 0x00);
-    VL6180x_WrByte( dev, SYSTEM_MODE_GPIO1, 0x10);
-    VL6180x_WrByte( dev, READOUT_AVERAGING_SAMPLE_PERIOD, 0x30);
-    VL6180x_WrByte( dev, SYSALS_ANALOGUE_GAIN, 0x46);
-    VL6180x_WrByte( dev, SYSRANGE_VHV_REPEAT_RATE, 0xFF);
-    VL6180x_WrByte( dev, SYSALS_INTEGRATION_PERIOD, 0x63);
-    VL6180x_WrByte( dev, SYSRANGE_VHV_RECALIBRATE, 0x01);
-    VL6180x_WrByte( dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, 0xff);
-    VL6180x_WrByte( dev, SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09);
-    VL6180x_WrByte( dev, SYSALS_INTERMEASUREMENT_PERIOD, 0x31);
-    VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24);
-#if VL6180x_EXTENDED_RANGE
-    VL6180x_RangeSetMaxConvergenceTime(dev, 63);
-#else
-    VL6180x_RangeSetMaxConvergenceTime(dev, 50);
-#endif
-    return 0;
-}
-#else
-#define VL6180x_UpscaleRegInit(...) -1
-#endif
- 
-int VL6180X::VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling)
-{
-    int status;
-    uint16_t Scaler;
-    int8_t  Offset;
- 
-    LOG_FUNCTION_START("%d",(int) scaling);
- 
-#ifdef VL6180x_HAVE_UPSCALE_DATA
-    #define min_scaling 1
-    #define max_scaling sizeof(ScalerLookUP)/sizeof(ScalerLookUP[0])
-#else
-     /* we are in fixed config so only allow configured factor */
-    #define min_scaling VL6180x_UPSCALE_SUPPORT
-    #define max_scaling VL6180x_UPSCALE_SUPPORT
-#endif
- 
-    if( scaling>=min_scaling  && scaling<= max_scaling ){
- 
-        Scaler = ScalerLookUP[scaling-1];
-        status = VL6180x_WrWord(dev, RANGE_SCALER, Scaler);
-        _SetUpscale(dev, scaling );
- 
-        /* Apply scaling on  part-2-part offset */
-        Offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM)/scaling;
-        status = VL6180x_WrByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, Offset);
-#if ! VL6180x_EXTENDED_RANGE
-        if( status ==0 ){
-            status = VL6180x_RangeSetEceState(dev, scaling == 1); /* enable ece only at 1x scaling */
-        }
-        if( status == 0 && !VL6180x_EXTENDED_RANGE && scaling!=1 ){
-            status = NOT_GUARANTEED ;
-        }
-#endif
-    }
-    else{
-        status = INVALID_PARAMS;
-    }
-#undef min_scaling
-#undef max_scaling
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_UpscaleGetScaling(VL6180xDev_t dev)
-{
-    int status;
-    LOG_FUNCTION_START("");
-    status=_GetUpscale(dev );
-    LOG_FUNCTION_END(status);
- 
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_UpscaleStaticInit(VL6180xDev_t dev)
-{
-    /* todo make these a fail macro in case only 1x is suppoted */
-    int status;
- 
-    LOG_FUNCTION_START("");
-    do{
-        status=VL6180x_UpscaleRegInit(dev);
-        if( status){
-            VL6180x_ErrLog("regInit fail");
-            break;
-        }
-#if VL6180x_EXTENDED_RANGE
-        status = VL6180x_RangeSetEceState(dev, 0);
-        if( status){
-            VL6180x_ErrLog("VL6180x_RangeSetEceState fail");
-            break;
-        }
-#endif
-    } while(0);
-    if( !status){
-        /*  must write the scaler at least once to the device to ensure the scaler is in a known state. */
-        status=VL6180x_UpscaleSetScaling(dev, _GetUpscale(dev));
-        VL6180x_WrByte( dev, SYSTEM_FRESH_OUT_OF_RESET, 0x00); /* change fresh out of set status to 0 */
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high)
-{
-    int status;
-    LOG_FUNCTION_START("%d %d",(int) pin, (int)active_high);
- 
-    if( pin ==0  || pin ==1  ){
-       uint16_t RegIndex;
-       uint8_t  DataSet;
-       if( pin==0 )
-           RegIndex= SYSTEM_MODE_GPIO0;
-       else
-           RegIndex= SYSTEM_MODE_GPIO1;
- 
-       if (active_high )
-           DataSet = GPIOx_POLARITY_SELECT_MASK;
-       else
-           DataSet = 0;
- 
-       status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_POLARITY_SELECT_MASK, DataSet);
-    }
-    else{
-        VL6180x_ErrLog("Invalid pin param %d", (int)pin);
-        status = INVALID_PARAMS;
-    }
- 
-    LOG_FUNCTION_END(status);
- 
-    return status;
-}
- 
-int VL6180X::VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality)
-{
-    int status;
- 
-    LOG_FUNCTION_START("%d %d",(int) pin, (int)functionality);
- 
-    if( ((pin ==0)  || (pin ==1))  && IsValidGPIOFunction(functionality)  ){
-       uint16_t RegIndex;
- 
-       if( pin==0 )
-           RegIndex= SYSTEM_MODE_GPIO0;
-       else
-           RegIndex= SYSTEM_MODE_GPIO1;
- 
-       status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_FUNCTIONALITY_SELECT_MASK,  functionality<<GPIOx_FUNCTIONALITY_SELECT_SHIFT);
-       if( status){
-           VL6180x_ErrLog("Update SYSTEM_MODE_GPIO%d fail", (int)pin);
-       }
-    }
-    else{
-        VL6180x_ErrLog("Invalid pin %d  or function %d", (int)pin, (int) functionality);
-        status = INVALID_PARAMS;
-    }
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin,  uint8_t IntFunction, int  ActiveHigh)
-{
-    int status;
- 
-    LOG_FUNCTION_START("%d %d",(int) pin, (int)IntFunction);
- 
-    if( ((pin ==0)  || (pin ==1))  && IsValidGPIOFunction(IntFunction)  ){
-       uint16_t RegIndex;
-       uint8_t value=0;
- 
-       if( pin==0 )
-           RegIndex= SYSTEM_MODE_GPIO0;
-       else
-           RegIndex= SYSTEM_MODE_GPIO1;
- 
-       if( ActiveHigh  )
-           value|=GPIOx_POLARITY_SELECT_MASK;
- 
-       value |=  IntFunction<<GPIOx_FUNCTIONALITY_SELECT_SHIFT;
-       status = VL6180x_WrByte(dev, RegIndex, value);
-       if( status ){
-           VL6180x_ErrLog("SYSTEM_MODE_GPIO%d wr fail", (int)pin-SYSTEM_MODE_GPIO0);
-       }
-    }
-    else{
-        VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, (int) IntFunction);
-        status = INVALID_PARAMS;
-    }
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin) {
-    int status;
- 
-    LOG_FUNCTION_START("%d",(int)pin);
- 
-    status=VL6180x_SetGPIOxFunctionality(dev, pin, GPIOx_SELECT_OFF);
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh)
-{
-    int status;
-    LOG_FUNCTION_START("%d %d",(int)IntFunction, (int)ActiveHigh  );
-    status=VL6180x_SetupGPIOx(dev, 1 , IntFunction, ActiveHigh);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
-{
-    int status;
- 
-    if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
-        status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_RANGE_MASK), ConfigGpioInt);
-    }
-    else{
-        VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
-        status = INVALID_PARAMS;
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t  FactorM, uint16_t FactorD){
-    int status;
-    uint8_t u8;
- 
-    LOG_FUNCTION_START("%d %d", (int)FactorM, (int)FactorD );
-    do{
-        /* D cannot be 0 M must be <=D and >= 0 */
-        if( FactorM <= FactorD  && FactorD> 0){
-            VL6180xDevDataSet(dev, EceFactorM, FactorM);
-            VL6180xDevDataSet(dev, EceFactorD, FactorD);
-            /* read and re-apply max conv time to get new ece factor set */
-            status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
-            if( status){
-               VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
-               break;
-            }
-            status = VL6180x_RangeSetMaxConvergenceTime(dev, u8);
-            if( status <0 ){
-                VL6180x_ErrLog("fail to apply time after ece m/d change");
-                break;
-            }
-        }
-        else{
-            VL6180x_ErrLog("invalid factor %d/%d", (int)FactorM, (int)FactorD );
-            status = INVALID_PARAMS;
-        }
-    }
-    while(0);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable ){
-    int status;
-    uint8_t or_mask;
- 
-    LOG_FUNCTION_START("%d", (int)enable);
-    if( enable )
-        or_mask = RANGE_CHECK_ECE_ENABLE_MASK;
-    else
-        or_mask = 0;
- 
-    status =VL6180x_UpdateByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, ~RANGE_CHECK_ECE_ENABLE_MASK, or_mask);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t  MaxConTime_msec)
-{
-    int status = 0;
-    LOG_FUNCTION_START("%d",(int)MaxConTime_msec);
-    do{
-        status=VL6180x_WrByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, MaxConTime_msec);
-        if( status ){
-            break;
-        }
-        status=VL6180x_RangeSetEarlyConvergenceEestimateThreshold(dev);
-        if( status){
-            break;
-        }
-        status = _DMax_InitData(dev);
-    }
-    while(0);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t  InterMeasTime_msec){
-    uint8_t SetTime;
-    int status;
- 
-    LOG_FUNCTION_START("%d",(int)InterMeasTime_msec);
-    do {
-        if( InterMeasTime_msec > 2550 ){
-            status = INVALID_PARAMS;
-            break;
-        }
-        /* doc in not 100% clear and confusing about the limit practically all value are OK but 0
-         * that can hang device in continuous mode */
-        if( InterMeasTime_msec < 10 ) {
-            InterMeasTime_msec=10;
-        }
-        SetTime=(uint8_t)(InterMeasTime_msec/10);
-        status=VL6180x_WrByte(dev, SYSRANGE_INTERMEASUREMENT_PERIOD, SetTime);
-        if( status ){
-            VL6180x_ErrLog("SYSRANGE_INTERMEASUREMENT_PERIOD wr fail");
-        }
-        else
-        if( SetTime != InterMeasTime_msec /10 ) {
-            status = MIN_CLIPED;  /* on success change status to clip if it did */
-        }
-    }while(0);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int * Ready){
-    int status;
-    uint8_t u8;
-    LOG_FUNCTION_START("%p", (int)Ready);
-    status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
-    if( !status)
-        *Ready = u8&RANGE_DEVICE_READY_MASK;
-    LOG_FUNCTION_END_FMT(status,"%d", *Ready);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
-    int status; /* if user specify an invalid <=0 loop count we'll return error */
-    int  n;
-    uint8_t u8;
-    LOG_FUNCTION_START("%d", (int)MaxLoop);
-    if( MaxLoop<1){
-        status=INVALID_PARAMS;
-    }
-    else{
-        for( n=0; n < MaxLoop ; n++){
-            status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
-            if( status)
-                break;
-            u8 = u8 & RANGE_DEVICE_READY_MASK;
-            if( u8 )
-                break;
- 
-        }
-        if( !status && !u8 ){
-            status = TIME_OUT;
-        }
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t  mode)
-{
-    int status;
-    LOG_FUNCTION_START("%d", (int)mode);
-    /* FIXME we are not checking device is ready via @a VL6180x_RangeWaitDeviceReady
-     * so if called back to back real fast we are not checking
-     * if previous mode "set" got absorbed => bit 0 must be 0 so that it work
-     */
-    if( mode <= 3){
-        status=VL6180x_WrByte(dev, SYSRANGE_START, mode);
-        if( status ){
-            VL6180x_ErrLog("SYSRANGE_START wr fail");
-        }
-    }
-    else{
-        status = INVALID_PARAMS;
-    }
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeStartContinuousMode(VL6180xDev_t dev)
-{
-    int status;
-    LOG_FUNCTION_START("");
-    status= VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_CONTINUOUS);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_RangeStartSingleShot(VL6180xDev_t dev) {
-    int status;
-    LOG_FUNCTION_START("");
-    status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-int VL6180X::VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev)
-{
-    int status;
- 
-    const uint32_t cMicroSecPerMilliSec  = 1000;
-    const uint32_t cEceSampleTime_us     = 500;
-    uint32_t ece_factor_m          = VL6180xDevDataGet(dev, EceFactorM);
-    uint32_t ece_factor_d          = VL6180xDevDataGet(dev, EceFactorD);
-    uint32_t convergTime_us;
-    uint32_t fineThresh;
-    uint32_t eceThresh;
-    uint8_t  u8;
-    uint32_t maxConv_ms;
-    int32_t AveTime;
- 
-    LOG_FUNCTION_START("");
- 
-    do{
-        status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
-        if( status ){
-            VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail");
-            break;
-        }
-        maxConv_ms = u8;
-        AveTime = _GetAveTotalTime(dev);
-        if( AveTime <0 ){
-            status=-1;
-            break;
-        }
- 
-        convergTime_us = maxConv_ms * cMicroSecPerMilliSec - AveTime;
-        status = VL6180x_RdDWord(dev, 0xB8, &fineThresh);
-        if( status ) {
-            VL6180x_ErrLog("reg 0xB8 rd fail");
-            break;
-        }
-        fineThresh*=256;
-        eceThresh      = ece_factor_m * cEceSampleTime_us * fineThresh/(convergTime_us * ece_factor_d);
- 
-        status=VL6180x_WrWord(dev, SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, (uint16_t)eceThresh);
-    }
-    while(0);
- 
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-/*
- * Return >0 = time
- *       <0 1 if fail to get read data from device to compute time
- */
-int32_t VL6180X::_GetAveTotalTime(VL6180xDev_t dev) {
-    uint32_t cFwOverhead_us = 24;
-    uint32_t cVcpSetupTime_us = 70;
-    uint32_t cPLL2_StartupDelay_us = 200;
-    uint8_t cMeasMask = 0x07;
-    uint32_t Samples;
-    uint32_t SamplePeriod;
-    uint32_t SingleTime_us;
-    int32_t TotalAveTime_us;
-    uint8_t u8;
-    int status;
- 
-    LOG_FUNCTION_START("");
- 
-    status = VL6180x_RdByte(dev, 0x109, &u8);
-    if (status) {
-        VL6180x_ErrLog("rd 0x109 fail");
-        return -1;
-    }
-    Samples = u8 & cMeasMask;
-    status = VL6180x_RdByte(dev, READOUT_AVERAGING_SAMPLE_PERIOD, &u8);
-    if (status) {
-        VL6180x_ErrLog("i2c READOUT_AVERAGING_SAMPLE_PERIOD fail");
-        return -1;
-    }
-    SamplePeriod = u8;
-    SingleTime_us = cFwOverhead_us + cVcpSetupTime_us + (SamplePeriod * 10);
-    TotalAveTime_us = (Samples + 1) * SingleTime_us + cPLL2_StartupDelay_us;
- 
-    LOG_FUNCTION_END(TotalAveTime_us);
-    return TotalAveTime_us;
-}
- 
-#if VL6180x_HAVE_DMAX_RANGING
-#define _GetDMaxDataRetSignalAt400mm(dev) VL6180xDevDataGet(dev, DMaxData.retSignalAt400mm)
-#else
-#define _GetDMaxDataRetSignalAt400mm(dev) 375 // Use a default high value
-#endif
- 
- 
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
- 
-#define FILTER_STDDEV_SAMPLES           6
-#define MIN_FILTER_STDDEV_SAMPLES       3
-#define MIN_FILTER_VALID_STDDEV_SAMPLES 3
-#define FILTER_INVALID_DISTANCE     65535
- 
-#define _FilterData(field) VL6180xDevDataGet(dev, FilterData.field)
-/*
- * One time init
- */
-static int _filter_Init( VL6180xDev_t dev) {
-    int i;
-    _FilterData(MeasurementIndex) = 0;
- 
-    _FilterData(Default_ZeroVal) = 0;
-    _FilterData(Default_VAVGVal) = 0;
-    _FilterData(NoDelay_ZeroVal) = 0;
-    _FilterData(NoDelay_VAVGVal) = 0;
-    _FilterData(Previous_VAVGDiff) = 0;
- 
-    _FilterData(StdFilteredReads) = 0;
- 
-    for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
-        _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
-        _FilterData(LastReturnRates)[i] = 0;
-    }
-    return 0;
-}
- 
- 
-static uint32_t _filter_StdDevDamper(uint32_t AmbientRate, uint32_t SignalRate, const uint32_t StdDevLimitLowLight, const uint32_t StdDevLimitLowLightSNR, const uint32_t StdDevLimitHighLight, const uint32_t StdDevLimitHighLightSNR) {
-    uint32_t newStdDev;
-    uint16_t SNR;
- 
-    if (AmbientRate > 0)
-        SNR = (uint16_t) ((100 * SignalRate) / AmbientRate);
-    else
-        SNR = 9999;
- 
-    if (SNR >= StdDevLimitLowLightSNR) {
-        newStdDev = StdDevLimitLowLight;
-    } else {
-        if (SNR <= StdDevLimitHighLightSNR)
-            newStdDev = StdDevLimitHighLight;
-        else {
-            newStdDev = (uint32_t) (StdDevLimitHighLight + (SNR - StdDevLimitHighLightSNR) * (int) (StdDevLimitLowLight - StdDevLimitHighLight) / (StdDevLimitLowLightSNR - StdDevLimitHighLightSNR));
-        }
-    }
- 
-    return newStdDev;
-}
- 
- 
-/*
- * Return <0 on error
- */
-int32_t VL6180X::_filter_Start(VL6180xDev_t dev, uint16_t m_trueRange_mm, uint16_t m_rawRange_mm, uint32_t m_rtnSignalRate, uint32_t m_rtnAmbientRate, uint16_t errorCode) {
-    int status;
-    uint16_t m_newTrueRange_mm = 0;
- 
-    uint16_t i;
-    uint16_t bypassFilter = 0;
- 
-    uint16_t registerValue;
- 
-    uint32_t register32BitsValue1;
-    uint32_t register32BitsValue2;
- 
-    uint16_t ValidDistance = 0;
- 
-    uint16_t WrapAroundFlag = 0;
-    uint16_t NoWrapAroundFlag = 0;
-    uint16_t NoWrapAroundHighConfidenceFlag = 0;
- 
-    uint16_t FlushFilter = 0;
-    uint32_t RateChange = 0;
- 
-    uint16_t StdDevSamples = 0;
-    uint32_t StdDevDistanceSum = 0;
-    uint32_t StdDevDistanceMean = 0;
-    uint32_t StdDevDistance = 0;
-    uint32_t StdDevRateSum = 0;
-    uint32_t StdDevRateMean = 0;
-    uint32_t StdDevRate = 0;
-    uint32_t StdDevLimitWithTargetMove = 0;
- 
-    uint32_t VAVGDiff;
-    uint32_t IdealVAVGDiff;
-    uint32_t MinVAVGDiff;
-    uint32_t MaxVAVGDiff;
- 
-    /* Filter Parameters */
-    static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit = 60;
-    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit_ROM = 800; // Shall be adapted depending on crossTalk
-    static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit2 = 165;
-    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit2_ROM = 180; // Shall be adapted depending on crossTalk and device sensitivity
- 
-    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateFilterLimit_ROM = 850; // Shall be adapted depending on crossTalk and device sensitivity
-    static const uint16_t ROMABLE_DATA WrapAroundHighRawRangeFilterLimit = 350;
-    static const uint32_t ROMABLE_DATA WrapAroundHighReturnRateFilterLimit_ROM = 1400; // Shall be adapted depending on crossTalk and device sensitivity
- 
-    static const uint32_t ROMABLE_DATA WrapAroundMaximumAmbientRateFilterLimit = 7500;
- 
-    /*  Temporal filter data and flush values */
-    static const uint32_t ROMABLE_DATA MinReturnRateFilterFlush = 75;
-    static const uint32_t ROMABLE_DATA MaxReturnRateChangeFilterFlush = 50;
- 
-    /* STDDEV values and damper values */
- 
-    static const uint32_t ROMABLE_DATA StdDevLimitLowLight = 300;
-    static const uint32_t ROMABLE_DATA StdDevLimitLowLightSNR = 30; /* 0.3 */
-    static const uint32_t ROMABLE_DATA StdDevLimitHighLight = 2500;
-    static const uint32_t ROMABLE_DATA StdDevLimitHighLightSNR = 5; /* 0.05 */
- 
-    static const uint32_t ROMABLE_DATA StdDevHighConfidenceSNRLimit = 8;
- 
-    static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevLimit = 90000;
- 
-    static const uint32_t ROMABLE_DATA StdDevMovingTargetReturnRateLimit = 3500;
-    static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevForReturnRateLimit = 5000;
- 
-    static const uint32_t ROMABLE_DATA MAX_VAVGDiff = 1800;
- 
-    /* WrapAroundDetection variables */
-    static const uint16_t ROMABLE_DATA WrapAroundNoDelayCheckPeriod = 2;
-    static const uint16_t ROMABLE_DATA StdFilteredReadsIncrement = 2;
-    static const uint16_t ROMABLE_DATA StdMaxFilteredReads = 4;
-    
-    uint32_t SignalRateDMax;
-    uint32_t WrapAroundLowReturnRateLimit; 
-    uint32_t WrapAroundLowReturnRateLimit2;
-    uint32_t WrapAroundLowReturnRateFilterLimit;
-    uint32_t WrapAroundHighReturnRateFilterLimit; 
- 
-    uint8_t u8, u8_2;
-    uint32_t XTalkCompRate_KCps;
-    uint32_t StdDevLimit = 300;
-    uint32_t MaxOrInvalidDistance =   255*_GetUpscale(dev);
-    /* #define MaxOrInvalidDistance  (uint16_t) (255 * 3) */
- 
-    /* Check if distance is Valid or not */
-    switch (errorCode) {
-    case 0x0C:
-        m_trueRange_mm = MaxOrInvalidDistance;
-        ValidDistance = 0;
-        break;
-    case 0x0D:
-        m_trueRange_mm = MaxOrInvalidDistance;
-        ValidDistance = 1;
-        break;
-    case 0x0F:
-        m_trueRange_mm = MaxOrInvalidDistance;
-        ValidDistance = 1;
-        break;
-    default:
-        if (m_rawRange_mm >= MaxOrInvalidDistance) {
-            ValidDistance = 0;
-        } else {
-            ValidDistance = 1;
-        }
-        break;
-    }
-    m_newTrueRange_mm = m_trueRange_mm;
-    
-    XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps );
- 
-    
-    //Update signal rate limits depending on crosstalk
-    SignalRateDMax = (uint32_t)_GetDMaxDataRetSignalAt400mm(dev) + XTalkCompRate_KCps;
-    WrapAroundLowReturnRateLimit = WrapAroundLowReturnRateLimit_ROM  + XTalkCompRate_KCps; 
-    WrapAroundLowReturnRateLimit2 = ((WrapAroundLowReturnRateLimit2_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
-    WrapAroundLowReturnRateFilterLimit = ((WrapAroundLowReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
-    WrapAroundHighReturnRateFilterLimit = ((WrapAroundHighReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps; 
- 
- 
-    /* Checks on low range data */
-    if ((m_rawRange_mm < WrapAroundLowRawRangeLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit)) {
-        m_newTrueRange_mm = MaxOrInvalidDistance;
-        bypassFilter = 1;
-    }
-    if ((m_rawRange_mm < WrapAroundLowRawRangeLimit2) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit2)) {
-        m_newTrueRange_mm = MaxOrInvalidDistance;
-        bypassFilter = 1;
-    }
- 
-    /* Checks on Ambient rate level */
-    if (m_rtnAmbientRate > WrapAroundMaximumAmbientRateFilterLimit) {
-        /* Too high ambient rate */
-        FlushFilter = 1;
-        bypassFilter = 1;
-    }
-    /*  Checks on Filter flush */
-    if (m_rtnSignalRate < MinReturnRateFilterFlush) {
-        /* Completely lost target, so flush the filter */
-        FlushFilter = 1;
-        bypassFilter = 1;
-    }
-    if (_FilterData(LastReturnRates)[0] != 0) {
-        if (m_rtnSignalRate > _FilterData(LastReturnRates)[0])
-            RateChange = (100 * (m_rtnSignalRate - _FilterData(LastReturnRates)[0])) / _FilterData(LastReturnRates)[0];
-        else
-            RateChange = (100 * (_FilterData(LastReturnRates)[0] - m_rtnSignalRate)) / _FilterData(LastReturnRates)[0];
-    } else
-        RateChange = 0;
-    if (RateChange > MaxReturnRateChangeFilterFlush) {
-        FlushFilter = 1;
-    }
-/* TODO optimize filter  using circular buffer */
-    if (FlushFilter == 1) {
-        _FilterData(MeasurementIndex) = 0;
-        for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
-            _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
-            _FilterData(LastReturnRates)[i] = 0;
-        }
-    } else {
-        for (i = (uint16_t) (FILTER_NBOF_SAMPLES - 1); i > 0; i--) {
-            _FilterData(LastTrueRange)[i] = _FilterData(LastTrueRange)[i - 1];
-            _FilterData(LastReturnRates)[i] = _FilterData(LastReturnRates)[i - 1];
-        }
-    }
-    if (ValidDistance == 1)
-        _FilterData(LastTrueRange)[0] = m_trueRange_mm;
-    else
-        _FilterData(LastTrueRange)[0] = FILTER_INVALID_DISTANCE;
-    _FilterData(LastReturnRates)[0] = m_rtnSignalRate;
- 
-    /* Check if we need to go through the filter or not */
-    if (!(((m_rawRange_mm < WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateFilterLimit)) || ((m_rawRange_mm >= WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundHighReturnRateFilterLimit))))
-        bypassFilter = 1;
- 
-    /* Check which kind of measurement has been made */
-    status = VL6180x_RdByte(dev, 0x01AC, &u8 );
-    if( status ){
-        VL6180x_ErrLog("0x01AC rd fail");
-        goto done_err;
-    }
-    registerValue =u8;
- 
-    /* Read data for filtering */
-    status = VL6180x_RdByte(dev, 0x10C, &u8 ); /* read only 8 lsb bits */
-    if( status ){
-        VL6180x_ErrLog("0x010C rd fail");
-        goto done_err;
-    }
-    register32BitsValue1=u8;
-    status = VL6180x_RdByte(dev, 0x0110, &u8); /* read only 8 lsb bits */
-    if( status ){
-        VL6180x_ErrLog("0x0110 rd fail");
-        goto done_err;
-    }
-    register32BitsValue2 = u8;
- 
-    if (registerValue == 0x3E) {
-        _FilterData(Default_ZeroVal) = register32BitsValue1;
-        _FilterData(Default_VAVGVal) = register32BitsValue2;
-    } else {
-        _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
-        _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
-    }
- 
-    if (bypassFilter == 1) {
-        /* Do not go through the filter */
-        if (registerValue != 0x3E) {
-            status = VL6180x_WrByte(dev, 0x1AC, 0x3E);
-            if( status ){
-                VL6180x_ErrLog("0x01AC bypass wr fail");
-                goto done_err;
-            }
-            status = VL6180x_WrByte(dev, 0x0F2, 0x01);
-            if( status ){
-                VL6180x_ErrLog("0x0F2 bypass wr fail");
-                goto done_err;
-            }
-        }
-        /* Set both Default and NoDelay To same value */
-        _FilterData(Default_ZeroVal) = register32BitsValue1;
-        _FilterData(Default_VAVGVal) = register32BitsValue2;
-        _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
-        _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
-        _FilterData(MeasurementIndex) = 0;
- 
-        return m_newTrueRange_mm;
-    }
- 
-    if (_FilterData(MeasurementIndex) % WrapAroundNoDelayCheckPeriod == 0) {
-        u8=0x3C;
-        u8_2 = 0x05;
-    } else {
-        u8=0x3E;
-        u8_2 = 0x01;
-    }
-    status = VL6180x_WrByte(dev, 0x01AC, u8);
-    if( status ){
-        VL6180x_ErrLog("0x01AC wr fail");
-        goto done_err;
-    }
-    status = VL6180x_WrByte(dev, 0x0F2, u8_2);
-    if( status ){
-        VL6180x_ErrLog("0x0F2  wr fail");
-        goto done_err;
-    }
- 
- 
-    _FilterData(MeasurementIndex)++;
- 
-    /* Computes current VAVGDiff */
-    if (_FilterData(Default_VAVGVal) > _FilterData(NoDelay_VAVGVal))
-        VAVGDiff = _FilterData(Default_VAVGVal) - _FilterData(NoDelay_VAVGVal);
-    else
-        VAVGDiff = 0;
-    _FilterData(Previous_VAVGDiff) = VAVGDiff;
- 
-    /* Check the VAVGDiff */
-    if (_FilterData(Default_ZeroVal) > _FilterData(NoDelay_ZeroVal))
-        IdealVAVGDiff = _FilterData(Default_ZeroVal) - _FilterData(NoDelay_ZeroVal);
-    else
-        IdealVAVGDiff = _FilterData(NoDelay_ZeroVal) - _FilterData(Default_ZeroVal);
-    if (IdealVAVGDiff > MAX_VAVGDiff)
-        MinVAVGDiff = IdealVAVGDiff - MAX_VAVGDiff;
-    else
-        MinVAVGDiff = 0;
-    MaxVAVGDiff = IdealVAVGDiff + MAX_VAVGDiff;
-    if (VAVGDiff < MinVAVGDiff || VAVGDiff > MaxVAVGDiff) {
-        WrapAroundFlag = 1;
-    } else {
-        /* Go through filtering check */
- 
-        /* StdDevLimit Damper on SNR */
-        StdDevLimit = _filter_StdDevDamper(m_rtnAmbientRate, m_rtnSignalRate, StdDevLimitLowLight, StdDevLimitLowLightSNR, StdDevLimitHighLight, StdDevLimitHighLightSNR);
- 
-        /* Standard deviations computations */
-        StdDevSamples = 0;
-        StdDevDistanceSum = 0;
-        StdDevDistanceMean = 0;
-        StdDevDistance = 0;
-        StdDevRateSum = 0;
-        StdDevRateMean = 0;
-        StdDevRate = 0;
-        for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
-            if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
-                StdDevSamples = (uint16_t) (StdDevSamples + 1);
-                StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + _FilterData(LastTrueRange)[i]);
-                StdDevRateSum = (uint32_t) (StdDevRateSum + _FilterData(LastReturnRates)[i]);
-            }
-        }
-        if (StdDevSamples > 0) {
-            StdDevDistanceMean = (uint32_t) (StdDevDistanceSum / StdDevSamples);
-            StdDevRateMean = (uint32_t) (StdDevRateSum / StdDevSamples);
-        }
-        /* TODO optimize shorten Std dev in aisngle loop computation using sum of x2 - (sum of x)2 */
-        StdDevSamples = 0;
-        StdDevDistanceSum = 0;
-        StdDevRateSum = 0;
-        for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
-            if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
-                StdDevSamples = (uint16_t) (StdDevSamples + 1);
-                StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean) * (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean));
-                StdDevRateSum = (uint32_t) (StdDevRateSum + (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean) * (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean));
-            }
-        }
-        if (StdDevSamples >= MIN_FILTER_STDDEV_SAMPLES) {
-            StdDevDistance = (uint16_t) (StdDevDistanceSum / StdDevSamples);
-            StdDevRate = (uint16_t) (StdDevRateSum / StdDevSamples);
-        } else {
-            StdDevDistance = 0;
-            StdDevRate = 0;
-        }
- 
-        /* Check Return rate standard deviation */
-        if (StdDevRate < StdDevMovingTargetStdDevLimit) {
-            if (StdDevSamples < MIN_FILTER_VALID_STDDEV_SAMPLES) {
-                m_newTrueRange_mm = MaxOrInvalidDistance;
-            } else {
-                /* Check distance standard deviation */
-                if (StdDevRate < StdDevMovingTargetReturnRateLimit)
-                    StdDevLimitWithTargetMove = StdDevLimit + (((StdDevMovingTargetStdDevForReturnRateLimit - StdDevLimit) * StdDevRate) / StdDevMovingTargetReturnRateLimit);
-                else
-                    StdDevLimitWithTargetMove = StdDevMovingTargetStdDevForReturnRateLimit;
- 
-                if ((StdDevDistance * StdDevHighConfidenceSNRLimit) < StdDevLimitWithTargetMove) {
-                    NoWrapAroundHighConfidenceFlag = 1;
-                } else {
-                    if (StdDevDistance < StdDevLimitWithTargetMove) {
-                        if (StdDevSamples >= MIN_FILTER_VALID_STDDEV_SAMPLES) {
-                            NoWrapAroundFlag = 1;
-                        } else {
-                            m_newTrueRange_mm = MaxOrInvalidDistance;
-                        }
-                    } else {
-                        WrapAroundFlag = 1;
-                    }
-                }
-            }
-        } else {
-            WrapAroundFlag = 1;
-        }
-    }
- 
-    if (m_newTrueRange_mm == MaxOrInvalidDistance) {
-        if (_FilterData(StdFilteredReads) > 0)
-            _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - 1);
-    } else {
-        if (WrapAroundFlag == 1) {
-            m_newTrueRange_mm = MaxOrInvalidDistance;
-            _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) + StdFilteredReadsIncrement);
-            if (_FilterData(StdFilteredReads) > StdMaxFilteredReads)
-                _FilterData(StdFilteredReads) = StdMaxFilteredReads;
-        } else {
-            if (NoWrapAroundFlag == 1) {
-                if (_FilterData(StdFilteredReads) > 0) {
-                    m_newTrueRange_mm = MaxOrInvalidDistance;
-                    if (_FilterData(StdFilteredReads) > StdFilteredReadsIncrement)
-                        _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - StdFilteredReadsIncrement);
-                    else
-                        _FilterData(StdFilteredReads) = 0;
-                }
-            } else {
-                if (NoWrapAroundHighConfidenceFlag == 1) {
-                    _FilterData(StdFilteredReads) = 0;
-                }
-            }
-        }
-    }
- 
-    return m_newTrueRange_mm;
-    done_err:
-    return -1;
- 
-    #undef MaxOrInvalidDistance
-}
- 
- 
-int VL6180X::_filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
-    uint32_t m_rawRange_mm = 0;
-    int32_t  FilteredRange;
-    const uint8_t scaler = _GetUpscale(dev);
-    uint8_t u8;
-    int status;
- 
-    do {
-        status = VL6180x_RdByte(dev, RESULT_RANGE_RAW, &u8);
-        if (status) {
-            VL6180x_ErrLog("RESULT_RANGE_RAW rd fail");
-            break;
-        }
-        m_rawRange_mm = u8;
- 
-        FilteredRange = _filter_Start(dev, pRangeData->range_mm, (m_rawRange_mm * scaler), pRangeData->rtnRate, pRangeData->rtnAmbRate, pRangeData->errorStatus);
-        if( FilteredRange<0 ){
-            status = -1;
-            break;
-        }
-        pRangeData->FilteredData.range_mm= FilteredRange;
-        pRangeData->FilteredData.rawRange_mm = m_rawRange_mm * scaler;
-    } while (0);
-    return status;
-}
- 
-#undef _FilterData
-#undef FILTER_STDDEV_SAMPLES
-#undef MIN_FILTER_STDDEV_SAMPLES
-#undef MIN_FILTER_VALID_STDDEV_SAMPLES
-#undef FILTER_INVALID_DISTANCE
- 
-#endif /* VL6180x_WRAP_AROUND_FILTER_SUPPORT */
- 
-#ifdef VL6180x_HAVE_RATE_DATA
- 
-int VL6180X::_GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
-    uint32_t m_rtnConvTime = 0;
-    uint32_t m_rtnSignalRate = 0;
-    uint32_t m_rtnAmbientRate = 0;
-    uint32_t m_rtnSignalCount = 0;
-    uint32_t m_rtnAmbientCount = 0;
-    uint32_t m_refConvTime = 0;
-    uint32_t cRtnSignalCountMax = 0x7FFFFFFF;
-    uint32_t cDllPeriods = 6;
-    uint32_t calcConvTime = 0;
- 
-    int status;
- 
-    do {
- 
-        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_SIGNAL_COUNT, &m_rtnSignalCount);
-        if (status) {
-            VL6180x_ErrLog("RESULT_RANGE_RETURN_SIGNAL_COUNT rd fail");
-            break;
-        }
-        if (m_rtnSignalCount > cRtnSignalCountMax) {
-            m_rtnSignalCount = 0;
-        }
- 
-        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_AMB_COUNT, &m_rtnAmbientCount);
-        if (status) {
-            VL6180x_ErrLog("RESULT_RANGE_RETURN_AMB_COUNTrd fail");
-            break;
-        }
- 
- 
-        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_CONV_TIME, &m_rtnConvTime);
-        if (status) {
-            VL6180x_ErrLog("RESULT_RANGE_RETURN_CONV_TIME rd fail");
-            break;
-        }
- 
-        status = VL6180x_RdDWord(dev, RESULT_RANGE_REFERENCE_CONV_TIME, &m_refConvTime);
-        if (status) {
-            VL6180x_ErrLog("RESULT_RANGE_REFERENCE_CONV_TIME rd fail");
-            break;
-        }
- 
-        pRangeData->rtnConvTime = m_rtnConvTime;
-        pRangeData->refConvTime = m_refConvTime;
- 
-        calcConvTime = m_refConvTime;
-        if (m_rtnConvTime > m_refConvTime) {
-            calcConvTime = m_rtnConvTime;
-        }
-        if (calcConvTime == 0)
-            calcConvTime = 63000;
- 
-        m_rtnSignalRate = (m_rtnSignalCount * 1000) / calcConvTime;
-        m_rtnAmbientRate = (m_rtnAmbientCount * cDllPeriods * 1000) / calcConvTime;
- 
-        pRangeData->rtnRate = m_rtnSignalRate;
-        pRangeData->rtnAmbRate = m_rtnAmbientRate;
- 
- 
-    } while (0);
-    return status;
-}
-#endif /* VL6180x_HAVE_RATE_DATA */
- 
- 
-int VL6180X::VL6180x_DMaxSetState(VL6180xDev_t dev, int state){
-    int status;
-    LOG_FUNCTION_START("%d", state);
-#if VL6180x_HAVE_DMAX_RANGING
-    VL6180xDevDataSet(dev,DMaxEnable, state);
-    if( state ){
-        status = _DMax_InitData(dev);
-    }
-    else {
-        status = 0;
-    }
-#else
-    status =  NOT_SUPPORTED;
-#endif
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-int VL6180X::VL6180x_DMaxGetState(VL6180xDev_t dev){
-    int status;
-    LOG_FUNCTION_START("");
-#if VL6180x_HAVE_DMAX_RANGING
-    status = VL6180xDevDataGet(dev,DMaxEnable);
-#else
-    status = 0;
-#endif
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
- 
-#if VL6180x_HAVE_DMAX_RANGING
- 
-#define _DMaxData(field) VL6180xDevDataGet(dev, DMaxData.field)
-/*
- * Convert fix point  x.7 to KCpount per sec
- */
- 
-#ifndef VL6180x_PLATFORM_PROVIDE_SQRT
- 
-/*
- * 32 bit integer square root with not so bad precision (integer result) and is quite fast
- * see http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
- */
-uint32_t VL6180x_SqrtUint32(uint32_t num) {
-    uint32_t res = 0;
-    uint32_t bit = 1 << 30; /* The second-to-top bit is set: 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;
-}
-#endif
- 
- 
-/* DMax one time init */
-void _DMax_OneTimeInit(VL6180xDev_t dev){
-    _DMaxData(ambTuningWindowFactor_K)=DEF_AMBIENT_TUNING;
-}
- 
- 
-static uint32_t _DMax_RawValueAtRateKCps(VL6180xDev_t dev, int32_t rate){
-    uint32_t snrLimit_K;
-    int32_t DMaxSq;
-    uint32_t RawDMax;
-    DMaxFix_t retSignalAt400mm;
-    uint32_t ambTuningWindowFactor_K;
- 
- 
-    ambTuningWindowFactor_K = _DMaxData(ambTuningWindowFactor_K);
-    snrLimit_K              = _DMaxData(snrLimit_K);
-    retSignalAt400mm        = _DMaxData(retSignalAt400mm); /* 12 to 18 bits Kcps */
-    if( rate > 0 ){
-        DMaxSq = 400*400*1000 / rate -(400*400/330); /* K of (1/RtnAmb -1/330 )=> 30bit- (12-18)bit  => 12-18 bits*/
-        if( DMaxSq<= 0){
-            RawDMax = 0;
-        }
-        else{
-            /* value can be more 32 bit so base on raneg apply *retSignalAt400mm before or after division to presevr accuracy */
-            if( DMaxSq< (2<<12)  ){
-                DMaxSq = DMaxSq*retSignalAt400mm/(snrLimit_K+ambTuningWindowFactor_K);       /* max 12 + 12 to 18 -10 => 12-26 bit */
-            }else{
-                DMaxSq = DMaxSq/(snrLimit_K+ambTuningWindowFactor_K)*retSignalAt400mm;       /* 12 to 18 -10 + 12 to 18 *=> 12-26 bit */
-            }
-            RawDMax=VL6180x_SqrtUint32(DMaxSq);
-        }
-    }
-    else{
-        RawDMax = 0x7FFFFFFF; /* bigest possibmle 32bit signed value */
-    }
-    return RawDMax;
-}
- 
-/*
- * fetch static data from register to avoid re-read
- * precompute all intermediate constant and cliipings
- *
- * to be re-used/call on  changes of :
- *  0x2A
- *  SYSRANGE_MAX_AMBIENT_LEVEL_MULT
- *  Dev Data XtalkComRate_KCPs
- *  SYSRANGE_MAX_CONVERGENCE_TIME
- *  SYSRANGE_RANGE_CHECK_ENABLES    mask RANGE_CHECK_RANGE_ENABLE_MASK
- *  range 0xb8-0xbb (0xbb)
- */
-int VL6180X::_DMax_InitData(VL6180xDev_t dev){
-    int status, warning;
-    uint8_t u8;
-    uint16_t u16;
-    uint32_t u32;
-    uint32_t Reg2A_KCps;
-    uint32_t RegB8;
-    uint8_t  MaxConvTime;
-    uint32_t XTalkCompRate_KCps;
-    uint32_t RangeIgnoreThreshold;
-    int32_t minSignalNeeded;
-    uint8_t SysRangeCheckEn;
-    uint8_t snrLimit;
-    warning=0;
- 
-    static const int ROMABLE_DATA MaxConvTimeAdjust=-4;
- 
-    LOG_FUNCTION_START("");
-    do{
-        status = VL6180x_RdByte(dev, 0x02A ,&u8);
-        if( status ){
-            VL6180x_ErrLog("Reg 0x02A rd fail");
-            break;
-        }
- 
-        if( u8 == 0 ) {
-            warning = CALIBRATION_WARNING;
-            u8 = 40; /* use a default average value */
-        }
-        Reg2A_KCps = Fix7_2_KCPs(u8); /* convert to KCPs */
- 
-        status = VL6180x_RdByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, &SysRangeCheckEn);
-        if (status) {
-            VL6180x_ErrLog("SYSRANGE_RANGE_CHECK_ENABLES rd fail ");
-            break;
-        }
- 
-        status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &MaxConvTime);
-        if( status){
-            VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
-            break;
-        }
- 
-        status = VL6180x_RdDWord(dev, 0x0B8, &RegB8);
-        if( status ){
-            VL6180x_ErrLog("reg 0x0B8 rd fail ");
-            break;
-        }
- 
-        status = VL6180x_RdByte(dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, &snrLimit);
-        if( status){
-            VL6180x_ErrLog("SYSRANGE_MAX_AMBIENT_LEVEL_MULT rd fail ");
-            break;
-        }
-        _DMaxData(snrLimit_K) = (int32_t)16*1000/snrLimit;
-        XTalkCompRate_KCps =   VL6180xDevDataGet(dev, XTalkCompRate_KCps );
- 
-        if( Reg2A_KCps >= XTalkCompRate_KCps){
-            _DMaxData(retSignalAt400mm)=( Reg2A_KCps - XTalkCompRate_KCps);
-        }
-        else{
-            _DMaxData(retSignalAt400mm)=0;             /* Reg2A_K - XTalkCompRate_KCp <0 is invalid */
-        }
- 
-        /* if xtalk range check is off omit it in snr clipping */
-        if( SysRangeCheckEn&RANGE_CHECK_RANGE_ENABLE_MASK ){
-            status = VL6180x_RdWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &u16);
-            if( status){
-                VL6180x_ErrLog("SYSRANGE_RANGE_IGNORE_THRESHOLD rd fail ");
-                break;
-            }
-            RangeIgnoreThreshold = Fix7_2_KCPs(u16);
-        }
-        else{
-            RangeIgnoreThreshold  = 0;
-        }
- 
-        minSignalNeeded = (RegB8*256)/((int32_t)MaxConvTime+(int32_t)MaxConvTimeAdjust); /* KCps 8+8 bit -(1 to 6 bit) => 15-10 bit */
-        /* minSignalNeeded = max ( minSignalNeeded,  RangeIgnoreThreshold - XTalkCompRate_KCps) */
-        if( minSignalNeeded  <= RangeIgnoreThreshold - XTalkCompRate_KCps )
-            minSignalNeeded  =  RangeIgnoreThreshold - XTalkCompRate_KCps;
- 
-        u32 = (minSignalNeeded*(uint32_t)snrLimit)/16;
-        _DMaxData(ClipSnrLimit ) = _DMax_RawValueAtRateKCps(dev, u32 ); /* clip to dmax to min signal snr limit rate*/
-    }
-    while(0);
-    if( !status )
-        status = warning;
-    LOG_FUNCTION_END(status);
-    return status;
-}
- 
-static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange){
-    uint32_t rtnAmbRate;
-    int32_t DMax;
-    int scaling;
-    uint16_t HwLimitAtScale;
-    static const int ROMABLE_DATA rtnAmbLowLimit_KCps=330*1000;
- 
-    rtnAmbRate = pRange->rtnAmbRate;
-    if( rtnAmbRate  < rtnAmbLowLimit_KCps ){
-        DMax = _DMax_RawValueAtRateKCps( dev, rtnAmbRate);
-        scaling = _GetUpscale(dev);
-        HwLimitAtScale=UpperLimitLookUP[scaling - 1];
- 
-        if( DMax > _DMaxData(ClipSnrLimit) ){
-            DMax=_DMaxData(ClipSnrLimit);
-        }
-        if( DMax > HwLimitAtScale ){
-            DMax=HwLimitAtScale;
-        }
-        pRange->DMax=DMax;
-    }
-    else{
-        pRange->DMax = 0;
-    }
-    return 0;
-}
- 
-#undef _DMaxData
-#undef Fix7_2_KCPs
- 
-#endif /* VL6180x_HAVE_DMAX_RANGING */
- 
- 
-/******************************************************************************/
-/******************************************************************************/
- 
- 
- 
-/****************** Write and read functions from I2C *************************/
- 
-int VL6180X::VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data)
-{
-   int  status;
- 
-   status=VL6180x_I2CWrite(Device->I2cAddr, index, &data,(uint8_t)1);
-   return status;
-}
- 
-int VL6180X::VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data)
-{
-   int  status;
-   
-   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)2);
-   return status;
-}
- 
-int VL6180X::VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data)
-{
-   int  status;
-   
-   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)4);
-   return status;
-}
- 
-int VL6180X::VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data)
-{
-   int  status;
-    
-   uint8_t buffer;
-   status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
-   if(!status)
-   {
-      *data=buffer;
-   }
-   return status;
-}
- 
-int VL6180X::VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data)
-{
-   int  status;
-    
-   uint8_t buffer[2];
-   status=VL6180x_I2CRead(Device->I2cAddr, index, buffer, 2);
-   if(!status)
-   {
-      memcpy(data, buffer, 2);
-   }
-   return status;
-}
- 
-int VL6180X::VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data)
-{
-   int status;
-   uint8_t buffer[4];
-   status=VL6180x_I2CRead(Device->I2cAddr, index, buffer,4);
-   if(!status)
-   {
-      memcpy(data, buffer, 4);
-   }
-   return status;
-}
- 
-int VL6180X::VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData)
-{
-   int  status;
-   uint8_t buffer;
- 
-   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)buffer,(uint8_t)0);
-   if(!status)
-   {
-      /* read data direct onto buffer */
-      status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
-      if(!status)
-      {
-         buffer=(buffer & AndData)|OrData;
-         status=VL6180x_I2CWrite(Device->I2cAddr, index, &buffer, (uint8_t)1);
-      }
-   }
-   return status;
-}
- 
-int VL6180X::VL6180x_I2CWrite(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToWrite)
-{
-   int ret;
-   int i;
-   uint8_t tmp[TEMP_BUF_SIZE];
-   uint16_t myRegisterAddr = RegisterAddr;
-   uint16_t WriteDeviceAddr=0;
-   
-   /* First, prepare 8 bits device address in 7bits i2ci format */
-   WriteDeviceAddr=DeviceAddr*2;
-   if(NumByteToWrite >= TEMP_BUF_SIZE) return -2;
-        
-   /* then prepare 16 bits register address in BE format. Then, send data and STOP condition */
-   tmp[0] = *(((uint8_t*)&myRegisterAddr)+1);  
-   tmp[1] = (uint8_t)RegisterAddr;
-    
-   if(NumByteToWrite>1)  /* swap data endianess */
-   {
-      for(i=0;i<NumByteToWrite;i++)
-      {
-         tmp[NumByteToWrite+sizeof(RegisterAddr)-1-i]=pBuffer[i];
-      }
-   }
-   else
-   {    
-      memcpy(tmp+sizeof(RegisterAddr), pBuffer, NumByteToWrite);
-   }
-   ret = dev_i2c.write(WriteDeviceAddr, (const char*)tmp, NumByteToWrite+sizeof(RegisterAddr), false);
- 
-   if(ret) 
-      return -1;
-   return 0;
-}
- 
-int VL6180X::VL6180x_I2CRead(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToRead)
-{
-   int ret,i;
-   uint8_t tmp[TEMP_BUF_SIZE]; 
-   uint16_t myRegisterAddr = RegisterAddr;
-   uint16_t myRegisterAddrBE;
-   uint16_t ReadDeviceAddr=DeviceAddr;
-     
-   ReadDeviceAddr=DeviceAddr*2;    
-   myRegisterAddrBE = *(((uint8_t*)&myRegisterAddr)+1);
-   *(((uint8_t*)&myRegisterAddrBE)+1) = (uint8_t)myRegisterAddr;
-    
-   /* Send 8 bits device address and 16 bits register address in BE format, with no STOP condition */
-   ret = dev_i2c.write(ReadDeviceAddr, (const char*)&myRegisterAddrBE, sizeof(RegisterAddr), true);
-   if(!ret) 
-   {
-      ReadDeviceAddr|=0x001;
-      /* Read data, with STOP condition  */
-      ret = dev_i2c.read(ReadDeviceAddr, (char*)tmp, NumByteToRead, false);
-   }    
-   if(ret) 
-      return -1;
-        
-   if(NumByteToRead>1)  /* swap data endianess */
-   {
-      for(i=0;i<NumByteToRead;i++)
-      {      
-         pBuffer[i] = tmp[NumByteToRead-1-i];
-      }
-   }
-   else
-   {      
-      memcpy(pBuffer, tmp, NumByteToRead);
-   }       
-   return 0;
-} 
-
-/******************************************************************************/
-
-int VL6180X::AlsSetThresholds(uint16_t lux_threshold_low, uint16_t lux_threshold_high)
-{
-   uint32_t AlsAnGain, IntPeriod, AlsScaler, GainFix, RawAlsHigh, RawAlsLow;
-   uint16_t RawThreshLow, RawThreshHigh;
-   const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
-   void *p_low;
-   void *p_high;
- 
-   AlsAnGain=VL6180xDevDataGet(Device, AlsGainCode);
-   IntPeriod=VL6180xDevDataGet(Device, IntegrationPeriod);
-   AlsScaler=VL6180xDevDataGet(Device, AlsScaler);
-   GainFix=AlsGainLookUp[AlsAnGain];
-   IntPeriod++;
-   RawAlsLow=lux_threshold_low*AlsScaler*GainFix;
-   RawAlsLow=RawAlsLow*IntPeriod;
-   RawAlsLow=RawAlsLow/LuxResxIntIme;  
-   RawAlsHigh=lux_threshold_high*(AlsScaler*GainFix);
-   RawAlsHigh=RawAlsHigh*IntPeriod;
-   RawAlsHigh=RawAlsHigh/LuxResxIntIme;
-   p_low=&RawAlsLow;
-   RawThreshLow=*(uint16_t*)p_low;
-   p_high=&RawAlsHigh;
-   RawThreshHigh=*(uint16_t*)p_high;
-   return VL6180x_AlsSetThresholds(Device, RawThreshLow, RawThreshHigh);
-}
-
-
-int VL6180X::ReadID()
-{
-   int status;
-   uint8_t rl_id=0;
-    
-   status=VL6180x_RdByte(Device, IDENTIFICATION_MODEL_ID, &rl_id);
-   if((status==0)&&(rl_id==0xB4))
-     return status;
-   else
-     return INVALID_PARAMS;
-}
- 
- 
-int VL6180X::InitSensor(uint8_t NewAddr)
-{
-   int status;
- 
-   VL6180x_Off();
-   VL6180x_On();
-   status=VL6180x_WaitDeviceBooted(Device);
-   if(status)
-      VL6180x_ErrLog("WaitDeviceBooted fail\n\r");
-   status=IsPresent();
-   if(!status)
-   {
-      Device->Present=1;
-      status=Init();
-      if(status)
-      {
-         printf("Failed to init VL6180X sensor!\n\r");
-         return status;
-      }
-      status=Prepare();
-      if(status)
-      {
-         printf("Failed to prepare VL6180X!\n\r");
-         return status;
-      }
-      if(NewAddr!=DEFAULT_DEVICE_ADDRESS)
-      {
-         status=SetI2CAddress(NewAddr);
-         if(status)
-         {
-            printf("Failed to change I2C address!\n\r");
-            return status;
-         }
-      }
-      else
-      {
-         printf("Invalid new address!\n\r");
-         return INVALID_PARAMS;
-      }
-      Device->Ready=1;
-   }
-   return status; 
-}
- 
- 
-int VL6180X::StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), uint16_t low, uint16_t high)
-{
-   int status, r_status, l_status;
-    
-   switch(operating_mode)
-   {
-      case(range_single_shot_polling):
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return RangeMeasPollSingleShot();
-        else
-           return (r_status|l_status);
-        
-      case(als_single_shot_polling):
-        r_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        l_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return AlsMeasPollSingleShot();
-        else
-           return (r_status|l_status);
-            
-      case(range_continuous_polling):
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return RangeMeasPollContinuousMode();
-        else
-           return (r_status|l_status);
-                 
-      case(als_continuous_polling):
-        r_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        l_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return AlsMeasPollContinuousMode();
-        else
-           return (r_status|l_status);
-                 
-      case(range_continuous_interrupt):
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return RangeMeasIntContinuousMode(fptr);
-        else
-           return (r_status|l_status);
-                     
-      case(als_continuous_interrupt):
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-           return AlsMeasIntContinuousMode(fptr);
-        else
-           return (r_status|l_status);
- 
-      case(interleaved_mode_interrupt):
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);            
-        if((!r_status)&&(!l_status))
-           return InterleavedMode(fptr);
-        else
-           return (r_status|l_status);
- 
-      case(range_continuous_polling_low_threshold):
-        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
-        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=RangeSetLowThreshold(low);
-           if(!status)
-              return RangeMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-       
-      case(range_continuous_polling_high_threshold):
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=RangeSetHighThreshold(high);
-           if(!status)
-              return RangeMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      case(range_continuous_polling_out_of_window):
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=VL6180x_RangeSetThresholds(Device,low,high,1);
-           if(!status)
-              return RangeMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      case(als_continuous_polling_low_threshold):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=AlsSetLowThreshold(low);
-           if(!status)
-              return AlsMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-            
-      case(als_continuous_polling_high_threshold):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=AlsSetHighThreshold(high);
-           if(!status)
-              return AlsMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      case(als_continuous_polling_out_of_window):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=VL6180x_AlsSetThresholds(Device,low,high);
-           if(!status)
-              return AlsMeasPollContinuousMode();
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      case(range_continuous_interrupt_low_threshold):
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=RangeSetLowThreshold(low);
-           if(!status)
-              return RangeMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);                  
-            
-      case(range_continuous_interrupt_high_threshold):   
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=RangeSetHighThreshold(high);
-           if(!status)
-              return RangeMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-       case(range_continuous_interrupt_out_of_window):
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=VL6180x_RangeSetThresholds(Device,low,high,1);
-           if(!status)
-              return RangeMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-            
-      case(als_continuous_interrupt_low_threshold):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=AlsSetLowThreshold(low);
-           if(!status)
-              return AlsMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);  
-                
-      case(als_continuous_interrupt_high_threshold):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=AlsSetHighThreshold(high);
-           if(!status)
-              return AlsMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      case(als_continuous_interrupt_out_of_window):
-        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
-        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-        if((!r_status)&&(!l_status))
-        {
-           status=VL6180x_AlsSetThresholds(Device,low,high);
-           if(!status)
-              return AlsMeasIntContinuousMode(fptr);
-           else
-              return status;
-        }
-        else
-           return (r_status|l_status);
-                
-      default:
-        return INVALID_PARAMS;
-   }
-}
- 
- 
-int VL6180X::GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData)
-{
-   Data->range_error=RangeData.errorStatus;
-   if(Data->range_error!=0)
-   {
-      VL6180x_ErrLog("Range error %d",Data->range_error);
-      return RANGE_ERROR;
-   }
-   return NoError_;
-}
- 
- 
-int VL6180X::GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData)
-{
-   Data->als_error=AlsData.errorStatus;
-   if(Data->als_error!=0)
-   {
-      VL6180x_ErrLog("Light error %d",Data->light_error);
-      return API_ERROR;
-   }
-   return NoError_;
-}
- 
- 
-int VL6180X::RangeMeasPollSingleShot()
-{
-   int status;
-            
-   status=VL6180x_RangeClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   return RangeStartSingleShot(); 
-}   
- 
- 
-int VL6180X::AlsMeasPollSingleShot()
-{
-   int status;            
-     
-   status=VL6180x_AlsClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   return AlsStartSingleShot();
-}
- 
- 
-int VL6180X::RangeMeasPollContinuousMode()
-{
-   int status;
-            
-   status=VL6180x_RangeClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   return RangeStartContinuousMode();
-}
- 
- 
-int VL6180X::AlsMeasPollContinuousMode() 
-{
-   int status;            
-     
-   status=VL6180x_AlsClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   return AlsStartContinuousMode();
-}
- 
- 
-int VL6180X::AlsGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData)
-{
-   int status;
-   uint8_t IntStatus;
-     
-   status=VL6180x_AlsGetInterruptStatus(dev, &IntStatus);
-   if(!status)
-   {
-      if(IntStatus==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
-      {
-         status = VL6180x_AlsGetMeasurement(dev, pAlsData);
-         if(!status)
-         {
-            status=VL6180x_AlsClearInterrupt(Device);
-            if(status)
-               VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-         }
-      }
-      else
-         status=NOT_READY;
-   }
-   else
-      VL6180x_ErrLog("Failed to get interrupt status");
-   return status;
-}
- 
- 
-int VL6180X::RangeMeasIntContinuousMode(void (*fptr)(void))
-{
-   int status, ClrStatus;
-     
-   EnableInterruptMeasureDetectionIRQ();
-   AttachInterruptMeasureDetectionIRQ(fptr);
-   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
-   ClrStatus=VL6180x_ClearAllInterrupt(Device);
-   if(ClrStatus)
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-   if(!status)
-      status=RangeStartContinuousMode();
-   return status;
-}
- 
- 
-int VL6180X::AlsMeasIntContinuousMode(void (*fptr)(void))
-{
-   int status, ClrStatus;
-    
-   EnableInterruptMeasureDetectionIRQ();
-   AttachInterruptMeasureDetectionIRQ(fptr);
-   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
-   ClrStatus=VL6180x_ClearAllInterrupt(Device);
-   if(ClrStatus)
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-   if(!status)
-      status=AlsStartContinuousMode();
-   return status;
-}   
- 
- 
-int VL6180X::StartInterleavedMode()
-{
-   int status;
-   uint16_t integration_period, intermeasurement_period_ms;
-   uint8_t max_convergence_time;
-   uint8_t buf;
-    
-   status=VL6180x_WrByte(Device, 0x2A3, 1);
-   if(status)
-   {
-      VL6180x_ErrLog("Failed to write INTERLEAVED_MODE_ENABLE!\n\r");
-      return status;
-   }
-   status=VL6180x_RdByte(Device, SYSRANGE_MAX_CONVERGENCE_TIME, &max_convergence_time);
-   if(status)
-   {
-      VL6180x_ErrLog("Failed to read SYSRANGE_MAX_CONVERGENCE_TIME!\n\r");
-      return status;
-   }
-   status=VL6180x_RdWord(Device, SYSALS_INTEGRATION_PERIOD, &integration_period);
-   if(status)
-   {
-      VL6180x_ErrLog("Failed to read SYSALS_INTEGRATION_PERIOD!\n\r");
-      return status;
-   }
-   max_convergence_time&=0x3F;
-   integration_period&=0x01FF;
-   intermeasurement_period_ms=((max_convergence_time+5)+(integration_period*1.1));
-   intermeasurement_period_ms=(intermeasurement_period_ms/0.9)+10;
-   intermeasurement_period_ms=200;
-   status=VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
-   VL6180x_RdByte(Device, 0x03E, &buf);
-   if(status)
-   {
-      VL6180x_ErrLog("Failed to write SYSALS_INTERMEASUREMENT_PERIOD!\n\r");
-      return status;
-   }
-   return AlsStartContinuousMode();
-}
- 
- 
-int VL6180X::InterleavedMode(void (*fptr)(void))
-{
-   int status, ClrStatus;
-    
-   EnableInterruptMeasureDetectionIRQ();
-   AttachInterruptMeasureDetectionIRQ(fptr);
-   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
-   ClrStatus=VL6180x_ClearAllInterrupt(Device);
-   if(ClrStatus)
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-   if(!status)
-      status=StartInterleavedMode();
-   return status;
-} 
- 
- 
-int VL6180X::HandleIRQ(OperatingMode operating_mode, MeasureData_t *Data)
-{
-   int status;
-    
-   EnableInterruptMeasureDetectionIRQ();
-   status=GetMeasurement(operating_mode, Data);
-   return status;
-}
-     
- 
-int VL6180X::RangeSetLowThreshold(uint16_t threshold)
-{
-   int status;
-   uint16_t low, high;
-     
-   status=VL6180x_RangeGetThresholds(Device, &low, &high);
-   if(!status)
-      status=VL6180x_RangeSetThresholds(Device, threshold, high, 1);
-   return status;
-}
- 
- 
-int VL6180X::RangeSetHighThreshold(uint16_t threshold)
-{
-   int status;
-   uint16_t low, high;
-     
-   status=VL6180x_RangeGetThresholds(Device, &low, &high);
-   if(!status)
-      status=VL6180x_RangeSetThresholds(Device, low, threshold, 1);
-   return status;
-}
-    
- 
-int VL6180X::AlsSetLowThreshold(uint16_t threshold)
-{
-   int status;
-   lux_t low, high;
-     
-   status=AlsGetThresholds(Device, &low, &high);
-   if(!status)
-      status=VL6180x_AlsSetThresholds(Device, threshold, high);
-   return status;
-}
-    
- 
-int VL6180X::AlsSetHighThreshold(uint16_t threshold)
-{
-   int status;
-   lux_t low, high;
-     
-   status=AlsGetThresholds(Device, &low, &high);
-   if(!status)
-      status=VL6180x_AlsSetThresholds(Device, low, threshold);
-   return status;
-}
- 
-    
-int VL6180X::AlsGetThresholds(VL6180xDev_t dev, lux_t *low, lux_t *high)  
-{
-   int status;
-   uint16_t RawAlsLow, RawAlsHigh;
-   uint32_t luxLowValue, luxHighValue, IntPeriod, AlsAnGain, GainFix, AlsScaler;
-   const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
-     
-   status=VL6180x_RdWord(dev, SYSALS_THRESH_LOW, &RawAlsLow);
-   if(status)
-   {
-      VL6180x_ErrLog("rd SYSALS_THRESH_LOW fail");
-      return status;
-   }
-   status=VL6180x_RdWord(dev, SYSALS_THRESH_HIGH, &RawAlsHigh);
-   if(status)
-   {
-      VL6180x_ErrLog("rd SYSALS_THRESH_HIGH fail");
-      return status;
-   }
-   AlsAnGain=VL6180xDevDataGet(dev, AlsGainCode);
-   IntPeriod=VL6180xDevDataGet(dev, IntegrationPeriod);
-   AlsScaler=VL6180xDevDataGet(dev, AlsScaler);
-   GainFix=AlsGainLookUp[AlsAnGain];
-   IntPeriod++;
-   luxLowValue=(uint32_t)RawAlsLow*LuxResxIntIme;
-   luxLowValue=luxLowValue/IntPeriod;
-   luxLowValue=luxLowValue/(AlsScaler*GainFix);
-   luxHighValue=(uint32_t)RawAlsHigh*LuxResxIntIme;
-   luxHighValue=luxHighValue/IntPeriod;
-   luxHighValue=luxHighValue/(AlsScaler*GainFix);
-   *low=luxLowValue;
-   *high=luxHighValue;
-   return status;
-}
-    
- 
-int VL6180X::GetMeasurement(OperatingMode operating_mode, MeasureData_t *Data)
-{
-   switch(operating_mode)
-   {
-      case(range_single_shot_polling):
-      case(range_continuous_polling):
-      case(range_continuous_interrupt):
-      case(range_continuous_polling_low_threshold):
-      case(range_continuous_polling_high_threshold):
-      case(range_continuous_polling_out_of_window):
-      case(range_continuous_interrupt_low_threshold):
-      case(range_continuous_interrupt_high_threshold):
-      case(range_continuous_interrupt_out_of_window):
-        return GetRangeMeas(operating_mode, Data);
-         
-      case(als_single_shot_polling):
-      case(als_continuous_polling):
-      case(als_continuous_interrupt):
-      case(als_continuous_polling_low_threshold):
-      case(als_continuous_polling_high_threshold):
-      case(als_continuous_polling_out_of_window):
-      case(als_continuous_interrupt_low_threshold):
-      case(als_continuous_interrupt_high_threshold):
-      case(als_continuous_interrupt_out_of_window):
-        return GetAlsMeas(operating_mode, Data);
-             
-      case(interleaved_mode_interrupt):
-        return GetRangeAlsMeas(Data);
-         
-      default:
-        return INVALID_PARAMS;
-   }
-}
-     
- 
-int VL6180X::GetRangeMeas(OperatingMode operating_mode, MeasureData_t *Data)
-{
-   VL6180x_RangeData_t RangeData;
-   int status, ClrStatus;
-   IntrStatus_t IntStatus;
-    
-   status=VL6180x_RangeGetInterruptStatus(Device, &IntStatus.val);
-   if(!status)
-   {
-      Data->int_error=IntStatus.status.Error;
-      if(IntStatus.status.Error!=0)
-      {
-         VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
-         status=RANGE_ERROR;
-      } 
-   }
-   else
-   {
-      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO");
-   }  
-   ClrStatus=VL6180x_RangeClearInterrupt(Device);
-   if(ClrStatus)
-   {
-      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-   }
-   ClrStatus=VL6180x_ClearErrorInterrupt(Device);
-   if(ClrStatus)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-   }
-   if(status)
-      return status;
-   if((operating_mode==range_single_shot_polling)||(operating_mode==range_continuous_polling)||(operating_mode==range_continuous_interrupt))
-   {
-      if(IntStatus.status.Range==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
-         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
-   else
-         return NOT_READY;
-   }
-   else if((operating_mode==range_continuous_polling_low_threshold)||(operating_mode==range_continuous_interrupt_low_threshold))
-   {
-      if(IntStatus.status.Range==RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD)
-         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
-      else
-         return NOT_READY;
-   }
-   else if((operating_mode==range_continuous_polling_high_threshold)||(operating_mode==range_continuous_interrupt_high_threshold))
-   {
-      if(IntStatus.status.Range==RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
-         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
-      else
-         return NOT_READY;
-   }
-   else if((operating_mode==range_continuous_polling_out_of_window)||(operating_mode==range_continuous_interrupt_out_of_window))
-   {
-      if(IntStatus.status.Range==RES_INT_STAT_GPIO_OUT_OF_WINDOW)
-         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
-      else
-         return NOT_READY;
-   }
-   if(!status)
-   {
-      status=GetRangeError(Data, RangeData);
-      if(!status)
-         Data->range_mm=RangeData.range_mm;
-      else
-         Data->range_mm=0xFFFFFFFF;
-   }
-   return status;
-}
- 
- 
-int VL6180X::GetAlsMeas(OperatingMode operating_mode, MeasureData_t *Data)
-{
-   VL6180x_AlsData_t AlsData;
-   int status, ClrStatus;
-   uint8_t IntStatus;
-    
-   status=VL6180x_AlsGetInterruptStatus(Device, &IntStatus);
-   if(status)
-   {
-      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO");
-   }
-   ClrStatus=VL6180x_AlsClearInterrupt(Device);
-   if(ClrStatus)
-   {
-      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-   }
-   ClrStatus=VL6180x_ClearErrorInterrupt(Device);
-   if(ClrStatus)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-   }
-   if(status)
-      return status;
-   if((operating_mode==als_single_shot_polling)||(operating_mode==als_continuous_polling)||(operating_mode==als_continuous_interrupt))
-   {
-      if(IntStatus==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
-         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
-      else
-         return NOT_READY;
-   }
-   else if((operating_mode==als_continuous_polling_low_threshold)||(operating_mode==als_continuous_interrupt_low_threshold))
-   {
-      if(IntStatus==RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD)
-         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
-      else
-         return NOT_READY;
-   }
-   else if((operating_mode==als_continuous_polling_high_threshold)||(operating_mode==als_continuous_interrupt_high_threshold))
-   {
-      if(IntStatus==RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
-         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
-      else
-         return NOT_READY;
-   }
-   else if((operating_mode==als_continuous_polling_out_of_window)||(operating_mode==als_continuous_interrupt_out_of_window))
-   {
-      if(IntStatus==RES_INT_STAT_GPIO_OUT_OF_WINDOW)
-         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
-      else
-         return NOT_READY;
-   }
-   if(!status)
-   {
-      status=GetAlsError(Data, AlsData);
-      if(!status)
-         Data->lux=AlsData.lux;
-      else
-         Data->lux=0xFFFFFFFF;
-   }
-   return status; 
-}
- 
- 
-int VL6180X::GetRangeAlsMeas(MeasureData_t *Data)
-{
-   int status, ClrStatus, r_status, l_status;
-   IntrStatus_t IntStatus;
-   VL6180x_RangeData_t RangeData;
-   VL6180x_AlsData_t AlsData;
-    
-   status=VL6180x_RdByte(Device, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus.val);
-   if(!status)
-   {
-      Data->int_error=IntStatus.status.Error;
-      if(IntStatus.status.Error!=0)
-      {
-         VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
-         status=RANGE_ERROR;
-      } 
-   }
-   else
-   {
-      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO"); 
-   }
-   ClrStatus=VL6180x_ClearAllInterrupt(Device);
-   if(ClrStatus)
-      VL6180x_ErrLog("VL6180x_ClearAllInterrupt fail");
-   if(status)
-      return status;
-     
-   if(IntStatus.status.Als==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
-   {
-      r_status=VL6180x_RangeGetMeasurement(Device, &RangeData);
-      l_status=VL6180x_AlsGetMeasurement(Device, &AlsData);
-      if((!r_status)&&(!l_status))
-      {
-         r_status=GetRangeError(Data, RangeData);
-         l_status=GetAlsError(Data, AlsData);
-         if(!r_status) 
-            Data->range_mm=RangeData.range_mm;
-         else
-            Data->range_mm=0xFFFFFFFF;
-         if(!l_status)
-            Data->lux=AlsData.lux;
-         else
-            Data->lux=0xFFFFFFFF;
-         status=r_status|l_status; 
-      }
-      else
-      {
-         status=r_status|l_status;
-      }
-   }
-   else
-      return NOT_READY;
-   return status; 
-}
- 
- 
-int VL6180X::StopMeasurement(OperatingMode operating_mode)
-{
-   int status;
-     
-   switch(operating_mode)
-   {
-      case(range_single_shot_polling):
-      case(range_continuous_polling):
-      case(range_continuous_interrupt):
-      case(range_continuous_polling_low_threshold):
-      case(range_continuous_polling_high_threshold):
-      case(range_continuous_polling_out_of_window):
-      case(range_continuous_interrupt_low_threshold):
-      case(range_continuous_interrupt_high_threshold):
-      case(range_continuous_interrupt_out_of_window):
-        return StopRangeMeasurement(operating_mode);
-         
-      case(als_single_shot_polling):
-      case(als_continuous_polling):
-      case(als_continuous_interrupt):
-      case(als_continuous_polling_low_threshold):
-      case(als_continuous_polling_high_threshold):
-      case(als_continuous_polling_out_of_window):
-      case(als_continuous_interrupt_low_threshold):
-      case(als_continuous_interrupt_high_threshold):
-      case(als_continuous_interrupt_out_of_window):
-        return StopAlsMeasurement(operating_mode);
-             
-      case(interleaved_mode_interrupt):
-        status=StopRangeMeasurement(range_continuous_interrupt);
-        if(!status)
-           return StopAlsMeasurement(als_continuous_interrupt);
-        else return status;
-         
-      default:
-        return INVALID_PARAMS;
-   }
-}
- 
- 
-int VL6180X::StopRangeMeasurement(OperatingMode operating_mode)
-{
-   int status;
-    
-   if(operating_mode==range_single_shot_polling)
-      status=VL6180x_RangeSetSystemMode(Device, MODE_SINGLESHOT);
-   else
-      status=VL6180x_RangeSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
-   if(status)
-      return status;
-   status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_RangeConfigInterrupt fail"\n\r);
-      return status;
-   }
-   status=VL6180x_RangeClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   status=VL6180x_RangeSetRawThresholds(Device, 10, 200);
-   if(status)
-      VL6180x_ErrLog("VL6180x_RangeSetThresholds fail");
-   return status;
-}
- 
- 
-int VL6180X::StopAlsMeasurement(OperatingMode operating_mode)
-{
-   int status;
-    
-   if(operating_mode==als_single_shot_polling)
-      status=VL6180x_AlsSetSystemMode(Device, MODE_SINGLESHOT);
-   else
-      status=VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
-   if(status)
-      return status;
-   status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail"\n\r);
-      return status;
-   }
-   status=VL6180x_AlsClearInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
-      return status;
-   }
-   status=VL6180x_ClearErrorInterrupt(Device);
-   if(status)
-   {
-      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
-      return status;
-   }
-   status=VL6180x_AlsSetThresholds(Device, 0x0, 1800);
-   if(status)
-      VL6180x_ErrLog("VL6180x_AlsSetThresholds fail");
-   return status;
-}
- 
- 
- 
- 
-/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\ No newline at end of file
--- a/VL6180X/vl6180x_class.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1162 +0,0 @@
-/**
- ******************************************************************************
- * @file    vl6180x_class.h
- * @author  AST / EST
- * @version V0.0.1
- * @date    9-November-2015
- * @brief   Header file for component VL6180X
- ******************************************************************************
- * @attention
- *
- * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
- *
- * 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 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 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.
- *
- ******************************************************************************
-*/
-
-#ifndef __VL6180X_CLASS_H
-#define __VL6180X_CLASS_H
-
-/* Includes ------------------------------------------------------------------*/
-#include "RangeSensor.h"
-#include "LightSensor.h"
-#include "DevI2C.h" 
-//#include "vl6180x_api.h"
-#include "vl6180x_cfg.h"
-#include "vl6180x_def.h"
-#include "vl6180x_types.h"
-#include "vl6180x_platform.h"
-
-
- 
-/* data struct containing range measure, light measure and type of error provided to the user
-   in case of invalid data range_mm=0xFFFFFFFF and lux=0xFFFFFFFF */	
-typedef struct MeasureData 
-{
-   uint32_t range_mm;
-   uint32_t lux;
-   uint32_t range_error;
-   uint32_t als_error;
-   uint32_t int_error;
-}MeasureData_t;
-
-/* sensor operating modes */ 
-typedef enum
-{
-   range_single_shot_polling=1,
-   als_single_shot_polling,
-   range_continuous_polling,
-   als_continuous_polling,
-   range_continuous_interrupt,
-   als_continuous_interrupt,
-   interleaved_mode_interrupt,
-   range_continuous_polling_low_threshold,
-   range_continuous_polling_high_threshold,
-   range_continuous_polling_out_of_window,
-   als_continuous_polling_low_threshold,
-   als_continuous_polling_high_threshold,
-   als_continuous_polling_out_of_window,
-   range_continuous_interrupt_low_threshold,
-   range_continuous_interrupt_high_threshold,
-   range_continuous_interrupt_out_of_window,
-   als_continuous_interrupt_low_threshold,
-   als_continuous_interrupt_high_threshold,
-   als_continuous_interrupt_out_of_window,
-   range_continuous_als_single_shot,
-   range_single_shot_als_continuous,
-}OperatingMode;
-
-/** default device address */
-#define DEFAULT_DEVICE_ADDRESS		0x29
-
-/* Classes -------------------------------------------------------------------*/
-/** Class representing a VL6180X sensor component
- */
-class VL6180X : public RangeSensor, public LightSensor
-{
- public:
-    /** Constructor 1
-     * @param[in] &i2c device I2C to be used for communication
-     * @param[in] &pin Mbed DigitalOut 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] DevAddr device address, 0x29 by default  
-     */
-    VL6180X(DevI2C &i2c, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c)
-    {
-       MyDevice.I2cAddr=DevAddr;		 
-       MyDevice.Present=0;
-       MyDevice.Ready=0;
-       Device=&MyDevice;;
-    }  
-    
-   /** Destructor
-    */
-    virtual ~VL6180X(){}     
-    /* warning: VL6180X 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 */		 
-    void VL6180x_On(void)
-    {
-    } 
-
-	/**
-	 * @brief       PowerOff the sensor
-	 * @return      void
-	 */		
-    /* turns off the sensor */
-    void VL6180x_Off(void) 
-    {
-    }
-    
-	/**
-	 * @brief       Initialize the sensor with default values
-	 * @return      0 on Success
-	 */					 
-    int InitSensor(uint8_t NewAddr);
-    
-	/**
-	 * @brief       Start the measure indicated by operating mode
-	 * @param[in]   operating_mode specifies requested measure 
-	 * @param[in]   fptr specifies call back function must be !NULL in case of interrupt measure	 
-	 * @param[in]   low specifies measure low threashold in Lux or in mm according to measure
-	 * @param[in]   high specifies measure high threashold in Lux or in mm according to measure
-	 * @return      0 on Success
-	 */					     
-    int StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), uint16_t low, uint16_t high);
-
-	/**
-	 * @brief       Get results for the measure indicated by operating mode
-	 * @param[in]   operating_mode specifies requested measure results
-	 * @param[out]  Data pointer to the MeasureData_t structure to read data in to
-	 * @return      0 on Success
-	 */					         
-    int GetMeasurement(OperatingMode operating_mode, MeasureData_t *Data);		
-
-	/**
-	 * @brief       Stop the currently running measure indicate by operating_mode
-	 * @param[in]   operating_mode specifies requested measure to stop
-	 * @return      0 on Success
-	 */					             
-    int StopMeasurement(OperatingMode operating_mode);
-     
- 	/**
-	 * @brief       Interrupt handling func to be called by user after an INT is occourred
-	 * @param[in]   opeating_mode indicating the in progress measure
-	 * @param[out]  Data pointer to the MeasureData_t structure to read data in to
-	 * @return      0 on Success
-	 */					          		
-    int HandleIRQ(OperatingMode operating_mode, MeasureData_t *Data);    
-
-	/**
-	 * @brief       Enable interrupt measure IRQ
-	 * @return      0 on Success
-	 */					     
-    void EnableInterruptMeasureDetectionIRQ(void) 
-    {
-    }
-
-	/**
-	 * @brief       Disable interrupt measure IRQ
-	 * @return      0 on Success
-	 */					          
-    void DisableInterruptMeasureDetectionIRQ(void) 
-    {
-    }
-	/*** End High level API ***/	          
-	
-	/**
-	 * @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 AttachInterruptMeasureDetectionIRQ(void (*fptr)(void))
-    {
-    }
-    
-	/**
-	 * @brief       Check the sensor presence
-	 * @return      1 when device is present
-	 */						
-    unsigned Present()
-    {
-       return Device->Present;
-    }
-		
-    /** Wrapper functions */	
-/** @defgroup api_init Init functions
- *  @brief    API init functions
- *  @ingroup api_hl
- *  @{  
- */
-/**
- * @brief Wait for device booted after chip enable (hardware standby)
- * @par Function Description
- * After Chip enable Application you can also simply wait at least 1ms to ensure device is ready
- * @warning After device chip enable (gpio0) de-asserted  user must wait gpio1 to get asserted (hardware standby).
- * or wait at least 400usec prior to do any low level access or api call .
- *
- * This function implements polling for standby but you must ensure 400usec from chip enable passed\n
- * @warning if device get prepared @a VL6180x_Prepare() re-using these function can hold indefinitely\n
- *
- * @param 		void
- * @return     0 on success
- */
-    int WaitDeviceBooted()
-    {
-       return VL6180x_WaitDeviceBooted(Device);
-    }
-
-/**
- *
- * @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 VL6180x_WaitDeviceBooted()
- *
- * @par Function Description
- * When not used after a fresh device "power up" or reset, it may return @a #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 VL6180x_InitData  multiple time
- * then it  must ensure proper offset calibration saving and restore on its own
- * by using @a VL6180x_GetOffsetCalibrationData() on first power up and then @a VL6180x_SetOffsetCalibrationData() all all subsequent init
- *
- * @param void
- * @return     0 on success,  @a #CALIBRATION_WARNING if failed
- */		
-    virtual int Init() 
-    {
-       return VL6180x_InitData(Device);
-    }
-
-/**
- * @brief Configure GPIO1 function and set polarity.
- * @par Function Description
- * To be used prior to arm single shot measure or start  continuous mode.
- *
- * The function uses @a VL6180x_SetupGPIOx() for setting gpio 1.
- * @warning  changing polarity can generate a spurious interrupt on pins.
- * It sets an interrupt flags condition that must be cleared to avoid polling hangs. \n
- * It is safe to run VL6180x_ClearAllInterrupt() just after.
- *
- * @param IntFunction   The interrupt functionality to use one of :\n
- *  @a #GPIOx_SELECT_OFF \n
- *  @a #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT
- * @param ActiveHigh  The interrupt line polarity see ::IntrPol_e
- *      use @a #INTR_POL_LOW (falling edge) or @a #INTR_POL_HIGH (rising edge)
- * @return 0 on success
- */		
-    int SetupGPIO1(uint8_t InitFunction, int ActiveHigh)
-    {
-       return VL6180x_SetupGPIO1(Device, InitFunction, ActiveHigh);
-    }
-
-/**
-  * @brief  Prepare device for operation
-  * @par Function Description
-  * Does static initialization and reprogram common default settings \n
-  * Device is prepared for new measure, ready single shot ranging or ALS typical polling operation\n
-  * After prepare user can : \n
-  * @li Call other API function to set other settings\n
-  * @li Configure the interrupt pins, etc... \n
-  * @li Then start ranging or ALS operations in single shot or continuous mode
-  *
-  * @param void
-  * @return      0 on success
-  */		
-    int Prepare()
-    {
-       return VL6180x_Prepare(Device);
-    }
-
- /**
- * @brief Start continuous ranging mode
- *
- * @details End user should ensure device is in idle state and not already running
- * @return      0 on success
- */		
-    int RangeStartContinuousMode()
-    {
-       return VL6180x_RangeStartContinuousMode(Device);
-    }
-
-/**
- * @brief Start single shot ranging measure
- *
- * @details End user should ensure device is in idle state and not already running
- * @return      0 on success 
- */		
-    int RangeStartSingleShot()
-    {
-       return VL6180x_RangeStartSingleShot(Device);
-    }
-
-/**
- * @brief Set maximum convergence time
- *
- * @par Function Description
- * Setting a low convergence time can impact maximal detectable distance.
- * Refer to VL6180x Datasheet Table 7 : Typical range convergence time.
- * A typical value for up to x3 scaling is 50 ms
- *
- * @param MaxConTime_msec
- * @return 0 on success. <0 on error. >0 for calibration warning status
- */		
-    int RangeSetMaxConvergenceTime(uint8_t MaxConTime_msec)
-    {
-       return VL6180x_RangeSetMaxConvergenceTime(Device, MaxConTime_msec);
-    }
-
-/**
-  * @brief Single shot Range measurement in polling mode.
-  *
-  * @par Function Description
-  * Kick off a new single shot range  then wait for ready to retrieve it by polling interrupt status \n
-  * Ranging must be prepared by a first call to  @a VL6180x_Prepare() and it is safer to clear  very first poll call \n
-  * This function reference VL6180x_PollDelay(dev) porting macro/call on each polling loop,
-  * but PollDelay(dev) may never be called if measure in ready on first poll loop \n
-  * Should not be use in continuous mode operation as it will stop it and cause stop/start misbehaviour \n
-  * \n This function clears Range Interrupt status , but not error one. For that uses  @a VL6180x_ClearErrorInterrupt() \n
-  * This range error is not related VL6180x_RangeData_t::errorStatus that refer measure status \n
-  * 
-  * @param pRangeData   Will be populated with the result ranging data @a  VL6180x_RangeData_t
-  * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use
-  *
-  * \sa ::VL6180x_RangeData_t
-  */		
-    int RangePollMeasurement(VL6180x_RangeData_t *pRangeData)
-    {
-       return VL6180x_RangePollMeasurement(Device, pRangeData);
-    }
-
-/**
- * @brief Check for measure readiness and get it if ready
- *
- * @par Function Description
- * Using this function is an alternative to @a VL6180x_RangePollMeasurement() to avoid polling operation. This is suitable for applications
- * where host CPU is triggered on a interrupt (not from VL6180X) to perform ranging operation. In this scenario, we assume that the very first ranging
- * operation is triggered by a call to @a VL6180x_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180x_RangeGetMeasurementIfReady() to
- * get a distance measure if ready. In case the distance is not ready, host may get it at the next call.\n
- *
- * @warning 
- * This function does not re-start a new measurement : this is up to the host CPU to do it.\n 
- * This function clears Range Interrupt for measure ready , but not error interrupts. For that, uses  @a VL6180x_ClearErrorInterrupt() \n
- *
- * @param pRangeData  Will be populated with the result ranging data if available
- * @return  0 when measure is ready pRange data is updated (untouched when not ready),  >0 for warning and @a #NOT_READY if measurement not yet ready, <0 for error @a #RANGE_ERROR if device report an error,
- */		
-    int RangeGetMeasurementIfReady(VL6180x_RangeData_t *pRangeData)
-    {
-       return VL6180x_RangeGetMeasurementIfReady(Device, pRangeData);
-    }
-
-/**
- * @brief Retrieve range measurements set  from device
- *
- * @par Function Description
- * The measurement is made of range_mm status and error code @a VL6180x_RangeData_t \n
- * Based on configuration selected extra measures are included.
- *
- * @warning should not be used in continuous if wrap around filter is active \n
- * Does not perform any wait nor check for result availability or validity.
- *\sa VL6180x_RangeGetResult for "range only" measurement
- *
- * @param pRangeData  Pointer to the data structure to fill up
- * @return            0 on success
- */		
-    int RangeGetMeasurement(VL6180x_RangeData_t *pRangeData)
-    {
-       return VL6180x_RangeGetMeasurement(Device, pRangeData);
-    }
-
-/**
- * @brief Get ranging result and only that
- *
- * @par Function Description
- * Unlike @a VL6180x_RangeGetMeasurement() this function only retrieves the range in millimeter \n
- * It does any required up-scale translation\n
- * It can be called after success status polling or in interrupt mode \n
- * @warning these function is not doing wrap around filtering \n
- * This function doesn't perform any data ready check!
- *
- * @param pRange_mm  Pointer to range distance
- * @return           0 on success
- */		
-    virtual int GetRange(int32_t *piData)
-    {
-       return VL6180x_RangeGetResult(Device, piData);
-    }
-		
-/**
- * @brief Configure ranging interrupt reported to application
- *
- * @param ConfigGpioInt  Select ranging report\n select one (and only one) of:\n
- *   @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
- *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
- *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
- *   @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
- *   @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
- * @return   0 on success
- */
-    int RangeConfigInterrupt(uint8_t ConfigGpioInt)
-    {
-       return VL6180x_RangeConfigInterrupt(Device, ConfigGpioInt);
-    }
-
-/**
- * @brief Return ranging error interrupt status
- *
- * @par Function Description
- * Appropriate Interrupt report must have been selected first by @a VL6180x_RangeConfigInterrupt() or @a  VL6180x_Prepare() \n
- *
- * Can be used in polling loop to wait for a given ranging event or in interrupt to read the trigger \n
- * Events triggers are : \n
- * @a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
- * @a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
- * @a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n (RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD|RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
- * @a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY \n
- *
- * @sa IntrStatus_t
- * @param pIntStatus Pointer to status variable to update
- * @return           0 on success
- */		
-    int RangeGetInterruptStatus(uint8_t *pIntStatus)
-    {
-       return VL6180x_RangeGetInterruptStatus(Device, pIntStatus);
-    }
-
-/**
- * @brief   Run a single ALS measurement in single shot polling mode
- *
- * @par Function Description
- * Kick off a new single shot ALS then wait new measurement ready to retrieve it ( polling system interrupt status register for als) \n
- * ALS must be prepared by a first call to @a VL6180x_Prepare() \n
- * \n Should not be used in continuous or interrupt mode it will break it and create hazard in start/stop \n
- *
- * @param dev          The device
- * @param pAlsData     Als data structure to fill up @a VL6180x_AlsData_t
- * @return             0 on success
- */		
-    int AlsPollMeasurement(VL6180x_AlsData_t *pAlsData)
-    {
-       return VL6180x_AlsPollMeasurement(Device, pAlsData);
-    }
-
-/**
- * @brief  Get actual ALS measurement
- *
- * @par Function Description
- * Can be called after success status polling or in interrupt mode to retrieve ALS measurement from device \n
- * This function doesn't perform any data ready check !
- *
- * @param pAlsData   Pointer to measurement struct @a VL6180x_AlsData_t
- * @return  0 on success
- */		
-    int AlsGetMeasurement(VL6180x_AlsData_t *pAlsData)
-    {
-       return VL6180x_AlsGetMeasurement(Device, pAlsData);
-    }
-
-/**
- * @brief  Configure ALS interrupts provide to application
- *
- * @param ConfigGpioInt  Select one (and only one) of : \n
- *   @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
- *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
- *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
- *   @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
- *   @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
- * @return               0 on success may return #INVALID_PARAMS for invalid mode
- */	
-    int AlsConfigInterrupt(uint8_t ConfigGpioInt)
-    {
-       return VL6180x_AlsConfigInterrupt(Device, ConfigGpioInt);
-    }
-
-/**
- * @brief Set ALS integration period
- *
- * @param period_ms  Integration period in msec. Value in between 50 to 100 msec is recommended\n
- * @return           0 on success
- */		
-    int AlsSetIntegrationPeriod(uint16_t period_ms)
-    {
-       return VL6180x_AlsSetIntegrationPeriod(Device, period_ms);	
-    }
-
-/**
- * @brief Set ALS "inter-measurement period"
- *
- * @par Function Description
- * The so call data-sheet "inter measurement period" is actually an extra inter-measurement delay
- *
- * @param intermeasurement_period_ms Inter measurement time in milli second\n
- *        @warning applied value is clipped to 2550 ms\n
- * @return           0 on success if value is
- */		
-    int AlsSetInterMeasurementPeriod(uint16_t intermeasurement_period_ms)
-    {
-       return VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
-    }
-
-/**
- * @brief Set ALS analog gain code
- *
- * @par Function Description
- * ALS gain code value programmed in @a SYSALS_ANALOGUE_GAIN .
- * @param gain  Gain code see datasheet or AlsGainLookUp for real value. Value is clipped to 7.
- * @return  0 on success
- */
-    int AlsSetAnalogueGain(uint8_t gain)
-    {
-       return VL6180x_AlsSetAnalogueGain(Device, gain);
-    }
-
-/**
- * @brief Set thresholds for ALS continuous mode 
- * @warning Threshold are raw device value not lux!
- *
- * @par Function Description
- * Basically value programmed in @a SYSALS_THRESH_LOW and @a SYSALS_THRESH_HIGH registers
- * @param low   ALS low raw threshold for @a SYSALS_THRESH_LOW
- * @param high  ALS high raw threshold for  @a SYSALS_THRESH_HIGH
- * @return  0 on success
- */		
-    int AlsSetThresholds(uint16_t lux_threshold_low, uint16_t lux_threshold_high);
-
-/**
- * Read ALS interrupt status
- * @param pIntStatus  Pointer to status
- * @return            0 on success
- */
-    int AlsGetInterruptStatus(uint8_t *pIntStatus)
-    {
-       return VL6180x_AlsGetInterruptStatus(Device, pIntStatus);
-    }
-
-/**
- * @brief Low level ranging and ALS register static settings (you should call @a VL6180x_Prepare() function instead)
- *
- * @return 0 on success
- */
-    int StaticInit()
-    {
-       return VL6180x_StaticInit(Device);
-    }
-
-/**
- * @brief Wait for device to be ready (before a new ranging command can be issued by application)
- * @param MaxLoop    Max Number of i2c polling loop see @a #msec_2_i2cloop
- * @return           0 on success. <0 when fail \n
- *                   @ref VL6180x_ErrCode_t::TIME_OUT for time out \n
- *                   @ref VL6180x_ErrCode_t::INVALID_PARAMS if MaxLop<1
- */		
-    int RangeWaitDeviceReady(int MaxLoop )
-    {
-       return VL6180x_RangeWaitDeviceReady(Device, MaxLoop);
-    }
-
-/**
- * @brief Program Inter measurement period (used only in continuous mode)
- *
- * @par Function Description
- * When trying to set too long time, it returns #INVALID_PARAMS
- *
- * @param InterMeasTime_msec Requires inter-measurement time in msec
- * @return 0 on success
- */		
-    int RangeSetInterMeasPeriod(uint32_t  InterMeasTime_msec)
-    {
-       return VL6180x_RangeSetInterMeasPeriod(Device, InterMeasTime_msec);
-    }
-
-/**
- * @brief Set device ranging scaling factor
- *
- * @par Function Description
- * The ranging scaling factor is applied on the raw distance measured by the device to increase operating ranging at the price of the precision.
- * Changing the scaling factor when device is not in f/w standby state (free running) is not safe.
- * It can be source of spurious interrupt, wrongly scaled range etc ...
- * @warning __This  function doesns't update high/low threshold and other programmed settings linked to scaling factor__.
- *  To ensure proper operation, threshold and scaling changes should be done following this procedure: \n
- *  @li Set Group hold  : @a VL6180x_SetGroupParamHold() \n
- *  @li Get Threshold @a VL6180x_RangeGetThresholds() \n
- *  @li Change scaling : @a VL6180x_UpscaleSetScaling() \n
- *  @li Set Threshold : @a VL6180x_RangeSetThresholds() \n
- *  @li Unset Group Hold : @a VL6180x_SetGroupParamHold()
- *
- * @param scaling  Scaling factor to apply (1,2 or 3)
- * @return          0 on success when up-scale support is not configured it fail for any
- *                  scaling than the one statically configured.
- */
-    int UpscaleSetScaling(uint8_t scaling)
-    {
-       return VL6180x_UpscaleSetScaling(Device, scaling);
-    }
-
-/**
- * @brief Get current ranging scaling factor
- *
- * @return    The current scaling factor
- */				
-    int UpscaleGetScaling()
-    {
-       return VL6180x_UpscaleGetScaling(Device);
-    }
-
-/**
- * @brief Get the maximal distance for actual scaling
- * @par Function Description
- * Do not use prior to @a VL6180x_Prepare() or at least @a VL6180x_InitData()
- *
- * Any range value more than the value returned by this function is to be considered as "no target detected"
- * or "no target in detectable range" \n
- * @warning The maximal distance depends on the scaling
- *
- * @return    The maximal range limit for actual mode and scaling
- */		
-    uint16_t GetUpperLimit()
-    {
-       return VL6180x_GetUpperLimit(Device);
-    }
-
-/**
- * @brief Apply low and high ranging thresholds that are considered only in continuous mode
- *
- * @par Function Description
- * This function programs low and high ranging thresholds that are considered in continuous mode : 
- * interrupt will be raised only when an object is detected at a distance inside this [low:high] range.  
- * The function takes care of applying current scaling factor if any.\n
- * To be safe, in continuous operation, thresholds must be changed under "group parameter hold" cover.
- * Group hold can be activated/deactivated directly in the function or externally (then set 0)
- * using /a VL6180x_SetGroupParamHold() function.
- *
- * @param low      Low threshold in mm
- * @param high     High threshold in mm
- * @param SafeHold  Use of group parameters hold to surround threshold programming.
- * @return  0 On success
- */		
-    int RangeSetThresholds(uint16_t low, uint16_t high, int SafeHold)
-    {
-       return VL6180x_RangeSetThresholds(Device, low, high, SafeHold);
-    }
-
-/**
- * @brief  Get scaled high and low threshold from device
- *
- * @par Function Description
- * Due to scaling factor, the returned value may be different from what has been programmed first (precision lost).
- * For instance VL6180x_RangeSetThresholds(dev,11,22) with scale 3
- * will read back 9 ((11/3)x3) and 21 ((22/3)x3).
- *
- * @param low  scaled low Threshold ptr  can be NULL if not needed
- * @param high scaled High Threshold ptr can be NULL if not needed
- * @return 0 on success, return value is undefined if both low and high are NULL
- * @warning return value is undefined if both low and high are NULL
- */
-    int RangeGetThresholds(uint16_t *low, uint16_t *high)
-    {
-       return VL6180x_RangeGetThresholds(Device, low, high);
-    }
-
-/**
- * @brief Set ranging raw thresholds (scaling not considered so not recommended to use it)
- *
- * @param low  raw low threshold set to raw register
- * @param high raw high threshold set to raw  register
- * @return 0 on success
- */			
-    int RangeSetRawThresholds(uint8_t low, uint8_t high)
-    {
-       return VL6180x_RangeSetRawThresholds(Device, low, high);
-    }
-
-/**
- * @brief Set Early Convergence Estimate ratio
- * @par Function Description
- * For more information on ECE check datasheet
- * @warning May return a calibration warning in some use cases
- *
- * @param FactorM    ECE factor M in M/D
- * @param FactorD    ECE factor D in M/D
- * @return           0 on success. <0 on error. >0 on warning
- */		
-    int RangeSetEceFactor(uint16_t  FactorM, uint16_t FactorD)
-    {
-       return VL6180x_RangeSetEceFactor(Device, FactorM, FactorD);
-    }
-
-/**
- * @brief Set Early Convergence Estimate state (See #SYSRANGE_RANGE_CHECK_ENABLES register)
- * @param enable    State to be set 0=disabled, otherwise enabled
- * @return          0 on success
- */		
-    int RangeSetEceState(int enable)
-    {
-       return VL6180x_RangeSetEceState(Device, enable);
-    }
-
-/**
- * @brief Set activation state of the wrap around filter
- * @param state New activation state (0=off,  otherwise on)
- * @return      0 on success
- */			
-    int FilterSetState(int state)
-    {
-       return VL6180x_FilterSetState(Device, state);
-    }
-
-/**
- * Get activation state of the wrap around filter
- * @return     Filter enabled or not, when filter is not supported it always returns 0S
- */			
-    int FilterGetState()
-    {
-       return VL6180x_FilterGetState(Device);
-    }
-
-/**
- * @brief Set activation state of  DMax computation
- * @param state New activation state (0=off,  otherwise on)
- * @return      0 on success
- */		
-    int DMaxSetState(int state)
-    {
-       return VL6180x_DMaxSetState(Device, state);
-    }
-
-/**
- * Get activation state of DMax computation
- * @return     Filter enabled or not, when filter is not supported it always returns 0S
- */		
-    int DMaxGetState()
-    {
-       return VL6180x_DMaxGetState(Device);
-    }
-
-/**
- * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180x_RangeStartSingleShot() or @a VL6180x_RangeStartContinuousMode())
- *
- * @par Function Description
- * When used outside scope of known polling single shot stopped state, \n
- * user must ensure the device state is "idle" before to issue a new command.
- *
- * @param mode  A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start/stop condition (#MODE_START_STOP) \n
- * @return      0 on success
- */		
-    int RangeSetSystemMode(uint8_t mode)
-    {
-       return VL6180x_RangeSetSystemMode(Device, mode);
-    }
-
-/** @}  */ 
-
-/** @defgroup api_ll_range_calibration Ranging calibration functions
- *  @brief    Ranging calibration functions
- *  @ingroup api_ll
- *  @{  
- */
-/**
- * @brief Get part to part calibration offset
- *
- * @par Function Description
- * Should only be used after a successful call to @a VL6180x_InitData to backup device nvm value
- *
- * @return part to part calibration offset from device
- */		
-    int8_t GetOffsetCalibrationData()
-    {
-       return VL6180x_GetOffsetCalibrationData(Device);
-    }
-
-/**
- * Set or over-write part to part calibration offset
- * \sa VL6180x_InitData(), VL6180x_GetOffsetCalibrationData()
- * @param offset   Offset
- */		
-    void SetOffsetCalibrationData(int8_t offset)
-    {
-       return VL6180x_SetOffsetCalibrationData(Device, offset);
-    }
-
-/**
- * @brief Set Cross talk compensation rate
- *
- * @par Function Description
- * It programs register @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE
- *
- * @param Rate Compensation rate (9.7 fix point) see datasheet for details
- * @return     0 on success
- */		
-    int SetXTalkCompensationRate(FixPoint97_t Rate)
-    {
-       return VL6180x_SetXTalkCompensationRate(Device, Rate);
-    }
-/** @}  */
-
-/** @defgroup api_ll_als ALS functions
- *  @brief    ALS functions
- *  @ingroup api_ll
- *  @{  
- */
-
-/**
- * @brief Wait for device to be ready for new als operation or max pollign loop (time out)
- * @param MaxLoop    Max Number of i2c polling loop see @a #msec_2_i2cloop
- * @return           0 on success. <0 when @a VL6180x_ErrCode_t::TIME_OUT if timed out
- */		
-    int AlsWaitDeviceReady(int MaxLoop)
-    {
-       return VL6180x_AlsWaitDeviceReady(Device, MaxLoop);
-    }
-		
-/**
- * @brief Set ALS system mode and start/stop measure
- *
- * @warning When used outside after single shot polling, \n
- * User must ensure  the device state is ready before issuing a new command (using @a VL6180x_AlsWaitDeviceReady()). \n
- * Non respect of this, can cause loss of interrupt or device hanging.
- *
- * @param mode  A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start condition (#MODE_START_STOP) \n
- * @return      0 on success
- */		
-    int AlsSetSystemMode(uint8_t mode)
-    {
-       return VL6180x_AlsSetSystemMode(Device, mode);
-    }
-
-/** @defgroup api_ll_misc Misc functions
- *  @brief    Misc functions
- *  @ingroup api_ll
- *  @{  
- */
-
-/**
- * Set Group parameter Hold state
- *
- * @par Function Description
- * Group parameter holds @a #SYSTEM_GROUPED_PARAMETER_HOLD enable safe update (non atomic across multiple measure) by host
- * \n The critical register group is composed of: \n
- * #SYSTEM_INTERRUPT_CONFIG_GPIO \n
- * #SYSRANGE_THRESH_HIGH \n
- * #SYSRANGE_THRESH_LOW \n
- * #SYSALS_INTEGRATION_PERIOD \n
- * #SYSALS_ANALOGUE_GAIN \n
- * #SYSALS_THRESH_HIGH \n
- * #SYSALS_THRESH_LOW
- *
- *
- * @param Hold  Group parameter Hold state to be set (on/off)
- * @return      0 on success
- */
-    int SetGroupParamHold(int Hold)
-    {
-       return VL6180x_SetGroupParamHold(Device, Hold);
-    }		
-
-/**
- * @brief Set new device i2c address
- *
- * After completion the device will answer to the new address programmed.
- *
- * @sa AN4478: Using multiple VL6180X's in a single design
- * @param NewAddr   The new i2c address (7bit)
- * @return          0 on success
- */		
-    int SetI2CAddress(int NewAddr)
-    {
-       int status;
-			
-       status=VL6180x_SetI2CAddress(Device, NewAddr);
-       if(!status)
-          Device->I2cAddr=NewAddr;
-       return status;
-    }
-
-/**
- * @brief Fully configure gpio 0/1 pin : polarity and functionality
- *
- * @param pin          gpio pin 0 or 1
- * @param IntFunction  Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
- * @param ActiveHigh   Set active high polarity, or active low see @a ::IntrPol_e
- * @return             0 on success
- */		
-    int SetupGPIOx(int pin, uint8_t IntFunction, int ActiveHigh)
-    {
-       return VL6180x_SetupGPIOx(Device, pin, IntFunction, ActiveHigh);
-    }
-
-/**
- * @brief Set interrupt pin polarity for the given GPIO
- *
- * @param pin          Pin 0 or 1
- * @param active_high  select active high or low polarity using @ref IntrPol_e
- * @return             0 on success
- */		
-    int SetGPIOxPolarity(int pin, int active_high)
-    {
-       return VL6180x_SetGPIOxPolarity(Device, pin, active_high);
-    }
-
-/**
- * Select interrupt functionality for the given GPIO
- *
- * @par Function Description
- * Functionality refer to @a SYSTEM_MODE_GPIO0
- *
- * @param pin            Pin to configure 0 or 1 (gpio0 or gpio1)\nNote that gpio0 is chip enable at power up !
- * @param functionality  Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
- * @return              0 on success
- */		 
-    int SetGPIOxFunctionality(int pin, uint8_t functionality)
-    {
-       return VL6180x_SetGPIOxFunctionality(Device, pin, functionality);
-    }
-
-/**
- * #brief Disable and turn to Hi-Z gpio output pin
- *
- * @param pin  The pin number to disable 0 or 1
- * @return     0 on success
- */	
-    int DisableGPIOxOut(int pin)
-    {
-       return VL6180x_DisableGPIOxOut(Device, pin);
-    }
-
-/** @}  */
-
-/** @defgroup api_ll_intr Interrupts management functions
- *  @brief    Interrupts management functions
- *  @ingroup api_ll
- *  @{  
- */
-
-/**
- * @brief     Get all interrupts cause
- *
- * @param status Ptr to interrupt status. You can use @a IntrStatus_t::val
- * @return 0 on success
- */		
-    int GetInterruptStatus(uint8_t *status)
-    {
-       return VL6180x_GetInterruptStatus(Device, status);
-    }
-
-/**
- * @brief Clear given system interrupt condition
- *
- * @par Function Description
- * Clear given interrupt cause by writing into register #SYSTEM_INTERRUPT_CLEAR register.
- * @param dev       The device 
- * @param IntClear  Which interrupt source to clear. Use any combinations of #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR.
- * @return  0       On success
- */		
-    int ClearInterrupt(uint8_t IntClear)
-    {
-       return VL6180x_ClearInterrupt(Device, IntClear );
-    }
-
-/**
- * @brief Clear error interrupt
- *
- * @param dev    The device
- * @return  0    On success
- */
- #define VL6180x_ClearErrorInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR)
-
-/**
- * @brief Clear All interrupt causes (als+range+error)
- *
- * @param dev    The device
- * @return  0    On success
- */
-#define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
-	
-/** @}  */
-
-/**
- * @brief Get the ALS (light in Lux) level
- *
- * @par Function Description
- * Get the ALS (light in Lux) level 
- * @param *piData The pointer to variable to write in the measure in Lux
- * @return  0       On success
- */				
-    virtual int GetLight(uint32_t *piData)
-    {
-       return VL6180x_AlsGetLux(Device, piData);
-    }
-
-/**
- * @brief Start the ALS (light) measure in continous mode
- *
- * @par Function Description
- * Start the ALS (light) measure in continous mode
- * @return  0       On success
- */						
-    int AlsStartContinuousMode()
-    {
-       return VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_CONTINUOUS);
-    }
-
-/**
- * @brief Start the ALS (light) measure in single shot mode
- *
- * @par Function Description
- * Start the ALS (light) measure in single shot mode
- * @return  0       On success
- */						    
-    int AlsStartSingleShot()
-    {
-       return VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
-    }
-		
- private:		
-    /* api.h functions */
-    int VL6180x_WaitDeviceBooted(VL6180xDev_t dev);
-    int VL6180x_InitData(VL6180xDev_t dev );
-    int VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh);
-    int VL6180x_Prepare(VL6180xDev_t dev);
-    int VL6180x_RangeStartContinuousMode(VL6180xDev_t dev);
-    int VL6180x_RangeStartSingleShot(VL6180xDev_t dev);
-    int VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t  MaxConTime_msec);
-    int VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
-    int VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
-    int VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
-    int VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm);
-    int VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt);
-    int VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus);
-    int VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
-    int VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
-    int VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt);
-    int VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms);
-    int VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev,  uint16_t intermeasurement_period_ms);
-    int VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain);
-    int VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high);
-    int VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus);
-    int VL6180x_StaticInit(VL6180xDev_t dev);
-    int VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop );
-    int VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t  InterMeasTime_msec);
-    int VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling);
-    int VL6180x_UpscaleGetScaling(VL6180xDev_t dev);
-    uint16_t VL6180x_GetUpperLimit(VL6180xDev_t dev);
-    int VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int SafeHold);
-    int VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high);
-    int VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high);
-    int VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t  FactorM, uint16_t FactorD);
-    int VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable );
-    int VL6180x_FilterSetState(VL6180xDev_t dev, int state);
-    int VL6180x_FilterGetState(VL6180xDev_t dev);
-    int VL6180x_DMaxSetState(VL6180xDev_t dev, int state);
-    int VL6180x_DMaxGetState(VL6180xDev_t dev);
-    int VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t mode);
-    int8_t VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev);
-    void VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset);
-    int VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate);
-    int VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop );
-    int VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode); 
-    int VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold);
-    int VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddr);
-    int VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin, uint8_t IntFunction, int ActiveHigh);
-    int VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high);
-    int VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality);
-    int VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin);
-    int VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *status);
-    int VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear );
-		
-    /*  Other functions defined in api.c */
-    int VL6180x_RangeStaticInit(VL6180xDev_t dev); 
-    int VL6180x_UpscaleRegInit(VL6180xDev_t dev);
-    int VL6180x_UpscaleStaticInit(VL6180xDev_t dev); 
-    int VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux);
-    int _UpscaleInitPatch0(VL6180xDev_t dev); 
-    int VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int * Ready);
-    int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev);
-    int32_t _GetAveTotalTime(VL6180xDev_t dev); 
-    int32_t _filter_Start(VL6180xDev_t dev, uint16_t m_trueRange_mm, uint16_t m_rawRange_mm, uint32_t m_rtnSignalRate, uint32_t m_rtnAmbientRate, uint16_t errorCode);
-    int _filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
-    int _GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); 
-    int _DMax_InitData(VL6180xDev_t dev);
-		
-    /* Read function of the ID device */
-    virtual int ReadID();
-    
-    /* Write and read functions from I2C */
-    int VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data);
-    int VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data);
-    int VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data);
-    int VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data);
-    int VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data);
-    int VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data);
-    int VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData);
-    int VL6180x_I2CWrite(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t *pBuffer, uint16_t NumByteToWrite);
-    int VL6180x_I2CRead(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t *pBuffer, uint16_t NumByteToRead);
-		
-		
-    int IsPresent()
-    {
-       int status;
-			
-       status=ReadID();
-       if(status)
-          VL6180x_ErrLog("Failed to read ID device. Device not present!\n\r");
-       return status;
-    }	
-    int StopRangeMeasurement(OperatingMode operating_mode);
-    int StopAlsMeasurement(OperatingMode operating_mode);
-    int GetRangeMeas(OperatingMode operating_mode, MeasureData_t *Data);	
-    int GetAlsMeas(OperatingMode operating_mode, MeasureData_t *Data);
-    int GetRangeAlsMeas(MeasureData_t *Data);
-    int RangeSetLowThreshold(uint16_t threshold);
-    int RangeSetHighThreshold(uint16_t threshold);
-    int AlsSetLowThreshold(uint16_t threshold);	
-    int AlsSetHighThreshold(uint16_t threshold);
-    int GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData);
-    int GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData);
-    int RangeMeasPollSingleShot();
-    int AlsMeasPollSingleShot();		
-    int RangeMeasPollContinuousMode();	
-    int AlsMeasPollContinuousMode();
-    int AlsGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
-    int RangeMeasIntContinuousMode(void (*fptr)(void));
-    int AlsMeasIntContinuousMode(void (*fptr)(void));
-    int InterleavedMode(void (*fptr)(void));
-    int StartInterleavedMode();
-    int AlsGetThresholds(VL6180xDev_t dev, lux_t *low, lux_t *high);
-
-		
-    /* IO Device */
-    DevI2C &dev_i2c;
-    /* Device data */
-    MyVL6180Dev_t MyDevice;
-    VL6180xDev_t Device;  
-};
-
-#endif // __VL6180X_CLASS_H
--- a/VL6180X/vl6180x_def.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,743 +0,0 @@
-/*******************************************************************************
-Copyright © 2014, 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.
-********************************************************************************/
-
-/*
- * $Date: 2015-05-13 14:12:05 +0200 (Wed, 13 May 2015) $
- * $Revision: 2290 $
- */
-
-/**
- * @file VL6180x_def.h
- *
- * @brief Type definitions for vl6180x api.
- *
- */
-
-
-#ifndef _VL6180x_DEF
-#define _VL6180x_DEF
-
-/** API major version */
-#define VL6180x_API_REV_MAJOR   3
-/** API minor version */
-#define VL6180x_API_REV_MINOR   0
-/** API sub version */
-#define VL6180x_API_REV_SUB     1
-
-#define VL6180X_STR_HELPER(x) #x
-#define VL6180X_STR(x) VL6180X_STR_HELPER(x)
-
-#include "vl6180x_cfg.h"
-#include "vl6180x_types.h"
-
-/*
- * check configuration macro raise error or warning and suggest a default value
- */
-
-#ifndef VL6180x_UPSCALE_SUPPORT
-#error "VL6180x_UPSCALE_SUPPORT not defined"
-/* TODO you must define value for  upscale support in your vl6180x_cfg.h  */
-#endif
-
-#ifndef VL6180x_ALS_SUPPORT
-#error "VL6180x_ALS_SUPPORT not defined"
-/* TODO you must define VL6180x_ALS_SUPPORT  with a value in your vl6180x_cfg.h  set to 0 do disable*/
-#endif
-
-#ifndef VL6180x_HAVE_DMAX_RANGING
-#error "VL6180x_HAVE_DMAX_RANGING not defined"
-/* TODO you may remove or comment these #error and keep the default below  or update your vl6180x_cfg.h .h file */
-/**
- * force VL6180x_HAVE_DMAX_RANGING to not supported when not part of cfg file
- */
-#define VL6180x_HAVE_DMAX_RANGING   0
-#endif
-
-#ifndef VL6180x_EXTENDED_RANGE
-#define VL6180x_EXTENDED_RANGE   0
-#endif
-
-#ifndef  VL6180x_WRAP_AROUND_FILTER_SUPPORT
-#error "VL6180x_WRAP_AROUND_FILTER_SUPPORT not defined ?"
-/* TODO you may remove or comment these #error and keep the default below  or update vl6180x_cfg.h file */
-/**
- * force VL6180x_WRAP_AROUND_FILTER_SUPPORT to not supported when not part of cfg file
- */
-#define VL6180x_WRAP_AROUND_FILTER_SUPPORT 0
-#endif
-
-
-
-
-/****************************************
- * PRIVATE define do not edit
- ****************************************/
-
-/** Maximal buffer size ever use in i2c */
-#define VL6180x_MAX_I2C_XFER_SIZE   8 /* At present time it 6 byte max but that can change */
-
-#if VL6180x_UPSCALE_SUPPORT < 0
-/**
- * @def VL6180x_HAVE_UPSCALE_DATA
- * @brief  is defined if device data structure has data so when user configurable up-scale is active
- */
-#define VL6180x_HAVE_UPSCALE_DATA /* have data only for user configurable up-scale config */
-#endif
-
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
-/**
- * @def VL6180x_HAVE_WRAP_AROUND_DATA
- * @brief  is defined if device data structure has filter data so when active in cfg file
- */
-#define  VL6180x_HAVE_WRAP_AROUND_DATA
-#endif
-
-#if VL6180x_ALS_SUPPORT != 0
-/**
- * @def  VL6180x_HAVE_ALS_DATA
- * @brief is defined when als data are include in device data structure so when als suport if configured
- */
-#define VL6180x_HAVE_ALS_DATA
-#endif
-
-
-#if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
-	#define	VL6180x_HAVE_RATE_DATA
-#endif
-
-/** Error and warning code returned by API
- *
- * negative value are true error mostly fatal\n
- * positive value  are warning most of time it's ok to continue\n
- */
-enum VL6180x_ErrCode_t{
-	API_NO_ERROR        = 0,
-    CALIBRATION_WARNING = 1,  /*!< warning invalid calibration data may be in used \a  VL6180x_InitData() \a VL6180x_GetOffsetCalibrationData \a VL6180x_SetOffsetCalibrationData*/
-    MIN_CLIPED          = 2,  /*!< warning parameter passed was clipped to min before to be applied */
-    NOT_GUARANTEED      = 3,  /*!< Correct operation is not guaranteed typically using extended ranging on vl6180x */
-    NOT_READY           = 4,  /*!< the data is not ready retry */
-
-    API_ERROR      = -1,    /*!< Unqualified error */
-    INVALID_PARAMS = -2,    /*!< parameter passed is invalid or out of range */
-    NOT_SUPPORTED  = -3,    /*!< function is not supported in current mode or configuration */
-    RANGE_ERROR    = -4,    /*!< device report a ranging error interrupt status */
-    TIME_OUT       = -5,    /*!< aborted due to time out */
-};
-
-/**
- * Filtered result data structure  range data is to be used
- */
-typedef struct RangeFilterResult_tag {
-    uint16_t range_mm;      /*!< Filtered ranging value */
-    uint16_t rawRange_mm;   /*!< raw range value (scaled) */
-} RangeFilterResult_t;
-
-/**
- * "small" unsigned data type used in filter
- *
- * if data space saving is not a concern it can be change to platform native unsigned int
- */
-typedef uint8_t  FilterType1_t;
-
-/**
- * @def FILTER_NBOF_SAMPLES
- * @brief sample history len used for wrap around filtering
- */
-#define FILTER_NBOF_SAMPLES             10
-/**
- * Wrap around filter internal data
- */
-struct FilterData_t {
-    uint32_t MeasurementIndex;                      /*!< current measurement index */
-    uint16_t LastTrueRange[FILTER_NBOF_SAMPLES];    /*!< filtered/corrected  distance history */
-    uint32_t LastReturnRates[FILTER_NBOF_SAMPLES];  /*!< Return rate history */
-    uint16_t StdFilteredReads;                      /*!< internal use */
-    FilterType1_t Default_ZeroVal;                  /*!< internal use */
-    FilterType1_t Default_VAVGVal;                  /*!< internal use */
-    FilterType1_t NoDelay_ZeroVal;                  /*!< internal use */
-    FilterType1_t NoDelay_VAVGVal;                  /*!< internal use */
-    FilterType1_t Previous_VAVGDiff;                /*!< internal use */
-};
-
-#if  VL6180x_HAVE_DMAX_RANGING
-typedef int32_t DMaxFix_t;
-struct DMaxData_t {
-    uint32_t ambTuningWindowFactor_K; /*!<  internal algo tuning (*1000) */
-
-    DMaxFix_t retSignalAt400mm;  /*!< intermediate dmax computation value caching @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE and private reg 0x02A */
-    //int32_t RegB8;              /*!< register 0xB8 cached to speed reduce i2c traffic for dmax computation */
-    /* place all word data below to optimize struct packing */
-    //int32_t minSignalNeeded;    /*!< optimized computation intermediate base on register cached value */
-    int32_t snrLimit_K;         /*!< cached and optimized computation intermediate from  @a #SYSRANGE_MAX_AMBIENT_LEVEL_MULT */
-    uint16_t ClipSnrLimit;      /*!< Max value for snr limit */
-    /* place all byte data below to optimize packing */
-    //uint8_t MaxConvTime;        /*!< cached max convergence time @a #SYSRANGE_MAX_CONVERGENCE_TIME*/
-};
-#endif
-
-/**
- * @struct VL6180xDevData_t
- *
- * @brief Per VL6180x device St private data structure \n
- * End user should never access any of these field directly
- *
- * These must never access directly but only via VL6180xDev/SetData(dev, field) macro
- */
-struct VL6180xDevData_t {
-
-    uint32_t Part2PartAmbNVM;  /*!< backed up NVM value */
-    uint32_t XTalkCompRate_KCps; /*! Cached XTlak Compensation Rate */
-
-    uint16_t EceFactorM;        /*!< Ece Factor M numerator  */
-    uint16_t EceFactorD;        /*!< Ece Factor D denominator*/
-
-#ifdef VL6180x_HAVE_ALS_DATA
-    uint16_t IntegrationPeriod; /*!< cached als Integration period avoid slow read from device at each measure */
-    uint16_t AlsGainCode;       /*!< cached Als gain avoid slow read from device at each measure */
-    uint16_t AlsScaler;         /*!< cached Als scaler avoid slow read from device at each measure */
-#endif
-
-#ifdef VL6180x_HAVE_UPSCALE_DATA
-    uint8_t UpscaleFactor;      /*!<  up-scaling factor*/
-#endif
-
-#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
-    uint8_t WrapAroundFilterActive; /*!< Filter on/off */
-    struct FilterData_t FilterData; /*!< Filter internal data state history ... */
-#endif
-
-#if  VL6180x_HAVE_DMAX_RANGING
-    struct DMaxData_t DMaxData;
-    uint8_t DMaxEnable;
-#endif
-    int8_t  Part2PartOffsetNVM;     /*!< backed up NVM value */
-};
-
-#if VL6180x_SINGLE_DEVICE_DRIVER
-extern  struct VL6180xDevData_t SingleVL6180xDevData;
-#define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field)
-/* is also used as direct accessor like VL6180xDevDataGet(dev, x)++*/
-#define VL6180xDevDataSet(dev, field, data) (SingleVL6180xDevData.field)=(data)
-#endif
-
-
-/**
- * @struct VL6180x_RangeData_t
- * @brief Range and any optional measurement data.
- */
-typedef struct {
-    int32_t range_mm;          /*!< range distance in mm. */
-    int32_t signalRate_mcps;   /*!< signal rate (MCPS)\n these is a 9.7 fix point value, which is effectively a measure of target reflectance.*/
-    uint32_t errorStatus;      /*!< Error status of the current measurement. \n
-                                  see @a ::RangeError_u @a VL6180x_GetRangeStatusErrString() */
-
-
-#ifdef VL6180x_HAVE_RATE_DATA
-    uint32_t rtnAmbRate;    /*!< Return Ambient rate in KCount per sec related to \a RESULT_RANGE_RETURN_AMB_COUNT */
-    uint32_t rtnRate;       /*!< Return rate in KCount per sec  related to \a RESULT_RANGE_RETURN_SIGNAL_COUNT  */
-    uint32_t rtnConvTime;   /*!< Return Convergence time \a RESULT_RANGE_RETURN_CONV_TIME */
-    uint32_t refConvTime;   /*!< Reference convergence time \a RESULT_RANGE_REFERENCE_CONV_TIME */
-#endif
-
-
-#if  VL6180x_HAVE_DMAX_RANGING
-    uint32_t DMax;              /*!< DMax  when applicable */
-#endif
-
-#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
-    RangeFilterResult_t FilteredData; /*!< Filter result main range_mm is updated */
-#endif
-}VL6180x_RangeData_t;
-
-
-/** use where fix point 9.7 bit values are expected
- *
- * given a floating point value f it's .7 bit point is (int)(f*(1<<7))*/
-typedef uint16_t FixPoint97_t;
-
-/** lux data type */
-typedef uint32_t lux_t;
-
-/**
- * @brief This data type defines als  measurement data.
- */
-typedef struct VL6180x_AlsData_st{
-    lux_t lux;                 /**< Light measurement (Lux) */
-    uint32_t errorStatus;      /**< Error status of the current measurement. \n
-     * No Error := 0. \n
-     * Refer to product sheets for other error codes. */
-}VL6180x_AlsData_t;
-
-/**
- * @brief Range status Error code
- *
- * @a VL6180x_GetRangeStatusErrString() if configured ( @a #VL6180x_RANGE_STATUS_ERRSTRING )
- * related to register @a #RESULT_RANGE_STATUS and additional post processing
- */
-typedef enum {
-    NoError_=0,                /*!< 0  0b0000 NoError  */
-    VCSEL_Continuity_Test,     /*!< 1  0b0001 VCSEL_Continuity_Test */
-    VCSEL_Watchdog_Test,       /*!< 2  0b0010 VCSEL_Watchdog_Test */
-    VCSEL_Watchdog,            /*!< 3  0b0011 VCSEL_Watchdog */
-    PLL1_Lock,                 /*!< 4  0b0100 PLL1_Lock */
-    PLL2_Lock,                 /*!< 5  0b0101 PLL2_Lock */
-    Early_Convergence_Estimate,/*!< 6  0b0110 Early_Convergence_Estimate */
-    Max_Convergence,           /*!< 7  0b0111 Max_Convergence */
-    No_Target_Ignore,          /*!< 8  0b1000 No_Target_Ignore */
-    Not_used_9,                /*!< 9  0b1001 Not_used */
-    Not_used_10,               /*!< 10 0b1010 Not_used_ */
-    Max_Signal_To_Noise_Ratio, /*!< 11 0b1011 Max_Signal_To_Noise_Ratio*/
-    Raw_Ranging_Algo_Underflow,/*!< 12 0b1100 Raw_Ranging_Algo_Underflow*/
-    Raw_Ranging_Algo_Overflow, /*!< 13 0b1101 Raw_Ranging_Algo_Overflow */
-    Ranging_Algo_Underflow,    /*!< 14 0b1110 Ranging_Algo_Underflow */
-    Ranging_Algo_Overflow,     /*!< 15 0b1111 Ranging_Algo_Overflow */
-
-    /* code below are addition for API/software side they are not hardware*/
-    RangingFiltered =0x10,     /*!< 16 0b10000 filtered by post processing*/
-
-} RangeError_u;
-
-
-/** @defgroup device_regdef Device registers & masks definitions
- *  @brief    Device registers and masks definitions
- */
-
- 
-/** @ingroup device_regdef
- * @{*/
-
-/**
- * The device model ID
- */
-#define IDENTIFICATION_MODEL_ID                 0x000
-/**
- * Revision identifier of the Device for major change.
- */
-#define IDENTIFICATION_MODULE_REV_MAJOR         0x003
-/**
- * Revision identifier of the Device for minor change.
- */
-#define IDENTIFICATION_MODULE_REV_MINOR         0x004
-
-
-/**
- * @def SYSTEM_MODE_GPIO0
- * @brief Configures polarity and select which function gpio 0 serves.
- *  Gpio0 is chip enable at power up ! Be aware of all h/w implication of turning it to output.
- *  Same definition as #SYSTEM_MODE_GPIO1
- * @ingroup device_regdef
- */
-#define SYSTEM_MODE_GPIO0                       0x010
-/**
- * @def SYSTEM_MODE_GPIO1
- * @brief Configures polarity and select what als or ranging functionality gpio pin serves.
- *
- * Function can be #GPIOx_SELECT_OFF  #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT.\n
- * Same definition apply to register GPIO0 that is used as chip enable at power up.
- * @ingroup device_regdef
- */
-#define SYSTEM_MODE_GPIO1                       0x011
-    /** gpio pad POLARITY mask in #SYSTEM_MODE_GPIO1 (and/or 0) write  1  to set active high polarity (positive edge) */
-    #define GPIOx_POLARITY_SELECT_MASK              0x20
-    /** gpio pad Function select shift in #SYSTEM_MODE_GPIO1 or 0 */
-    #define GPIOx_FUNCTIONALITY_SELECT_SHIFT          1
-    /** gpio pad Function select mask in #SYSTEM_MODE_GPIO1 or 0 */
-    #define GPIOx_FUNCTIONALITY_SELECT_MASK          (0xF<<GPIOx_FUNCTIONALITY_SELECT_SHIFT)
-    /** select no interrupt in #SYSTEM_MODE_GPIO1 pad is put in  Hi-Z*/
-    #define GPIOx_SELECT_OFF                        0x00
-    /** select gpiox as interrupt output in  #SYSTEM_MODE_GPIO1 */
-    #define GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT      0x08
-    /** select range as source for interrupt on in #SYSTEM_MODE_GPIO1 */
-    #define GPIOx_MODE_SELECT_RANGING               0x00
-    /** select als as source for interrupt on in #SYSTEM_MODE_GPIO1 */
-    #define GPIOx_MODE_SELECT_ALS                   0x01
-
-
-/**
- * @def SYSTEM_INTERRUPT_CONFIG_GPIO
- *
- * @brief   Configure Als and Ranging interrupt reporting
- *
- * Possible values for Range and ALS are\n
- *
- * #CONFIG_GPIO_INTERRUPT_DISABLED\n
- * #CONFIG_GPIO_INTERRUPT_LEVEL_LOW\n
- * #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH\n
- * #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW\n
- * #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY\n
- * Apply respective rang/als shift and mask \n
- *  #CONFIG_GPIO_RANGE_SHIFT and full reg mask #CONFIG_GPIO_RANGE_MASK\n
- *  #CONFIG_GPIO_ALS_SHIFT and full reg mask #CONFIG_GPIO_ALS_MASK\n
- *
- * \sa GPIO use for interrupt #SYSTEM_MODE_GPIO0 or #SYSTEM_MODE_GPIO1\n
- * @ingroup device_regdef
- */
-#define SYSTEM_INTERRUPT_CONFIG_GPIO           0x014
-    /** RANGE bits shift in #SYSTEM_INTERRUPT_CONFIG_GPIO */
-    #define CONFIG_GPIO_RANGE_SHIFT            0
-    /** RANGE bits mask in #SYSTEM_INTERRUPT_CONFIG_GPIO  (unshifted)*/
-    #define CONFIG_GPIO_RANGE_MASK             (0x7<<CONFIG_GPIO_RANGE_SHIFT)
-    /** ALS bits shift in #SYSTEM_INTERRUPT_CONFIG_GPIO */
-    #define CONFIG_GPIO_ALS_SHIFT              3
-    /** ALS bits mask in #SYSTEM_INTERRUPT_CONFIG_GPIO  (unshifted)*/
-    #define CONFIG_GPIO_ALS_MASK               (0x7<<CONFIG_GPIO_ALS_SHIFT)
-    /** interrupt is disabled */
-    #define CONFIG_GPIO_INTERRUPT_DISABLED         0x00
-    /** trigger when value < low threshold */
-    #define CONFIG_GPIO_INTERRUPT_LEVEL_LOW        0x01
-    /** trigger when value < low threshold */
-    #define CONFIG_GPIO_INTERRUPT_LEVEL_HIGH       0x02
-    /** trigger when outside range defined by high low threshold */
-    #define CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW    0x03
-    /** trigger when new sample are ready */
-    #define CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY 0x04
-
-/**
- *  @def SYSTEM_INTERRUPT_CLEAR
- *  @brief Writing to this register will clear interrupt source
- *
- *  Use or combination of any #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR
- *  @ingroup device_regdef
- */
-#define SYSTEM_INTERRUPT_CLEAR                0x015
-    /** clear ranging interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
-    #define INTERRUPT_CLEAR_RANGING                0x01
-    /** clear als interrupt  in write to #SYSTEM_INTERRUPT_CLEAR */
-    #define INTERRUPT_CLEAR_ALS                    0x02
-    /** clear error interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
-    #define INTERRUPT_CLEAR_ERROR                  0x04
-
-/** After power up or reset this register will start reading 1 when device is ready */
-#define SYSTEM_FRESH_OUT_OF_RESET             0x016
-
-/**
- * @def SYSTEM_GROUPED_PARAMETER_HOLD
- * @brief Writing 1/0 activate/deactivate safe host update of multiple register in critical group \n
- *        rather use \a VL6180x_SetGroupParamHold()
- *
- * The critical register group is made of: \n
- * #SYSTEM_INTERRUPT_CONFIG_GPIO \n
- * #SYSRANGE_THRESH_HIGH \n
- * #SYSRANGE_THRESH_LOW \n
- * #SYSALS_INTEGRATION_PERIOD \n
- * #SYSALS_ANALOGUE_GAIN \n
- * #SYSALS_THRESH_HIGH \n
- * #SYSALS_THRESH_LOW
- * @ingroup device_regdef
- */
-#define SYSTEM_GROUPED_PARAMETER_HOLD         0x017
-
-
-/**
- * @def SYSRANGE_START
- * @brief Start/stop and set operating range mode
- *
- * Write Combination of #MODE_START_STOP  and #MODE_CONTINUOUS to select and start desired operation.
- *
- * @ingroup device_regdef
- */
-#define SYSRANGE_START                        0x018
-    /** mask existing bit in #SYSRANGE_START*/
-    #define MODE_MASK          0x03
-    /** bit 0 in #SYSRANGE_START write 1 toggle state in continuous mode and arm next shot in single shot mode */
-    #define MODE_START_STOP    0x01
-    /** bit 1 write 1 in #SYSRANGE_START set continuous operation mode */
-    #define MODE_CONTINUOUS    0x02
-    /** bit 1 write 0 in #SYSRANGE_START set single shot mode */
-    #define MODE_SINGLESHOT    0x00
-
-/**
- * @def SYSRANGE_THRESH_HIGH
- * High level range  threshold (must be scaled)
- * @ingroup device_regdef
- */
-#define SYSRANGE_THRESH_HIGH                  0x019
-
-/**
- * @def SYSRANGE_THRESH_LOW
- * Low level range  threshold (must be scaled)
- * @ingroup device_regdef
- */
-#define SYSRANGE_THRESH_LOW                   0x01A
-
-/**
- * @def SYSRANGE_INTERMEASUREMENT_PERIOD
- * @brief Continuous mode intermeasurement delay \a VL6180x_RangeSetInterMeasPeriod()
- *
- * Time delay between measurements in Ranging continuous mode.\n
- * Range 0-254 (0 = 10ms).\n Step size = 10ms.
- *
- * @ingroup device_regdef
- */
-#define SYSRANGE_INTERMEASUREMENT_PERIOD      0x01B
-
-/**
- * @brief Maximum time to run measurement in Ranging modes.
- * Range 1 - 63 ms (1 code = 1 ms);
- *
- * Measurement aborted when limit reached to aid power  reduction.\
- * For example, 0x01 = 1ms, 0x0a = 10ms.\
- * Note: Effective max_convergence_time depends on readout_averaging_sample_period setting.
- *
- * @ingroup device_regdef
- */
-#define SYSRANGE_MAX_CONVERGENCE_TIME         0x01C
-/**@brief Cross talk compensation rate
- * @warning  never write register directly use @a VL6180x_SetXTalkCompensationRate()
- * refer to manual for calibration procedure and computation
- * @ingroup device_regdef
- */
-#define SYSRANGE_CROSSTALK_COMPENSATION_RATE  0x01E
-/**
- * @brief Minimum range value in mm to qualify for crosstalk compensation
- */
-#define SYSRANGE_CROSSTALK_VALID_HEIGHT       0x021
-#define SYSRANGE_EARLY_CONVERGENCE_ESTIMATE   0x022
-#define SYSRANGE_PART_TO_PART_RANGE_OFFSET    0x024
-#define SYSRANGE_RANGE_IGNORE_VALID_HEIGHT    0x025
-#define SYSRANGE_RANGE_IGNORE_THRESHOLD       0x026
-#define SYSRANGE_EMITTER_BLOCK_THRESHOLD      0x028
-#define SYSRANGE_MAX_AMBIENT_LEVEL_THRESH     0x02A
-#define SYSRANGE_MAX_AMBIENT_LEVEL_MULT       0x02C
-/** @brief  various Enable check enabel register
- *  @a VL6180x_RangeSetEceState()
- */
-#define SYSRANGE_RANGE_CHECK_ENABLES          0x02D
-    #define RANGE_CHECK_ECE_ENABLE_MASK      0x01
-    #define RANGE_CHECK_RANGE_ENABLE_MASK    0x02
-    #define RANGE_CHECK_SNR_ENABLKE          0x10
-
-#define SYSRANGE_VHV_RECALIBRATE              0x02E
-#define SYSRANGE_VHV_REPEAT_RATE              0x031
-
-/**
- * @def SYSALS_START
- * @brief Start/stop and set operating als mode
- *
- * same bit definition as range \a #SYSRANGE_START \n
- */
-#define SYSALS_START                          0x038
-
-/** ALS low Threshold high */
-#define SYSALS_THRESH_HIGH                    0x03A
-/** ALS low Threshold low */
-#define SYSALS_THRESH_LOW                     0x03C
-/** ALS intermeasurement period */
-#define SYSALS_INTERMEASUREMENT_PERIOD        0x03E
-/** 
- * @warning or value with 0x40 when writing to these register*/
-#define SYSALS_ANALOGUE_GAIN                  0x03F
-/** ALS integration period */
-#define SYSALS_INTEGRATION_PERIOD             0x040
-
-/**
- * @brief Result range status
- *
- *  Hold the various range interrupt flags and error Specific error codes
- */
-#define RESULT_RANGE_STATUS                   0x04D
-    /** Device ready for new command bit 0*/
-    #define RANGE_DEVICE_READY_MASK       0x01
-    /** mask for error status covers bits [7:4]  in #RESULT_RANGE_STATUS @a ::RangeError_u */
-    #define RANGE_ERROR_CODE_MASK         0xF0 /* */
-    /** range error bit position in #RESULT_RANGE_STATUS */
-    #define RANGE_ERROR_CODE_SHIFT        4
-
-/**
- * @def RESULT_ALS_STATUS
- * @brief Result  als status \n
- *  Hold the various als interrupt flags and Specific error codes
- */
-#define RESULT_ALS_STATUS                     0x4E
-    /** Device ready for new command bit 0*/
-   #define ALS_DEVICE_READY_MASK       0x01
-
-/**
- * @def RESULT_ALS_VAL
- * @brief 16 Bit ALS count output value.
- *
- * Lux value depends on Gain and integration settings and calibrated lux/count setting
- * \a VL6180x_AlsGetLux() \a VL6180x_AlsGetMeasurement()
- */
-#define RESULT_ALS_VAL                        0x50
-
-/**
- * @def FW_ALS_RESULT_SCALER
- * @brief Als scaler register  Bits [3:0] analogue gain 1 to 16x
- * these register content is cached by API in \a VL6180xDevData_t::AlsScaler
- * for lux computation acceleration
- */
-#define FW_ALS_RESULT_SCALER                  0x120
-
-
-/**
- * these union can be use as a generic bit field type for map #RESULT_INTERRUPT_STATUS_GPIO register
- * @ingroup device_regdef
- */
-typedef union IntrStatus_u{
-    uint8_t val;           /*!< raw 8 bit register value*/
-    struct  {
-        unsigned Range     :3; /*!< Range status one of :\n  \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY */
-        unsigned Als       :3; /*!< Als status one of: \n \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY  */
-        unsigned Error     :2; /*!<  Error status of: \n \a #RES_INT_ERROR_LASER_SAFETY  \n \a #RES_INT_ERROR_PLL */
-     } status;                 /*!< interrupt status as bit field */
-} IntrStatus_t;
-
-/**
- * @def RESULT_INTERRUPT_STATUS_GPIO
- * @brief System interrupt status report selected interrupt for als and ranging
- *
- * These register can be polled even if no gpio pins is active\n
- * What reported is selected by \a  #SYSTEM_INTERRUPT_CONFIG_GPIO \n
- * Range mask with \a #RES_INT_RANGE_MASK and shit by \a #RES_INT_RANGE_SHIFT
- * Als   mask with \a #RES_INT_ALS_MASK and shit by \a #RES_INT_ALS_SHIFT
- * Result value express condition (or combination?)
- * \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
- * \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
- * \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n
- * \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY
- *
- * @ingroup device_regdef
- */
-#define RESULT_INTERRUPT_STATUS_GPIO          0x4F
-    /** ranging interrupt 1st bit position in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_RANGE_SHIFT  0
-    /** ALS interrupt 1st bit position in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_ALS_SHIFT    3
-    /** interrupt bit position in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_ERROR_SHIFT  6
-    /** Ranging interrupt mask in #RESULT_INTERRUPT_STATUS_GPIO (prior to shift)  \sa IntrStatus_t */
-    #define RES_INT_RANGE_MASK (0x7<<RES_INT_RANGE_SHIFT)
-    /** als interrupt mask in #RESULT_INTERRUPT_STATUS_GPIO (prior to shift)  \sa IntrStatus_t */
-    #define RES_INT_ALS_MASK   (0x7<<RES_INT_ALS_SHIFT)
-
-    /** low threshold condition in #RESULT_INTERRUPT_STATUS_GPIO for */
-    #define RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  0x01
-    /** high threshold condition in #RESULT_INTERRUPT_STATUS_GPIO for ALs or Rage*/
-    #define RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD 0x02
-    /** out of window condition in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_STAT_GPIO_OUT_OF_WINDOW        0x03
-    /** new sample ready in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_STAT_GPIO_NEW_SAMPLE_READY     0x04
-    /** error  in #RESULT_INTERRUPT_STATUS_GPIO */
-    #define RES_INT_ERROR_MASK (0x3<<RES_INT_ERROR_SHIFT)
-        /** laser safety error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO */
-        #define RES_INT_ERROR_LASER_SAFETY  1
-        /** pll 1 or 2 error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO*/
-        #define RES_INT_ERROR_PLL           2
-
-/**
- * Final range result value presented to the user for use. Unit is in mm.
- */
-#define RESULT_RANGE_VAL                        0x062
-
-/**
- * Raw Range result value with offset applied (no cross talk compensation applied). Unit is in mm.
- */
-#define RESULT_RANGE_RAW                        0x064
-
-/**
- * @brief Sensor count rate of signal returns correlated to IR emitter.
- *
- * Computed from RETURN_SIGNAL_COUNT / RETURN_CONV_TIME. Mcps 9.7 format
- */
-#define RESULT_RANGE_SIGNAL_RATE                0x066
-
-/**
- * @brief Return signal count
- *
- *  Sensor count output value attributed to signal correlated to IR emitter on the Return array.
- */
-#define RESULT_RANGE_RETURN_SIGNAL_COUNT        0x06C
-
-/**
- * @brief Reference signal count
- *
- * sensor count output value attributed to signal correlated to IR emitter on the Reference array.
- */
-#define RESULT_RANGE_REFERENCE_SIGNAL_COUNT     0x070
-
-/**
- * @brief Return ambient count
- *
- * sensor count output value attributed to uncorrelated ambient signal on the Return array.
- * Must be multiplied by 6 if used to calculate the ambient to signal threshold
- */
-#define RESULT_RANGE_RETURN_AMB_COUNT           0x074
-
-/**
- * @brief   Reference ambient count
- *
- * Sensor count output value attributed to uncorrelated ambient signal on the Reference array.
- */
-#define RESULT_RANGE_REFERENCE_AMB_COUNT        0x078
-
-/**
- * sensor count output value attributed to signal on the Return array.
- */
-#define RESULT_RANGE_RETURN_CONV_TIME           0x07C
-
-/**
- * sensor count output value attributed to signal on the Reference array.
- */
-#define RESULT_RANGE_REFERENCE_CONV_TIME        0x080
-
-
-/**
- * @def RANGE_SCALER
- * @brief RANGE scaling register
- *
- * Never should  user write directly onto that register directly \a VL6180x_UpscaleSetScaling()
- */
-#define RANGE_SCALER                            0x096
-
-/**
- * @def READOUT_AVERAGING_SAMPLE_PERIOD
- * @brief Readout averaging sample period register
- *
- *
- * The internal readout averaging sample period can be adjusted from 0 to 255.
- * Increasing the sampling period decreases noise but also reduces the effective
- * max convergence time and increases power consumption
- * Each unit sample period corresponds to around 64.5 μs additional processing time.
- * The recommended setting is 48 which equates to around 4.3 ms.
- *
- * see datasheet for more detail
- */
-#define READOUT_AVERAGING_SAMPLE_PERIOD     0x10A
-
-/**
- * @def I2C_SLAVE_DEVICE_ADDRESS
- * User programmable I2C address (7-bit). Device address can be re-designated after power-up.
- * @warning What programmed in the register 7-0 are bit 8-1 of i2c address on bus (bit 0 is rd/wr)
- * so what prohamd is commonly whar ergfer as adrerss /2
- * @sa VL6180x_SetI2CAddress()
- */
-#define I2C_SLAVE_DEVICE_ADDRESS               0x212
-
-#endif /* _VL6180x_DEF */
--- a/VL6180X/vl6180x_platform.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +0,0 @@
-/*******************************************************************************
-################################################################################
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License version 2 and only version 2 as
-# published by the Free Software Foundation.
-#
-# 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, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-#------------------------------------------------------------------------------
-#                             Imaging Division
-################################################################################
-********************************************************************************/
-
-
-/* vl6180x_platform.h STM32 Nucleo F401 single device  sample code project */
-
-#ifndef VL6180x_PLATFORM
-#define VL6180x_PLATFORM
-
-
-#include "vl6180x_def.h"
-
-
-#define VL6180x_SINGLE_DEVICE_DRIVER 	0
-#define VL6180x_RANGE_STATUS_ERRSTRING  1
-#define VL6180X_SAFE_POLLING_ENTER 	0
-#define VL6180X_LOG_ENABLE              0
-#define MY_LOG                          1
-
-#define VL6180x_DEV_DATA_ATTR
-#define ROMABLE_DATA
-
-
-#if VL6180X_LOG_ENABLE
-/*  dot not include non ansi here trace was a case :( */
-#ifdef TRACE
-#include "diag/trace.h"
-extern volatile uint32_t g_TickCnt;
-#define LOG_GET_TIME()  g_TickCnt
-//#define LOG_GET_TIME()  HAL_GetTick()
-#else
-/* these is nto stm32 vl6180x GNuArm eclpse build*/
-#define trace_printf(...) (void)0
-#define LOG_GET_TIME() (int)0 /* add your code here expect to be an integer native (%d) type  value  */
-#endif
-
-
-
-#define LOG_FUNCTION_START(fmt, ... ) \
-    trace_printf("beg %s start @%d\t" fmt "\n", __func__, LOG_GET_TIME(), ##__VA_ARGS__)
-
-#define LOG_FUNCTION_END(status)\
-        trace_printf("end %s @%d %d\n", __func__, LOG_GET_TIME(), (int)status)
-
-#define LOG_FUNCTION_END_FMT(status, fmt, ... )\
-        trace_printf("End %s @%d %d\t"fmt"\n" , __func__, LOG_GET_TIME(), (int)status, ##__VA_ARGS__)
-
-#define VL6180x_ErrLog(msg, ... )\
-    do{\
-        trace_printf("ERR in %s line %d\n" msg, __func__, __LINE__, ##__VA_ARGS__);\
-    }while(0)
-
-#else /* VL6180X_LOG_ENABLE no logging */
-  //void OnErrLog(void);
-  #define LOG_FUNCTION_START(...) (void)0
-  #define LOG_FUNCTION_END(...) (void)0
-  #define LOG_FUNCTION_END_FMT(...) (void)0
-  #define VL6180x_ErrLog(... ) //OnErrLog() //(void)0
-#endif
-
-  
-#ifdef MY_LOG  /* define printf as pc.printf in order to change the baudrate */
-  extern Serial pc;
-  #define printf(...) pc.printf(__VA_ARGS__)
-#endif
-
-
-#if  VL6180x_SINGLE_DEVICE_DRIVER
-    #error "VL6180x_SINGLE_DEVICE_DRIVER must be set"
-#endif
-		
-struct MyVL6180Dev_t {
-    struct VL6180xDevData_t Data;
-    uint8_t I2cAddr;
-    //uint8_t DevID;
-    
-    //misc flags for application 	
-    unsigned Present:1;
-    unsigned Ready:1;
-};
-typedef struct MyVL6180Dev_t *VL6180xDev_t;
-
-#define VL6180xDevDataGet(dev, field) (dev->Data.field)
-#define VL6180xDevDataSet(dev, field, data) (dev->Data.field)=(data)
-
-
-#endif  /* VL6180x_PLATFORM */
-
-
-
--- a/VL6180X/vl6180x_types.h	Fri Mar 25 21:27:03 2016 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,62 +0,0 @@
-/*******************************************************************************
-Copyright © 2014, 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 VL6180x_TYPES_H_
-#define VL6180x_TYPES_H_
-
-
-#include <stdint.h>
-#include <stddef.h> /* these is for NULL */
-
-#ifndef NULL
-#error "review  NULL definition or add required include "
-#endif
-
-#if !defined(STDINT_H) &&  !defined(_GCC_STDINT_H) && !defined(__STDINT_DECLS) && !defined(_STDINT) && !defined(_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
-  */
-
-typedef unsigned int uint32_t;
-typedef int int32_t;
-
-typedef unsigned short uint16_t;
-typedef short int16_t;
-
-typedef unsigned char uint8_t;
-
-typedef signed char int8_t;
-
-#endif /* _STDINT_H */
-
-#endif /* VL6180x_TYPES_H_ */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/GenericSensor.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,67 @@
+/**
+ ******************************************************************************
+ * @file    GenericSensor.h
+ * @author  AST / EST 
+ * @version V0.0.1
+ * @date    13-April-2015
+ * @brief   This file contains the abstract class describing in general
+ *          the interfaces of a generic sensor
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * 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 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 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.
+ *
+ ******************************************************************************
+ */
+
+/* Define to prevent from recursive inclusion --------------------------------*/
+#ifndef __GENERIC_SENSOR_CLASS_H
+#define __GENERIC_SENSOR_CLASS_H
+
+/* Includes ------------------------------------------------------------------*/
+#include <stdint.h>
+
+/* Classes  ------------------------------------------------------------------*/
+/** An abstract class for Generic sensors
+ */
+class GenericSensor
+{
+ public:
+    /**
+     * @brief       Initialization of sensor
+     * @param[out]  ptr Pointer to device specific initalization structure
+     * @return      0 in case of success, an error code otherwise
+     */
+    virtual int Init() = 0;
+
+    /**
+     * @brief       Get ID of sensor
+     * @param[out]  id Pointer to where to store the ID to
+     * @return      0 in case of success, an error code otherwise
+     */
+    virtual int ReadID() = 0;
+};
+
+#endif /* __GENERIC_SENSOR_CLASS_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/LightSensor.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,60 @@
+/**
+ ******************************************************************************
+ * @file    LightSensor.h
+ * @author  AST / EST
+ * @version V0.0.1
+ * @date    13-April-2015
+ * @brief   This file contains the abstract class describing in general
+ *          the interfaces of an ambient light sensor (ALS)
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * 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 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 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.
+ *
+ ******************************************************************************
+ */
+
+/* Define to prevent from recursive inclusion --------------------------------*/
+#ifndef __LIGHT_SENSOR_CLASS_H
+#define __LIGHT_SENSOR_CLASS_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "GenericSensor.h"
+
+/* Classes  ------------------------------------------------------------------*/
+/** An abstract class for ambient light sensors
+ */
+class LightSensor : public GenericSensor
+{
+ public:
+    /**
+     * @brief       Get current light [lux]
+     * @param[out]  piData Pointer to where to store light to
+     * @return      0 in case of success, an error code otherwise
+     */
+    virtual int GetLight(uint32_t *piData) = 0;
+};
+
+#endif /* __LIGHT_SENSOR_CLASS_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/RangeSensor.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,60 @@
+/**
+ ******************************************************************************
+ * @file    RangeSensor.h
+ * @author  AST / EST
+ * @version V0.0.1
+ * @date    13-April-2015
+ * @brief   This file contains the abstract class describing in general
+ *          the interfaces of a range sensor
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * 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 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 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.
+ *
+ ******************************************************************************
+ */
+
+/* Define to prevent from recursive inclusion --------------------------------*/
+#ifndef __RANGE_SENSOR_CLASS_H
+#define __RANGE_SENSOR_CLASS_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "GenericSensor.h"
+
+/* Classes  ------------------------------------------------------------------*/
+/** An abstract class for range sensors
+ */
+class RangeSensor : public GenericSensor
+{
+ public:
+    /**
+     * @brief       Get current range [mm]
+     * @param[out]  piData Pointer to where to store range to
+     * @return      0 in case of success, an error code otherwise
+     */
+    virtual int GetRange(int32_t *piData) = 0;
+};
+
+#endif /* __RANGE_SENSOR_CLASS_H */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_cfg.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,129 @@
+/*******************************************************************************
+Copyright © 2014, 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.
+********************************************************************************/
+/*
+ * $Date: 2015-01-08 14:35:34 +0100 (Thu, 08 Jan 2015) $
+ * $Revision: 2042 $
+ */
+ 
+/**
+ * @file VL6180x_cfg.h
+ *
+ * Proximity and ALS configuration
+ */
+
+#ifndef VL6180x_CFG_H_
+#define VL6180x_CFG_H_
+
+/** @defgroup api_config Configuration
+ *  @brief API static configuration
+ */
+
+
+
+/** @ingroup api_config
+ * @{*/
+
+
+/**
+ * @def VL6180x_UPSCALE_SUPPORT
+ * @brief Configure up-scale capabilities and default up-scale factor for ranging operations
+ * 
+ * @li 1 : Fixed scaling by 1 (no up-scaling support)
+ * @li 2 : Fixed scaling by 2
+ * @li 3 : Fixed scaling by 3
+ * @li  -1 -2 -3 : Run time programmable through @a VL6180x_UpscaleSetScaling(). Default scaling factore is -VL6180x_UPSCALE_SUPPORT \n
+ */
+//#define VL6180x_UPSCALE_SUPPORT -1
+
+/**
+ * @def VL6180x_ALS_SUPPORT
+ * @brief Enable ALS support
+ *
+ * Set to 0 if ALS is not used in application. This can help reducing code size if it is a concern.
+ */
+#define VL6180x_ALS_SUPPORT      1
+
+/**
+ * @def VL6180x_HAVE_DMAX_RANGING
+ * @brief Enable DMax calculation for ranging applications.
+ *  
+ * When set to 1, __Dmax__ is returned by API typically when  @a VL6180x_RangePollMeasurement() high level
+ * function is called (this is returned in @a VL6180x_RangeData_t structure).
+ * __Dmax__ is an estimation of the maximum distance (in mm) the product can report a valid distance of a 17% target for 
+ * the current ambient light conditions (__Dmax__ decreases when ambient light increases). __Dmax__ should be used only
+ * when the product is not able to return a valid distance (no object or object is too far from the ranging sensor).
+ * Typically, this is done by checking the __errorStatus__ field of the @a VL6180x_RangeData_t structure returned by 
+ * the @a VL6180x_RangePollMeasurement() function.
+ * You may refer to ::RangeError_u to get full list of supported error codes.
+ * @warning Dmax is estimated for a 17% grey target. If the real target has a reflectance lower than 17%, report Dmax could be over-estimated 
+ */
+#define VL6180x_HAVE_DMAX_RANGING   1
+
+/**
+ * @def VL6180x_WRAP_AROUND_FILTER_SUPPORT
+ * @brief Enable wrap around filter (WAF) feature
+ *  
+ * In specific conditions, when targeting a mirror or a very reflective metal, a __wrap around__ effect can occur internally to the
+ * ranging product which results in returning a wrong distance (under-estimated). Goal of the WAF is to detect this wrap arround effect
+ * and to filter it by returning a non-valid distance : __errorStatus__ set to 16 (see ::RangeError_u)
+ * @warning Wrap-around filter can not be used when device is running in continuous mode 
+ * 
+ * @li 0 : Filter is not supported, no filtering code is included in API
+ * @li 1 : Filter is supported and active by default
+ * @li -1 : Filter is supported but is not active by default @a VL6180x_FilterSetState() can turn it on and off at any time
+ */
+#define VL6180x_WRAP_AROUND_FILTER_SUPPORT   1
+
+/**
+ * @def VL6180x_EXTENDED_RANGE
+ * @brief Enable extended ranging support
+ *
+ * Device that do not formally support extended ranging should only be used with a scaling factor of 1.
+ * Correct operation with scaling factor other than 1 (>200mm ) is not granted by ST.
+ */
+//#define VL6180x_EXTENDED_RANGE 0
+
+#define EXTENDED_RANGE_50CM     0
+//#define EXTENDED_RANGE_50CM     1
+
+#if EXTENDED_RANGE_50CM
+#define VL6180x_UPSCALE_SUPPORT -3
+#define VL6180x_EXTENDED_RANGE  1
+#else
+#define VL6180x_UPSCALE_SUPPORT -1
+#define VL6180x_EXTENDED_RANGE  0
+#endif
+
+#if (VL6180x_EXTENDED_RANGE) && (VL6180x_ALS_SUPPORT)
+#warning "Als support should be OFF for extended range"
+#endif
+
+#endif
+/** @} */ // end of api_config
+
+/* VL6180x_CFG_H_ */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_class.cpp	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,3634 @@
+/**
+ ******************************************************************************
+ * @file    vl6180x_class.cpp
+ * @author  AST / EST
+ * @version V0.0.1
+ * @date    14-April-2015
+ * @brief   Implementation file for the HTS221 driver class
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * 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 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 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.
+ *
+ ******************************************************************************
+*/
+ 
+/* Includes */
+#include "vl6180x_class.h"
+ 
+ 
+#ifndef  VL6180x_RANGE_STATUS_ERRSTRING
+#warning "VL6180x_RANGE_STATUS_ERRSTRING not defined ?"
+/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
+   or update your vl6180x_platform.h file */
+/**
+ * force VL6180x_RANGE_STATUS_ERRSTRING to not supported when not part of any cfg file
+ */
+#define VL6180x_RANGE_STATUS_ERRSTRING  0
+#endif
+ 
+#ifndef  VL6180X_SAFE_POLLING_ENTER
+#warning "VL6180X_SAFE_POLLING_ENTER not defined, likely old vl6180x_cfg.h file ?"
+/* TODO you may remove or comment these #warning and keep the default below to keep compatibility
+   or update your vl6180x_platform.h file */
+/**
+ * force VL6180X_SAFE_POLLING_ENTER to off when not in cfg file
+ */
+#define VL6180X_SAFE_POLLING_ENTER 0 /* off by default as in api 2.0 */
+#endif
+ 
+#ifndef VL6180X_LOG_ENABLE
+/**
+ * Force VL6180X_LOG_ENABLE to none as default
+ */
+#define VL6180X_LOG_ENABLE  0
+#endif
+
+#ifdef MY_LOG 
+Serial pc(USBTX, USBRX);
+#endif 
+ 
+#if VL6180x_RANGE_STATUS_ERRSTRING
+/**@def VL6180x_HAVE_RANGE_STATUS_ERRSTRING
+ * @brief is defined when @a #VL6180x_RANGE_STATUS_ERRSTRING is enable
+ */
+#define  VL6180x_HAVE_RANGE_STATUS_ERRSTRING
+#endif
+ 
+ 
+/** @brief Get API version as "hex integer" 0xMMnnss
+ */
+#define VL6180x_ApiRevInt  ((VL6180x_API_REV_MAJOR<<24)+(VL6180x_API_REV_MINOR<<16)+VL6180x_API_REV_SUB)
+ 
+/** Get API version as string for exe "2.1.12" "
+ */
+#define VL6180x_ApiRevStr  VL6180X_STR(VL6180x_API_REV_MAJOR) "." VL6180X_STR(VL6180x_API_REV_MINOR) "." VL6180X_STR(VL6180x_API_REV_SUB)
+ 
+/** @defgroup api_init Init functions
+ *  @brief    API init functions
+ *  @ingroup api_hl
+ *  @{  
+ */
+ 
+ 
+/****************** define for i2c configuration *******************************/
+ 
+#define TEMP_BUF_SIZE   32
+ 
+#define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
+/**
+ * @brief Clear All interrupt causes (als+range+error)
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+#define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
+/**
+ * @brief  Clear ALS interrupt
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+ #define VL6180x_AlsClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ALS)
+/**
+ * @brief Clear range interrupt
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+#define VL6180x_RangeClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_RANGING)
+ 
+/******************************************************************************/
+/******************************* file api.c ***********************************/
+ 
+#define VL6180x_9to7Conv(x) (x)
+ 
+/* TODO when set all "cached" value with "default init" are updated after init from register read back */
+#define REFRESH_CACHED_DATA_AFTER_INIT  1
+ 
+ 
+#define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
+ 
+ 
+/** default value ECE factor Molecular */
+#define DEF_ECE_FACTOR_M    85
+/** default value ECE factor Denominator */
+#define DEF_ECE_FACTOR_D    100
+/** default value ALS integration time */
+#define DEF_INT_PEFRIOD     100
+/** default value ALS gain */
+#define DEF_ALS_GAIN        1
+/** default value ALS scaler */
+#define DEF_ALS_SCALER      1
+/** default value for DMAX Enbale */
+#define DEF_DMAX_ENABLE     1
+/** default ambient tuning factor %x1000 */
+#define DEF_AMBIENT_TUNING  80
+ 
+#if VL6180x_SINGLE_DEVICE_DRIVER
+extern  struct VL6180xDevData_t SingleVL6180xDevData;
+#define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field)
+#define VL6180xDevDataSet(dev, field, data) SingleVL6180xDevData.field=(data)
+#endif
+ 
+#define LUXRES_FIX_PREC 8
+#define GAIN_FIX_PREC    8  /* ! if not sme as LUX_PREC then :( adjust GetLux */
+#define AN_GAIN_MULT    (1<<GAIN_FIX_PREC)
+ 
+ 
+//int32_t _GetAveTotalTime(VL6180xDev_t dev);
+//int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev);
+ 
+/**
+ * ScalerLookUP scaling factor-1 to register #RANGE_SCALER lookup
+ */
+static const uint16_t ScalerLookUP[]      ROMABLE_DATA ={ 253, 127,  84}; /* lookup table for scaling->scalar 1x2x 3x */
+/**
+ * scaling factor to Upper limit look up
+ */
+static const uint16_t UpperLimitLookUP[]  ROMABLE_DATA ={ 185, 370,  580}; /* lookup table for scaling->limit  1x2x3x */
+/**
+ * Als Code gain to fix point gain lookup
+ */
+static const uint16_t AlsGainLookUp[8]    ROMABLE_DATA = {
+        (uint16_t)(20.0f * AN_GAIN_MULT),
+        (uint16_t)(10.0f * AN_GAIN_MULT),
+        (uint16_t)(5.0f  * AN_GAIN_MULT),
+        (uint16_t)(2.5f  * AN_GAIN_MULT),
+        (uint16_t)(1.67f * AN_GAIN_MULT),
+        (uint16_t)(1.25f * AN_GAIN_MULT),
+        (uint16_t)(1.0f  * AN_GAIN_MULT),
+        (uint16_t)(40.0f * AN_GAIN_MULT),
+};
+ 
+ 
+#if VL6180x_RANGE_STATUS_ERRSTRING
+const char * ROMABLE_DATA VL6180x_RangeStatusErrString[]={
+       "No Error",
+       "VCSEL Continuity Test",
+       "VCSEL Watchdog Test",
+       "VCSEL Watchdog",
+       "PLL1 Lock",
+       "PLL2 Lock",
+       "Early Convergence Estimate",
+       "Max Convergence",
+       "No Target Ignore",
+       "Not used 9",
+       "Not used 10",
+       "Max Signal To Noise Ratio",
+       "Raw Ranging Algo Underflow",
+       "Raw Ranging Algo Overflow",
+       "Ranging Algo Underflow",
+       "Ranging Algo Overflow",
+ 
+       "Filtered by post processing"
+};
+ 
+const char * VL6180x_RangeGetStatusErrString(uint8_t RangeErrCode){
+    if( RangeErrCode  > sizeof(VL6180x_RangeStatusErrString)/sizeof(VL6180x_RangeStatusErrString[0]) )
+        return NULL;
+    return  VL6180x_RangeStatusErrString[RangeErrCode];
+}
+#endif
+ 
+#if VL6180x_UPSCALE_SUPPORT == 1
+    #define _GetUpscale(dev, ... )  1
+    #define _SetUpscale(...) -1
+    #define DEF_UPSCALE 1
+#elif VL6180x_UPSCALE_SUPPORT == 2
+    #define _GetUpscale(dev, ... )  2
+    #define _SetUpscale(...)
+    #define DEF_UPSCALE 2
+#elif  VL6180x_UPSCALE_SUPPORT == 3
+    #define _GetUpscale(dev, ... )  3
+    #define _SetUpscale(...)
+    #define DEF_UPSCALE 3
+#else
+    #define DEF_UPSCALE (-(VL6180x_UPSCALE_SUPPORT))
+    #define _GetUpscale(dev, ... ) VL6180xDevDataGet(dev, UpscaleFactor)
+    #define _SetUpscale(dev, Scaling ) VL6180xDevDataSet(dev, UpscaleFactor, Scaling)
+#endif
+ 
+ 
+#if VL6180x_SINGLE_DEVICE_DRIVER
+/**
+ * the unique driver data  When single device driver is active
+ */
+struct VL6180xDevData_t VL6180x_DEV_DATA_ATTR  SingleVL6180xDevData={
+        .EceFactorM        = DEF_ECE_FACTOR_M,
+        .EceFactorD        = DEF_ECE_FACTOR_D,
+#ifdef VL6180x_HAVE_UPSCALE_DATA
+        .UpscaleFactor     = DEF_UPSCALE,
+#endif
+#ifdef VL6180x_HAVE_ALS_DATA
+        .IntegrationPeriod = DEF_INT_PEFRIOD,
+        .AlsGainCode       = DEF_ALS_GAIN,
+        .AlsScaler         = DEF_ALS_SCALER,
+#endif
+#ifdef VL6180x_HAVE_DMAX_RANGING
+        .DMaxEnable =   DEF_DMAX_ENABLE,
+#endif
+};
+#endif /* VL6180x_SINGLE_DEVICE_DRIVER */
+ 
+#define Fix7_2_KCPs(x) ((((uint32_t)(x))*1000)>>7)
+ 
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+static int _filter_Init(VL6180xDev_t dev);
+    #define _IsWrapArroundActive(dev) VL6180xDevDataGet(dev,WrapAroundFilterActive)
+#else
+    #define _IsWrapArroundActive(dev) 0
+#endif
+ 
+ 
+#if VL6180x_HAVE_DMAX_RANGING
+   void _DMax_OneTimeInit(VL6180xDev_t dev);
+//   static int _DMax_InitData(VL6180xDev_t dev);
+   static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange);
+    #define _IsDMaxActive(dev) VL6180xDevDataGet(dev,DMaxEnable)
+#else
+    #define _DMax_InitData(...) 0 /* success */
+    #define _DMax_OneTimeInit(...) (void)0
+    #define _IsDMaxActive(...) 0
+#endif
+ 
+//static int VL6180x_RangeStaticInit(VL6180xDev_t dev);
+//static int  VL6180x_UpscaleStaticInit(VL6180xDev_t dev);
+ 
+int VL6180X::VL6180x_WaitDeviceBooted(VL6180xDev_t dev){
+    uint8_t FreshOutReset;
+    int status;
+    LOG_FUNCTION_START("");
+    do{
+        status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
+    }
+    while( FreshOutReset!=1 && status==0);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_InitData(VL6180xDev_t dev){
+    int status, dmax_status ;
+    int8_t offset;
+    uint8_t FreshOutReset;
+    uint32_t CalValue;
+    uint16_t u16;
+    uint32_t XTalkCompRate_KCps;
+ 
+    LOG_FUNCTION_START("");
+ 
+    VL6180xDevDataSet(dev, EceFactorM , DEF_ECE_FACTOR_M);
+    VL6180xDevDataSet(dev, EceFactorD , DEF_ECE_FACTOR_D);
+ 
+#ifdef VL6180x_HAVE_UPSCALE_DATA
+    VL6180xDevDataSet(dev, UpscaleFactor ,  DEF_UPSCALE);
+#endif
+ 
+#ifdef VL6180x_HAVE_ALS_DATA
+    VL6180xDevDataSet(dev, IntegrationPeriod, DEF_INT_PEFRIOD);
+    VL6180xDevDataSet(dev, AlsGainCode, DEF_ALS_GAIN);
+    VL6180xDevDataSet(dev, AlsScaler, DEF_ALS_SCALER);
+#endif
+ 
+#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
+    VL6180xDevDataSet(dev, WrapAroundFilterActive, (VL6180x_WRAP_AROUND_FILTER_SUPPORT >0));
+    VL6180xDevDataSet(dev, DMaxEnable, DEF_DMAX_ENABLE);
+#endif
+ 
+    _DMax_OneTimeInit(dev);
+    do{
+ 
+        /* backup offset initial value from nvm these must be done prior any over call that use offset */
+        status = VL6180X::VL6180x_RdByte(dev,SYSRANGE_PART_TO_PART_RANGE_OFFSET, (uint8_t*)&offset);
+        if( status ){
+            VL6180x_ErrLog("SYSRANGE_PART_TO_PART_RANGE_OFFSET rd fail");
+            break;
+        }
+        VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
+ 
+        status=VL6180x_RdDWord( dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &CalValue);
+        if( status ){
+            VL6180x_ErrLog("Part2PartAmbNVM rd fail");
+            break;
+        }
+        if( (CalValue&0xFFFF0000) == 0 ){
+            CalValue=0x00CE03F8;
+        }
+        VL6180xDevDataSet(dev, Part2PartAmbNVM, CalValue);
+ 
+        status = VL6180x_RdWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE ,&u16);
+        if( status){
+            VL6180x_ErrLog("SYSRANGE_CROSSTALK_COMPENSATION_RATE rd fail ");
+            break;
+        }
+        XTalkCompRate_KCps = Fix7_2_KCPs(u16);
+        VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
+ 
+        dmax_status = _DMax_InitData(dev);
+        if( dmax_status < 0 ){
+            VL6180x_ErrLog("DMax init failure");
+            break;
+        }
+ 
+        /* Read or wait for fresh out of reset  */
+        status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
+        if( status )  {
+            VL6180x_ErrLog("SYSTEM_FRESH_OUT_OF_RESET rd fail");
+            break;
+        }
+        if( FreshOutReset!= 1 || dmax_status )
+            status = CALIBRATION_WARNING;
+ 
+    }
+    while(0);
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int8_t VL6180X::VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev)
+{
+    int8_t offset;
+    LOG_FUNCTION_START("");
+    offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM);
+    LOG_FUNCTION_END( offset );
+    return offset;
+}
+ 
+void VL6180X::VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset)
+{
+    LOG_FUNCTION_START("%d", offset);
+    VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
+    LOG_FUNCTION_END(0);
+}
+ 
+int VL6180X::VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate)
+{
+    int status;
+    LOG_FUNCTION_START("%d", Rate);
+    status = VL6180x_WrWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE, Rate);
+    if( status ==0 ){
+        uint32_t XTalkCompRate_KCps;
+        XTalkCompRate_KCps = Fix7_2_KCPs(Rate);
+        VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
+        /* update dmax whenever xtalk rate changes */
+        status = _DMax_InitData(dev);
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddress){
+    int status;
+    LOG_FUNCTION_START("");
+ 
+    status = VL6180x_WrByte(dev, I2C_SLAVE_DEVICE_ADDRESS, NewAddress);
+    if( status ){
+        VL6180x_ErrLog("new i2c addr Wr fail");
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+uint16_t VL6180X::VL6180x_GetUpperLimit(VL6180xDev_t dev) {
+    uint16_t limit;
+    int scaling;
+ 
+    LOG_FUNCTION_START("");
+ 
+    scaling = _GetUpscale(dev);
+    /* FIXME we do assume here _GetUpscale is valid if  user call us prior to init we may overflow the LUT  mem area */
+    limit = UpperLimitLookUP[scaling - 1];
+ 
+    LOG_FUNCTION_END((int )limit);
+    return limit;
+}
+ 
+ 
+ 
+int VL6180X::VL6180x_StaticInit(VL6180xDev_t dev){
+    int status=0, init_status;
+    LOG_FUNCTION_START("");
+ 
+    /* TODO doc When using configurable scaling but using 1x as start condition
+     * load tunning upscale  or not ??? */
+    if( _GetUpscale(dev) == 1 && !(VL6180x_UPSCALE_SUPPORT<0))
+        init_status=VL6180x_RangeStaticInit(dev);
+    else
+        init_status=VL6180x_UpscaleStaticInit(dev);
+ 
+    if( init_status <0 ){
+        VL6180x_ErrLog("StaticInit fail");
+        goto error;
+    }
+    else if(init_status > 0){
+        VL6180x_ErrLog("StaticInit warning");
+    }
+ 
+#if REFRESH_CACHED_DATA_AFTER_INIT
+    /* update cached value after tuning applied */
+    do{
+#ifdef  VL6180x_HAVE_ALS_DATA
+        uint8_t data;
+        status=  VL6180x_RdByte(dev, FW_ALS_RESULT_SCALER, &data);
+        if( status ) break;
+        VL6180xDevDataSet(dev, AlsScaler, data);
+ 
+        status=  VL6180x_RdByte(dev, SYSALS_ANALOGUE_GAIN, &data);
+        if( status ) break;
+        VL6180x_AlsSetAnalogueGain(dev, data);
+#endif
+    }
+    while(0);
+#endif /* REFRESH_CACHED_DATA_AFTER_INIT */
+    if( status < 0 ){
+        VL6180x_ErrLog("StaticInit fail");
+    }
+    if( !status && init_status){
+        status = init_status;
+    }
+error:
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold)
+{
+    int status;
+    uint8_t value;
+ 
+    LOG_FUNCTION_START("%d", Hold);
+    if( Hold )
+        value = 1;
+    else
+        value = 0;
+    status = VL6180x_WrByte(dev, SYSTEM_GROUPED_PARAMETER_HOLD, value);
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+ 
+}
+ 
+int VL6180X::VL6180x_Prepare(VL6180xDev_t dev)
+{
+    int status;
+    LOG_FUNCTION_START("");
+ 
+    do{
+        status=VL6180x_StaticInit(dev);
+        if( status<0) break;
+ 
+        /* set range InterruptMode to new sample */
+        status=VL6180x_RangeConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_DISABLED );
+        if( status)
+            break;
+ 
+        /* set default threshold */
+        status=VL6180x_RangeSetRawThresholds(dev, 10, 200);
+        if( status ){
+            VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
+            break;
+        }
+#if VL6180x_ALS_SUPPORT
+        status =VL6180x_AlsSetIntegrationPeriod(dev, 100);
+        if( status ) break;
+        status = VL6180x_AlsSetInterMeasurementPeriod(dev,  200);
+        if( status ) break;
+        status = VL6180x_AlsSetAnalogueGain(dev,  0);
+        if( status ) break;
+        status = VL6180x_AlsSetThresholds(dev, 0, 0xFFFF);
+        if( status ) break;
+        /* set Als InterruptMode to new sample */
+        status=VL6180x_AlsConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if( status ) {
+            VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail");
+            break;
+        }
+#endif
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+        _filter_Init(dev);
+#endif
+        /* make sure to reset any left previous condition that can hangs first poll */
+        status=VL6180x_ClearAllInterrupt(dev);
+    }
+    while(0);
+    LOG_FUNCTION_END(status);
+ 
+    return status;
+}
+ 
+#if VL6180x_ALS_SUPPORT
+int VL6180X::VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux)
+{
+    int status;
+    uint16_t RawAls;
+    uint32_t luxValue = 0;
+    uint32_t IntPeriod;
+    uint32_t AlsAnGain;
+    uint32_t GainFix;
+    uint32_t AlsScaler;
+ 
+#if LUXRES_FIX_PREC !=  GAIN_FIX_PREC
+#error "LUXRES_FIX_PREC != GAIN_FIX_PREC  review these code to be correct"
+#endif
+    const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
+ 
+    LOG_FUNCTION_START("%p", pLux);
+ 
+    status = VL6180x_RdWord( dev, RESULT_ALS_VAL, &RawAls);
+    if( !status){
+        /* wer are yet here at no fix point */
+        IntPeriod=VL6180xDevDataGet(dev, IntegrationPeriod);
+        AlsScaler=VL6180xDevDataGet(dev, AlsScaler);
+        IntPeriod++; /* what stored is real time  ms -1 and it can be 0 for or 0 or 1ms */
+        luxValue = (uint32_t)RawAls * LuxResxIntIme; /* max # 16+8bits + 6bit (0.56*100)  */
+        luxValue /= IntPeriod;                         /* max # 16+8bits + 6bit 16+8+1 to 9 bit */
+        /* between  29 - 21 bit */
+        AlsAnGain = VL6180xDevDataGet(dev, AlsGainCode);
+        GainFix = AlsGainLookUp[AlsAnGain];
+        luxValue = luxValue / (AlsScaler * GainFix);
+        *pLux=luxValue;
+    }
+ 
+    LOG_FUNCTION_END_FMT(status, "%x",(int)*pLux);
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData)
+{
+    int status;
+    uint8_t ErrStatus;
+ 
+    LOG_FUNCTION_START("%p", pAlsData);
+ 
+    status = VL6180x_AlsGetLux(dev, &pAlsData->lux);
+    if( !status ){
+        status = VL6180x_RdByte(dev, RESULT_ALS_STATUS, & ErrStatus);
+        pAlsData->errorStatus = ErrStatus>>4;
+    }
+    LOG_FUNCTION_END_FMT(status,"%d %d", (int)pAlsData->lux,  (int)pAlsData->errorStatus);
+ 
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData) {
+    int status;
+    int ClrStatus;
+    uint8_t IntStatus;
+ 
+    LOG_FUNCTION_START("%p", pAlsData);
+#if VL6180X_SAFE_POLLING_ENTER
+    /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
+    status=VL6180x_AlsClearInterrupt(dev);
+    if(status){
+        VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+        goto over;
+    }
+#endif
+ 
+    status=VL6180x_AlsSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
+    if( status){
+        VL6180x_ErrLog("VL6180x_AlsSetSystemMode fail");
+        goto over;
+    }
+ 
+    /* poll for new sample ready */
+    while (1 ) {
+        status = VL6180x_AlsGetInterruptStatus(dev, &IntStatus);
+        if (status) {
+            break;
+        }
+        if (IntStatus == RES_INT_STAT_GPIO_NEW_SAMPLE_READY) {
+            break; /* break on new data (status is 0)  */
+        }
+        wait_ms(10);
+    };
+ 
+    if (!status) {
+        status = VL6180x_AlsGetMeasurement(dev, pAlsData);
+    }
+ 
+    ClrStatus = VL6180x_AlsClearInterrupt(dev);
+    if (ClrStatus) {
+        VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+        if (!status) {
+            status = ClrStatus; /* leave previous if already on error */
+        }
+    }
+over:
+    LOG_FUNCTION_END(status);
+ 
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
+    int status;
+    uint8_t IntStatus;
+    LOG_FUNCTION_START("%p", pIntStatus);
+ 
+    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
+    *pIntStatus= (IntStatus>>3)&0x07;
+ 
+    LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
+    int status;
+    int  n;
+    uint8_t u8;
+    LOG_FUNCTION_START("%d", (int)MaxLoop);
+    if( MaxLoop<1){
+          status=INVALID_PARAMS;
+     }
+    else{
+        for( n=0; n < MaxLoop ; n++){
+            status=VL6180x_RdByte(dev, RESULT_ALS_STATUS, &u8);
+            if( status)
+                break;
+            u8 = u8 & ALS_DEVICE_READY_MASK;
+            if( u8 )
+                break;
+ 
+        }
+        if( !status && !u8 ){
+            status = TIME_OUT;
+        }
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode)
+{
+    int status;
+    LOG_FUNCTION_START("%d", (int)mode);
+    /* FIXME if we are called back to back real fast we are not checking
+     * if previous mode "set" got absorbed => bit 0 must be 0 so that wr 1 work */
+    if( mode <= 3){
+        status=VL6180x_WrByte(dev, SYSALS_START, mode);
+    }
+    else{
+        status = INVALID_PARAMS;
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
+{
+    int status;
+ 
+    if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
+        status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_ALS_MASK), (ConfigGpioInt<<3));
+    }
+    else{
+        VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
+        status = INVALID_PARAMS;
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+ 
+int VL6180X::VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high) { 
+    int status;
+
+    LOG_FUNCTION_START("%d %d", (int )low, (int)high);
+
+    status = VL6180x_WrWord(dev, SYSALS_THRESH_LOW, low);
+    if(!status ){
+        status = VL6180x_WrWord(dev, SYSALS_THRESH_HIGH, high);
+    }
+
+    LOG_FUNCTION_END(status) ;
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain) {
+    int status;
+    uint8_t GainTotal;
+ 
+    LOG_FUNCTION_START("%d", (int )gain);
+    gain&=~0x40;
+    if (gain > 7) {
+        gain = 7;
+    }
+    GainTotal = gain|0x40;
+ 
+    status = VL6180x_WrByte(dev, SYSALS_ANALOGUE_GAIN, GainTotal);
+    if( !status){
+        VL6180xDevDataSet(dev, AlsGainCode, gain);
+    }
+ 
+    LOG_FUNCTION_END_FMT(status, "%d %d", (int ) gain, (int )GainTotal);
+    return status;
+}
+ 
+int VL6180X::VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev,  uint16_t intermeasurement_period_ms)
+{
+    int status;
+ 
+    LOG_FUNCTION_START("%d",(int)intermeasurement_period_ms);
+        /* clipping: range is 0-2550ms */
+        if (intermeasurement_period_ms >= 255 *10)
+                intermeasurement_period_ms = 255 *10;
+    status=VL6180x_WrByte(dev, SYSALS_INTERMEASUREMENT_PERIOD, (uint8_t)(intermeasurement_period_ms/10));
+ 
+    LOG_FUNCTION_END_FMT(status, "%d", (int) intermeasurement_period_ms);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms)
+{
+    int status;
+    uint16_t SetIntegrationPeriod;
+ 
+    LOG_FUNCTION_START("%d", (int)period_ms);
+ 
+    if( period_ms>=1 )
+        SetIntegrationPeriod = period_ms - 1;
+    else
+        SetIntegrationPeriod = period_ms;
+ 
+    if (SetIntegrationPeriod > 464) {
+        SetIntegrationPeriod = 464;
+    }
+    else if (SetIntegrationPeriod == 255)   {
+        SetIntegrationPeriod++; /* can't write 255 since this causes the device to lock out.*/
+    }
+ 
+    status =VL6180x_WrWord(dev, SYSALS_INTEGRATION_PERIOD, SetIntegrationPeriod);
+    if( !status ){
+        VL6180xDevDataSet(dev, IntegrationPeriod, SetIntegrationPeriod) ;
+    }
+    LOG_FUNCTION_END_FMT(status, "%d", (int)SetIntegrationPeriod);
+    return status;
+}
+ 
+#endif /* HAVE_ALS_SUPPORT */
+ 
+ 
+int VL6180X::VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
+{
+    int status;
+    int ClrStatus;
+    IntrStatus_t IntStatus;
+ 
+    LOG_FUNCTION_START("");
+    /* start single range measurement */
+ 
+ 
+#if VL6180X_SAFE_POLLING_ENTER
+    /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
+    status=VL6180x_RangeClearInterrupt(dev);
+    if(status){
+        VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+        goto done;
+    }
+#endif
+    /* //![single_shot_snipet] */
+    status=VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
+    if( status ){
+        VL6180x_ErrLog("VL6180x_RangeSetSystemMode fail");
+        goto done;
+    }
+ 
+    /* poll for new sample ready */
+    while(1 ){
+        status=VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
+        if( status ){
+            break;
+        }
+        if( IntStatus.status.Error !=0 ){
+          VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
+          status = RANGE_ERROR;
+          break;
+        }
+        else
+        if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
+            break;
+        }
+        wait_ms(10);
+    }
+ /* //![single_shot_snipet] */
+ 
+    if ( !status ){
+        status = VL6180x_RangeGetMeasurement(dev, pRangeData);
+    }
+ 
+    /*  clear range interrupt source */
+    ClrStatus = VL6180x_RangeClearInterrupt(dev);
+    if( ClrStatus ){
+        VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+        /*  leave initial status if already in error  */
+        if( !status ){
+            status=ClrStatus;
+        }
+    }
+done:
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+ 
+int VL6180X::VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
+{
+    int status;
+    uint16_t RawRate;
+    uint8_t RawStatus;
+ 
+    LOG_FUNCTION_START("");
+ 
+    status = VL6180x_RangeGetResult(dev, &pRangeData->range_mm);
+    if( !status ){
+        status = VL6180x_RdWord(dev,RESULT_RANGE_SIGNAL_RATE, &RawRate );
+        if( !status ){
+            pRangeData->signalRate_mcps = VL6180x_9to7Conv(RawRate);
+            status = VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &RawStatus);
+            if( !status ){
+                pRangeData->errorStatus = RawStatus >>4;
+            }
+            else{
+                VL6180x_ErrLog("Rd RESULT_RANGE_STATUS fail");
+            }
+    #if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
+            status = _GetRateResult(dev, pRangeData);
+            if( status )
+                goto error;
+    #endif
+    #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+            /* if enabled run filter */
+            if( _IsWrapArroundActive(dev) ){
+                status=_filter_GetResult(dev, pRangeData);
+                if( !status){
+                    /* patch the range status and measure if it is filtered */
+                    if( pRangeData->range_mm != pRangeData->FilteredData.range_mm) {
+                        pRangeData->errorStatus=RangingFiltered;
+                        pRangeData->range_mm = pRangeData->FilteredData.range_mm;
+                    }
+                }
+            }
+    #endif
+ 
+#if VL6180x_HAVE_DMAX_RANGING
+            if(_IsDMaxActive(dev) ){
+                _DMax_Compute(dev, pRangeData);
+            }
+#endif
+        }
+        else{
+            VL6180x_ErrLog("Rd RESULT_RANGE_SIGNAL_RATE fail");
+        }
+    }
+    else{
+        VL6180x_ErrLog("VL6180x_GetRangeResult fail");
+    }
+error:
+    LOG_FUNCTION_END_FMT(status, "%d %d %d", (int)pRangeData->range_mm, (int)pRangeData->signalRate_mcps,  (int)pRangeData->errorStatus) ;
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
+{
+    int status;
+    IntrStatus_t IntStatus;
+ 
+    LOG_FUNCTION_START();
+ 
+    status = VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
+    if( status ==0 ){
+        if( IntStatus.status.Error !=0 ){
+            VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
+            status = RANGE_ERROR;
+        }
+        else
+        if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
+           status = VL6180x_RangeGetMeasurement(dev,pRangeData );
+           if( status == 0){
+               /*  clear range interrupt source */
+               status = VL6180x_RangeClearInterrupt(dev);
+               if( status ){
+                   VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+               }
+           }
+        }
+        else{
+            status = NOT_READY;
+        }
+    }
+    else{
+        VL6180x_ErrLog("fail to get interrupt status");
+    }
+    LOG_FUNCTION_END(status) ;
+    return status;
+}
+ 
+int VL6180X::VL6180x_FilterSetState(VL6180xDev_t dev, int state){
+    int status;
+    LOG_FUNCTION_START("%d", state);
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+    VL6180xDevDataSet(dev,WrapAroundFilterActive, state);
+    status = 0;
+#else
+    status =  NOT_SUPPORTED;
+#endif
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_FilterGetState(VL6180xDev_t dev){
+    int status;
+    LOG_FUNCTION_START("");
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+    status = VL6180xDevDataGet(dev,WrapAroundFilterActive);
+#else
+    status = 0;
+#endif
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm) {
+    int status;
+    uint8_t RawRange;
+    int32_t Upscale;
+ 
+    LOG_FUNCTION_START("%p",pRange_mm);
+ 
+    status = VL6180x_RdByte(dev, RESULT_RANGE_VAL, &RawRange);
+    if( !status ){
+         Upscale = _GetUpscale(dev);
+        *pRange_mm= Upscale*(int32_t)RawRange;
+    }
+    LOG_FUNCTION_END_FMT(status, "%d", (int)*pRange_mm);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high)
+{
+    int status;
+    LOG_FUNCTION_START("%d %d", (int) low, (int)high);
+    /* TODO we can optimize here grouping high/low in a word but that's cpu endianness dependent */
+    status=VL6180x_WrByte(dev, SYSRANGE_THRESH_HIGH,high);
+    if( !status){
+        status=VL6180x_WrByte(dev, SYSRANGE_THRESH_LOW, low);
+    }
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int UseSafeParamHold)
+{
+    int status;
+    int scale;
+    LOG_FUNCTION_START("%d %d", (int) low, (int)high);
+    scale=_GetUpscale(dev,UpscaleFactor);
+    if( low>scale*255 || high >scale*255){
+        status = INVALID_PARAMS;
+    }
+    else{
+        do{
+            if( UseSafeParamHold ){
+                status=VL6180x_SetGroupParamHold(dev, 1);
+                if( status )
+                    break;
+            }
+            status=VL6180x_RangeSetRawThresholds(dev, (uint8_t)(low/scale), (uint8_t)(high/scale));
+            if( status ){
+                VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
+            }
+            if( UseSafeParamHold ){
+                int HoldStatus;
+                /* tryt to unset param hold vene if previous fail */
+                HoldStatus=VL6180x_SetGroupParamHold(dev, 0);
+                if( !status)
+                    status=HoldStatus;
+            }
+        }
+        while(0);
+    }
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high)
+{
+    int status;
+    uint8_t RawLow, RawHigh;
+    int scale;
+ 
+    LOG_FUNCTION_START("%p %p", low , high);
+ 
+    scale=_GetUpscale(dev,UpscaleFactor);
+    do{
+        if( high != NULL ){
+            status=VL6180x_RdByte(dev, SYSRANGE_THRESH_HIGH,&RawHigh);
+            if( status ){
+                VL6180x_ErrLog("rd SYSRANGE_THRESH_HIGH fail");
+                break;
+            }
+            *high=(uint16_t)RawHigh*scale;
+        }
+        if( low != NULL ) {
+            status=VL6180x_RdByte(dev, SYSRANGE_THRESH_LOW, &RawLow);
+            if( status ){
+                VL6180x_ErrLog("rd SYSRANGE_THRESH_LOW fail");
+                break;
+            }
+            *low=(uint16_t)RawLow*scale;
+        }
+    }
+    while(0);
+    LOG_FUNCTION_END_FMT(status, "%d %d",(int)*low ,(int)*high);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
+    int status;
+    uint8_t IntStatus;
+    LOG_FUNCTION_START("%p", pIntStatus);
+    /* FIXME we are grouping "error" with over status the user must check implicitly for it
+     * not just new sample or over status , that will nevr show up in case of error*/
+    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
+    *pIntStatus= IntStatus&0xC7;
+ 
+    LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *IntStatus)
+{
+    int status;
+    LOG_FUNCTION_START("%p" , IntStatus);
+    status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, IntStatus);
+    LOG_FUNCTION_END_FMT(status, "%d", (int)*IntStatus);
+    return status;
+}
+ 
+int VL6180X::VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear )
+{
+    int status;
+    LOG_FUNCTION_START("%d" ,(int)IntClear);
+    if( IntClear <= 7 ){
+        status=VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CLEAR, IntClear);
+    }
+    else{
+        status = INVALID_PARAMS;
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeStaticInit(VL6180xDev_t dev)
+{
+    int status;
+    LOG_FUNCTION_START("");
+ 
+    /* REGISTER_TUNING_SR03_270514_CustomerView.txt */
+    VL6180x_WrByte( dev, 0x0207, 0x01);
+    VL6180x_WrByte( dev, 0x0208, 0x01);
+    VL6180x_WrByte( dev, 0x0096, 0x00);
+    VL6180x_WrByte( dev, 0x0097, 0xfd);
+    VL6180x_WrByte( dev, 0x00e3, 0x00);
+    VL6180x_WrByte( dev, 0x00e4, 0x04);
+    VL6180x_WrByte( dev, 0x00e5, 0x02);
+    VL6180x_WrByte( dev, 0x00e6, 0x01);
+    VL6180x_WrByte( dev, 0x00e7, 0x03);
+    VL6180x_WrByte( dev, 0x00f5, 0x02);
+    VL6180x_WrByte( dev, 0x00d9, 0x05);
+    VL6180x_WrByte( dev, 0x00db, 0xce);
+    VL6180x_WrByte( dev, 0x00dc, 0x03);
+    VL6180x_WrByte( dev, 0x00dd, 0xf8);
+    VL6180x_WrByte( dev, 0x009f, 0x00);
+    VL6180x_WrByte( dev, 0x00a3, 0x3c);
+    VL6180x_WrByte( dev, 0x00b7, 0x00);
+    VL6180x_WrByte( dev, 0x00bb, 0x3c);
+    VL6180x_WrByte( dev, 0x00b2, 0x09);
+    VL6180x_WrByte( dev, 0x00ca, 0x09);
+    VL6180x_WrByte( dev, 0x0198, 0x01);
+    VL6180x_WrByte( dev, 0x01b0, 0x17);
+    VL6180x_WrByte( dev, 0x01ad, 0x00);
+    VL6180x_WrByte( dev, 0x00ff, 0x05);
+    VL6180x_WrByte( dev, 0x0100, 0x05);
+    VL6180x_WrByte( dev, 0x0199, 0x05);
+    VL6180x_WrByte( dev, 0x01a6, 0x1b);
+    VL6180x_WrByte( dev, 0x01ac, 0x3e);
+    VL6180x_WrByte( dev, 0x01a7, 0x1f);
+    VL6180x_WrByte( dev, 0x0030, 0x00);
+ 
+    /* Recommended : Public registers - See data sheet for more detail */
+    VL6180x_WrByte( dev, SYSTEM_MODE_GPIO1, 0x10); /* Enables polling for New Sample ready when measurement completes */
+    VL6180x_WrByte( dev, READOUT_AVERAGING_SAMPLE_PERIOD, 0x30); /* Set the averaging sample period (compromise between lower noise and increased execution time) */
+    VL6180x_WrByte( dev, SYSALS_ANALOGUE_GAIN, 0x46); /* Sets the light and dark gain (upper nibble). Dark gain should not be changed.*/
+    VL6180x_WrByte( dev, SYSRANGE_VHV_REPEAT_RATE, 0xFF); /* sets the # of range measurements after which auto calibration of system is performed */
+    VL6180x_WrByte( dev, SYSALS_INTEGRATION_PERIOD, 0x63); /* Set ALS integration time to 100ms */
+    VL6180x_WrByte( dev, SYSRANGE_VHV_RECALIBRATE, 0x01); /* perform a single temperature calibration of the ranging sensor */
+ 
+    /* Optional: Public registers - See data sheet for more detail */
+    VL6180x_WrByte( dev, SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09); /* Set default ranging inter-measurement period to 100ms */
+    VL6180x_WrByte( dev, SYSALS_INTERMEASUREMENT_PERIOD, 0x31); /* Set default ALS inter-measurement period to 500ms */
+    VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24); /* Configures interrupt on New sample ready */
+ 
+ 
+    status=VL6180x_RangeSetMaxConvergenceTime(dev, 50); /*  Calculate ece value on initialization (use max conv) */
+    LOG_FUNCTION_END(status);
+ 
+    return status;
+}
+ 
+#if VL6180x_UPSCALE_SUPPORT != 1
+ 
+int VL6180X::_UpscaleInitPatch0(VL6180xDev_t dev){
+    int status;
+    uint32_t CalValue=0;
+    CalValue= VL6180xDevDataGet(dev, Part2PartAmbNVM);
+    status=VL6180x_WrDWord( dev, 0xDA, CalValue);
+    return status;
+}
+ 
+/* only include up-scaling register setting when up-scale support is configured in */
+int VL6180X::VL6180x_UpscaleRegInit(VL6180xDev_t dev)
+{
+    /*  apply REGISTER_TUNING_ER02_100614_CustomerView.txt */
+    VL6180x_WrByte( dev, 0x0207, 0x01);
+    VL6180x_WrByte( dev, 0x0208, 0x01);
+    VL6180x_WrByte( dev, 0x0096, 0x00);
+    VL6180x_WrByte( dev, 0x0097, 0x54);
+    VL6180x_WrByte( dev, 0x00e3, 0x00);
+    VL6180x_WrByte( dev, 0x00e4, 0x04);
+    VL6180x_WrByte( dev, 0x00e5, 0x02);
+    VL6180x_WrByte( dev, 0x00e6, 0x01);
+    VL6180x_WrByte( dev, 0x00e7, 0x03);
+    VL6180x_WrByte( dev, 0x00f5, 0x02);
+    VL6180x_WrByte( dev, 0x00d9, 0x05);
+ 
+    _UpscaleInitPatch0(dev);
+ 
+    VL6180x_WrByte( dev, 0x009f, 0x00);
+    VL6180x_WrByte( dev, 0x00a3, 0x28);
+    VL6180x_WrByte( dev, 0x00b7, 0x00);
+    VL6180x_WrByte( dev, 0x00bb, 0x28);
+    VL6180x_WrByte( dev, 0x00b2, 0x09);
+    VL6180x_WrByte( dev, 0x00ca, 0x09);
+    VL6180x_WrByte( dev, 0x0198, 0x01);
+    VL6180x_WrByte( dev, 0x01b0, 0x17);
+    VL6180x_WrByte( dev, 0x01ad, 0x00);
+    VL6180x_WrByte( dev, 0x00ff, 0x05);
+    VL6180x_WrByte( dev, 0x0100, 0x05);
+    VL6180x_WrByte( dev, 0x0199, 0x05);
+    VL6180x_WrByte( dev, 0x01a6, 0x1b);
+    VL6180x_WrByte( dev, 0x01ac, 0x3e);
+    VL6180x_WrByte( dev, 0x01a7, 0x1f);
+    VL6180x_WrByte( dev, 0x0030, 0x00);
+    VL6180x_WrByte( dev, SYSTEM_MODE_GPIO1, 0x10);
+    VL6180x_WrByte( dev, READOUT_AVERAGING_SAMPLE_PERIOD, 0x30);
+    VL6180x_WrByte( dev, SYSALS_ANALOGUE_GAIN, 0x46);
+    VL6180x_WrByte( dev, SYSRANGE_VHV_REPEAT_RATE, 0xFF);
+    VL6180x_WrByte( dev, SYSALS_INTEGRATION_PERIOD, 0x63);
+    VL6180x_WrByte( dev, SYSRANGE_VHV_RECALIBRATE, 0x01);
+    VL6180x_WrByte( dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, 0xff);
+    VL6180x_WrByte( dev, SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09);
+    VL6180x_WrByte( dev, SYSALS_INTERMEASUREMENT_PERIOD, 0x31);
+    VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24);
+#if VL6180x_EXTENDED_RANGE
+    VL6180x_RangeSetMaxConvergenceTime(dev, 63);
+#else
+    VL6180x_RangeSetMaxConvergenceTime(dev, 50);
+#endif
+    return 0;
+}
+#else
+#define VL6180x_UpscaleRegInit(...) -1
+#endif
+ 
+int VL6180X::VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling)
+{
+    int status;
+    uint16_t Scaler;
+    int8_t  Offset;
+ 
+    LOG_FUNCTION_START("%d",(int) scaling);
+ 
+#ifdef VL6180x_HAVE_UPSCALE_DATA
+    #define min_scaling 1
+    #define max_scaling sizeof(ScalerLookUP)/sizeof(ScalerLookUP[0])
+#else
+     /* we are in fixed config so only allow configured factor */
+    #define min_scaling VL6180x_UPSCALE_SUPPORT
+    #define max_scaling VL6180x_UPSCALE_SUPPORT
+#endif
+ 
+    if( scaling>=min_scaling  && scaling<= max_scaling ){
+ 
+        Scaler = ScalerLookUP[scaling-1];
+        status = VL6180x_WrWord(dev, RANGE_SCALER, Scaler);
+        _SetUpscale(dev, scaling );
+ 
+        /* Apply scaling on  part-2-part offset */
+        Offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM)/scaling;
+        status = VL6180x_WrByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, Offset);
+#if ! VL6180x_EXTENDED_RANGE
+        if( status ==0 ){
+            status = VL6180x_RangeSetEceState(dev, scaling == 1); /* enable ece only at 1x scaling */
+        }
+        if( status == 0 && !VL6180x_EXTENDED_RANGE && scaling!=1 ){
+            status = NOT_GUARANTEED ;
+        }
+#endif
+    }
+    else{
+        status = INVALID_PARAMS;
+    }
+#undef min_scaling
+#undef max_scaling
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_UpscaleGetScaling(VL6180xDev_t dev)
+{
+    int status;
+    LOG_FUNCTION_START("");
+    status=_GetUpscale(dev );
+    LOG_FUNCTION_END(status);
+ 
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_UpscaleStaticInit(VL6180xDev_t dev)
+{
+    /* todo make these a fail macro in case only 1x is suppoted */
+    int status;
+ 
+    LOG_FUNCTION_START("");
+    do{
+        status=VL6180x_UpscaleRegInit(dev);
+        if( status){
+            VL6180x_ErrLog("regInit fail");
+            break;
+        }
+#if VL6180x_EXTENDED_RANGE
+        status = VL6180x_RangeSetEceState(dev, 0);
+        if( status){
+            VL6180x_ErrLog("VL6180x_RangeSetEceState fail");
+            break;
+        }
+#endif
+    } while(0);
+    if( !status){
+        /*  must write the scaler at least once to the device to ensure the scaler is in a known state. */
+        status=VL6180x_UpscaleSetScaling(dev, _GetUpscale(dev));
+        VL6180x_WrByte( dev, SYSTEM_FRESH_OUT_OF_RESET, 0x00); /* change fresh out of set status to 0 */
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high)
+{
+    int status;
+    LOG_FUNCTION_START("%d %d",(int) pin, (int)active_high);
+ 
+    if( pin ==0  || pin ==1  ){
+       uint16_t RegIndex;
+       uint8_t  DataSet;
+       if( pin==0 )
+           RegIndex= SYSTEM_MODE_GPIO0;
+       else
+           RegIndex= SYSTEM_MODE_GPIO1;
+ 
+       if (active_high )
+           DataSet = GPIOx_POLARITY_SELECT_MASK;
+       else
+           DataSet = 0;
+ 
+       status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_POLARITY_SELECT_MASK, DataSet);
+    }
+    else{
+        VL6180x_ErrLog("Invalid pin param %d", (int)pin);
+        status = INVALID_PARAMS;
+    }
+ 
+    LOG_FUNCTION_END(status);
+ 
+    return status;
+}
+ 
+int VL6180X::VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality)
+{
+    int status;
+ 
+    LOG_FUNCTION_START("%d %d",(int) pin, (int)functionality);
+ 
+    if( ((pin ==0)  || (pin ==1))  && IsValidGPIOFunction(functionality)  ){
+       uint16_t RegIndex;
+ 
+       if( pin==0 )
+           RegIndex= SYSTEM_MODE_GPIO0;
+       else
+           RegIndex= SYSTEM_MODE_GPIO1;
+ 
+       status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_FUNCTIONALITY_SELECT_MASK,  functionality<<GPIOx_FUNCTIONALITY_SELECT_SHIFT);
+       if( status){
+           VL6180x_ErrLog("Update SYSTEM_MODE_GPIO%d fail", (int)pin);
+       }
+    }
+    else{
+        VL6180x_ErrLog("Invalid pin %d  or function %d", (int)pin, (int) functionality);
+        status = INVALID_PARAMS;
+    }
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin,  uint8_t IntFunction, int  ActiveHigh)
+{
+    int status;
+ 
+    LOG_FUNCTION_START("%d %d",(int) pin, (int)IntFunction);
+ 
+    if( ((pin ==0)  || (pin ==1))  && IsValidGPIOFunction(IntFunction)  ){
+       uint16_t RegIndex;
+       uint8_t value=0;
+ 
+       if( pin==0 )
+           RegIndex= SYSTEM_MODE_GPIO0;
+       else
+           RegIndex= SYSTEM_MODE_GPIO1;
+ 
+       if( ActiveHigh  )
+           value|=GPIOx_POLARITY_SELECT_MASK;
+ 
+       value |=  IntFunction<<GPIOx_FUNCTIONALITY_SELECT_SHIFT;
+       status = VL6180x_WrByte(dev, RegIndex, value);
+       if( status ){
+           VL6180x_ErrLog("SYSTEM_MODE_GPIO%d wr fail", (int)pin-SYSTEM_MODE_GPIO0);
+       }
+    }
+    else{
+        VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, (int) IntFunction);
+        status = INVALID_PARAMS;
+    }
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin) {
+    int status;
+ 
+    LOG_FUNCTION_START("%d",(int)pin);
+ 
+    status=VL6180x_SetGPIOxFunctionality(dev, pin, GPIOx_SELECT_OFF);
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh)
+{
+    int status;
+    LOG_FUNCTION_START("%d %d",(int)IntFunction, (int)ActiveHigh  );
+    status=VL6180x_SetupGPIOx(dev, 1 , IntFunction, ActiveHigh);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
+{
+    int status;
+ 
+    if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
+        status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_RANGE_MASK), ConfigGpioInt);
+    }
+    else{
+        VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
+        status = INVALID_PARAMS;
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t  FactorM, uint16_t FactorD){
+    int status;
+    uint8_t u8;
+ 
+    LOG_FUNCTION_START("%d %d", (int)FactorM, (int)FactorD );
+    do{
+        /* D cannot be 0 M must be <=D and >= 0 */
+        if( FactorM <= FactorD  && FactorD> 0){
+            VL6180xDevDataSet(dev, EceFactorM, FactorM);
+            VL6180xDevDataSet(dev, EceFactorD, FactorD);
+            /* read and re-apply max conv time to get new ece factor set */
+            status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
+            if( status){
+               VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
+               break;
+            }
+            status = VL6180x_RangeSetMaxConvergenceTime(dev, u8);
+            if( status <0 ){
+                VL6180x_ErrLog("fail to apply time after ece m/d change");
+                break;
+            }
+        }
+        else{
+            VL6180x_ErrLog("invalid factor %d/%d", (int)FactorM, (int)FactorD );
+            status = INVALID_PARAMS;
+        }
+    }
+    while(0);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable ){
+    int status;
+    uint8_t or_mask;
+ 
+    LOG_FUNCTION_START("%d", (int)enable);
+    if( enable )
+        or_mask = RANGE_CHECK_ECE_ENABLE_MASK;
+    else
+        or_mask = 0;
+ 
+    status =VL6180x_UpdateByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, ~RANGE_CHECK_ECE_ENABLE_MASK, or_mask);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t  MaxConTime_msec)
+{
+    int status = 0;
+    LOG_FUNCTION_START("%d",(int)MaxConTime_msec);
+    do{
+        status=VL6180x_WrByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, MaxConTime_msec);
+        if( status ){
+            break;
+        }
+        status=VL6180x_RangeSetEarlyConvergenceEestimateThreshold(dev);
+        if( status){
+            break;
+        }
+        status = _DMax_InitData(dev);
+    }
+    while(0);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t  InterMeasTime_msec){
+    uint8_t SetTime;
+    int status;
+ 
+    LOG_FUNCTION_START("%d",(int)InterMeasTime_msec);
+    do {
+        if( InterMeasTime_msec > 2550 ){
+            status = INVALID_PARAMS;
+            break;
+        }
+        /* doc in not 100% clear and confusing about the limit practically all value are OK but 0
+         * that can hang device in continuous mode */
+        if( InterMeasTime_msec < 10 ) {
+            InterMeasTime_msec=10;
+        }
+        SetTime=(uint8_t)(InterMeasTime_msec/10);
+        status=VL6180x_WrByte(dev, SYSRANGE_INTERMEASUREMENT_PERIOD, SetTime);
+        if( status ){
+            VL6180x_ErrLog("SYSRANGE_INTERMEASUREMENT_PERIOD wr fail");
+        }
+        else
+        if( SetTime != InterMeasTime_msec /10 ) {
+            status = MIN_CLIPED;  /* on success change status to clip if it did */
+        }
+    }while(0);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int * Ready){
+    int status;
+    uint8_t u8;
+    LOG_FUNCTION_START("%p", (int)Ready);
+    status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
+    if( !status)
+        *Ready = u8&RANGE_DEVICE_READY_MASK;
+    LOG_FUNCTION_END_FMT(status,"%d", *Ready);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
+    int status; /* if user specify an invalid <=0 loop count we'll return error */
+    int  n;
+    uint8_t u8;
+    LOG_FUNCTION_START("%d", (int)MaxLoop);
+    if( MaxLoop<1){
+        status=INVALID_PARAMS;
+    }
+    else{
+        for( n=0; n < MaxLoop ; n++){
+            status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
+            if( status)
+                break;
+            u8 = u8 & RANGE_DEVICE_READY_MASK;
+            if( u8 )
+                break;
+ 
+        }
+        if( !status && !u8 ){
+            status = TIME_OUT;
+        }
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t  mode)
+{
+    int status;
+    LOG_FUNCTION_START("%d", (int)mode);
+    /* FIXME we are not checking device is ready via @a VL6180x_RangeWaitDeviceReady
+     * so if called back to back real fast we are not checking
+     * if previous mode "set" got absorbed => bit 0 must be 0 so that it work
+     */
+    if( mode <= 3){
+        status=VL6180x_WrByte(dev, SYSRANGE_START, mode);
+        if( status ){
+            VL6180x_ErrLog("SYSRANGE_START wr fail");
+        }
+    }
+    else{
+        status = INVALID_PARAMS;
+    }
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeStartContinuousMode(VL6180xDev_t dev)
+{
+    int status;
+    LOG_FUNCTION_START("");
+    status= VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_CONTINUOUS);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_RangeStartSingleShot(VL6180xDev_t dev) {
+    int status;
+    LOG_FUNCTION_START("");
+    status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+int VL6180X::VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev)
+{
+    int status;
+ 
+    const uint32_t cMicroSecPerMilliSec  = 1000;
+    const uint32_t cEceSampleTime_us     = 500;
+    uint32_t ece_factor_m          = VL6180xDevDataGet(dev, EceFactorM);
+    uint32_t ece_factor_d          = VL6180xDevDataGet(dev, EceFactorD);
+    uint32_t convergTime_us;
+    uint32_t fineThresh;
+    uint32_t eceThresh;
+    uint8_t  u8;
+    uint32_t maxConv_ms;
+    int32_t AveTime;
+ 
+    LOG_FUNCTION_START("");
+ 
+    do{
+        status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
+        if( status ){
+            VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail");
+            break;
+        }
+        maxConv_ms = u8;
+        AveTime = _GetAveTotalTime(dev);
+        if( AveTime <0 ){
+            status=-1;
+            break;
+        }
+ 
+        convergTime_us = maxConv_ms * cMicroSecPerMilliSec - AveTime;
+        status = VL6180x_RdDWord(dev, 0xB8, &fineThresh);
+        if( status ) {
+            VL6180x_ErrLog("reg 0xB8 rd fail");
+            break;
+        }
+        fineThresh*=256;
+        eceThresh      = ece_factor_m * cEceSampleTime_us * fineThresh/(convergTime_us * ece_factor_d);
+ 
+        status=VL6180x_WrWord(dev, SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, (uint16_t)eceThresh);
+    }
+    while(0);
+ 
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+/*
+ * Return >0 = time
+ *       <0 1 if fail to get read data from device to compute time
+ */
+int32_t VL6180X::_GetAveTotalTime(VL6180xDev_t dev) {
+    uint32_t cFwOverhead_us = 24;
+    uint32_t cVcpSetupTime_us = 70;
+    uint32_t cPLL2_StartupDelay_us = 200;
+    uint8_t cMeasMask = 0x07;
+    uint32_t Samples;
+    uint32_t SamplePeriod;
+    uint32_t SingleTime_us;
+    int32_t TotalAveTime_us;
+    uint8_t u8;
+    int status;
+ 
+    LOG_FUNCTION_START("");
+ 
+    status = VL6180x_RdByte(dev, 0x109, &u8);
+    if (status) {
+        VL6180x_ErrLog("rd 0x109 fail");
+        return -1;
+    }
+    Samples = u8 & cMeasMask;
+    status = VL6180x_RdByte(dev, READOUT_AVERAGING_SAMPLE_PERIOD, &u8);
+    if (status) {
+        VL6180x_ErrLog("i2c READOUT_AVERAGING_SAMPLE_PERIOD fail");
+        return -1;
+    }
+    SamplePeriod = u8;
+    SingleTime_us = cFwOverhead_us + cVcpSetupTime_us + (SamplePeriod * 10);
+    TotalAveTime_us = (Samples + 1) * SingleTime_us + cPLL2_StartupDelay_us;
+ 
+    LOG_FUNCTION_END(TotalAveTime_us);
+    return TotalAveTime_us;
+}
+ 
+#if VL6180x_HAVE_DMAX_RANGING
+#define _GetDMaxDataRetSignalAt400mm(dev) VL6180xDevDataGet(dev, DMaxData.retSignalAt400mm)
+#else
+#define _GetDMaxDataRetSignalAt400mm(dev) 375 // Use a default high value
+#endif
+ 
+ 
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+ 
+#define FILTER_STDDEV_SAMPLES           6
+#define MIN_FILTER_STDDEV_SAMPLES       3
+#define MIN_FILTER_VALID_STDDEV_SAMPLES 3
+#define FILTER_INVALID_DISTANCE     65535
+ 
+#define _FilterData(field) VL6180xDevDataGet(dev, FilterData.field)
+/*
+ * One time init
+ */
+static int _filter_Init( VL6180xDev_t dev) {
+    int i;
+    _FilterData(MeasurementIndex) = 0;
+ 
+    _FilterData(Default_ZeroVal) = 0;
+    _FilterData(Default_VAVGVal) = 0;
+    _FilterData(NoDelay_ZeroVal) = 0;
+    _FilterData(NoDelay_VAVGVal) = 0;
+    _FilterData(Previous_VAVGDiff) = 0;
+ 
+    _FilterData(StdFilteredReads) = 0;
+ 
+    for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
+        _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
+        _FilterData(LastReturnRates)[i] = 0;
+    }
+    return 0;
+}
+ 
+ 
+static uint32_t _filter_StdDevDamper(uint32_t AmbientRate, uint32_t SignalRate, const uint32_t StdDevLimitLowLight, const uint32_t StdDevLimitLowLightSNR, const uint32_t StdDevLimitHighLight, const uint32_t StdDevLimitHighLightSNR) {
+    uint32_t newStdDev;
+    uint16_t SNR;
+ 
+    if (AmbientRate > 0)
+        SNR = (uint16_t) ((100 * SignalRate) / AmbientRate);
+    else
+        SNR = 9999;
+ 
+    if (SNR >= StdDevLimitLowLightSNR) {
+        newStdDev = StdDevLimitLowLight;
+    } else {
+        if (SNR <= StdDevLimitHighLightSNR)
+            newStdDev = StdDevLimitHighLight;
+        else {
+            newStdDev = (uint32_t) (StdDevLimitHighLight + (SNR - StdDevLimitHighLightSNR) * (int) (StdDevLimitLowLight - StdDevLimitHighLight) / (StdDevLimitLowLightSNR - StdDevLimitHighLightSNR));
+        }
+    }
+ 
+    return newStdDev;
+}
+ 
+ 
+/*
+ * Return <0 on error
+ */
+int32_t VL6180X::_filter_Start(VL6180xDev_t dev, uint16_t m_trueRange_mm, uint16_t m_rawRange_mm, uint32_t m_rtnSignalRate, uint32_t m_rtnAmbientRate, uint16_t errorCode) {
+    int status;
+    uint16_t m_newTrueRange_mm = 0;
+ 
+    uint16_t i;
+    uint16_t bypassFilter = 0;
+ 
+    uint16_t registerValue;
+ 
+    uint32_t register32BitsValue1;
+    uint32_t register32BitsValue2;
+ 
+    uint16_t ValidDistance = 0;
+ 
+    uint16_t WrapAroundFlag = 0;
+    uint16_t NoWrapAroundFlag = 0;
+    uint16_t NoWrapAroundHighConfidenceFlag = 0;
+ 
+    uint16_t FlushFilter = 0;
+    uint32_t RateChange = 0;
+ 
+    uint16_t StdDevSamples = 0;
+    uint32_t StdDevDistanceSum = 0;
+    uint32_t StdDevDistanceMean = 0;
+    uint32_t StdDevDistance = 0;
+    uint32_t StdDevRateSum = 0;
+    uint32_t StdDevRateMean = 0;
+    uint32_t StdDevRate = 0;
+    uint32_t StdDevLimitWithTargetMove = 0;
+ 
+    uint32_t VAVGDiff;
+    uint32_t IdealVAVGDiff;
+    uint32_t MinVAVGDiff;
+    uint32_t MaxVAVGDiff;
+ 
+    /* Filter Parameters */
+    static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit = 60;
+    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit_ROM = 800; // Shall be adapted depending on crossTalk
+    static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit2 = 165;
+    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit2_ROM = 180; // Shall be adapted depending on crossTalk and device sensitivity
+ 
+    static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateFilterLimit_ROM = 850; // Shall be adapted depending on crossTalk and device sensitivity
+    static const uint16_t ROMABLE_DATA WrapAroundHighRawRangeFilterLimit = 350;
+    static const uint32_t ROMABLE_DATA WrapAroundHighReturnRateFilterLimit_ROM = 1400; // Shall be adapted depending on crossTalk and device sensitivity
+ 
+    static const uint32_t ROMABLE_DATA WrapAroundMaximumAmbientRateFilterLimit = 7500;
+ 
+    /*  Temporal filter data and flush values */
+    static const uint32_t ROMABLE_DATA MinReturnRateFilterFlush = 75;
+    static const uint32_t ROMABLE_DATA MaxReturnRateChangeFilterFlush = 50;
+ 
+    /* STDDEV values and damper values */
+ 
+    static const uint32_t ROMABLE_DATA StdDevLimitLowLight = 300;
+    static const uint32_t ROMABLE_DATA StdDevLimitLowLightSNR = 30; /* 0.3 */
+    static const uint32_t ROMABLE_DATA StdDevLimitHighLight = 2500;
+    static const uint32_t ROMABLE_DATA StdDevLimitHighLightSNR = 5; /* 0.05 */
+ 
+    static const uint32_t ROMABLE_DATA StdDevHighConfidenceSNRLimit = 8;
+ 
+    static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevLimit = 90000;
+ 
+    static const uint32_t ROMABLE_DATA StdDevMovingTargetReturnRateLimit = 3500;
+    static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevForReturnRateLimit = 5000;
+ 
+    static const uint32_t ROMABLE_DATA MAX_VAVGDiff = 1800;
+ 
+    /* WrapAroundDetection variables */
+    static const uint16_t ROMABLE_DATA WrapAroundNoDelayCheckPeriod = 2;
+    static const uint16_t ROMABLE_DATA StdFilteredReadsIncrement = 2;
+    static const uint16_t ROMABLE_DATA StdMaxFilteredReads = 4;
+    
+    uint32_t SignalRateDMax;
+    uint32_t WrapAroundLowReturnRateLimit; 
+    uint32_t WrapAroundLowReturnRateLimit2;
+    uint32_t WrapAroundLowReturnRateFilterLimit;
+    uint32_t WrapAroundHighReturnRateFilterLimit; 
+ 
+    uint8_t u8, u8_2;
+    uint32_t XTalkCompRate_KCps;
+    uint32_t StdDevLimit = 300;
+    uint32_t MaxOrInvalidDistance =   255*_GetUpscale(dev);
+    /* #define MaxOrInvalidDistance  (uint16_t) (255 * 3) */
+ 
+    /* Check if distance is Valid or not */
+    switch (errorCode) {
+    case 0x0C:
+        m_trueRange_mm = MaxOrInvalidDistance;
+        ValidDistance = 0;
+        break;
+    case 0x0D:
+        m_trueRange_mm = MaxOrInvalidDistance;
+        ValidDistance = 1;
+        break;
+    case 0x0F:
+        m_trueRange_mm = MaxOrInvalidDistance;
+        ValidDistance = 1;
+        break;
+    default:
+        if (m_rawRange_mm >= MaxOrInvalidDistance) {
+            ValidDistance = 0;
+        } else {
+            ValidDistance = 1;
+        }
+        break;
+    }
+    m_newTrueRange_mm = m_trueRange_mm;
+    
+    XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps );
+ 
+    
+    //Update signal rate limits depending on crosstalk
+    SignalRateDMax = (uint32_t)_GetDMaxDataRetSignalAt400mm(dev) + XTalkCompRate_KCps;
+    WrapAroundLowReturnRateLimit = WrapAroundLowReturnRateLimit_ROM  + XTalkCompRate_KCps; 
+    WrapAroundLowReturnRateLimit2 = ((WrapAroundLowReturnRateLimit2_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
+    WrapAroundLowReturnRateFilterLimit = ((WrapAroundLowReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
+    WrapAroundHighReturnRateFilterLimit = ((WrapAroundHighReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps; 
+ 
+ 
+    /* Checks on low range data */
+    if ((m_rawRange_mm < WrapAroundLowRawRangeLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit)) {
+        m_newTrueRange_mm = MaxOrInvalidDistance;
+        bypassFilter = 1;
+    }
+    if ((m_rawRange_mm < WrapAroundLowRawRangeLimit2) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit2)) {
+        m_newTrueRange_mm = MaxOrInvalidDistance;
+        bypassFilter = 1;
+    }
+ 
+    /* Checks on Ambient rate level */
+    if (m_rtnAmbientRate > WrapAroundMaximumAmbientRateFilterLimit) {
+        /* Too high ambient rate */
+        FlushFilter = 1;
+        bypassFilter = 1;
+    }
+    /*  Checks on Filter flush */
+    if (m_rtnSignalRate < MinReturnRateFilterFlush) {
+        /* Completely lost target, so flush the filter */
+        FlushFilter = 1;
+        bypassFilter = 1;
+    }
+    if (_FilterData(LastReturnRates)[0] != 0) {
+        if (m_rtnSignalRate > _FilterData(LastReturnRates)[0])
+            RateChange = (100 * (m_rtnSignalRate - _FilterData(LastReturnRates)[0])) / _FilterData(LastReturnRates)[0];
+        else
+            RateChange = (100 * (_FilterData(LastReturnRates)[0] - m_rtnSignalRate)) / _FilterData(LastReturnRates)[0];
+    } else
+        RateChange = 0;
+    if (RateChange > MaxReturnRateChangeFilterFlush) {
+        FlushFilter = 1;
+    }
+/* TODO optimize filter  using circular buffer */
+    if (FlushFilter == 1) {
+        _FilterData(MeasurementIndex) = 0;
+        for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
+            _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
+            _FilterData(LastReturnRates)[i] = 0;
+        }
+    } else {
+        for (i = (uint16_t) (FILTER_NBOF_SAMPLES - 1); i > 0; i--) {
+            _FilterData(LastTrueRange)[i] = _FilterData(LastTrueRange)[i - 1];
+            _FilterData(LastReturnRates)[i] = _FilterData(LastReturnRates)[i - 1];
+        }
+    }
+    if (ValidDistance == 1)
+        _FilterData(LastTrueRange)[0] = m_trueRange_mm;
+    else
+        _FilterData(LastTrueRange)[0] = FILTER_INVALID_DISTANCE;
+    _FilterData(LastReturnRates)[0] = m_rtnSignalRate;
+ 
+    /* Check if we need to go through the filter or not */
+    if (!(((m_rawRange_mm < WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateFilterLimit)) || ((m_rawRange_mm >= WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundHighReturnRateFilterLimit))))
+        bypassFilter = 1;
+ 
+    /* Check which kind of measurement has been made */
+    status = VL6180x_RdByte(dev, 0x01AC, &u8 );
+    if( status ){
+        VL6180x_ErrLog("0x01AC rd fail");
+        goto done_err;
+    }
+    registerValue =u8;
+ 
+    /* Read data for filtering */
+    status = VL6180x_RdByte(dev, 0x10C, &u8 ); /* read only 8 lsb bits */
+    if( status ){
+        VL6180x_ErrLog("0x010C rd fail");
+        goto done_err;
+    }
+    register32BitsValue1=u8;
+    status = VL6180x_RdByte(dev, 0x0110, &u8); /* read only 8 lsb bits */
+    if( status ){
+        VL6180x_ErrLog("0x0110 rd fail");
+        goto done_err;
+    }
+    register32BitsValue2 = u8;
+ 
+    if (registerValue == 0x3E) {
+        _FilterData(Default_ZeroVal) = register32BitsValue1;
+        _FilterData(Default_VAVGVal) = register32BitsValue2;
+    } else {
+        _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
+        _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
+    }
+ 
+    if (bypassFilter == 1) {
+        /* Do not go through the filter */
+        if (registerValue != 0x3E) {
+            status = VL6180x_WrByte(dev, 0x1AC, 0x3E);
+            if( status ){
+                VL6180x_ErrLog("0x01AC bypass wr fail");
+                goto done_err;
+            }
+            status = VL6180x_WrByte(dev, 0x0F2, 0x01);
+            if( status ){
+                VL6180x_ErrLog("0x0F2 bypass wr fail");
+                goto done_err;
+            }
+        }
+        /* Set both Default and NoDelay To same value */
+        _FilterData(Default_ZeroVal) = register32BitsValue1;
+        _FilterData(Default_VAVGVal) = register32BitsValue2;
+        _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
+        _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
+        _FilterData(MeasurementIndex) = 0;
+ 
+        return m_newTrueRange_mm;
+    }
+ 
+    if (_FilterData(MeasurementIndex) % WrapAroundNoDelayCheckPeriod == 0) {
+        u8=0x3C;
+        u8_2 = 0x05;
+    } else {
+        u8=0x3E;
+        u8_2 = 0x01;
+    }
+    status = VL6180x_WrByte(dev, 0x01AC, u8);
+    if( status ){
+        VL6180x_ErrLog("0x01AC wr fail");
+        goto done_err;
+    }
+    status = VL6180x_WrByte(dev, 0x0F2, u8_2);
+    if( status ){
+        VL6180x_ErrLog("0x0F2  wr fail");
+        goto done_err;
+    }
+ 
+ 
+    _FilterData(MeasurementIndex)++;
+ 
+    /* Computes current VAVGDiff */
+    if (_FilterData(Default_VAVGVal) > _FilterData(NoDelay_VAVGVal))
+        VAVGDiff = _FilterData(Default_VAVGVal) - _FilterData(NoDelay_VAVGVal);
+    else
+        VAVGDiff = 0;
+    _FilterData(Previous_VAVGDiff) = VAVGDiff;
+ 
+    /* Check the VAVGDiff */
+    if (_FilterData(Default_ZeroVal) > _FilterData(NoDelay_ZeroVal))
+        IdealVAVGDiff = _FilterData(Default_ZeroVal) - _FilterData(NoDelay_ZeroVal);
+    else
+        IdealVAVGDiff = _FilterData(NoDelay_ZeroVal) - _FilterData(Default_ZeroVal);
+    if (IdealVAVGDiff > MAX_VAVGDiff)
+        MinVAVGDiff = IdealVAVGDiff - MAX_VAVGDiff;
+    else
+        MinVAVGDiff = 0;
+    MaxVAVGDiff = IdealVAVGDiff + MAX_VAVGDiff;
+    if (VAVGDiff < MinVAVGDiff || VAVGDiff > MaxVAVGDiff) {
+        WrapAroundFlag = 1;
+    } else {
+        /* Go through filtering check */
+ 
+        /* StdDevLimit Damper on SNR */
+        StdDevLimit = _filter_StdDevDamper(m_rtnAmbientRate, m_rtnSignalRate, StdDevLimitLowLight, StdDevLimitLowLightSNR, StdDevLimitHighLight, StdDevLimitHighLightSNR);
+ 
+        /* Standard deviations computations */
+        StdDevSamples = 0;
+        StdDevDistanceSum = 0;
+        StdDevDistanceMean = 0;
+        StdDevDistance = 0;
+        StdDevRateSum = 0;
+        StdDevRateMean = 0;
+        StdDevRate = 0;
+        for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
+            if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
+                StdDevSamples = (uint16_t) (StdDevSamples + 1);
+                StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + _FilterData(LastTrueRange)[i]);
+                StdDevRateSum = (uint32_t) (StdDevRateSum + _FilterData(LastReturnRates)[i]);
+            }
+        }
+        if (StdDevSamples > 0) {
+            StdDevDistanceMean = (uint32_t) (StdDevDistanceSum / StdDevSamples);
+            StdDevRateMean = (uint32_t) (StdDevRateSum / StdDevSamples);
+        }
+        /* TODO optimize shorten Std dev in aisngle loop computation using sum of x2 - (sum of x)2 */
+        StdDevSamples = 0;
+        StdDevDistanceSum = 0;
+        StdDevRateSum = 0;
+        for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
+            if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
+                StdDevSamples = (uint16_t) (StdDevSamples + 1);
+                StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean) * (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean));
+                StdDevRateSum = (uint32_t) (StdDevRateSum + (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean) * (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean));
+            }
+        }
+        if (StdDevSamples >= MIN_FILTER_STDDEV_SAMPLES) {
+            StdDevDistance = (uint16_t) (StdDevDistanceSum / StdDevSamples);
+            StdDevRate = (uint16_t) (StdDevRateSum / StdDevSamples);
+        } else {
+            StdDevDistance = 0;
+            StdDevRate = 0;
+        }
+ 
+        /* Check Return rate standard deviation */
+        if (StdDevRate < StdDevMovingTargetStdDevLimit) {
+            if (StdDevSamples < MIN_FILTER_VALID_STDDEV_SAMPLES) {
+                m_newTrueRange_mm = MaxOrInvalidDistance;
+            } else {
+                /* Check distance standard deviation */
+                if (StdDevRate < StdDevMovingTargetReturnRateLimit)
+                    StdDevLimitWithTargetMove = StdDevLimit + (((StdDevMovingTargetStdDevForReturnRateLimit - StdDevLimit) * StdDevRate) / StdDevMovingTargetReturnRateLimit);
+                else
+                    StdDevLimitWithTargetMove = StdDevMovingTargetStdDevForReturnRateLimit;
+ 
+                if ((StdDevDistance * StdDevHighConfidenceSNRLimit) < StdDevLimitWithTargetMove) {
+                    NoWrapAroundHighConfidenceFlag = 1;
+                } else {
+                    if (StdDevDistance < StdDevLimitWithTargetMove) {
+                        if (StdDevSamples >= MIN_FILTER_VALID_STDDEV_SAMPLES) {
+                            NoWrapAroundFlag = 1;
+                        } else {
+                            m_newTrueRange_mm = MaxOrInvalidDistance;
+                        }
+                    } else {
+                        WrapAroundFlag = 1;
+                    }
+                }
+            }
+        } else {
+            WrapAroundFlag = 1;
+        }
+    }
+ 
+    if (m_newTrueRange_mm == MaxOrInvalidDistance) {
+        if (_FilterData(StdFilteredReads) > 0)
+            _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - 1);
+    } else {
+        if (WrapAroundFlag == 1) {
+            m_newTrueRange_mm = MaxOrInvalidDistance;
+            _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) + StdFilteredReadsIncrement);
+            if (_FilterData(StdFilteredReads) > StdMaxFilteredReads)
+                _FilterData(StdFilteredReads) = StdMaxFilteredReads;
+        } else {
+            if (NoWrapAroundFlag == 1) {
+                if (_FilterData(StdFilteredReads) > 0) {
+                    m_newTrueRange_mm = MaxOrInvalidDistance;
+                    if (_FilterData(StdFilteredReads) > StdFilteredReadsIncrement)
+                        _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - StdFilteredReadsIncrement);
+                    else
+                        _FilterData(StdFilteredReads) = 0;
+                }
+            } else {
+                if (NoWrapAroundHighConfidenceFlag == 1) {
+                    _FilterData(StdFilteredReads) = 0;
+                }
+            }
+        }
+    }
+ 
+    return m_newTrueRange_mm;
+    done_err:
+    return -1;
+ 
+    #undef MaxOrInvalidDistance
+}
+ 
+ 
+int VL6180X::_filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
+    uint32_t m_rawRange_mm = 0;
+    int32_t  FilteredRange;
+    const uint8_t scaler = _GetUpscale(dev);
+    uint8_t u8;
+    int status;
+ 
+    do {
+        status = VL6180x_RdByte(dev, RESULT_RANGE_RAW, &u8);
+        if (status) {
+            VL6180x_ErrLog("RESULT_RANGE_RAW rd fail");
+            break;
+        }
+        m_rawRange_mm = u8;
+ 
+        FilteredRange = _filter_Start(dev, pRangeData->range_mm, (m_rawRange_mm * scaler), pRangeData->rtnRate, pRangeData->rtnAmbRate, pRangeData->errorStatus);
+        if( FilteredRange<0 ){
+            status = -1;
+            break;
+        }
+        pRangeData->FilteredData.range_mm= FilteredRange;
+        pRangeData->FilteredData.rawRange_mm = m_rawRange_mm * scaler;
+    } while (0);
+    return status;
+}
+ 
+#undef _FilterData
+#undef FILTER_STDDEV_SAMPLES
+#undef MIN_FILTER_STDDEV_SAMPLES
+#undef MIN_FILTER_VALID_STDDEV_SAMPLES
+#undef FILTER_INVALID_DISTANCE
+ 
+#endif /* VL6180x_WRAP_AROUND_FILTER_SUPPORT */
+ 
+#ifdef VL6180x_HAVE_RATE_DATA
+ 
+int VL6180X::_GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
+    uint32_t m_rtnConvTime = 0;
+    uint32_t m_rtnSignalRate = 0;
+    uint32_t m_rtnAmbientRate = 0;
+    uint32_t m_rtnSignalCount = 0;
+    uint32_t m_rtnAmbientCount = 0;
+    uint32_t m_refConvTime = 0;
+    uint32_t cRtnSignalCountMax = 0x7FFFFFFF;
+    uint32_t cDllPeriods = 6;
+    uint32_t calcConvTime = 0;
+ 
+    int status;
+ 
+    do {
+ 
+        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_SIGNAL_COUNT, &m_rtnSignalCount);
+        if (status) {
+            VL6180x_ErrLog("RESULT_RANGE_RETURN_SIGNAL_COUNT rd fail");
+            break;
+        }
+        if (m_rtnSignalCount > cRtnSignalCountMax) {
+            m_rtnSignalCount = 0;
+        }
+ 
+        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_AMB_COUNT, &m_rtnAmbientCount);
+        if (status) {
+            VL6180x_ErrLog("RESULT_RANGE_RETURN_AMB_COUNTrd fail");
+            break;
+        }
+ 
+ 
+        status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_CONV_TIME, &m_rtnConvTime);
+        if (status) {
+            VL6180x_ErrLog("RESULT_RANGE_RETURN_CONV_TIME rd fail");
+            break;
+        }
+ 
+        status = VL6180x_RdDWord(dev, RESULT_RANGE_REFERENCE_CONV_TIME, &m_refConvTime);
+        if (status) {
+            VL6180x_ErrLog("RESULT_RANGE_REFERENCE_CONV_TIME rd fail");
+            break;
+        }
+ 
+        pRangeData->rtnConvTime = m_rtnConvTime;
+        pRangeData->refConvTime = m_refConvTime;
+ 
+        calcConvTime = m_refConvTime;
+        if (m_rtnConvTime > m_refConvTime) {
+            calcConvTime = m_rtnConvTime;
+        }
+        if (calcConvTime == 0)
+            calcConvTime = 63000;
+ 
+        m_rtnSignalRate = (m_rtnSignalCount * 1000) / calcConvTime;
+        m_rtnAmbientRate = (m_rtnAmbientCount * cDllPeriods * 1000) / calcConvTime;
+ 
+        pRangeData->rtnRate = m_rtnSignalRate;
+        pRangeData->rtnAmbRate = m_rtnAmbientRate;
+ 
+ 
+    } while (0);
+    return status;
+}
+#endif /* VL6180x_HAVE_RATE_DATA */
+ 
+ 
+int VL6180X::VL6180x_DMaxSetState(VL6180xDev_t dev, int state){
+    int status;
+    LOG_FUNCTION_START("%d", state);
+#if VL6180x_HAVE_DMAX_RANGING
+    VL6180xDevDataSet(dev,DMaxEnable, state);
+    if( state ){
+        status = _DMax_InitData(dev);
+    }
+    else {
+        status = 0;
+    }
+#else
+    status =  NOT_SUPPORTED;
+#endif
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+int VL6180X::VL6180x_DMaxGetState(VL6180xDev_t dev){
+    int status;
+    LOG_FUNCTION_START("");
+#if VL6180x_HAVE_DMAX_RANGING
+    status = VL6180xDevDataGet(dev,DMaxEnable);
+#else
+    status = 0;
+#endif
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+ 
+#if VL6180x_HAVE_DMAX_RANGING
+ 
+#define _DMaxData(field) VL6180xDevDataGet(dev, DMaxData.field)
+/*
+ * Convert fix point  x.7 to KCpount per sec
+ */
+ 
+#ifndef VL6180x_PLATFORM_PROVIDE_SQRT
+ 
+/*
+ * 32 bit integer square root with not so bad precision (integer result) and is quite fast
+ * see http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
+ */
+uint32_t VL6180x_SqrtUint32(uint32_t num) {
+    uint32_t res = 0;
+    uint32_t bit = 1 << 30; /* The second-to-top bit is set: 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;
+}
+#endif
+ 
+ 
+/* DMax one time init */
+void _DMax_OneTimeInit(VL6180xDev_t dev){
+    _DMaxData(ambTuningWindowFactor_K)=DEF_AMBIENT_TUNING;
+}
+ 
+ 
+static uint32_t _DMax_RawValueAtRateKCps(VL6180xDev_t dev, int32_t rate){
+    uint32_t snrLimit_K;
+    int32_t DMaxSq;
+    uint32_t RawDMax;
+    DMaxFix_t retSignalAt400mm;
+    uint32_t ambTuningWindowFactor_K;
+ 
+ 
+    ambTuningWindowFactor_K = _DMaxData(ambTuningWindowFactor_K);
+    snrLimit_K              = _DMaxData(snrLimit_K);
+    retSignalAt400mm        = _DMaxData(retSignalAt400mm); /* 12 to 18 bits Kcps */
+    if( rate > 0 ){
+        DMaxSq = 400*400*1000 / rate -(400*400/330); /* K of (1/RtnAmb -1/330 )=> 30bit- (12-18)bit  => 12-18 bits*/
+        if( DMaxSq<= 0){
+            RawDMax = 0;
+        }
+        else{
+            /* value can be more 32 bit so base on raneg apply *retSignalAt400mm before or after division to presevr accuracy */
+            if( DMaxSq< (2<<12)  ){
+                DMaxSq = DMaxSq*retSignalAt400mm/(snrLimit_K+ambTuningWindowFactor_K);       /* max 12 + 12 to 18 -10 => 12-26 bit */
+            }else{
+                DMaxSq = DMaxSq/(snrLimit_K+ambTuningWindowFactor_K)*retSignalAt400mm;       /* 12 to 18 -10 + 12 to 18 *=> 12-26 bit */
+            }
+            RawDMax=VL6180x_SqrtUint32(DMaxSq);
+        }
+    }
+    else{
+        RawDMax = 0x7FFFFFFF; /* bigest possibmle 32bit signed value */
+    }
+    return RawDMax;
+}
+ 
+/*
+ * fetch static data from register to avoid re-read
+ * precompute all intermediate constant and cliipings
+ *
+ * to be re-used/call on  changes of :
+ *  0x2A
+ *  SYSRANGE_MAX_AMBIENT_LEVEL_MULT
+ *  Dev Data XtalkComRate_KCPs
+ *  SYSRANGE_MAX_CONVERGENCE_TIME
+ *  SYSRANGE_RANGE_CHECK_ENABLES    mask RANGE_CHECK_RANGE_ENABLE_MASK
+ *  range 0xb8-0xbb (0xbb)
+ */
+int VL6180X::_DMax_InitData(VL6180xDev_t dev){
+    int status, warning;
+    uint8_t u8;
+    uint16_t u16;
+    uint32_t u32;
+    uint32_t Reg2A_KCps;
+    uint32_t RegB8;
+    uint8_t  MaxConvTime;
+    uint32_t XTalkCompRate_KCps;
+    uint32_t RangeIgnoreThreshold;
+    int32_t minSignalNeeded;
+    uint8_t SysRangeCheckEn;
+    uint8_t snrLimit;
+    warning=0;
+ 
+    static const int ROMABLE_DATA MaxConvTimeAdjust=-4;
+ 
+    LOG_FUNCTION_START("");
+    do{
+        status = VL6180x_RdByte(dev, 0x02A ,&u8);
+        if( status ){
+            VL6180x_ErrLog("Reg 0x02A rd fail");
+            break;
+        }
+ 
+        if( u8 == 0 ) {
+            warning = CALIBRATION_WARNING;
+            u8 = 40; /* use a default average value */
+        }
+        Reg2A_KCps = Fix7_2_KCPs(u8); /* convert to KCPs */
+ 
+        status = VL6180x_RdByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, &SysRangeCheckEn);
+        if (status) {
+            VL6180x_ErrLog("SYSRANGE_RANGE_CHECK_ENABLES rd fail ");
+            break;
+        }
+ 
+        status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &MaxConvTime);
+        if( status){
+            VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
+            break;
+        }
+ 
+        status = VL6180x_RdDWord(dev, 0x0B8, &RegB8);
+        if( status ){
+            VL6180x_ErrLog("reg 0x0B8 rd fail ");
+            break;
+        }
+ 
+        status = VL6180x_RdByte(dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, &snrLimit);
+        if( status){
+            VL6180x_ErrLog("SYSRANGE_MAX_AMBIENT_LEVEL_MULT rd fail ");
+            break;
+        }
+        _DMaxData(snrLimit_K) = (int32_t)16*1000/snrLimit;
+        XTalkCompRate_KCps =   VL6180xDevDataGet(dev, XTalkCompRate_KCps );
+ 
+        if( Reg2A_KCps >= XTalkCompRate_KCps){
+            _DMaxData(retSignalAt400mm)=( Reg2A_KCps - XTalkCompRate_KCps);
+        }
+        else{
+            _DMaxData(retSignalAt400mm)=0;             /* Reg2A_K - XTalkCompRate_KCp <0 is invalid */
+        }
+ 
+        /* if xtalk range check is off omit it in snr clipping */
+        if( SysRangeCheckEn&RANGE_CHECK_RANGE_ENABLE_MASK ){
+            status = VL6180x_RdWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &u16);
+            if( status){
+                VL6180x_ErrLog("SYSRANGE_RANGE_IGNORE_THRESHOLD rd fail ");
+                break;
+            }
+            RangeIgnoreThreshold = Fix7_2_KCPs(u16);
+        }
+        else{
+            RangeIgnoreThreshold  = 0;
+        }
+ 
+        minSignalNeeded = (RegB8*256)/((int32_t)MaxConvTime+(int32_t)MaxConvTimeAdjust); /* KCps 8+8 bit -(1 to 6 bit) => 15-10 bit */
+        /* minSignalNeeded = max ( minSignalNeeded,  RangeIgnoreThreshold - XTalkCompRate_KCps) */
+        if( minSignalNeeded  <= RangeIgnoreThreshold - XTalkCompRate_KCps )
+            minSignalNeeded  =  RangeIgnoreThreshold - XTalkCompRate_KCps;
+ 
+        u32 = (minSignalNeeded*(uint32_t)snrLimit)/16;
+        _DMaxData(ClipSnrLimit ) = _DMax_RawValueAtRateKCps(dev, u32 ); /* clip to dmax to min signal snr limit rate*/
+    }
+    while(0);
+    if( !status )
+        status = warning;
+    LOG_FUNCTION_END(status);
+    return status;
+}
+ 
+static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange){
+    uint32_t rtnAmbRate;
+    int32_t DMax;
+    int scaling;
+    uint16_t HwLimitAtScale;
+    static const int ROMABLE_DATA rtnAmbLowLimit_KCps=330*1000;
+ 
+    rtnAmbRate = pRange->rtnAmbRate;
+    if( rtnAmbRate  < rtnAmbLowLimit_KCps ){
+        DMax = _DMax_RawValueAtRateKCps( dev, rtnAmbRate);
+        scaling = _GetUpscale(dev);
+        HwLimitAtScale=UpperLimitLookUP[scaling - 1];
+ 
+        if( DMax > _DMaxData(ClipSnrLimit) ){
+            DMax=_DMaxData(ClipSnrLimit);
+        }
+        if( DMax > HwLimitAtScale ){
+            DMax=HwLimitAtScale;
+        }
+        pRange->DMax=DMax;
+    }
+    else{
+        pRange->DMax = 0;
+    }
+    return 0;
+}
+ 
+#undef _DMaxData
+#undef Fix7_2_KCPs
+ 
+#endif /* VL6180x_HAVE_DMAX_RANGING */
+ 
+ 
+/******************************************************************************/
+/******************************************************************************/
+ 
+ 
+ 
+/****************** Write and read functions from I2C *************************/
+ 
+int VL6180X::VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data)
+{
+   int  status;
+ 
+   status=VL6180x_I2CWrite(Device->I2cAddr, index, &data,(uint8_t)1);
+   return status;
+}
+ 
+int VL6180X::VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data)
+{
+   int  status;
+   
+   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)2);
+   return status;
+}
+ 
+int VL6180X::VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data)
+{
+   int  status;
+   
+   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)4);
+   return status;
+}
+ 
+int VL6180X::VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data)
+{
+   int  status;
+    
+   uint8_t buffer;
+   status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
+   if(!status)
+   {
+      *data=buffer;
+   }
+   return status;
+}
+ 
+int VL6180X::VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data)
+{
+   int  status;
+    
+   uint8_t buffer[2];
+   status=VL6180x_I2CRead(Device->I2cAddr, index, buffer, 2);
+   if(!status)
+   {
+      memcpy(data, buffer, 2);
+   }
+   return status;
+}
+ 
+int VL6180X::VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data)
+{
+   int status;
+   uint8_t buffer[4];
+   status=VL6180x_I2CRead(Device->I2cAddr, index, buffer,4);
+   if(!status)
+   {
+      memcpy(data, buffer, 4);
+   }
+   return status;
+}
+ 
+int VL6180X::VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData)
+{
+   int  status;
+   uint8_t buffer;
+ 
+   status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)buffer,(uint8_t)0);
+   if(!status)
+   {
+      /* read data direct onto buffer */
+      status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
+      if(!status)
+      {
+         buffer=(buffer & AndData)|OrData;
+         status=VL6180x_I2CWrite(Device->I2cAddr, index, &buffer, (uint8_t)1);
+      }
+   }
+   return status;
+}
+ 
+int VL6180X::VL6180x_I2CWrite(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToWrite)
+{
+   int ret;
+   int i;
+   uint8_t tmp[TEMP_BUF_SIZE];
+   uint16_t myRegisterAddr = RegisterAddr;
+   uint16_t WriteDeviceAddr=0;
+   
+   /* First, prepare 8 bits device address in 7bits i2ci format */
+   WriteDeviceAddr=DeviceAddr*2;
+   if(NumByteToWrite >= TEMP_BUF_SIZE) return -2;
+        
+   /* then prepare 16 bits register address in BE format. Then, send data and STOP condition */
+   tmp[0] = *(((uint8_t*)&myRegisterAddr)+1);  
+   tmp[1] = (uint8_t)RegisterAddr;
+    
+   if(NumByteToWrite>1)  /* swap data endianess */
+   {
+      for(i=0;i<NumByteToWrite;i++)
+      {
+         tmp[NumByteToWrite+sizeof(RegisterAddr)-1-i]=pBuffer[i];
+      }
+   }
+   else
+   {    
+      memcpy(tmp+sizeof(RegisterAddr), pBuffer, NumByteToWrite);
+   }
+   ret = dev_i2c.write(WriteDeviceAddr, (const char*)tmp, NumByteToWrite+sizeof(RegisterAddr), false);
+ 
+   if(ret) 
+      return -1;
+   return 0;
+}
+ 
+int VL6180X::VL6180x_I2CRead(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToRead)
+{
+   int ret,i;
+   uint8_t tmp[TEMP_BUF_SIZE]; 
+   uint16_t myRegisterAddr = RegisterAddr;
+   uint16_t myRegisterAddrBE;
+   uint16_t ReadDeviceAddr=DeviceAddr;
+     
+   ReadDeviceAddr=DeviceAddr*2;    
+   myRegisterAddrBE = *(((uint8_t*)&myRegisterAddr)+1);
+   *(((uint8_t*)&myRegisterAddrBE)+1) = (uint8_t)myRegisterAddr;
+    
+   /* Send 8 bits device address and 16 bits register address in BE format, with no STOP condition */
+   ret = dev_i2c.write(ReadDeviceAddr, (const char*)&myRegisterAddrBE, sizeof(RegisterAddr), true);
+   if(!ret) 
+   {
+      ReadDeviceAddr|=0x001;
+      /* Read data, with STOP condition  */
+      ret = dev_i2c.read(ReadDeviceAddr, (char*)tmp, NumByteToRead, false);
+   }    
+   if(ret) 
+      return -1;
+        
+   if(NumByteToRead>1)  /* swap data endianess */
+   {
+      for(i=0;i<NumByteToRead;i++)
+      {      
+         pBuffer[i] = tmp[NumByteToRead-1-i];
+      }
+   }
+   else
+   {      
+      memcpy(pBuffer, tmp, NumByteToRead);
+   }       
+   return 0;
+} 
+
+/******************************************************************************/
+
+int VL6180X::AlsSetThresholds(uint16_t lux_threshold_low, uint16_t lux_threshold_high)
+{
+   uint32_t AlsAnGain, IntPeriod, AlsScaler, GainFix, RawAlsHigh, RawAlsLow;
+   uint16_t RawThreshLow, RawThreshHigh;
+   const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
+   void *p_low;
+   void *p_high;
+ 
+   AlsAnGain=VL6180xDevDataGet(Device, AlsGainCode);
+   IntPeriod=VL6180xDevDataGet(Device, IntegrationPeriod);
+   AlsScaler=VL6180xDevDataGet(Device, AlsScaler);
+   GainFix=AlsGainLookUp[AlsAnGain];
+   IntPeriod++;
+   RawAlsLow=lux_threshold_low*AlsScaler*GainFix;
+   RawAlsLow=RawAlsLow*IntPeriod;
+   RawAlsLow=RawAlsLow/LuxResxIntIme;  
+   RawAlsHigh=lux_threshold_high*(AlsScaler*GainFix);
+   RawAlsHigh=RawAlsHigh*IntPeriod;
+   RawAlsHigh=RawAlsHigh/LuxResxIntIme;
+   p_low=&RawAlsLow;
+   RawThreshLow=*(uint16_t*)p_low;
+   p_high=&RawAlsHigh;
+   RawThreshHigh=*(uint16_t*)p_high;
+   return VL6180x_AlsSetThresholds(Device, RawThreshLow, RawThreshHigh);
+}
+
+
+int VL6180X::ReadID()
+{
+   int status;
+   uint8_t rl_id=0;
+    
+   status=VL6180x_RdByte(Device, IDENTIFICATION_MODEL_ID, &rl_id);
+   if((status==0)&&(rl_id==0xB4))
+     return status;
+   else
+     return INVALID_PARAMS;
+}
+ 
+ 
+int VL6180X::InitSensor(uint8_t NewAddr)
+{
+   int status;
+ 
+   VL6180x_Off();
+   VL6180x_On();
+   status=VL6180x_WaitDeviceBooted(Device);
+   if(status)
+      VL6180x_ErrLog("WaitDeviceBooted fail\n\r");
+   status=IsPresent();
+   if(!status)
+   {
+      Device->Present=1;
+      status=Init();
+      if(status)
+      {
+         printf("Failed to init VL6180X sensor!\n\r");
+         return status;
+      }
+      status=Prepare();
+      if(status)
+      {
+         printf("Failed to prepare VL6180X!\n\r");
+         return status;
+      }
+      if(NewAddr!=DEFAULT_DEVICE_ADDRESS)
+      {
+         status=SetI2CAddress(NewAddr);
+         if(status)
+         {
+            printf("Failed to change I2C address!\n\r");
+            return status;
+         }
+      }
+      else
+      {
+         printf("Invalid new address!\n\r");
+         return INVALID_PARAMS;
+      }
+      Device->Ready=1;
+   }
+   return status; 
+}
+ 
+ 
+int VL6180X::StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), uint16_t low, uint16_t high)
+{
+   int status, r_status, l_status;
+    
+   switch(operating_mode)
+   {
+      case(range_single_shot_polling):
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return RangeMeasPollSingleShot();
+        else
+           return (r_status|l_status);
+        
+      case(als_single_shot_polling):
+        r_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        l_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return AlsMeasPollSingleShot();
+        else
+           return (r_status|l_status);
+            
+      case(range_continuous_polling):
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return RangeMeasPollContinuousMode();
+        else
+           return (r_status|l_status);
+                 
+      case(als_continuous_polling):
+        r_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        l_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return AlsMeasPollContinuousMode();
+        else
+           return (r_status|l_status);
+                 
+      case(range_continuous_interrupt):
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return RangeMeasIntContinuousMode(fptr);
+        else
+           return (r_status|l_status);
+                     
+      case(als_continuous_interrupt):
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+           return AlsMeasIntContinuousMode(fptr);
+        else
+           return (r_status|l_status);
+ 
+      case(interleaved_mode_interrupt):
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);            
+        if((!r_status)&&(!l_status))
+           return InterleavedMode(fptr);
+        else
+           return (r_status|l_status);
+ 
+      case(range_continuous_polling_low_threshold):
+        r_status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
+        l_status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=RangeSetLowThreshold(low);
+           if(!status)
+              return RangeMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+       
+      case(range_continuous_polling_high_threshold):
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=RangeSetHighThreshold(high);
+           if(!status)
+              return RangeMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      case(range_continuous_polling_out_of_window):
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=VL6180x_RangeSetThresholds(Device,low,high,1);
+           if(!status)
+              return RangeMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      case(als_continuous_polling_low_threshold):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=AlsSetLowThreshold(low);
+           if(!status)
+              return AlsMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+            
+      case(als_continuous_polling_high_threshold):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=AlsSetHighThreshold(high);
+           if(!status)
+              return AlsMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      case(als_continuous_polling_out_of_window):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=VL6180x_AlsSetThresholds(Device,low,high);
+           if(!status)
+              return AlsMeasPollContinuousMode();
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      case(range_continuous_interrupt_low_threshold):
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=RangeSetLowThreshold(low);
+           if(!status)
+              return RangeMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);                  
+            
+      case(range_continuous_interrupt_high_threshold):   
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=RangeSetHighThreshold(high);
+           if(!status)
+              return RangeMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+       case(range_continuous_interrupt_out_of_window):
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=VL6180x_RangeSetThresholds(Device,low,high,1);
+           if(!status)
+              return RangeMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+            
+      case(als_continuous_interrupt_low_threshold):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_LOW);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=AlsSetLowThreshold(low);
+           if(!status)
+              return AlsMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);  
+                
+      case(als_continuous_interrupt_high_threshold):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_LEVEL_HIGH);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=AlsSetHighThreshold(high);
+           if(!status)
+              return AlsMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      case(als_continuous_interrupt_out_of_window):
+        status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW);
+        status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+        if((!r_status)&&(!l_status))
+        {
+           status=VL6180x_AlsSetThresholds(Device,low,high);
+           if(!status)
+              return AlsMeasIntContinuousMode(fptr);
+           else
+              return status;
+        }
+        else
+           return (r_status|l_status);
+                
+      default:
+        return INVALID_PARAMS;
+   }
+}
+ 
+ 
+int VL6180X::GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData)
+{
+   Data->range_error=RangeData.errorStatus;
+   if(Data->range_error!=0)
+   {
+      VL6180x_ErrLog("Range error %d",Data->range_error);
+      return RANGE_ERROR;
+   }
+   return NoError_;
+}
+ 
+ 
+int VL6180X::GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData)
+{
+   Data->als_error=AlsData.errorStatus;
+   if(Data->als_error!=0)
+   {
+      VL6180x_ErrLog("Light error %d",Data->light_error);
+      return API_ERROR;
+   }
+   return NoError_;
+}
+ 
+ 
+int VL6180X::RangeMeasPollSingleShot()
+{
+   int status;
+            
+   status=VL6180x_RangeClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   return RangeStartSingleShot(); 
+}   
+ 
+ 
+int VL6180X::AlsMeasPollSingleShot()
+{
+   int status;            
+     
+   status=VL6180x_AlsClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   return AlsStartSingleShot();
+}
+ 
+ 
+int VL6180X::RangeMeasPollContinuousMode()
+{
+   int status;
+            
+   status=VL6180x_RangeClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   return RangeStartContinuousMode();
+}
+ 
+ 
+int VL6180X::AlsMeasPollContinuousMode() 
+{
+   int status;            
+     
+   status=VL6180x_AlsClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   return AlsStartContinuousMode();
+}
+ 
+ 
+int VL6180X::AlsGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData)
+{
+   int status;
+   uint8_t IntStatus;
+     
+   status=VL6180x_AlsGetInterruptStatus(dev, &IntStatus);
+   if(!status)
+   {
+      if(IntStatus==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
+      {
+         status = VL6180x_AlsGetMeasurement(dev, pAlsData);
+         if(!status)
+         {
+            status=VL6180x_AlsClearInterrupt(Device);
+            if(status)
+               VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+         }
+      }
+      else
+         status=NOT_READY;
+   }
+   else
+      VL6180x_ErrLog("Failed to get interrupt status");
+   return status;
+}
+ 
+ 
+int VL6180X::RangeMeasIntContinuousMode(void (*fptr)(void))
+{
+   int status, ClrStatus;
+     
+   EnableInterruptMeasureDetectionIRQ();
+   AttachInterruptMeasureDetectionIRQ(fptr);
+   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+   ClrStatus=VL6180x_ClearAllInterrupt(Device);
+   if(ClrStatus)
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+   if(!status)
+      status=RangeStartContinuousMode();
+   return status;
+}
+ 
+ 
+int VL6180X::AlsMeasIntContinuousMode(void (*fptr)(void))
+{
+   int status, ClrStatus;
+    
+   EnableInterruptMeasureDetectionIRQ();
+   AttachInterruptMeasureDetectionIRQ(fptr);
+   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+   ClrStatus=VL6180x_ClearAllInterrupt(Device);
+   if(ClrStatus)
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+   if(!status)
+      status=AlsStartContinuousMode();
+   return status;
+}   
+ 
+ 
+int VL6180X::StartInterleavedMode()
+{
+   int status;
+   uint16_t integration_period, intermeasurement_period_ms;
+   uint8_t max_convergence_time;
+   uint8_t buf;
+    
+   status=VL6180x_WrByte(Device, 0x2A3, 1);
+   if(status)
+   {
+      VL6180x_ErrLog("Failed to write INTERLEAVED_MODE_ENABLE!\n\r");
+      return status;
+   }
+   status=VL6180x_RdByte(Device, SYSRANGE_MAX_CONVERGENCE_TIME, &max_convergence_time);
+   if(status)
+   {
+      VL6180x_ErrLog("Failed to read SYSRANGE_MAX_CONVERGENCE_TIME!\n\r");
+      return status;
+   }
+   status=VL6180x_RdWord(Device, SYSALS_INTEGRATION_PERIOD, &integration_period);
+   if(status)
+   {
+      VL6180x_ErrLog("Failed to read SYSALS_INTEGRATION_PERIOD!\n\r");
+      return status;
+   }
+   max_convergence_time&=0x3F;
+   integration_period&=0x01FF;
+   intermeasurement_period_ms=((max_convergence_time+5)+(integration_period*1.1));
+   intermeasurement_period_ms=(intermeasurement_period_ms/0.9)+10;
+   intermeasurement_period_ms=200;
+   status=VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
+   VL6180x_RdByte(Device, 0x03E, &buf);
+   if(status)
+   {
+      VL6180x_ErrLog("Failed to write SYSALS_INTERMEASUREMENT_PERIOD!\n\r");
+      return status;
+   }
+   return AlsStartContinuousMode();
+}
+ 
+ 
+int VL6180X::InterleavedMode(void (*fptr)(void))
+{
+   int status, ClrStatus;
+    
+   EnableInterruptMeasureDetectionIRQ();
+   AttachInterruptMeasureDetectionIRQ(fptr);
+   status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
+   ClrStatus=VL6180x_ClearAllInterrupt(Device);
+   if(ClrStatus)
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+   if(!status)
+      status=StartInterleavedMode();
+   return status;
+} 
+ 
+ 
+int VL6180X::HandleIRQ(OperatingMode operating_mode, MeasureData_t *Data)
+{
+   int status;
+    
+   EnableInterruptMeasureDetectionIRQ();
+   status=GetMeasurement(operating_mode, Data);
+   return status;
+}
+     
+ 
+int VL6180X::RangeSetLowThreshold(uint16_t threshold)
+{
+   int status;
+   uint16_t low, high;
+     
+   status=VL6180x_RangeGetThresholds(Device, &low, &high);
+   if(!status)
+      status=VL6180x_RangeSetThresholds(Device, threshold, high, 1);
+   return status;
+}
+ 
+ 
+int VL6180X::RangeSetHighThreshold(uint16_t threshold)
+{
+   int status;
+   uint16_t low, high;
+     
+   status=VL6180x_RangeGetThresholds(Device, &low, &high);
+   if(!status)
+      status=VL6180x_RangeSetThresholds(Device, low, threshold, 1);
+   return status;
+}
+    
+ 
+int VL6180X::AlsSetLowThreshold(uint16_t threshold)
+{
+   int status;
+   lux_t low, high;
+     
+   status=AlsGetThresholds(Device, &low, &high);
+   if(!status)
+      status=VL6180x_AlsSetThresholds(Device, threshold, high);
+   return status;
+}
+    
+ 
+int VL6180X::AlsSetHighThreshold(uint16_t threshold)
+{
+   int status;
+   lux_t low, high;
+     
+   status=AlsGetThresholds(Device, &low, &high);
+   if(!status)
+      status=VL6180x_AlsSetThresholds(Device, low, threshold);
+   return status;
+}
+ 
+    
+int VL6180X::AlsGetThresholds(VL6180xDev_t dev, lux_t *low, lux_t *high)  
+{
+   int status;
+   uint16_t RawAlsLow, RawAlsHigh;
+   uint32_t luxLowValue, luxHighValue, IntPeriod, AlsAnGain, GainFix, AlsScaler;
+   const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
+     
+   status=VL6180x_RdWord(dev, SYSALS_THRESH_LOW, &RawAlsLow);
+   if(status)
+   {
+      VL6180x_ErrLog("rd SYSALS_THRESH_LOW fail");
+      return status;
+   }
+   status=VL6180x_RdWord(dev, SYSALS_THRESH_HIGH, &RawAlsHigh);
+   if(status)
+   {
+      VL6180x_ErrLog("rd SYSALS_THRESH_HIGH fail");
+      return status;
+   }
+   AlsAnGain=VL6180xDevDataGet(dev, AlsGainCode);
+   IntPeriod=VL6180xDevDataGet(dev, IntegrationPeriod);
+   AlsScaler=VL6180xDevDataGet(dev, AlsScaler);
+   GainFix=AlsGainLookUp[AlsAnGain];
+   IntPeriod++;
+   luxLowValue=(uint32_t)RawAlsLow*LuxResxIntIme;
+   luxLowValue=luxLowValue/IntPeriod;
+   luxLowValue=luxLowValue/(AlsScaler*GainFix);
+   luxHighValue=(uint32_t)RawAlsHigh*LuxResxIntIme;
+   luxHighValue=luxHighValue/IntPeriod;
+   luxHighValue=luxHighValue/(AlsScaler*GainFix);
+   *low=luxLowValue;
+   *high=luxHighValue;
+   return status;
+}
+    
+ 
+int VL6180X::GetMeasurement(OperatingMode operating_mode, MeasureData_t *Data)
+{
+   switch(operating_mode)
+   {
+      case(range_single_shot_polling):
+      case(range_continuous_polling):
+      case(range_continuous_interrupt):
+      case(range_continuous_polling_low_threshold):
+      case(range_continuous_polling_high_threshold):
+      case(range_continuous_polling_out_of_window):
+      case(range_continuous_interrupt_low_threshold):
+      case(range_continuous_interrupt_high_threshold):
+      case(range_continuous_interrupt_out_of_window):
+        return GetRangeMeas(operating_mode, Data);
+         
+      case(als_single_shot_polling):
+      case(als_continuous_polling):
+      case(als_continuous_interrupt):
+      case(als_continuous_polling_low_threshold):
+      case(als_continuous_polling_high_threshold):
+      case(als_continuous_polling_out_of_window):
+      case(als_continuous_interrupt_low_threshold):
+      case(als_continuous_interrupt_high_threshold):
+      case(als_continuous_interrupt_out_of_window):
+        return GetAlsMeas(operating_mode, Data);
+             
+      case(interleaved_mode_interrupt):
+        return GetRangeAlsMeas(Data);
+         
+      default:
+        return INVALID_PARAMS;
+   }
+}
+     
+ 
+int VL6180X::GetRangeMeas(OperatingMode operating_mode, MeasureData_t *Data)
+{
+   VL6180x_RangeData_t RangeData;
+   int status, ClrStatus;
+   IntrStatus_t IntStatus;
+    
+   status=VL6180x_RangeGetInterruptStatus(Device, &IntStatus.val);
+   if(!status)
+   {
+      Data->int_error=IntStatus.status.Error;
+      if(IntStatus.status.Error!=0)
+      {
+         VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
+         status=RANGE_ERROR;
+      } 
+   }
+   else
+   {
+      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO");
+   }  
+   ClrStatus=VL6180x_RangeClearInterrupt(Device);
+   if(ClrStatus)
+   {
+      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+   }
+   ClrStatus=VL6180x_ClearErrorInterrupt(Device);
+   if(ClrStatus)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+   }
+   if(status)
+      return status;
+   if((operating_mode==range_single_shot_polling)||(operating_mode==range_continuous_polling)||(operating_mode==range_continuous_interrupt))
+   {
+      if(IntStatus.status.Range==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
+         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+   else
+         return NOT_READY;
+   }
+   else if((operating_mode==range_continuous_polling_low_threshold)||(operating_mode==range_continuous_interrupt_low_threshold))
+   {
+      if(IntStatus.status.Range==RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD)
+         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+      else
+         return NOT_READY;
+   }
+   else if((operating_mode==range_continuous_polling_high_threshold)||(operating_mode==range_continuous_interrupt_high_threshold))
+   {
+      if(IntStatus.status.Range==RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
+         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+      else
+         return NOT_READY;
+   }
+   else if((operating_mode==range_continuous_polling_out_of_window)||(operating_mode==range_continuous_interrupt_out_of_window))
+   {
+      if(IntStatus.status.Range==RES_INT_STAT_GPIO_OUT_OF_WINDOW)
+         status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+      else
+         return NOT_READY;
+   }
+   if(!status)
+   {
+      status=GetRangeError(Data, RangeData);
+      if(!status)
+         Data->range_mm=RangeData.range_mm;
+      else
+         Data->range_mm=0xFFFFFFFF;
+   }
+   return status;
+}
+ 
+ 
+int VL6180X::GetAlsMeas(OperatingMode operating_mode, MeasureData_t *Data)
+{
+   VL6180x_AlsData_t AlsData;
+   int status, ClrStatus;
+   uint8_t IntStatus;
+    
+   status=VL6180x_AlsGetInterruptStatus(Device, &IntStatus);
+   if(status)
+   {
+      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO");
+   }
+   ClrStatus=VL6180x_AlsClearInterrupt(Device);
+   if(ClrStatus)
+   {
+      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+   }
+   ClrStatus=VL6180x_ClearErrorInterrupt(Device);
+   if(ClrStatus)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+   }
+   if(status)
+      return status;
+   if((operating_mode==als_single_shot_polling)||(operating_mode==als_continuous_polling)||(operating_mode==als_continuous_interrupt))
+   {
+      if(IntStatus==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
+         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+      else
+         return NOT_READY;
+   }
+   else if((operating_mode==als_continuous_polling_low_threshold)||(operating_mode==als_continuous_interrupt_low_threshold))
+   {
+      if(IntStatus==RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD)
+         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+      else
+         return NOT_READY;
+   }
+   else if((operating_mode==als_continuous_polling_high_threshold)||(operating_mode==als_continuous_interrupt_high_threshold))
+   {
+      if(IntStatus==RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
+         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+      else
+         return NOT_READY;
+   }
+   else if((operating_mode==als_continuous_polling_out_of_window)||(operating_mode==als_continuous_interrupt_out_of_window))
+   {
+      if(IntStatus==RES_INT_STAT_GPIO_OUT_OF_WINDOW)
+         status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+      else
+         return NOT_READY;
+   }
+   if(!status)
+   {
+      status=GetAlsError(Data, AlsData);
+      if(!status)
+         Data->lux=AlsData.lux;
+      else
+         Data->lux=0xFFFFFFFF;
+   }
+   return status; 
+}
+ 
+ 
+int VL6180X::GetRangeAlsMeas(MeasureData_t *Data)
+{
+   int status, ClrStatus, r_status, l_status;
+   IntrStatus_t IntStatus;
+   VL6180x_RangeData_t RangeData;
+   VL6180x_AlsData_t AlsData;
+    
+   status=VL6180x_RdByte(Device, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus.val);
+   if(!status)
+   {
+      Data->int_error=IntStatus.status.Error;
+      if(IntStatus.status.Error!=0)
+      {
+         VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
+         status=RANGE_ERROR;
+      } 
+   }
+   else
+   {
+      VL6180x_ErrLog("Failed to read RESULT_INTERRUPT_STATUS_GPIO"); 
+   }
+   ClrStatus=VL6180x_ClearAllInterrupt(Device);
+   if(ClrStatus)
+      VL6180x_ErrLog("VL6180x_ClearAllInterrupt fail");
+   if(status)
+      return status;
+     
+   if(IntStatus.status.Als==RES_INT_STAT_GPIO_NEW_SAMPLE_READY)
+   {
+      r_status=VL6180x_RangeGetMeasurement(Device, &RangeData);
+      l_status=VL6180x_AlsGetMeasurement(Device, &AlsData);
+      if((!r_status)&&(!l_status))
+      {
+         r_status=GetRangeError(Data, RangeData);
+         l_status=GetAlsError(Data, AlsData);
+         if(!r_status) 
+            Data->range_mm=RangeData.range_mm;
+         else
+            Data->range_mm=0xFFFFFFFF;
+         if(!l_status)
+            Data->lux=AlsData.lux;
+         else
+            Data->lux=0xFFFFFFFF;
+         status=r_status|l_status; 
+      }
+      else
+      {
+         status=r_status|l_status;
+      }
+   }
+   else
+      return NOT_READY;
+   return status; 
+}
+ 
+ 
+int VL6180X::StopMeasurement(OperatingMode operating_mode)
+{
+   int status;
+     
+   switch(operating_mode)
+   {
+      case(range_single_shot_polling):
+      case(range_continuous_polling):
+      case(range_continuous_interrupt):
+      case(range_continuous_polling_low_threshold):
+      case(range_continuous_polling_high_threshold):
+      case(range_continuous_polling_out_of_window):
+      case(range_continuous_interrupt_low_threshold):
+      case(range_continuous_interrupt_high_threshold):
+      case(range_continuous_interrupt_out_of_window):
+        return StopRangeMeasurement(operating_mode);
+         
+      case(als_single_shot_polling):
+      case(als_continuous_polling):
+      case(als_continuous_interrupt):
+      case(als_continuous_polling_low_threshold):
+      case(als_continuous_polling_high_threshold):
+      case(als_continuous_polling_out_of_window):
+      case(als_continuous_interrupt_low_threshold):
+      case(als_continuous_interrupt_high_threshold):
+      case(als_continuous_interrupt_out_of_window):
+        return StopAlsMeasurement(operating_mode);
+             
+      case(interleaved_mode_interrupt):
+        status=StopRangeMeasurement(range_continuous_interrupt);
+        if(!status)
+           return StopAlsMeasurement(als_continuous_interrupt);
+        else return status;
+         
+      default:
+        return INVALID_PARAMS;
+   }
+}
+ 
+ 
+int VL6180X::StopRangeMeasurement(OperatingMode operating_mode)
+{
+   int status;
+    
+   if(operating_mode==range_single_shot_polling)
+      status=VL6180x_RangeSetSystemMode(Device, MODE_SINGLESHOT);
+   else
+      status=VL6180x_RangeSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
+   if(status)
+      return status;
+   status=VL6180x_RangeConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_RangeConfigInterrupt fail"\n\r);
+      return status;
+   }
+   status=VL6180x_RangeClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   status=VL6180x_RangeSetRawThresholds(Device, 10, 200);
+   if(status)
+      VL6180x_ErrLog("VL6180x_RangeSetThresholds fail");
+   return status;
+}
+ 
+ 
+int VL6180X::StopAlsMeasurement(OperatingMode operating_mode)
+{
+   int status;
+    
+   if(operating_mode==als_single_shot_polling)
+      status=VL6180x_AlsSetSystemMode(Device, MODE_SINGLESHOT);
+   else
+      status=VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
+   if(status)
+      return status;
+   status=VL6180x_AlsConfigInterrupt(Device, CONFIG_GPIO_INTERRUPT_DISABLED);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail"\n\r);
+      return status;
+   }
+   status=VL6180x_AlsClearInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
+      return status;
+   }
+   status=VL6180x_ClearErrorInterrupt(Device);
+   if(status)
+   {
+      VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
+      return status;
+   }
+   status=VL6180x_AlsSetThresholds(Device, 0x0, 1800);
+   if(status)
+      VL6180x_ErrLog("VL6180x_AlsSetThresholds fail");
+   return status;
+}
+ 
+ 
+ 
+ 
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
\ No newline at end of file
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_class.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,1162 @@
+/**
+ ******************************************************************************
+ * @file    vl6180x_class.h
+ * @author  AST / EST
+ * @version V0.0.1
+ * @date    9-November-2015
+ * @brief   Header file for component VL6180X
+ ******************************************************************************
+ * @attention
+ *
+ * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
+ *
+ * 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 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 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.
+ *
+ ******************************************************************************
+*/
+
+#ifndef __VL6180X_CLASS_H
+#define __VL6180X_CLASS_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "RangeSensor.h"
+#include "LightSensor.h"
+#include "DevI2C.h" 
+//#include "vl6180x_api.h"
+#include "vl6180x_cfg.h"
+#include "vl6180x_def.h"
+#include "vl6180x_types.h"
+#include "vl6180x_platform.h"
+
+
+ 
+/* data struct containing range measure, light measure and type of error provided to the user
+   in case of invalid data range_mm=0xFFFFFFFF and lux=0xFFFFFFFF */	
+typedef struct MeasureData 
+{
+   uint32_t range_mm;
+   uint32_t lux;
+   uint32_t range_error;
+   uint32_t als_error;
+   uint32_t int_error;
+}MeasureData_t;
+
+/* sensor operating modes */ 
+typedef enum
+{
+   range_single_shot_polling=1,
+   als_single_shot_polling,
+   range_continuous_polling,
+   als_continuous_polling,
+   range_continuous_interrupt,
+   als_continuous_interrupt,
+   interleaved_mode_interrupt,
+   range_continuous_polling_low_threshold,
+   range_continuous_polling_high_threshold,
+   range_continuous_polling_out_of_window,
+   als_continuous_polling_low_threshold,
+   als_continuous_polling_high_threshold,
+   als_continuous_polling_out_of_window,
+   range_continuous_interrupt_low_threshold,
+   range_continuous_interrupt_high_threshold,
+   range_continuous_interrupt_out_of_window,
+   als_continuous_interrupt_low_threshold,
+   als_continuous_interrupt_high_threshold,
+   als_continuous_interrupt_out_of_window,
+   range_continuous_als_single_shot,
+   range_single_shot_als_continuous,
+}OperatingMode;
+
+/** default device address */
+#define DEFAULT_DEVICE_ADDRESS		0x29
+
+/* Classes -------------------------------------------------------------------*/
+/** Class representing a VL6180X sensor component
+ */
+class VL6180X : public RangeSensor, public LightSensor
+{
+ public:
+    /** Constructor 1
+     * @param[in] &i2c device I2C to be used for communication
+     * @param[in] &pin Mbed DigitalOut 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] DevAddr device address, 0x29 by default  
+     */
+    VL6180X(DevI2C &i2c, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), LightSensor(), dev_i2c(i2c)
+    {
+       MyDevice.I2cAddr=DevAddr;		 
+       MyDevice.Present=0;
+       MyDevice.Ready=0;
+       Device=&MyDevice;;
+    }  
+    
+   /** Destructor
+    */
+    virtual ~VL6180X(){}     
+    /* warning: VL6180X 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 */		 
+    void VL6180x_On(void)
+    {
+    } 
+
+	/**
+	 * @brief       PowerOff the sensor
+	 * @return      void
+	 */		
+    /* turns off the sensor */
+    void VL6180x_Off(void) 
+    {
+    }
+    
+	/**
+	 * @brief       Initialize the sensor with default values
+	 * @return      0 on Success
+	 */					 
+    int InitSensor(uint8_t NewAddr);
+    
+	/**
+	 * @brief       Start the measure indicated by operating mode
+	 * @param[in]   operating_mode specifies requested measure 
+	 * @param[in]   fptr specifies call back function must be !NULL in case of interrupt measure	 
+	 * @param[in]   low specifies measure low threashold in Lux or in mm according to measure
+	 * @param[in]   high specifies measure high threashold in Lux or in mm according to measure
+	 * @return      0 on Success
+	 */					     
+    int StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), uint16_t low, uint16_t high);
+
+	/**
+	 * @brief       Get results for the measure indicated by operating mode
+	 * @param[in]   operating_mode specifies requested measure results
+	 * @param[out]  Data pointer to the MeasureData_t structure to read data in to
+	 * @return      0 on Success
+	 */					         
+    int GetMeasurement(OperatingMode operating_mode, MeasureData_t *Data);		
+
+	/**
+	 * @brief       Stop the currently running measure indicate by operating_mode
+	 * @param[in]   operating_mode specifies requested measure to stop
+	 * @return      0 on Success
+	 */					             
+    int StopMeasurement(OperatingMode operating_mode);
+     
+ 	/**
+	 * @brief       Interrupt handling func to be called by user after an INT is occourred
+	 * @param[in]   opeating_mode indicating the in progress measure
+	 * @param[out]  Data pointer to the MeasureData_t structure to read data in to
+	 * @return      0 on Success
+	 */					          		
+    int HandleIRQ(OperatingMode operating_mode, MeasureData_t *Data);    
+
+	/**
+	 * @brief       Enable interrupt measure IRQ
+	 * @return      0 on Success
+	 */					     
+    void EnableInterruptMeasureDetectionIRQ(void) 
+    {
+    }
+
+	/**
+	 * @brief       Disable interrupt measure IRQ
+	 * @return      0 on Success
+	 */					          
+    void DisableInterruptMeasureDetectionIRQ(void) 
+    {
+    }
+	/*** End High level API ***/	          
+	
+	/**
+	 * @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 AttachInterruptMeasureDetectionIRQ(void (*fptr)(void))
+    {
+    }
+    
+	/**
+	 * @brief       Check the sensor presence
+	 * @return      1 when device is present
+	 */						
+    unsigned Present()
+    {
+       return Device->Present;
+    }
+		
+    /** Wrapper functions */	
+/** @defgroup api_init Init functions
+ *  @brief    API init functions
+ *  @ingroup api_hl
+ *  @{  
+ */
+/**
+ * @brief Wait for device booted after chip enable (hardware standby)
+ * @par Function Description
+ * After Chip enable Application you can also simply wait at least 1ms to ensure device is ready
+ * @warning After device chip enable (gpio0) de-asserted  user must wait gpio1 to get asserted (hardware standby).
+ * or wait at least 400usec prior to do any low level access or api call .
+ *
+ * This function implements polling for standby but you must ensure 400usec from chip enable passed\n
+ * @warning if device get prepared @a VL6180x_Prepare() re-using these function can hold indefinitely\n
+ *
+ * @param 		void
+ * @return     0 on success
+ */
+    int WaitDeviceBooted()
+    {
+       return VL6180x_WaitDeviceBooted(Device);
+    }
+
+/**
+ *
+ * @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 VL6180x_WaitDeviceBooted()
+ *
+ * @par Function Description
+ * When not used after a fresh device "power up" or reset, it may return @a #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 VL6180x_InitData  multiple time
+ * then it  must ensure proper offset calibration saving and restore on its own
+ * by using @a VL6180x_GetOffsetCalibrationData() on first power up and then @a VL6180x_SetOffsetCalibrationData() all all subsequent init
+ *
+ * @param void
+ * @return     0 on success,  @a #CALIBRATION_WARNING if failed
+ */		
+    virtual int Init() 
+    {
+       return VL6180x_InitData(Device);
+    }
+
+/**
+ * @brief Configure GPIO1 function and set polarity.
+ * @par Function Description
+ * To be used prior to arm single shot measure or start  continuous mode.
+ *
+ * The function uses @a VL6180x_SetupGPIOx() for setting gpio 1.
+ * @warning  changing polarity can generate a spurious interrupt on pins.
+ * It sets an interrupt flags condition that must be cleared to avoid polling hangs. \n
+ * It is safe to run VL6180x_ClearAllInterrupt() just after.
+ *
+ * @param IntFunction   The interrupt functionality to use one of :\n
+ *  @a #GPIOx_SELECT_OFF \n
+ *  @a #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT
+ * @param ActiveHigh  The interrupt line polarity see ::IntrPol_e
+ *      use @a #INTR_POL_LOW (falling edge) or @a #INTR_POL_HIGH (rising edge)
+ * @return 0 on success
+ */		
+    int SetupGPIO1(uint8_t InitFunction, int ActiveHigh)
+    {
+       return VL6180x_SetupGPIO1(Device, InitFunction, ActiveHigh);
+    }
+
+/**
+  * @brief  Prepare device for operation
+  * @par Function Description
+  * Does static initialization and reprogram common default settings \n
+  * Device is prepared for new measure, ready single shot ranging or ALS typical polling operation\n
+  * After prepare user can : \n
+  * @li Call other API function to set other settings\n
+  * @li Configure the interrupt pins, etc... \n
+  * @li Then start ranging or ALS operations in single shot or continuous mode
+  *
+  * @param void
+  * @return      0 on success
+  */		
+    int Prepare()
+    {
+       return VL6180x_Prepare(Device);
+    }
+
+ /**
+ * @brief Start continuous ranging mode
+ *
+ * @details End user should ensure device is in idle state and not already running
+ * @return      0 on success
+ */		
+    int RangeStartContinuousMode()
+    {
+       return VL6180x_RangeStartContinuousMode(Device);
+    }
+
+/**
+ * @brief Start single shot ranging measure
+ *
+ * @details End user should ensure device is in idle state and not already running
+ * @return      0 on success 
+ */		
+    int RangeStartSingleShot()
+    {
+       return VL6180x_RangeStartSingleShot(Device);
+    }
+
+/**
+ * @brief Set maximum convergence time
+ *
+ * @par Function Description
+ * Setting a low convergence time can impact maximal detectable distance.
+ * Refer to VL6180x Datasheet Table 7 : Typical range convergence time.
+ * A typical value for up to x3 scaling is 50 ms
+ *
+ * @param MaxConTime_msec
+ * @return 0 on success. <0 on error. >0 for calibration warning status
+ */		
+    int RangeSetMaxConvergenceTime(uint8_t MaxConTime_msec)
+    {
+       return VL6180x_RangeSetMaxConvergenceTime(Device, MaxConTime_msec);
+    }
+
+/**
+  * @brief Single shot Range measurement in polling mode.
+  *
+  * @par Function Description
+  * Kick off a new single shot range  then wait for ready to retrieve it by polling interrupt status \n
+  * Ranging must be prepared by a first call to  @a VL6180x_Prepare() and it is safer to clear  very first poll call \n
+  * This function reference VL6180x_PollDelay(dev) porting macro/call on each polling loop,
+  * but PollDelay(dev) may never be called if measure in ready on first poll loop \n
+  * Should not be use in continuous mode operation as it will stop it and cause stop/start misbehaviour \n
+  * \n This function clears Range Interrupt status , but not error one. For that uses  @a VL6180x_ClearErrorInterrupt() \n
+  * This range error is not related VL6180x_RangeData_t::errorStatus that refer measure status \n
+  * 
+  * @param pRangeData   Will be populated with the result ranging data @a  VL6180x_RangeData_t
+  * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use
+  *
+  * \sa ::VL6180x_RangeData_t
+  */		
+    int RangePollMeasurement(VL6180x_RangeData_t *pRangeData)
+    {
+       return VL6180x_RangePollMeasurement(Device, pRangeData);
+    }
+
+/**
+ * @brief Check for measure readiness and get it if ready
+ *
+ * @par Function Description
+ * Using this function is an alternative to @a VL6180x_RangePollMeasurement() to avoid polling operation. This is suitable for applications
+ * where host CPU is triggered on a interrupt (not from VL6180X) to perform ranging operation. In this scenario, we assume that the very first ranging
+ * operation is triggered by a call to @a VL6180x_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180x_RangeGetMeasurementIfReady() to
+ * get a distance measure if ready. In case the distance is not ready, host may get it at the next call.\n
+ *
+ * @warning 
+ * This function does not re-start a new measurement : this is up to the host CPU to do it.\n 
+ * This function clears Range Interrupt for measure ready , but not error interrupts. For that, uses  @a VL6180x_ClearErrorInterrupt() \n
+ *
+ * @param pRangeData  Will be populated with the result ranging data if available
+ * @return  0 when measure is ready pRange data is updated (untouched when not ready),  >0 for warning and @a #NOT_READY if measurement not yet ready, <0 for error @a #RANGE_ERROR if device report an error,
+ */		
+    int RangeGetMeasurementIfReady(VL6180x_RangeData_t *pRangeData)
+    {
+       return VL6180x_RangeGetMeasurementIfReady(Device, pRangeData);
+    }
+
+/**
+ * @brief Retrieve range measurements set  from device
+ *
+ * @par Function Description
+ * The measurement is made of range_mm status and error code @a VL6180x_RangeData_t \n
+ * Based on configuration selected extra measures are included.
+ *
+ * @warning should not be used in continuous if wrap around filter is active \n
+ * Does not perform any wait nor check for result availability or validity.
+ *\sa VL6180x_RangeGetResult for "range only" measurement
+ *
+ * @param pRangeData  Pointer to the data structure to fill up
+ * @return            0 on success
+ */		
+    int RangeGetMeasurement(VL6180x_RangeData_t *pRangeData)
+    {
+       return VL6180x_RangeGetMeasurement(Device, pRangeData);
+    }
+
+/**
+ * @brief Get ranging result and only that
+ *
+ * @par Function Description
+ * Unlike @a VL6180x_RangeGetMeasurement() this function only retrieves the range in millimeter \n
+ * It does any required up-scale translation\n
+ * It can be called after success status polling or in interrupt mode \n
+ * @warning these function is not doing wrap around filtering \n
+ * This function doesn't perform any data ready check!
+ *
+ * @param pRange_mm  Pointer to range distance
+ * @return           0 on success
+ */		
+    virtual int GetRange(int32_t *piData)
+    {
+       return VL6180x_RangeGetResult(Device, piData);
+    }
+		
+/**
+ * @brief Configure ranging interrupt reported to application
+ *
+ * @param ConfigGpioInt  Select ranging report\n select one (and only one) of:\n
+ *   @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
+ *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
+ *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
+ *   @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
+ *   @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
+ * @return   0 on success
+ */
+    int RangeConfigInterrupt(uint8_t ConfigGpioInt)
+    {
+       return VL6180x_RangeConfigInterrupt(Device, ConfigGpioInt);
+    }
+
+/**
+ * @brief Return ranging error interrupt status
+ *
+ * @par Function Description
+ * Appropriate Interrupt report must have been selected first by @a VL6180x_RangeConfigInterrupt() or @a  VL6180x_Prepare() \n
+ *
+ * Can be used in polling loop to wait for a given ranging event or in interrupt to read the trigger \n
+ * Events triggers are : \n
+ * @a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
+ * @a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
+ * @a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n (RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD|RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
+ * @a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY \n
+ *
+ * @sa IntrStatus_t
+ * @param pIntStatus Pointer to status variable to update
+ * @return           0 on success
+ */		
+    int RangeGetInterruptStatus(uint8_t *pIntStatus)
+    {
+       return VL6180x_RangeGetInterruptStatus(Device, pIntStatus);
+    }
+
+/**
+ * @brief   Run a single ALS measurement in single shot polling mode
+ *
+ * @par Function Description
+ * Kick off a new single shot ALS then wait new measurement ready to retrieve it ( polling system interrupt status register for als) \n
+ * ALS must be prepared by a first call to @a VL6180x_Prepare() \n
+ * \n Should not be used in continuous or interrupt mode it will break it and create hazard in start/stop \n
+ *
+ * @param dev          The device
+ * @param pAlsData     Als data structure to fill up @a VL6180x_AlsData_t
+ * @return             0 on success
+ */		
+    int AlsPollMeasurement(VL6180x_AlsData_t *pAlsData)
+    {
+       return VL6180x_AlsPollMeasurement(Device, pAlsData);
+    }
+
+/**
+ * @brief  Get actual ALS measurement
+ *
+ * @par Function Description
+ * Can be called after success status polling or in interrupt mode to retrieve ALS measurement from device \n
+ * This function doesn't perform any data ready check !
+ *
+ * @param pAlsData   Pointer to measurement struct @a VL6180x_AlsData_t
+ * @return  0 on success
+ */		
+    int AlsGetMeasurement(VL6180x_AlsData_t *pAlsData)
+    {
+       return VL6180x_AlsGetMeasurement(Device, pAlsData);
+    }
+
+/**
+ * @brief  Configure ALS interrupts provide to application
+ *
+ * @param ConfigGpioInt  Select one (and only one) of : \n
+ *   @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
+ *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
+ *   @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
+ *   @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
+ *   @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
+ * @return               0 on success may return #INVALID_PARAMS for invalid mode
+ */	
+    int AlsConfigInterrupt(uint8_t ConfigGpioInt)
+    {
+       return VL6180x_AlsConfigInterrupt(Device, ConfigGpioInt);
+    }
+
+/**
+ * @brief Set ALS integration period
+ *
+ * @param period_ms  Integration period in msec. Value in between 50 to 100 msec is recommended\n
+ * @return           0 on success
+ */		
+    int AlsSetIntegrationPeriod(uint16_t period_ms)
+    {
+       return VL6180x_AlsSetIntegrationPeriod(Device, period_ms);	
+    }
+
+/**
+ * @brief Set ALS "inter-measurement period"
+ *
+ * @par Function Description
+ * The so call data-sheet "inter measurement period" is actually an extra inter-measurement delay
+ *
+ * @param intermeasurement_period_ms Inter measurement time in milli second\n
+ *        @warning applied value is clipped to 2550 ms\n
+ * @return           0 on success if value is
+ */		
+    int AlsSetInterMeasurementPeriod(uint16_t intermeasurement_period_ms)
+    {
+       return VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
+    }
+
+/**
+ * @brief Set ALS analog gain code
+ *
+ * @par Function Description
+ * ALS gain code value programmed in @a SYSALS_ANALOGUE_GAIN .
+ * @param gain  Gain code see datasheet or AlsGainLookUp for real value. Value is clipped to 7.
+ * @return  0 on success
+ */
+    int AlsSetAnalogueGain(uint8_t gain)
+    {
+       return VL6180x_AlsSetAnalogueGain(Device, gain);
+    }
+
+/**
+ * @brief Set thresholds for ALS continuous mode 
+ * @warning Threshold are raw device value not lux!
+ *
+ * @par Function Description
+ * Basically value programmed in @a SYSALS_THRESH_LOW and @a SYSALS_THRESH_HIGH registers
+ * @param low   ALS low raw threshold for @a SYSALS_THRESH_LOW
+ * @param high  ALS high raw threshold for  @a SYSALS_THRESH_HIGH
+ * @return  0 on success
+ */		
+    int AlsSetThresholds(uint16_t lux_threshold_low, uint16_t lux_threshold_high);
+
+/**
+ * Read ALS interrupt status
+ * @param pIntStatus  Pointer to status
+ * @return            0 on success
+ */
+    int AlsGetInterruptStatus(uint8_t *pIntStatus)
+    {
+       return VL6180x_AlsGetInterruptStatus(Device, pIntStatus);
+    }
+
+/**
+ * @brief Low level ranging and ALS register static settings (you should call @a VL6180x_Prepare() function instead)
+ *
+ * @return 0 on success
+ */
+    int StaticInit()
+    {
+       return VL6180x_StaticInit(Device);
+    }
+
+/**
+ * @brief Wait for device to be ready (before a new ranging command can be issued by application)
+ * @param MaxLoop    Max Number of i2c polling loop see @a #msec_2_i2cloop
+ * @return           0 on success. <0 when fail \n
+ *                   @ref VL6180x_ErrCode_t::TIME_OUT for time out \n
+ *                   @ref VL6180x_ErrCode_t::INVALID_PARAMS if MaxLop<1
+ */		
+    int RangeWaitDeviceReady(int MaxLoop )
+    {
+       return VL6180x_RangeWaitDeviceReady(Device, MaxLoop);
+    }
+
+/**
+ * @brief Program Inter measurement period (used only in continuous mode)
+ *
+ * @par Function Description
+ * When trying to set too long time, it returns #INVALID_PARAMS
+ *
+ * @param InterMeasTime_msec Requires inter-measurement time in msec
+ * @return 0 on success
+ */		
+    int RangeSetInterMeasPeriod(uint32_t  InterMeasTime_msec)
+    {
+       return VL6180x_RangeSetInterMeasPeriod(Device, InterMeasTime_msec);
+    }
+
+/**
+ * @brief Set device ranging scaling factor
+ *
+ * @par Function Description
+ * The ranging scaling factor is applied on the raw distance measured by the device to increase operating ranging at the price of the precision.
+ * Changing the scaling factor when device is not in f/w standby state (free running) is not safe.
+ * It can be source of spurious interrupt, wrongly scaled range etc ...
+ * @warning __This  function doesns't update high/low threshold and other programmed settings linked to scaling factor__.
+ *  To ensure proper operation, threshold and scaling changes should be done following this procedure: \n
+ *  @li Set Group hold  : @a VL6180x_SetGroupParamHold() \n
+ *  @li Get Threshold @a VL6180x_RangeGetThresholds() \n
+ *  @li Change scaling : @a VL6180x_UpscaleSetScaling() \n
+ *  @li Set Threshold : @a VL6180x_RangeSetThresholds() \n
+ *  @li Unset Group Hold : @a VL6180x_SetGroupParamHold()
+ *
+ * @param scaling  Scaling factor to apply (1,2 or 3)
+ * @return          0 on success when up-scale support is not configured it fail for any
+ *                  scaling than the one statically configured.
+ */
+    int UpscaleSetScaling(uint8_t scaling)
+    {
+       return VL6180x_UpscaleSetScaling(Device, scaling);
+    }
+
+/**
+ * @brief Get current ranging scaling factor
+ *
+ * @return    The current scaling factor
+ */				
+    int UpscaleGetScaling()
+    {
+       return VL6180x_UpscaleGetScaling(Device);
+    }
+
+/**
+ * @brief Get the maximal distance for actual scaling
+ * @par Function Description
+ * Do not use prior to @a VL6180x_Prepare() or at least @a VL6180x_InitData()
+ *
+ * Any range value more than the value returned by this function is to be considered as "no target detected"
+ * or "no target in detectable range" \n
+ * @warning The maximal distance depends on the scaling
+ *
+ * @return    The maximal range limit for actual mode and scaling
+ */		
+    uint16_t GetUpperLimit()
+    {
+       return VL6180x_GetUpperLimit(Device);
+    }
+
+/**
+ * @brief Apply low and high ranging thresholds that are considered only in continuous mode
+ *
+ * @par Function Description
+ * This function programs low and high ranging thresholds that are considered in continuous mode : 
+ * interrupt will be raised only when an object is detected at a distance inside this [low:high] range.  
+ * The function takes care of applying current scaling factor if any.\n
+ * To be safe, in continuous operation, thresholds must be changed under "group parameter hold" cover.
+ * Group hold can be activated/deactivated directly in the function or externally (then set 0)
+ * using /a VL6180x_SetGroupParamHold() function.
+ *
+ * @param low      Low threshold in mm
+ * @param high     High threshold in mm
+ * @param SafeHold  Use of group parameters hold to surround threshold programming.
+ * @return  0 On success
+ */		
+    int RangeSetThresholds(uint16_t low, uint16_t high, int SafeHold)
+    {
+       return VL6180x_RangeSetThresholds(Device, low, high, SafeHold);
+    }
+
+/**
+ * @brief  Get scaled high and low threshold from device
+ *
+ * @par Function Description
+ * Due to scaling factor, the returned value may be different from what has been programmed first (precision lost).
+ * For instance VL6180x_RangeSetThresholds(dev,11,22) with scale 3
+ * will read back 9 ((11/3)x3) and 21 ((22/3)x3).
+ *
+ * @param low  scaled low Threshold ptr  can be NULL if not needed
+ * @param high scaled High Threshold ptr can be NULL if not needed
+ * @return 0 on success, return value is undefined if both low and high are NULL
+ * @warning return value is undefined if both low and high are NULL
+ */
+    int RangeGetThresholds(uint16_t *low, uint16_t *high)
+    {
+       return VL6180x_RangeGetThresholds(Device, low, high);
+    }
+
+/**
+ * @brief Set ranging raw thresholds (scaling not considered so not recommended to use it)
+ *
+ * @param low  raw low threshold set to raw register
+ * @param high raw high threshold set to raw  register
+ * @return 0 on success
+ */			
+    int RangeSetRawThresholds(uint8_t low, uint8_t high)
+    {
+       return VL6180x_RangeSetRawThresholds(Device, low, high);
+    }
+
+/**
+ * @brief Set Early Convergence Estimate ratio
+ * @par Function Description
+ * For more information on ECE check datasheet
+ * @warning May return a calibration warning in some use cases
+ *
+ * @param FactorM    ECE factor M in M/D
+ * @param FactorD    ECE factor D in M/D
+ * @return           0 on success. <0 on error. >0 on warning
+ */		
+    int RangeSetEceFactor(uint16_t  FactorM, uint16_t FactorD)
+    {
+       return VL6180x_RangeSetEceFactor(Device, FactorM, FactorD);
+    }
+
+/**
+ * @brief Set Early Convergence Estimate state (See #SYSRANGE_RANGE_CHECK_ENABLES register)
+ * @param enable    State to be set 0=disabled, otherwise enabled
+ * @return          0 on success
+ */		
+    int RangeSetEceState(int enable)
+    {
+       return VL6180x_RangeSetEceState(Device, enable);
+    }
+
+/**
+ * @brief Set activation state of the wrap around filter
+ * @param state New activation state (0=off,  otherwise on)
+ * @return      0 on success
+ */			
+    int FilterSetState(int state)
+    {
+       return VL6180x_FilterSetState(Device, state);
+    }
+
+/**
+ * Get activation state of the wrap around filter
+ * @return     Filter enabled or not, when filter is not supported it always returns 0S
+ */			
+    int FilterGetState()
+    {
+       return VL6180x_FilterGetState(Device);
+    }
+
+/**
+ * @brief Set activation state of  DMax computation
+ * @param state New activation state (0=off,  otherwise on)
+ * @return      0 on success
+ */		
+    int DMaxSetState(int state)
+    {
+       return VL6180x_DMaxSetState(Device, state);
+    }
+
+/**
+ * Get activation state of DMax computation
+ * @return     Filter enabled or not, when filter is not supported it always returns 0S
+ */		
+    int DMaxGetState()
+    {
+       return VL6180x_DMaxGetState(Device);
+    }
+
+/**
+ * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180x_RangeStartSingleShot() or @a VL6180x_RangeStartContinuousMode())
+ *
+ * @par Function Description
+ * When used outside scope of known polling single shot stopped state, \n
+ * user must ensure the device state is "idle" before to issue a new command.
+ *
+ * @param mode  A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start/stop condition (#MODE_START_STOP) \n
+ * @return      0 on success
+ */		
+    int RangeSetSystemMode(uint8_t mode)
+    {
+       return VL6180x_RangeSetSystemMode(Device, mode);
+    }
+
+/** @}  */ 
+
+/** @defgroup api_ll_range_calibration Ranging calibration functions
+ *  @brief    Ranging calibration functions
+ *  @ingroup api_ll
+ *  @{  
+ */
+/**
+ * @brief Get part to part calibration offset
+ *
+ * @par Function Description
+ * Should only be used after a successful call to @a VL6180x_InitData to backup device nvm value
+ *
+ * @return part to part calibration offset from device
+ */		
+    int8_t GetOffsetCalibrationData()
+    {
+       return VL6180x_GetOffsetCalibrationData(Device);
+    }
+
+/**
+ * Set or over-write part to part calibration offset
+ * \sa VL6180x_InitData(), VL6180x_GetOffsetCalibrationData()
+ * @param offset   Offset
+ */		
+    void SetOffsetCalibrationData(int8_t offset)
+    {
+       return VL6180x_SetOffsetCalibrationData(Device, offset);
+    }
+
+/**
+ * @brief Set Cross talk compensation rate
+ *
+ * @par Function Description
+ * It programs register @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE
+ *
+ * @param Rate Compensation rate (9.7 fix point) see datasheet for details
+ * @return     0 on success
+ */		
+    int SetXTalkCompensationRate(FixPoint97_t Rate)
+    {
+       return VL6180x_SetXTalkCompensationRate(Device, Rate);
+    }
+/** @}  */
+
+/** @defgroup api_ll_als ALS functions
+ *  @brief    ALS functions
+ *  @ingroup api_ll
+ *  @{  
+ */
+
+/**
+ * @brief Wait for device to be ready for new als operation or max pollign loop (time out)
+ * @param MaxLoop    Max Number of i2c polling loop see @a #msec_2_i2cloop
+ * @return           0 on success. <0 when @a VL6180x_ErrCode_t::TIME_OUT if timed out
+ */		
+    int AlsWaitDeviceReady(int MaxLoop)
+    {
+       return VL6180x_AlsWaitDeviceReady(Device, MaxLoop);
+    }
+		
+/**
+ * @brief Set ALS system mode and start/stop measure
+ *
+ * @warning When used outside after single shot polling, \n
+ * User must ensure  the device state is ready before issuing a new command (using @a VL6180x_AlsWaitDeviceReady()). \n
+ * Non respect of this, can cause loss of interrupt or device hanging.
+ *
+ * @param mode  A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start condition (#MODE_START_STOP) \n
+ * @return      0 on success
+ */		
+    int AlsSetSystemMode(uint8_t mode)
+    {
+       return VL6180x_AlsSetSystemMode(Device, mode);
+    }
+
+/** @defgroup api_ll_misc Misc functions
+ *  @brief    Misc functions
+ *  @ingroup api_ll
+ *  @{  
+ */
+
+/**
+ * Set Group parameter Hold state
+ *
+ * @par Function Description
+ * Group parameter holds @a #SYSTEM_GROUPED_PARAMETER_HOLD enable safe update (non atomic across multiple measure) by host
+ * \n The critical register group is composed of: \n
+ * #SYSTEM_INTERRUPT_CONFIG_GPIO \n
+ * #SYSRANGE_THRESH_HIGH \n
+ * #SYSRANGE_THRESH_LOW \n
+ * #SYSALS_INTEGRATION_PERIOD \n
+ * #SYSALS_ANALOGUE_GAIN \n
+ * #SYSALS_THRESH_HIGH \n
+ * #SYSALS_THRESH_LOW
+ *
+ *
+ * @param Hold  Group parameter Hold state to be set (on/off)
+ * @return      0 on success
+ */
+    int SetGroupParamHold(int Hold)
+    {
+       return VL6180x_SetGroupParamHold(Device, Hold);
+    }		
+
+/**
+ * @brief Set new device i2c address
+ *
+ * After completion the device will answer to the new address programmed.
+ *
+ * @sa AN4478: Using multiple VL6180X's in a single design
+ * @param NewAddr   The new i2c address (7bit)
+ * @return          0 on success
+ */		
+    int SetI2CAddress(int NewAddr)
+    {
+       int status;
+			
+       status=VL6180x_SetI2CAddress(Device, NewAddr);
+       if(!status)
+          Device->I2cAddr=NewAddr;
+       return status;
+    }
+
+/**
+ * @brief Fully configure gpio 0/1 pin : polarity and functionality
+ *
+ * @param pin          gpio pin 0 or 1
+ * @param IntFunction  Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
+ * @param ActiveHigh   Set active high polarity, or active low see @a ::IntrPol_e
+ * @return             0 on success
+ */		
+    int SetupGPIOx(int pin, uint8_t IntFunction, int ActiveHigh)
+    {
+       return VL6180x_SetupGPIOx(Device, pin, IntFunction, ActiveHigh);
+    }
+
+/**
+ * @brief Set interrupt pin polarity for the given GPIO
+ *
+ * @param pin          Pin 0 or 1
+ * @param active_high  select active high or low polarity using @ref IntrPol_e
+ * @return             0 on success
+ */		
+    int SetGPIOxPolarity(int pin, int active_high)
+    {
+       return VL6180x_SetGPIOxPolarity(Device, pin, active_high);
+    }
+
+/**
+ * Select interrupt functionality for the given GPIO
+ *
+ * @par Function Description
+ * Functionality refer to @a SYSTEM_MODE_GPIO0
+ *
+ * @param pin            Pin to configure 0 or 1 (gpio0 or gpio1)\nNote that gpio0 is chip enable at power up !
+ * @param functionality  Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
+ * @return              0 on success
+ */		 
+    int SetGPIOxFunctionality(int pin, uint8_t functionality)
+    {
+       return VL6180x_SetGPIOxFunctionality(Device, pin, functionality);
+    }
+
+/**
+ * #brief Disable and turn to Hi-Z gpio output pin
+ *
+ * @param pin  The pin number to disable 0 or 1
+ * @return     0 on success
+ */	
+    int DisableGPIOxOut(int pin)
+    {
+       return VL6180x_DisableGPIOxOut(Device, pin);
+    }
+
+/** @}  */
+
+/** @defgroup api_ll_intr Interrupts management functions
+ *  @brief    Interrupts management functions
+ *  @ingroup api_ll
+ *  @{  
+ */
+
+/**
+ * @brief     Get all interrupts cause
+ *
+ * @param status Ptr to interrupt status. You can use @a IntrStatus_t::val
+ * @return 0 on success
+ */		
+    int GetInterruptStatus(uint8_t *status)
+    {
+       return VL6180x_GetInterruptStatus(Device, status);
+    }
+
+/**
+ * @brief Clear given system interrupt condition
+ *
+ * @par Function Description
+ * Clear given interrupt cause by writing into register #SYSTEM_INTERRUPT_CLEAR register.
+ * @param dev       The device 
+ * @param IntClear  Which interrupt source to clear. Use any combinations of #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR.
+ * @return  0       On success
+ */		
+    int ClearInterrupt(uint8_t IntClear)
+    {
+       return VL6180x_ClearInterrupt(Device, IntClear );
+    }
+
+/**
+ * @brief Clear error interrupt
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+ #define VL6180x_ClearErrorInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR)
+
+/**
+ * @brief Clear All interrupt causes (als+range+error)
+ *
+ * @param dev    The device
+ * @return  0    On success
+ */
+#define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
+	
+/** @}  */
+
+/**
+ * @brief Get the ALS (light in Lux) level
+ *
+ * @par Function Description
+ * Get the ALS (light in Lux) level 
+ * @param *piData The pointer to variable to write in the measure in Lux
+ * @return  0       On success
+ */				
+    virtual int GetLight(uint32_t *piData)
+    {
+       return VL6180x_AlsGetLux(Device, piData);
+    }
+
+/**
+ * @brief Start the ALS (light) measure in continous mode
+ *
+ * @par Function Description
+ * Start the ALS (light) measure in continous mode
+ * @return  0       On success
+ */						
+    int AlsStartContinuousMode()
+    {
+       return VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_CONTINUOUS);
+    }
+
+/**
+ * @brief Start the ALS (light) measure in single shot mode
+ *
+ * @par Function Description
+ * Start the ALS (light) measure in single shot mode
+ * @return  0       On success
+ */						    
+    int AlsStartSingleShot()
+    {
+       return VL6180x_AlsSetSystemMode(Device, MODE_START_STOP|MODE_SINGLESHOT);
+    }
+		
+ private:		
+    /* api.h functions */
+    int VL6180x_WaitDeviceBooted(VL6180xDev_t dev);
+    int VL6180x_InitData(VL6180xDev_t dev );
+    int VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh);
+    int VL6180x_Prepare(VL6180xDev_t dev);
+    int VL6180x_RangeStartContinuousMode(VL6180xDev_t dev);
+    int VL6180x_RangeStartSingleShot(VL6180xDev_t dev);
+    int VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t  MaxConTime_msec);
+    int VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
+    int VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
+    int VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
+    int VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm);
+    int VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt);
+    int VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus);
+    int VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
+    int VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
+    int VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt);
+    int VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms);
+    int VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev,  uint16_t intermeasurement_period_ms);
+    int VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain);
+    int VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high);
+    int VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus);
+    int VL6180x_StaticInit(VL6180xDev_t dev);
+    int VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop );
+    int VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t  InterMeasTime_msec);
+    int VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling);
+    int VL6180x_UpscaleGetScaling(VL6180xDev_t dev);
+    uint16_t VL6180x_GetUpperLimit(VL6180xDev_t dev);
+    int VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int SafeHold);
+    int VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high);
+    int VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high);
+    int VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t  FactorM, uint16_t FactorD);
+    int VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable );
+    int VL6180x_FilterSetState(VL6180xDev_t dev, int state);
+    int VL6180x_FilterGetState(VL6180xDev_t dev);
+    int VL6180x_DMaxSetState(VL6180xDev_t dev, int state);
+    int VL6180x_DMaxGetState(VL6180xDev_t dev);
+    int VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t mode);
+    int8_t VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev);
+    void VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset);
+    int VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate);
+    int VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop );
+    int VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode); 
+    int VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold);
+    int VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddr);
+    int VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin, uint8_t IntFunction, int ActiveHigh);
+    int VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high);
+    int VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality);
+    int VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin);
+    int VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *status);
+    int VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear );
+		
+    /*  Other functions defined in api.c */
+    int VL6180x_RangeStaticInit(VL6180xDev_t dev); 
+    int VL6180x_UpscaleRegInit(VL6180xDev_t dev);
+    int VL6180x_UpscaleStaticInit(VL6180xDev_t dev); 
+    int VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux);
+    int _UpscaleInitPatch0(VL6180xDev_t dev); 
+    int VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int * Ready);
+    int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev);
+    int32_t _GetAveTotalTime(VL6180xDev_t dev); 
+    int32_t _filter_Start(VL6180xDev_t dev, uint16_t m_trueRange_mm, uint16_t m_rawRange_mm, uint32_t m_rtnSignalRate, uint32_t m_rtnAmbientRate, uint16_t errorCode);
+    int _filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
+    int _GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData); 
+    int _DMax_InitData(VL6180xDev_t dev);
+		
+    /* Read function of the ID device */
+    virtual int ReadID();
+    
+    /* Write and read functions from I2C */
+    int VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data);
+    int VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data);
+    int VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data);
+    int VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data);
+    int VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data);
+    int VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data);
+    int VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData);
+    int VL6180x_I2CWrite(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t *pBuffer, uint16_t NumByteToWrite);
+    int VL6180x_I2CRead(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t *pBuffer, uint16_t NumByteToRead);
+		
+		
+    int IsPresent()
+    {
+       int status;
+			
+       status=ReadID();
+       if(status)
+          VL6180x_ErrLog("Failed to read ID device. Device not present!\n\r");
+       return status;
+    }	
+    int StopRangeMeasurement(OperatingMode operating_mode);
+    int StopAlsMeasurement(OperatingMode operating_mode);
+    int GetRangeMeas(OperatingMode operating_mode, MeasureData_t *Data);	
+    int GetAlsMeas(OperatingMode operating_mode, MeasureData_t *Data);
+    int GetRangeAlsMeas(MeasureData_t *Data);
+    int RangeSetLowThreshold(uint16_t threshold);
+    int RangeSetHighThreshold(uint16_t threshold);
+    int AlsSetLowThreshold(uint16_t threshold);	
+    int AlsSetHighThreshold(uint16_t threshold);
+    int GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData);
+    int GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData);
+    int RangeMeasPollSingleShot();
+    int AlsMeasPollSingleShot();		
+    int RangeMeasPollContinuousMode();	
+    int AlsMeasPollContinuousMode();
+    int AlsGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData);
+    int RangeMeasIntContinuousMode(void (*fptr)(void));
+    int AlsMeasIntContinuousMode(void (*fptr)(void));
+    int InterleavedMode(void (*fptr)(void));
+    int StartInterleavedMode();
+    int AlsGetThresholds(VL6180xDev_t dev, lux_t *low, lux_t *high);
+
+		
+    /* IO Device */
+    DevI2C &dev_i2c;
+    /* Device data */
+    MyVL6180Dev_t MyDevice;
+    VL6180xDev_t Device;  
+};
+
+#endif // __VL6180X_CLASS_H
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_def.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,743 @@
+/*******************************************************************************
+Copyright © 2014, 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.
+********************************************************************************/
+
+/*
+ * $Date: 2015-05-13 14:12:05 +0200 (Wed, 13 May 2015) $
+ * $Revision: 2290 $
+ */
+
+/**
+ * @file VL6180x_def.h
+ *
+ * @brief Type definitions for vl6180x api.
+ *
+ */
+
+
+#ifndef _VL6180x_DEF
+#define _VL6180x_DEF
+
+/** API major version */
+#define VL6180x_API_REV_MAJOR   3
+/** API minor version */
+#define VL6180x_API_REV_MINOR   0
+/** API sub version */
+#define VL6180x_API_REV_SUB     1
+
+#define VL6180X_STR_HELPER(x) #x
+#define VL6180X_STR(x) VL6180X_STR_HELPER(x)
+
+#include "vl6180x_cfg.h"
+#include "vl6180x_types.h"
+
+/*
+ * check configuration macro raise error or warning and suggest a default value
+ */
+
+#ifndef VL6180x_UPSCALE_SUPPORT
+#error "VL6180x_UPSCALE_SUPPORT not defined"
+/* TODO you must define value for  upscale support in your vl6180x_cfg.h  */
+#endif
+
+#ifndef VL6180x_ALS_SUPPORT
+#error "VL6180x_ALS_SUPPORT not defined"
+/* TODO you must define VL6180x_ALS_SUPPORT  with a value in your vl6180x_cfg.h  set to 0 do disable*/
+#endif
+
+#ifndef VL6180x_HAVE_DMAX_RANGING
+#error "VL6180x_HAVE_DMAX_RANGING not defined"
+/* TODO you may remove or comment these #error and keep the default below  or update your vl6180x_cfg.h .h file */
+/**
+ * force VL6180x_HAVE_DMAX_RANGING to not supported when not part of cfg file
+ */
+#define VL6180x_HAVE_DMAX_RANGING   0
+#endif
+
+#ifndef VL6180x_EXTENDED_RANGE
+#define VL6180x_EXTENDED_RANGE   0
+#endif
+
+#ifndef  VL6180x_WRAP_AROUND_FILTER_SUPPORT
+#error "VL6180x_WRAP_AROUND_FILTER_SUPPORT not defined ?"
+/* TODO you may remove or comment these #error and keep the default below  or update vl6180x_cfg.h file */
+/**
+ * force VL6180x_WRAP_AROUND_FILTER_SUPPORT to not supported when not part of cfg file
+ */
+#define VL6180x_WRAP_AROUND_FILTER_SUPPORT 0
+#endif
+
+
+
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/** Maximal buffer size ever use in i2c */
+#define VL6180x_MAX_I2C_XFER_SIZE   8 /* At present time it 6 byte max but that can change */
+
+#if VL6180x_UPSCALE_SUPPORT < 0
+/**
+ * @def VL6180x_HAVE_UPSCALE_DATA
+ * @brief  is defined if device data structure has data so when user configurable up-scale is active
+ */
+#define VL6180x_HAVE_UPSCALE_DATA /* have data only for user configurable up-scale config */
+#endif
+
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT
+/**
+ * @def VL6180x_HAVE_WRAP_AROUND_DATA
+ * @brief  is defined if device data structure has filter data so when active in cfg file
+ */
+#define  VL6180x_HAVE_WRAP_AROUND_DATA
+#endif
+
+#if VL6180x_ALS_SUPPORT != 0
+/**
+ * @def  VL6180x_HAVE_ALS_DATA
+ * @brief is defined when als data are include in device data structure so when als suport if configured
+ */
+#define VL6180x_HAVE_ALS_DATA
+#endif
+
+
+#if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
+	#define	VL6180x_HAVE_RATE_DATA
+#endif
+
+/** Error and warning code returned by API
+ *
+ * negative value are true error mostly fatal\n
+ * positive value  are warning most of time it's ok to continue\n
+ */
+enum VL6180x_ErrCode_t{
+	API_NO_ERROR        = 0,
+    CALIBRATION_WARNING = 1,  /*!< warning invalid calibration data may be in used \a  VL6180x_InitData() \a VL6180x_GetOffsetCalibrationData \a VL6180x_SetOffsetCalibrationData*/
+    MIN_CLIPED          = 2,  /*!< warning parameter passed was clipped to min before to be applied */
+    NOT_GUARANTEED      = 3,  /*!< Correct operation is not guaranteed typically using extended ranging on vl6180x */
+    NOT_READY           = 4,  /*!< the data is not ready retry */
+
+    API_ERROR      = -1,    /*!< Unqualified error */
+    INVALID_PARAMS = -2,    /*!< parameter passed is invalid or out of range */
+    NOT_SUPPORTED  = -3,    /*!< function is not supported in current mode or configuration */
+    RANGE_ERROR    = -4,    /*!< device report a ranging error interrupt status */
+    TIME_OUT       = -5,    /*!< aborted due to time out */
+};
+
+/**
+ * Filtered result data structure  range data is to be used
+ */
+typedef struct RangeFilterResult_tag {
+    uint16_t range_mm;      /*!< Filtered ranging value */
+    uint16_t rawRange_mm;   /*!< raw range value (scaled) */
+} RangeFilterResult_t;
+
+/**
+ * "small" unsigned data type used in filter
+ *
+ * if data space saving is not a concern it can be change to platform native unsigned int
+ */
+typedef uint8_t  FilterType1_t;
+
+/**
+ * @def FILTER_NBOF_SAMPLES
+ * @brief sample history len used for wrap around filtering
+ */
+#define FILTER_NBOF_SAMPLES             10
+/**
+ * Wrap around filter internal data
+ */
+struct FilterData_t {
+    uint32_t MeasurementIndex;                      /*!< current measurement index */
+    uint16_t LastTrueRange[FILTER_NBOF_SAMPLES];    /*!< filtered/corrected  distance history */
+    uint32_t LastReturnRates[FILTER_NBOF_SAMPLES];  /*!< Return rate history */
+    uint16_t StdFilteredReads;                      /*!< internal use */
+    FilterType1_t Default_ZeroVal;                  /*!< internal use */
+    FilterType1_t Default_VAVGVal;                  /*!< internal use */
+    FilterType1_t NoDelay_ZeroVal;                  /*!< internal use */
+    FilterType1_t NoDelay_VAVGVal;                  /*!< internal use */
+    FilterType1_t Previous_VAVGDiff;                /*!< internal use */
+};
+
+#if  VL6180x_HAVE_DMAX_RANGING
+typedef int32_t DMaxFix_t;
+struct DMaxData_t {
+    uint32_t ambTuningWindowFactor_K; /*!<  internal algo tuning (*1000) */
+
+    DMaxFix_t retSignalAt400mm;  /*!< intermediate dmax computation value caching @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE and private reg 0x02A */
+    //int32_t RegB8;              /*!< register 0xB8 cached to speed reduce i2c traffic for dmax computation */
+    /* place all word data below to optimize struct packing */
+    //int32_t minSignalNeeded;    /*!< optimized computation intermediate base on register cached value */
+    int32_t snrLimit_K;         /*!< cached and optimized computation intermediate from  @a #SYSRANGE_MAX_AMBIENT_LEVEL_MULT */
+    uint16_t ClipSnrLimit;      /*!< Max value for snr limit */
+    /* place all byte data below to optimize packing */
+    //uint8_t MaxConvTime;        /*!< cached max convergence time @a #SYSRANGE_MAX_CONVERGENCE_TIME*/
+};
+#endif
+
+/**
+ * @struct VL6180xDevData_t
+ *
+ * @brief Per VL6180x device St private data structure \n
+ * End user should never access any of these field directly
+ *
+ * These must never access directly but only via VL6180xDev/SetData(dev, field) macro
+ */
+struct VL6180xDevData_t {
+
+    uint32_t Part2PartAmbNVM;  /*!< backed up NVM value */
+    uint32_t XTalkCompRate_KCps; /*! Cached XTlak Compensation Rate */
+
+    uint16_t EceFactorM;        /*!< Ece Factor M numerator  */
+    uint16_t EceFactorD;        /*!< Ece Factor D denominator*/
+
+#ifdef VL6180x_HAVE_ALS_DATA
+    uint16_t IntegrationPeriod; /*!< cached als Integration period avoid slow read from device at each measure */
+    uint16_t AlsGainCode;       /*!< cached Als gain avoid slow read from device at each measure */
+    uint16_t AlsScaler;         /*!< cached Als scaler avoid slow read from device at each measure */
+#endif
+
+#ifdef VL6180x_HAVE_UPSCALE_DATA
+    uint8_t UpscaleFactor;      /*!<  up-scaling factor*/
+#endif
+
+#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
+    uint8_t WrapAroundFilterActive; /*!< Filter on/off */
+    struct FilterData_t FilterData; /*!< Filter internal data state history ... */
+#endif
+
+#if  VL6180x_HAVE_DMAX_RANGING
+    struct DMaxData_t DMaxData;
+    uint8_t DMaxEnable;
+#endif
+    int8_t  Part2PartOffsetNVM;     /*!< backed up NVM value */
+};
+
+#if VL6180x_SINGLE_DEVICE_DRIVER
+extern  struct VL6180xDevData_t SingleVL6180xDevData;
+#define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field)
+/* is also used as direct accessor like VL6180xDevDataGet(dev, x)++*/
+#define VL6180xDevDataSet(dev, field, data) (SingleVL6180xDevData.field)=(data)
+#endif
+
+
+/**
+ * @struct VL6180x_RangeData_t
+ * @brief Range and any optional measurement data.
+ */
+typedef struct {
+    int32_t range_mm;          /*!< range distance in mm. */
+    int32_t signalRate_mcps;   /*!< signal rate (MCPS)\n these is a 9.7 fix point value, which is effectively a measure of target reflectance.*/
+    uint32_t errorStatus;      /*!< Error status of the current measurement. \n
+                                  see @a ::RangeError_u @a VL6180x_GetRangeStatusErrString() */
+
+
+#ifdef VL6180x_HAVE_RATE_DATA
+    uint32_t rtnAmbRate;    /*!< Return Ambient rate in KCount per sec related to \a RESULT_RANGE_RETURN_AMB_COUNT */
+    uint32_t rtnRate;       /*!< Return rate in KCount per sec  related to \a RESULT_RANGE_RETURN_SIGNAL_COUNT  */
+    uint32_t rtnConvTime;   /*!< Return Convergence time \a RESULT_RANGE_RETURN_CONV_TIME */
+    uint32_t refConvTime;   /*!< Reference convergence time \a RESULT_RANGE_REFERENCE_CONV_TIME */
+#endif
+
+
+#if  VL6180x_HAVE_DMAX_RANGING
+    uint32_t DMax;              /*!< DMax  when applicable */
+#endif
+
+#ifdef  VL6180x_HAVE_WRAP_AROUND_DATA
+    RangeFilterResult_t FilteredData; /*!< Filter result main range_mm is updated */
+#endif
+}VL6180x_RangeData_t;
+
+
+/** use where fix point 9.7 bit values are expected
+ *
+ * given a floating point value f it's .7 bit point is (int)(f*(1<<7))*/
+typedef uint16_t FixPoint97_t;
+
+/** lux data type */
+typedef uint32_t lux_t;
+
+/**
+ * @brief This data type defines als  measurement data.
+ */
+typedef struct VL6180x_AlsData_st{
+    lux_t lux;                 /**< Light measurement (Lux) */
+    uint32_t errorStatus;      /**< Error status of the current measurement. \n
+     * No Error := 0. \n
+     * Refer to product sheets for other error codes. */
+}VL6180x_AlsData_t;
+
+/**
+ * @brief Range status Error code
+ *
+ * @a VL6180x_GetRangeStatusErrString() if configured ( @a #VL6180x_RANGE_STATUS_ERRSTRING )
+ * related to register @a #RESULT_RANGE_STATUS and additional post processing
+ */
+typedef enum {
+    NoError_=0,                /*!< 0  0b0000 NoError  */
+    VCSEL_Continuity_Test,     /*!< 1  0b0001 VCSEL_Continuity_Test */
+    VCSEL_Watchdog_Test,       /*!< 2  0b0010 VCSEL_Watchdog_Test */
+    VCSEL_Watchdog,            /*!< 3  0b0011 VCSEL_Watchdog */
+    PLL1_Lock,                 /*!< 4  0b0100 PLL1_Lock */
+    PLL2_Lock,                 /*!< 5  0b0101 PLL2_Lock */
+    Early_Convergence_Estimate,/*!< 6  0b0110 Early_Convergence_Estimate */
+    Max_Convergence,           /*!< 7  0b0111 Max_Convergence */
+    No_Target_Ignore,          /*!< 8  0b1000 No_Target_Ignore */
+    Not_used_9,                /*!< 9  0b1001 Not_used */
+    Not_used_10,               /*!< 10 0b1010 Not_used_ */
+    Max_Signal_To_Noise_Ratio, /*!< 11 0b1011 Max_Signal_To_Noise_Ratio*/
+    Raw_Ranging_Algo_Underflow,/*!< 12 0b1100 Raw_Ranging_Algo_Underflow*/
+    Raw_Ranging_Algo_Overflow, /*!< 13 0b1101 Raw_Ranging_Algo_Overflow */
+    Ranging_Algo_Underflow,    /*!< 14 0b1110 Ranging_Algo_Underflow */
+    Ranging_Algo_Overflow,     /*!< 15 0b1111 Ranging_Algo_Overflow */
+
+    /* code below are addition for API/software side they are not hardware*/
+    RangingFiltered =0x10,     /*!< 16 0b10000 filtered by post processing*/
+
+} RangeError_u;
+
+
+/** @defgroup device_regdef Device registers & masks definitions
+ *  @brief    Device registers and masks definitions
+ */
+
+ 
+/** @ingroup device_regdef
+ * @{*/
+
+/**
+ * The device model ID
+ */
+#define IDENTIFICATION_MODEL_ID                 0x000
+/**
+ * Revision identifier of the Device for major change.
+ */
+#define IDENTIFICATION_MODULE_REV_MAJOR         0x003
+/**
+ * Revision identifier of the Device for minor change.
+ */
+#define IDENTIFICATION_MODULE_REV_MINOR         0x004
+
+
+/**
+ * @def SYSTEM_MODE_GPIO0
+ * @brief Configures polarity and select which function gpio 0 serves.
+ *  Gpio0 is chip enable at power up ! Be aware of all h/w implication of turning it to output.
+ *  Same definition as #SYSTEM_MODE_GPIO1
+ * @ingroup device_regdef
+ */
+#define SYSTEM_MODE_GPIO0                       0x010
+/**
+ * @def SYSTEM_MODE_GPIO1
+ * @brief Configures polarity and select what als or ranging functionality gpio pin serves.
+ *
+ * Function can be #GPIOx_SELECT_OFF  #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT.\n
+ * Same definition apply to register GPIO0 that is used as chip enable at power up.
+ * @ingroup device_regdef
+ */
+#define SYSTEM_MODE_GPIO1                       0x011
+    /** gpio pad POLARITY mask in #SYSTEM_MODE_GPIO1 (and/or 0) write  1  to set active high polarity (positive edge) */
+    #define GPIOx_POLARITY_SELECT_MASK              0x20
+    /** gpio pad Function select shift in #SYSTEM_MODE_GPIO1 or 0 */
+    #define GPIOx_FUNCTIONALITY_SELECT_SHIFT          1
+    /** gpio pad Function select mask in #SYSTEM_MODE_GPIO1 or 0 */
+    #define GPIOx_FUNCTIONALITY_SELECT_MASK          (0xF<<GPIOx_FUNCTIONALITY_SELECT_SHIFT)
+    /** select no interrupt in #SYSTEM_MODE_GPIO1 pad is put in  Hi-Z*/
+    #define GPIOx_SELECT_OFF                        0x00
+    /** select gpiox as interrupt output in  #SYSTEM_MODE_GPIO1 */
+    #define GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT      0x08
+    /** select range as source for interrupt on in #SYSTEM_MODE_GPIO1 */
+    #define GPIOx_MODE_SELECT_RANGING               0x00
+    /** select als as source for interrupt on in #SYSTEM_MODE_GPIO1 */
+    #define GPIOx_MODE_SELECT_ALS                   0x01
+
+
+/**
+ * @def SYSTEM_INTERRUPT_CONFIG_GPIO
+ *
+ * @brief   Configure Als and Ranging interrupt reporting
+ *
+ * Possible values for Range and ALS are\n
+ *
+ * #CONFIG_GPIO_INTERRUPT_DISABLED\n
+ * #CONFIG_GPIO_INTERRUPT_LEVEL_LOW\n
+ * #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH\n
+ * #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW\n
+ * #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY\n
+ * Apply respective rang/als shift and mask \n
+ *  #CONFIG_GPIO_RANGE_SHIFT and full reg mask #CONFIG_GPIO_RANGE_MASK\n
+ *  #CONFIG_GPIO_ALS_SHIFT and full reg mask #CONFIG_GPIO_ALS_MASK\n
+ *
+ * \sa GPIO use for interrupt #SYSTEM_MODE_GPIO0 or #SYSTEM_MODE_GPIO1\n
+ * @ingroup device_regdef
+ */
+#define SYSTEM_INTERRUPT_CONFIG_GPIO           0x014
+    /** RANGE bits shift in #SYSTEM_INTERRUPT_CONFIG_GPIO */
+    #define CONFIG_GPIO_RANGE_SHIFT            0
+    /** RANGE bits mask in #SYSTEM_INTERRUPT_CONFIG_GPIO  (unshifted)*/
+    #define CONFIG_GPIO_RANGE_MASK             (0x7<<CONFIG_GPIO_RANGE_SHIFT)
+    /** ALS bits shift in #SYSTEM_INTERRUPT_CONFIG_GPIO */
+    #define CONFIG_GPIO_ALS_SHIFT              3
+    /** ALS bits mask in #SYSTEM_INTERRUPT_CONFIG_GPIO  (unshifted)*/
+    #define CONFIG_GPIO_ALS_MASK               (0x7<<CONFIG_GPIO_ALS_SHIFT)
+    /** interrupt is disabled */
+    #define CONFIG_GPIO_INTERRUPT_DISABLED         0x00
+    /** trigger when value < low threshold */
+    #define CONFIG_GPIO_INTERRUPT_LEVEL_LOW        0x01
+    /** trigger when value < low threshold */
+    #define CONFIG_GPIO_INTERRUPT_LEVEL_HIGH       0x02
+    /** trigger when outside range defined by high low threshold */
+    #define CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW    0x03
+    /** trigger when new sample are ready */
+    #define CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY 0x04
+
+/**
+ *  @def SYSTEM_INTERRUPT_CLEAR
+ *  @brief Writing to this register will clear interrupt source
+ *
+ *  Use or combination of any #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR
+ *  @ingroup device_regdef
+ */
+#define SYSTEM_INTERRUPT_CLEAR                0x015
+    /** clear ranging interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
+    #define INTERRUPT_CLEAR_RANGING                0x01
+    /** clear als interrupt  in write to #SYSTEM_INTERRUPT_CLEAR */
+    #define INTERRUPT_CLEAR_ALS                    0x02
+    /** clear error interrupt in write to #SYSTEM_INTERRUPT_CLEAR */
+    #define INTERRUPT_CLEAR_ERROR                  0x04
+
+/** After power up or reset this register will start reading 1 when device is ready */
+#define SYSTEM_FRESH_OUT_OF_RESET             0x016
+
+/**
+ * @def SYSTEM_GROUPED_PARAMETER_HOLD
+ * @brief Writing 1/0 activate/deactivate safe host update of multiple register in critical group \n
+ *        rather use \a VL6180x_SetGroupParamHold()
+ *
+ * The critical register group is made of: \n
+ * #SYSTEM_INTERRUPT_CONFIG_GPIO \n
+ * #SYSRANGE_THRESH_HIGH \n
+ * #SYSRANGE_THRESH_LOW \n
+ * #SYSALS_INTEGRATION_PERIOD \n
+ * #SYSALS_ANALOGUE_GAIN \n
+ * #SYSALS_THRESH_HIGH \n
+ * #SYSALS_THRESH_LOW
+ * @ingroup device_regdef
+ */
+#define SYSTEM_GROUPED_PARAMETER_HOLD         0x017
+
+
+/**
+ * @def SYSRANGE_START
+ * @brief Start/stop and set operating range mode
+ *
+ * Write Combination of #MODE_START_STOP  and #MODE_CONTINUOUS to select and start desired operation.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_START                        0x018
+    /** mask existing bit in #SYSRANGE_START*/
+    #define MODE_MASK          0x03
+    /** bit 0 in #SYSRANGE_START write 1 toggle state in continuous mode and arm next shot in single shot mode */
+    #define MODE_START_STOP    0x01
+    /** bit 1 write 1 in #SYSRANGE_START set continuous operation mode */
+    #define MODE_CONTINUOUS    0x02
+    /** bit 1 write 0 in #SYSRANGE_START set single shot mode */
+    #define MODE_SINGLESHOT    0x00
+
+/**
+ * @def SYSRANGE_THRESH_HIGH
+ * High level range  threshold (must be scaled)
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_THRESH_HIGH                  0x019
+
+/**
+ * @def SYSRANGE_THRESH_LOW
+ * Low level range  threshold (must be scaled)
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_THRESH_LOW                   0x01A
+
+/**
+ * @def SYSRANGE_INTERMEASUREMENT_PERIOD
+ * @brief Continuous mode intermeasurement delay \a VL6180x_RangeSetInterMeasPeriod()
+ *
+ * Time delay between measurements in Ranging continuous mode.\n
+ * Range 0-254 (0 = 10ms).\n Step size = 10ms.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_INTERMEASUREMENT_PERIOD      0x01B
+
+/**
+ * @brief Maximum time to run measurement in Ranging modes.
+ * Range 1 - 63 ms (1 code = 1 ms);
+ *
+ * Measurement aborted when limit reached to aid power  reduction.\
+ * For example, 0x01 = 1ms, 0x0a = 10ms.\
+ * Note: Effective max_convergence_time depends on readout_averaging_sample_period setting.
+ *
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_MAX_CONVERGENCE_TIME         0x01C
+/**@brief Cross talk compensation rate
+ * @warning  never write register directly use @a VL6180x_SetXTalkCompensationRate()
+ * refer to manual for calibration procedure and computation
+ * @ingroup device_regdef
+ */
+#define SYSRANGE_CROSSTALK_COMPENSATION_RATE  0x01E
+/**
+ * @brief Minimum range value in mm to qualify for crosstalk compensation
+ */
+#define SYSRANGE_CROSSTALK_VALID_HEIGHT       0x021
+#define SYSRANGE_EARLY_CONVERGENCE_ESTIMATE   0x022
+#define SYSRANGE_PART_TO_PART_RANGE_OFFSET    0x024
+#define SYSRANGE_RANGE_IGNORE_VALID_HEIGHT    0x025
+#define SYSRANGE_RANGE_IGNORE_THRESHOLD       0x026
+#define SYSRANGE_EMITTER_BLOCK_THRESHOLD      0x028
+#define SYSRANGE_MAX_AMBIENT_LEVEL_THRESH     0x02A
+#define SYSRANGE_MAX_AMBIENT_LEVEL_MULT       0x02C
+/** @brief  various Enable check enabel register
+ *  @a VL6180x_RangeSetEceState()
+ */
+#define SYSRANGE_RANGE_CHECK_ENABLES          0x02D
+    #define RANGE_CHECK_ECE_ENABLE_MASK      0x01
+    #define RANGE_CHECK_RANGE_ENABLE_MASK    0x02
+    #define RANGE_CHECK_SNR_ENABLKE          0x10
+
+#define SYSRANGE_VHV_RECALIBRATE              0x02E
+#define SYSRANGE_VHV_REPEAT_RATE              0x031
+
+/**
+ * @def SYSALS_START
+ * @brief Start/stop and set operating als mode
+ *
+ * same bit definition as range \a #SYSRANGE_START \n
+ */
+#define SYSALS_START                          0x038
+
+/** ALS low Threshold high */
+#define SYSALS_THRESH_HIGH                    0x03A
+/** ALS low Threshold low */
+#define SYSALS_THRESH_LOW                     0x03C
+/** ALS intermeasurement period */
+#define SYSALS_INTERMEASUREMENT_PERIOD        0x03E
+/** 
+ * @warning or value with 0x40 when writing to these register*/
+#define SYSALS_ANALOGUE_GAIN                  0x03F
+/** ALS integration period */
+#define SYSALS_INTEGRATION_PERIOD             0x040
+
+/**
+ * @brief Result range status
+ *
+ *  Hold the various range interrupt flags and error Specific error codes
+ */
+#define RESULT_RANGE_STATUS                   0x04D
+    /** Device ready for new command bit 0*/
+    #define RANGE_DEVICE_READY_MASK       0x01
+    /** mask for error status covers bits [7:4]  in #RESULT_RANGE_STATUS @a ::RangeError_u */
+    #define RANGE_ERROR_CODE_MASK         0xF0 /* */
+    /** range error bit position in #RESULT_RANGE_STATUS */
+    #define RANGE_ERROR_CODE_SHIFT        4
+
+/**
+ * @def RESULT_ALS_STATUS
+ * @brief Result  als status \n
+ *  Hold the various als interrupt flags and Specific error codes
+ */
+#define RESULT_ALS_STATUS                     0x4E
+    /** Device ready for new command bit 0*/
+   #define ALS_DEVICE_READY_MASK       0x01
+
+/**
+ * @def RESULT_ALS_VAL
+ * @brief 16 Bit ALS count output value.
+ *
+ * Lux value depends on Gain and integration settings and calibrated lux/count setting
+ * \a VL6180x_AlsGetLux() \a VL6180x_AlsGetMeasurement()
+ */
+#define RESULT_ALS_VAL                        0x50
+
+/**
+ * @def FW_ALS_RESULT_SCALER
+ * @brief Als scaler register  Bits [3:0] analogue gain 1 to 16x
+ * these register content is cached by API in \a VL6180xDevData_t::AlsScaler
+ * for lux computation acceleration
+ */
+#define FW_ALS_RESULT_SCALER                  0x120
+
+
+/**
+ * these union can be use as a generic bit field type for map #RESULT_INTERRUPT_STATUS_GPIO register
+ * @ingroup device_regdef
+ */
+typedef union IntrStatus_u{
+    uint8_t val;           /*!< raw 8 bit register value*/
+    struct  {
+        unsigned Range     :3; /*!< Range status one of :\n  \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY */
+        unsigned Als       :3; /*!< Als status one of: \n \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD  \n \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY  */
+        unsigned Error     :2; /*!<  Error status of: \n \a #RES_INT_ERROR_LASER_SAFETY  \n \a #RES_INT_ERROR_PLL */
+     } status;                 /*!< interrupt status as bit field */
+} IntrStatus_t;
+
+/**
+ * @def RESULT_INTERRUPT_STATUS_GPIO
+ * @brief System interrupt status report selected interrupt for als and ranging
+ *
+ * These register can be polled even if no gpio pins is active\n
+ * What reported is selected by \a  #SYSTEM_INTERRUPT_CONFIG_GPIO \n
+ * Range mask with \a #RES_INT_RANGE_MASK and shit by \a #RES_INT_RANGE_SHIFT
+ * Als   mask with \a #RES_INT_ALS_MASK and shit by \a #RES_INT_ALS_SHIFT
+ * Result value express condition (or combination?)
+ * \a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
+ * \a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
+ * \a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n
+ * \a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY
+ *
+ * @ingroup device_regdef
+ */
+#define RESULT_INTERRUPT_STATUS_GPIO          0x4F
+    /** ranging interrupt 1st bit position in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_RANGE_SHIFT  0
+    /** ALS interrupt 1st bit position in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_ALS_SHIFT    3
+    /** interrupt bit position in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_ERROR_SHIFT  6
+    /** Ranging interrupt mask in #RESULT_INTERRUPT_STATUS_GPIO (prior to shift)  \sa IntrStatus_t */
+    #define RES_INT_RANGE_MASK (0x7<<RES_INT_RANGE_SHIFT)
+    /** als interrupt mask in #RESULT_INTERRUPT_STATUS_GPIO (prior to shift)  \sa IntrStatus_t */
+    #define RES_INT_ALS_MASK   (0x7<<RES_INT_ALS_SHIFT)
+
+    /** low threshold condition in #RESULT_INTERRUPT_STATUS_GPIO for */
+    #define RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD  0x01
+    /** high threshold condition in #RESULT_INTERRUPT_STATUS_GPIO for ALs or Rage*/
+    #define RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD 0x02
+    /** out of window condition in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_STAT_GPIO_OUT_OF_WINDOW        0x03
+    /** new sample ready in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_STAT_GPIO_NEW_SAMPLE_READY     0x04
+    /** error  in #RESULT_INTERRUPT_STATUS_GPIO */
+    #define RES_INT_ERROR_MASK (0x3<<RES_INT_ERROR_SHIFT)
+        /** laser safety error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO */
+        #define RES_INT_ERROR_LASER_SAFETY  1
+        /** pll 1 or 2 error on #RES_INT_ERROR_MASK of #RESULT_INTERRUPT_STATUS_GPIO*/
+        #define RES_INT_ERROR_PLL           2
+
+/**
+ * Final range result value presented to the user for use. Unit is in mm.
+ */
+#define RESULT_RANGE_VAL                        0x062
+
+/**
+ * Raw Range result value with offset applied (no cross talk compensation applied). Unit is in mm.
+ */
+#define RESULT_RANGE_RAW                        0x064
+
+/**
+ * @brief Sensor count rate of signal returns correlated to IR emitter.
+ *
+ * Computed from RETURN_SIGNAL_COUNT / RETURN_CONV_TIME. Mcps 9.7 format
+ */
+#define RESULT_RANGE_SIGNAL_RATE                0x066
+
+/**
+ * @brief Return signal count
+ *
+ *  Sensor count output value attributed to signal correlated to IR emitter on the Return array.
+ */
+#define RESULT_RANGE_RETURN_SIGNAL_COUNT        0x06C
+
+/**
+ * @brief Reference signal count
+ *
+ * sensor count output value attributed to signal correlated to IR emitter on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_SIGNAL_COUNT     0x070
+
+/**
+ * @brief Return ambient count
+ *
+ * sensor count output value attributed to uncorrelated ambient signal on the Return array.
+ * Must be multiplied by 6 if used to calculate the ambient to signal threshold
+ */
+#define RESULT_RANGE_RETURN_AMB_COUNT           0x074
+
+/**
+ * @brief   Reference ambient count
+ *
+ * Sensor count output value attributed to uncorrelated ambient signal on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_AMB_COUNT        0x078
+
+/**
+ * sensor count output value attributed to signal on the Return array.
+ */
+#define RESULT_RANGE_RETURN_CONV_TIME           0x07C
+
+/**
+ * sensor count output value attributed to signal on the Reference array.
+ */
+#define RESULT_RANGE_REFERENCE_CONV_TIME        0x080
+
+
+/**
+ * @def RANGE_SCALER
+ * @brief RANGE scaling register
+ *
+ * Never should  user write directly onto that register directly \a VL6180x_UpscaleSetScaling()
+ */
+#define RANGE_SCALER                            0x096
+
+/**
+ * @def READOUT_AVERAGING_SAMPLE_PERIOD
+ * @brief Readout averaging sample period register
+ *
+ *
+ * The internal readout averaging sample period can be adjusted from 0 to 255.
+ * Increasing the sampling period decreases noise but also reduces the effective
+ * max convergence time and increases power consumption
+ * Each unit sample period corresponds to around 64.5 μs additional processing time.
+ * The recommended setting is 48 which equates to around 4.3 ms.
+ *
+ * see datasheet for more detail
+ */
+#define READOUT_AVERAGING_SAMPLE_PERIOD     0x10A
+
+/**
+ * @def I2C_SLAVE_DEVICE_ADDRESS
+ * User programmable I2C address (7-bit). Device address can be re-designated after power-up.
+ * @warning What programmed in the register 7-0 are bit 8-1 of i2c address on bus (bit 0 is rd/wr)
+ * so what prohamd is commonly whar ergfer as adrerss /2
+ * @sa VL6180x_SetI2CAddress()
+ */
+#define I2C_SLAVE_DEVICE_ADDRESS               0x212
+
+#endif /* _VL6180x_DEF */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_platform.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,108 @@
+/*******************************************************************************
+################################################################################
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License version 2 and only version 2 as
+# published by the Free Software Foundation.
+#
+# 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+#------------------------------------------------------------------------------
+#                             Imaging Division
+################################################################################
+********************************************************************************/
+
+
+/* vl6180x_platform.h STM32 Nucleo F401 single device  sample code project */
+
+#ifndef VL6180x_PLATFORM
+#define VL6180x_PLATFORM
+
+
+#include "vl6180x_def.h"
+
+
+#define VL6180x_SINGLE_DEVICE_DRIVER 	0
+#define VL6180x_RANGE_STATUS_ERRSTRING  1
+#define VL6180X_SAFE_POLLING_ENTER 	0
+#define VL6180X_LOG_ENABLE              0
+#define MY_LOG                          1
+
+#define VL6180x_DEV_DATA_ATTR
+#define ROMABLE_DATA
+
+
+#if VL6180X_LOG_ENABLE
+/*  dot not include non ansi here trace was a case :( */
+#ifdef TRACE
+#include "diag/trace.h"
+extern volatile uint32_t g_TickCnt;
+#define LOG_GET_TIME()  g_TickCnt
+//#define LOG_GET_TIME()  HAL_GetTick()
+#else
+/* these is nto stm32 vl6180x GNuArm eclpse build*/
+#define trace_printf(...) (void)0
+#define LOG_GET_TIME() (int)0 /* add your code here expect to be an integer native (%d) type  value  */
+#endif
+
+
+
+#define LOG_FUNCTION_START(fmt, ... ) \
+    trace_printf("beg %s start @%d\t" fmt "\n", __func__, LOG_GET_TIME(), ##__VA_ARGS__)
+
+#define LOG_FUNCTION_END(status)\
+        trace_printf("end %s @%d %d\n", __func__, LOG_GET_TIME(), (int)status)
+
+#define LOG_FUNCTION_END_FMT(status, fmt, ... )\
+        trace_printf("End %s @%d %d\t"fmt"\n" , __func__, LOG_GET_TIME(), (int)status, ##__VA_ARGS__)
+
+#define VL6180x_ErrLog(msg, ... )\
+    do{\
+        trace_printf("ERR in %s line %d\n" msg, __func__, __LINE__, ##__VA_ARGS__);\
+    }while(0)
+
+#else /* VL6180X_LOG_ENABLE no logging */
+  //void OnErrLog(void);
+  #define LOG_FUNCTION_START(...) (void)0
+  #define LOG_FUNCTION_END(...) (void)0
+  #define LOG_FUNCTION_END_FMT(...) (void)0
+  #define VL6180x_ErrLog(... ) //OnErrLog() //(void)0
+#endif
+
+  
+#ifdef MY_LOG  /* define printf as pc.printf in order to change the baudrate */
+  extern Serial pc;
+  #define printf(...) pc.printf(__VA_ARGS__)
+#endif
+
+
+#if  VL6180x_SINGLE_DEVICE_DRIVER
+    #error "VL6180x_SINGLE_DEVICE_DRIVER must be set"
+#endif
+		
+struct MyVL6180Dev_t {
+    struct VL6180xDevData_t Data;
+    uint8_t I2cAddr;
+    //uint8_t DevID;
+    
+    //misc flags for application 	
+    unsigned Present:1;
+    unsigned Ready:1;
+};
+typedef struct MyVL6180Dev_t *VL6180xDev_t;
+
+#define VL6180xDevDataGet(dev, field) (dev->Data.field)
+#define VL6180xDevDataSet(dev, field, data) (dev->Data.field)=(data)
+
+
+#endif  /* VL6180x_PLATFORM */
+
+
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180X_bis/vl6180x_types.h	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,62 @@
+/*******************************************************************************
+Copyright © 2014, 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 VL6180x_TYPES_H_
+#define VL6180x_TYPES_H_
+
+
+#include <stdint.h>
+#include <stddef.h> /* these is for NULL */
+
+#ifndef NULL
+#error "review  NULL definition or add required include "
+#endif
+
+#if !defined(STDINT_H) &&  !defined(_GCC_STDINT_H) && !defined(__STDINT_DECLS) && !defined(_STDINT) && !defined(_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
+  */
+
+typedef unsigned int uint32_t;
+typedef int int32_t;
+
+typedef unsigned short uint16_t;
+typedef short int16_t;
+
+typedef unsigned char uint8_t;
+
+typedef signed char int8_t;
+
+#endif /* _STDINT_H */
+
+#endif /* VL6180x_TYPES_H_ */
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180x.lib	Sat Apr 02 10:07:34 2016 +0000
@@ -0,0 +1,1 @@
+https://developer.mbed.org/users/julientiron/code/VL6180x/#f65cc86f43a2
--- a/X_NUCLEO_IHM01A1.lib	Fri Mar 25 21:27:03 2016 +0000
+++ b/X_NUCLEO_IHM01A1.lib	Sat Apr 02 10:07:34 2016 +0000
@@ -1,1 +1,1 @@
-https://developer.mbed.org/teams/Robotique-FIP/code/X_NUCLEO_IHM01A1/#456a51498c6b
+https://developer.mbed.org/users/julientiron/code/X_NUCLEO_IHM01A1/#7ac4b4c49276
--- a/main.cpp	Fri Mar 25 21:27:03 2016 +0000
+++ b/main.cpp	Sat Apr 02 10:07:34 2016 +0000
@@ -15,6 +15,7 @@
 #include "l6474_class.h"
 #include "DevI2C.h"
 #include "vl6180x_class.h"
+#include "VL6180x.h"
 
 /* Definitions ---------------------------------------------------------------*/
 
@@ -27,16 +28,22 @@
 Ticker game_length;
 volatile bool start = 1;
 volatile bool end = 1;
+char data = 0x08 | (char)64;
+bool tag = true;
+int i2cAddres=0x70;                // Address of DS1307 is 0x68 (7 bit address)
+int i2c8BitAddres= i2cAddres <<1;  // Convert to 8bit addressing used by mbed
 
 /* Motor Control Component */
 L6474 *motor1;
 L6474 *motor2;
 
 /* Distance Sensors Component */
-DevI2C *i2c =new DevI2C(D14, D15); 
+/*DevI2C *i2c =new DevI2C(D14, D15);
 VL6180X sensor1(i2c);
 VL6180X sensor2(i2c);
-VL6180X sensor3(i2c);
+VL6180X sensor3(i2c);*/
+I2C i2c(D14, D15);
+VL6180x sensor(D14, D15, VL6180X_ADDRESS<<1);
 
 /* Functions -----------------------------------------------------------------*/
 
@@ -50,12 +57,14 @@
     end = 0;
 }
 
-void init_sensor(){
-    
+void init_sensor()
+{
+
 }
-    
-void switch_sensor(int number){
-    
+
+void switch_sensor(int number)
+{
+
 }
 
 /* Main ----------------------------------------------------------------------*/
@@ -74,47 +83,43 @@
         exit(EXIT_FAILURE);
     if (motor2->Init() != COMPONENT_OK)
         exit(EXIT_FAILURE);
+    int result = i2c.write(i2c8BitAddres, &data, 1 );
+    sensor.VL6180xDefautSettings();
 
     /* Interrupt to start the robot */
     startup.fall(&go);
-    
-    /* Interrupt to stop the robot */
-    game_length.attach(&stop, 90); //1 minutes 30 secondes pour la Coupe
 
     while(start) {
         /* Waiting code */
     }
-    
+
     while(end) {
         /* In-game code */
-        
-        /* Requesting to run backward. */
-        motor1->Run(StepperMotor::BWD);
-        motor2->Run(StepperMotor::FWD);
+
+        /* Interrupt to stop the robot */
+        game_length.attach(&stop, 10); //1 minutes 30 secondes pour la Coupe
 
-        /* Waiting until delay has expired. */
-        wait_ms(3000);
-        
-        motor1->HardStop();
-        motor2->HardStop();
+        if(sensor.getDistance()<100) {
+            printf("1");
+            if(tag == false) {
+                motor1->Run(StepperMotor::FWD);
+                motor2->Run(StepperMotor::FWD);
 
-        motor1->WaitWhileActive();
-        motor2->WaitWhileActive();
-        
-        /* Requesting to run backward. */
-        motor1->Run(StepperMotor::FWD);
-        motor2->Run(StepperMotor::BWD);
+                tag = true;
+            }
+        } else {
+            printf("0");
+            if(tag == true) {
+                motor1->Run(StepperMotor::FWD);
+                motor2->Run(StepperMotor::BWD);
 
+                tag = false;
+            }
+        }
+        wait_ms(100);
         /* Waiting until delay has expired. */
-        wait_ms(3000);
-        
-        motor1->HardStop();
-        motor2->HardStop();
+    }
 
-        motor1->WaitWhileActive();
-        motor2->WaitWhileActive();
-    }
-    
     motor1->HardStop();
     motor2->HardStop();