INSAT Mini Project

Dependencies:   ST_INTERFACES X_NUCLEO_COMMON

Fork of X_NUCLEO_6180XA1 by ST

Committer:
gallonm
Date:
Tue Oct 13 14:22:45 2015 +0200
Revision:
12:71d589e6fd2c
Parent:
10:4954b09b72d8
Child:
14:0effa0bbf192
Introduced virtual functions GetRange and GetLight of the sensor classes.
Fixed as wrapper functions of VL6180x_RangeGetResult and VL6180x_AlsGetLux.

Fixed a comment of the stmpe1600_class.h

Fixed the function InitSensor.
Introduced the function StartMeasurement to choose the operating mode.
Introduced the funcions RangeMeasPollSingleShot, AlsMeasPollSingleShot,
RangeMeasPollContinuousMode, AlsMeasPollContinuousMode, RangeMeasIntContinuousMode,
AlsMeasIntContinuousMode and InterleavedMode to manage different type of operating
mode.
Introduced the functions GetRangeError and GetAlsError to verify error measurement.
Introduced the functions GetRangeMeasContinuousMode and GetAlsMeasContinuousMode
to get the result of the measure in continuous mode.
Introduced the function StartInterleavedMode to start the interleaved mode.
Introduced the function HandleIRQ to manage the interrupt request.

Introduced MeasureData_t struct that contains the results of range and als measure
and related error (range, als and gpio).
Introduced enum OperatingMode and MeasureType.
Fixed the Vl6180x constructor, introducing the parameter PinName gpio1 needed to
interrupt_measure.
Introduced the wrapper functions.
Introducede InterruptIn interrupt_measure to handle the interrupt request.

Fixed the x_nucleo_6180xa1 constructor.

Fixed the object sensor_top.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
gallonm 1:1de1ea2994d9 1 /**
gallonm 1:1de1ea2994d9 2 ******************************************************************************
gallonm 1:1de1ea2994d9 3 * @file vl6180x_class.cpp
gallonm 1:1de1ea2994d9 4 * @author AST / EST
gallonm 1:1de1ea2994d9 5 * @version V0.0.1
gallonm 1:1de1ea2994d9 6 * @date 14-April-2015
gallonm 1:1de1ea2994d9 7 * @brief Implementation file for the HTS221 driver class
gallonm 1:1de1ea2994d9 8 ******************************************************************************
gallonm 1:1de1ea2994d9 9 * @attention
gallonm 1:1de1ea2994d9 10 *
gallonm 1:1de1ea2994d9 11 * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>
gallonm 1:1de1ea2994d9 12 *
gallonm 1:1de1ea2994d9 13 * Redistribution and use in source and binary forms, with or without modification,
gallonm 1:1de1ea2994d9 14 * are permitted provided that the following conditions are met:
gallonm 1:1de1ea2994d9 15 * 1. Redistributions of source code must retain the above copyright notice,
gallonm 1:1de1ea2994d9 16 * this list of conditions and the following disclaimer.
gallonm 1:1de1ea2994d9 17 * 2. Redistributions in binary form must reproduce the above copyright notice,
gallonm 1:1de1ea2994d9 18 * this list of conditions and the following disclaimer in the documentation
gallonm 1:1de1ea2994d9 19 * and/or other materials provided with the distribution.
gallonm 1:1de1ea2994d9 20 * 3. Neither the name of STMicroelectronics nor the names of its contributors
gallonm 1:1de1ea2994d9 21 * may be used to endorse or promote products derived from this software
gallonm 1:1de1ea2994d9 22 * without specific prior written permission.
gallonm 1:1de1ea2994d9 23 *
gallonm 1:1de1ea2994d9 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
gallonm 1:1de1ea2994d9 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
gallonm 1:1de1ea2994d9 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
gallonm 1:1de1ea2994d9 27 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
gallonm 1:1de1ea2994d9 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
gallonm 1:1de1ea2994d9 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
gallonm 1:1de1ea2994d9 30 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
gallonm 1:1de1ea2994d9 31 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
gallonm 1:1de1ea2994d9 32 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
gallonm 1:1de1ea2994d9 33 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
gallonm 1:1de1ea2994d9 34 *
gallonm 1:1de1ea2994d9 35 ******************************************************************************
gallonm 1:1de1ea2994d9 36 */
gallonm 1:1de1ea2994d9 37
gallonm 7:2dc81120c917 38 /* Includes */
gallonm 1:1de1ea2994d9 39 #include "vl6180x_class.h"
licio.mapelli@st.com 8:f943a1fca15f 40
licio.mapelli@st.com 8:f943a1fca15f 41
licio.mapelli@st.com 8:f943a1fca15f 42 #ifndef VL6180x_RANGE_STATUS_ERRSTRING
licio.mapelli@st.com 8:f943a1fca15f 43 #warning "VL6180x_RANGE_STATUS_ERRSTRING not defined ?"
licio.mapelli@st.com 8:f943a1fca15f 44 /* TODO you may remove or comment these #warning and keep the default below to keep compatibility
licio.mapelli@st.com 8:f943a1fca15f 45 or update your vl6180x_platform.h file */
licio.mapelli@st.com 8:f943a1fca15f 46 /**
licio.mapelli@st.com 8:f943a1fca15f 47 * force VL6180x_RANGE_STATUS_ERRSTRING to not supported when not part of any cfg file
licio.mapelli@st.com 8:f943a1fca15f 48 */
licio.mapelli@st.com 8:f943a1fca15f 49 #define VL6180x_RANGE_STATUS_ERRSTRING 0
licio.mapelli@st.com 8:f943a1fca15f 50 #endif
licio.mapelli@st.com 8:f943a1fca15f 51
licio.mapelli@st.com 8:f943a1fca15f 52 #ifndef VL6180X_SAFE_POLLING_ENTER
licio.mapelli@st.com 8:f943a1fca15f 53 #warning "VL6180X_SAFE_POLLING_ENTER not defined, likely old vl6180x_cfg.h file ?"
licio.mapelli@st.com 8:f943a1fca15f 54 /* TODO you may remove or comment these #warning and keep the default below to keep compatibility
licio.mapelli@st.com 8:f943a1fca15f 55 or update your vl6180x_platform.h file */
licio.mapelli@st.com 8:f943a1fca15f 56 /**
licio.mapelli@st.com 8:f943a1fca15f 57 * force VL6180X_SAFE_POLLING_ENTER to off when not in cfg file
licio.mapelli@st.com 8:f943a1fca15f 58 */
licio.mapelli@st.com 8:f943a1fca15f 59 #define VL6180X_SAFE_POLLING_ENTER 0 /* off by default as in api 2.0 */
licio.mapelli@st.com 8:f943a1fca15f 60 #endif
licio.mapelli@st.com 8:f943a1fca15f 61
licio.mapelli@st.com 8:f943a1fca15f 62 #ifndef VL6180X_LOG_ENABLE
licio.mapelli@st.com 8:f943a1fca15f 63 /**
licio.mapelli@st.com 8:f943a1fca15f 64 * Force VL6180X_LOG_ENABLE to none as default
licio.mapelli@st.com 8:f943a1fca15f 65 */
licio.mapelli@st.com 8:f943a1fca15f 66 #define VL6180X_LOG_ENABLE 0
licio.mapelli@st.com 8:f943a1fca15f 67 #endif
licio.mapelli@st.com 8:f943a1fca15f 68
licio.mapelli@st.com 8:f943a1fca15f 69 #if VL6180x_RANGE_STATUS_ERRSTRING
licio.mapelli@st.com 8:f943a1fca15f 70 /**@def VL6180x_HAVE_RANGE_STATUS_ERRSTRING
licio.mapelli@st.com 8:f943a1fca15f 71 * @brief is defined when @a #VL6180x_RANGE_STATUS_ERRSTRING is enable
licio.mapelli@st.com 8:f943a1fca15f 72 */
licio.mapelli@st.com 8:f943a1fca15f 73 #define VL6180x_HAVE_RANGE_STATUS_ERRSTRING
licio.mapelli@st.com 8:f943a1fca15f 74 #endif
licio.mapelli@st.com 8:f943a1fca15f 75
licio.mapelli@st.com 8:f943a1fca15f 76
licio.mapelli@st.com 8:f943a1fca15f 77 /** @brief Get API version as "hex integer" 0xMMnnss
licio.mapelli@st.com 8:f943a1fca15f 78 */
licio.mapelli@st.com 8:f943a1fca15f 79 #define VL6180x_ApiRevInt ((VL6180x_API_REV_MAJOR<<24)+(VL6180x_API_REV_MINOR<<16)+VL6180x_API_REV_SUB)
licio.mapelli@st.com 8:f943a1fca15f 80
licio.mapelli@st.com 8:f943a1fca15f 81 /** Get API version as string for exe "2.1.12" "
licio.mapelli@st.com 8:f943a1fca15f 82 */
licio.mapelli@st.com 8:f943a1fca15f 83 #define VL6180x_ApiRevStr VL6180X_STR(VL6180x_API_REV_MAJOR) "." VL6180X_STR(VL6180x_API_REV_MINOR) "." VL6180X_STR(VL6180x_API_REV_SUB)
licio.mapelli@st.com 8:f943a1fca15f 84
licio.mapelli@st.com 8:f943a1fca15f 85 /** @defgroup api_init Init functions
licio.mapelli@st.com 8:f943a1fca15f 86 * @brief API init functions
licio.mapelli@st.com 8:f943a1fca15f 87 * @ingroup api_hl
licio.mapelli@st.com 8:f943a1fca15f 88 * @{
licio.mapelli@st.com 8:f943a1fca15f 89 */
licio.mapelli@st.com 8:f943a1fca15f 90
gallonm 1:1de1ea2994d9 91
gallonm 7:2dc81120c917 92 /****************** define for i2c configuration *******************************/
gallonm 12:71d589e6fd2c 93
gallonm 4:a5abf7757947 94 #define TEMP_BUF_SIZE 32
gallonm 4:a5abf7757947 95
gallonm 7:2dc81120c917 96 #define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
licio.mapelli@st.com 8:f943a1fca15f 97 /**
licio.mapelli@st.com 8:f943a1fca15f 98 * @brief Clear All interrupt causes (als+range+error)
licio.mapelli@st.com 8:f943a1fca15f 99 *
licio.mapelli@st.com 8:f943a1fca15f 100 * @param dev The device
licio.mapelli@st.com 8:f943a1fca15f 101 * @return 0 On success
licio.mapelli@st.com 8:f943a1fca15f 102 */
licio.mapelli@st.com 8:f943a1fca15f 103 #define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
licio.mapelli@st.com 8:f943a1fca15f 104 /**
licio.mapelli@st.com 8:f943a1fca15f 105 * @brief Clear ALS interrupt
licio.mapelli@st.com 8:f943a1fca15f 106 *
licio.mapelli@st.com 8:f943a1fca15f 107 * @param dev The device
licio.mapelli@st.com 8:f943a1fca15f 108 * @return 0 On success
licio.mapelli@st.com 8:f943a1fca15f 109 */
licio.mapelli@st.com 8:f943a1fca15f 110 #define VL6180x_AlsClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ALS)
licio.mapelli@st.com 8:f943a1fca15f 111 /**
licio.mapelli@st.com 8:f943a1fca15f 112 * @brief Clear range interrupt
licio.mapelli@st.com 8:f943a1fca15f 113 *
licio.mapelli@st.com 8:f943a1fca15f 114 * @param dev The device
licio.mapelli@st.com 8:f943a1fca15f 115 * @return 0 On success
licio.mapelli@st.com 8:f943a1fca15f 116 */
licio.mapelli@st.com 8:f943a1fca15f 117 #define VL6180x_RangeClearInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_RANGING)
gallonm 7:2dc81120c917 118
gallonm 7:2dc81120c917 119 /******************************************************************************/
gallonm 7:2dc81120c917 120 /******************************* file api.c ***********************************/
gallonm 7:2dc81120c917 121
gallonm 7:2dc81120c917 122 #define VL6180x_9to7Conv(x) (x)
gallonm 7:2dc81120c917 123
gallonm 7:2dc81120c917 124 /* TODO when set all "cached" value with "default init" are updated after init from register read back */
gallonm 7:2dc81120c917 125 #define REFRESH_CACHED_DATA_AFTER_INIT 1
gallonm 7:2dc81120c917 126
gallonm 7:2dc81120c917 127
gallonm 7:2dc81120c917 128 #define IsValidGPIOFunction(x) ((x)==GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT || (x)==GPIOx_SELECT_OFF)
gallonm 7:2dc81120c917 129
gallonm 7:2dc81120c917 130
gallonm 7:2dc81120c917 131 /** default value ECE factor Molecular */
gallonm 7:2dc81120c917 132 #define DEF_ECE_FACTOR_M 85
gallonm 7:2dc81120c917 133 /** default value ECE factor Denominator */
gallonm 7:2dc81120c917 134 #define DEF_ECE_FACTOR_D 100
gallonm 7:2dc81120c917 135 /** default value ALS integration time */
gallonm 7:2dc81120c917 136 #define DEF_INT_PEFRIOD 100
gallonm 7:2dc81120c917 137 /** default value ALS gain */
gallonm 7:2dc81120c917 138 #define DEF_ALS_GAIN 1
gallonm 7:2dc81120c917 139 /** default value ALS scaler */
gallonm 7:2dc81120c917 140 #define DEF_ALS_SCALER 1
gallonm 7:2dc81120c917 141 /** default value for DMAX Enbale */
gallonm 7:2dc81120c917 142 #define DEF_DMAX_ENABLE 1
gallonm 7:2dc81120c917 143 /** default ambient tuning factor %x1000 */
gallonm 7:2dc81120c917 144 #define DEF_AMBIENT_TUNING 80
gallonm 7:2dc81120c917 145
gallonm 10:4954b09b72d8 146 #if VL6180x_SINGLE_DEVICE_DRIVER
gallonm 10:4954b09b72d8 147 extern struct VL6180xDevData_t SingleVL6180xDevData;
gallonm 10:4954b09b72d8 148 #define VL6180xDevDataGet(dev, field) (SingleVL6180xDevData.field)
gallonm 10:4954b09b72d8 149 #define VL6180xDevDataSet(dev, field, data) SingleVL6180xDevData.field=(data)
gallonm 10:4954b09b72d8 150 #endif
gallonm 7:2dc81120c917 151
gallonm 7:2dc81120c917 152 #define LUXRES_FIX_PREC 8
gallonm 7:2dc81120c917 153 #define GAIN_FIX_PREC 8 /* ! if not sme as LUX_PREC then :( adjust GetLux */
gallonm 7:2dc81120c917 154 #define AN_GAIN_MULT (1<<GAIN_FIX_PREC)
gallonm 7:2dc81120c917 155
gallonm 7:2dc81120c917 156
gallonm 7:2dc81120c917 157 static int32_t _GetAveTotalTime(VL6180xDev_t dev);
gallonm 7:2dc81120c917 158 static int VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev);
gallonm 7:2dc81120c917 159
gallonm 7:2dc81120c917 160 /**
gallonm 7:2dc81120c917 161 * ScalerLookUP scaling factor-1 to register #RANGE_SCALER lookup
gallonm 7:2dc81120c917 162 */
gallonm 7:2dc81120c917 163 static const uint16_t ScalerLookUP[] ROMABLE_DATA ={ 253, 127, 84}; /* lookup table for scaling->scalar 1x2x 3x */
gallonm 7:2dc81120c917 164 /**
gallonm 7:2dc81120c917 165 * scaling factor to Upper limit look up
gallonm 7:2dc81120c917 166 */
gallonm 7:2dc81120c917 167 static const uint16_t UpperLimitLookUP[] ROMABLE_DATA ={ 185, 370, 580}; /* lookup table for scaling->limit 1x2x3x */
gallonm 7:2dc81120c917 168 /**
gallonm 7:2dc81120c917 169 * Als Code gain to fix point gain lookup
gallonm 7:2dc81120c917 170 */
gallonm 7:2dc81120c917 171 static const uint16_t AlsGainLookUp[8] ROMABLE_DATA = {
gallonm 7:2dc81120c917 172 (uint16_t)(20.0f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 173 (uint16_t)(10.0f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 174 (uint16_t)(5.0f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 175 (uint16_t)(2.5f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 176 (uint16_t)(1.67f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 177 (uint16_t)(1.25f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 178 (uint16_t)(1.0f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 179 (uint16_t)(40.0f * AN_GAIN_MULT),
gallonm 7:2dc81120c917 180 };
gallonm 7:2dc81120c917 181
gallonm 7:2dc81120c917 182
gallonm 7:2dc81120c917 183 #if VL6180x_RANGE_STATUS_ERRSTRING
gallonm 7:2dc81120c917 184 const char * ROMABLE_DATA VL6180x_RangeStatusErrString[]={
gallonm 7:2dc81120c917 185 "No Error",
gallonm 7:2dc81120c917 186 "VCSEL Continuity Test",
gallonm 7:2dc81120c917 187 "VCSEL Watchdog Test",
gallonm 7:2dc81120c917 188 "VCSEL Watchdog",
gallonm 7:2dc81120c917 189 "PLL1 Lock",
gallonm 7:2dc81120c917 190 "PLL2 Lock",
gallonm 7:2dc81120c917 191 "Early Convergence Estimate",
gallonm 7:2dc81120c917 192 "Max Convergence",
gallonm 7:2dc81120c917 193 "No Target Ignore",
gallonm 7:2dc81120c917 194 "Not used 9",
gallonm 7:2dc81120c917 195 "Not used 10",
gallonm 7:2dc81120c917 196 "Max Signal To Noise Ratio",
gallonm 7:2dc81120c917 197 "Raw Ranging Algo Underflow",
gallonm 7:2dc81120c917 198 "Raw Ranging Algo Overflow",
gallonm 7:2dc81120c917 199 "Ranging Algo Underflow",
gallonm 7:2dc81120c917 200 "Ranging Algo Overflow",
gallonm 7:2dc81120c917 201
gallonm 7:2dc81120c917 202 "Filtered by post processing"
gallonm 7:2dc81120c917 203 };
gallonm 7:2dc81120c917 204
gallonm 7:2dc81120c917 205 const char * VL6180x_RangeGetStatusErrString(uint8_t RangeErrCode){
gallonm 7:2dc81120c917 206 if( RangeErrCode > sizeof(VL6180x_RangeStatusErrString)/sizeof(VL6180x_RangeStatusErrString[0]) )
gallonm 7:2dc81120c917 207 return NULL;
gallonm 7:2dc81120c917 208 return VL6180x_RangeStatusErrString[RangeErrCode];
gallonm 7:2dc81120c917 209 }
gallonm 7:2dc81120c917 210 #endif
gallonm 7:2dc81120c917 211
gallonm 7:2dc81120c917 212 #if VL6180x_UPSCALE_SUPPORT == 1
gallonm 7:2dc81120c917 213 #define _GetUpscale(dev, ... ) 1
gallonm 7:2dc81120c917 214 #define _SetUpscale(...) -1
gallonm 7:2dc81120c917 215 #define DEF_UPSCALE 1
gallonm 7:2dc81120c917 216 #elif VL6180x_UPSCALE_SUPPORT == 2
gallonm 7:2dc81120c917 217 #define _GetUpscale(dev, ... ) 2
gallonm 7:2dc81120c917 218 #define _SetUpscale(...)
gallonm 7:2dc81120c917 219 #define DEF_UPSCALE 2
gallonm 7:2dc81120c917 220 #elif VL6180x_UPSCALE_SUPPORT == 3
gallonm 7:2dc81120c917 221 #define _GetUpscale(dev, ... ) 3
gallonm 7:2dc81120c917 222 #define _SetUpscale(...)
gallonm 7:2dc81120c917 223 #define DEF_UPSCALE 3
gallonm 7:2dc81120c917 224 #else
gallonm 7:2dc81120c917 225 #define DEF_UPSCALE (-(VL6180x_UPSCALE_SUPPORT))
gallonm 7:2dc81120c917 226 #define _GetUpscale(dev, ... ) VL6180xDevDataGet(dev, UpscaleFactor)
gallonm 7:2dc81120c917 227 #define _SetUpscale(dev, Scaling ) VL6180xDevDataSet(dev, UpscaleFactor, Scaling)
gallonm 7:2dc81120c917 228 #endif
gallonm 7:2dc81120c917 229
gallonm 10:4954b09b72d8 230
gallonm 10:4954b09b72d8 231 #if VL6180x_SINGLE_DEVICE_DRIVER
gallonm 10:4954b09b72d8 232 /**
gallonm 10:4954b09b72d8 233 * the unique driver data When single device driver is active
gallonm 10:4954b09b72d8 234 */
gallonm 10:4954b09b72d8 235 struct VL6180xDevData_t VL6180x_DEV_DATA_ATTR SingleVL6180xDevData={
gallonm 10:4954b09b72d8 236 .EceFactorM = DEF_ECE_FACTOR_M,
gallonm 10:4954b09b72d8 237 .EceFactorD = DEF_ECE_FACTOR_D,
gallonm 10:4954b09b72d8 238 #ifdef VL6180x_HAVE_UPSCALE_DATA
gallonm 10:4954b09b72d8 239 .UpscaleFactor = DEF_UPSCALE,
gallonm 10:4954b09b72d8 240 #endif
gallonm 10:4954b09b72d8 241 #ifdef VL6180x_HAVE_ALS_DATA
gallonm 10:4954b09b72d8 242 .IntegrationPeriod = DEF_INT_PEFRIOD,
gallonm 10:4954b09b72d8 243 .AlsGainCode = DEF_ALS_GAIN,
gallonm 10:4954b09b72d8 244 .AlsScaler = DEF_ALS_SCALER,
gallonm 10:4954b09b72d8 245 #endif
gallonm 10:4954b09b72d8 246 #ifdef VL6180x_HAVE_DMAX_RANGING
gallonm 10:4954b09b72d8 247 .DMaxEnable = DEF_DMAX_ENABLE,
gallonm 10:4954b09b72d8 248 #endif
gallonm 10:4954b09b72d8 249 };
gallonm 10:4954b09b72d8 250 #endif /* VL6180x_SINGLE_DEVICE_DRIVER */
gallonm 10:4954b09b72d8 251
gallonm 10:4954b09b72d8 252
gallonm 10:4954b09b72d8 253
gallonm 7:2dc81120c917 254 #define Fix7_2_KCPs(x) ((((uint32_t)(x))*1000)>>7)
gallonm 7:2dc81120c917 255
gallonm 7:2dc81120c917 256
gallonm 7:2dc81120c917 257 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 258 static int _GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData);
gallonm 7:2dc81120c917 259 #endif
gallonm 7:2dc81120c917 260
gallonm 7:2dc81120c917 261 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 262 static int _filter_Init(VL6180xDev_t dev);
gallonm 7:2dc81120c917 263 static int _filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pData);
gallonm 7:2dc81120c917 264 #define _IsWrapArroundActive(dev) VL6180xDevDataGet(dev,WrapAroundFilterActive)
gallonm 7:2dc81120c917 265 #else
gallonm 7:2dc81120c917 266 #define _IsWrapArroundActive(dev) 0
gallonm 7:2dc81120c917 267 #endif
gallonm 7:2dc81120c917 268
gallonm 7:2dc81120c917 269
gallonm 7:2dc81120c917 270 #if VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 271 void _DMax_OneTimeInit(VL6180xDev_t dev);
gallonm 7:2dc81120c917 272 static int _DMax_InitData(VL6180xDev_t dev);
gallonm 7:2dc81120c917 273 static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange);
gallonm 7:2dc81120c917 274 #define _IsDMaxActive(dev) VL6180xDevDataGet(dev,DMaxEnable)
gallonm 7:2dc81120c917 275 #else
gallonm 7:2dc81120c917 276 #define _DMax_InitData(...) 0 /* success */
gallonm 7:2dc81120c917 277 #define _DMax_OneTimeInit(...) (void)0
gallonm 7:2dc81120c917 278 #define _IsDMaxActive(...) 0
gallonm 7:2dc81120c917 279 #endif
gallonm 7:2dc81120c917 280
gallonm 7:2dc81120c917 281 static int VL6180x_RangeStaticInit(VL6180xDev_t dev);
gallonm 7:2dc81120c917 282 static int VL6180x_UpscaleStaticInit(VL6180xDev_t dev);
gallonm 7:2dc81120c917 283
gallonm 7:2dc81120c917 284 int VL6180X::VL6180x_WaitDeviceBooted(VL6180xDev_t dev){
gallonm 7:2dc81120c917 285 uint8_t FreshOutReset;
gallonm 7:2dc81120c917 286 int status;
gallonm 7:2dc81120c917 287 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 288 do{
gallonm 7:2dc81120c917 289 status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
gallonm 7:2dc81120c917 290 }
gallonm 7:2dc81120c917 291 while( FreshOutReset!=1 && status==0);
gallonm 7:2dc81120c917 292 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 293 return status;
gallonm 7:2dc81120c917 294 }
gallonm 7:2dc81120c917 295
gallonm 7:2dc81120c917 296 int VL6180X::VL6180x_InitData(VL6180xDev_t dev){
gallonm 3:454541a079f4 297 int status, dmax_status ;
gallonm 3:454541a079f4 298 int8_t offset;
gallonm 3:454541a079f4 299 uint8_t FreshOutReset;
gallonm 3:454541a079f4 300 uint32_t CalValue;
gallonm 3:454541a079f4 301 uint16_t u16;
gallonm 3:454541a079f4 302 uint32_t XTalkCompRate_KCps;
gallonm 3:454541a079f4 303
gallonm 3:454541a079f4 304 LOG_FUNCTION_START("");
gallonm 3:454541a079f4 305
gallonm 3:454541a079f4 306 VL6180xDevDataSet(dev, EceFactorM , DEF_ECE_FACTOR_M);
gallonm 3:454541a079f4 307 VL6180xDevDataSet(dev, EceFactorD , DEF_ECE_FACTOR_D);
gallonm 3:454541a079f4 308
gallonm 3:454541a079f4 309 #ifdef VL6180x_HAVE_UPSCALE_DATA
gallonm 3:454541a079f4 310 VL6180xDevDataSet(dev, UpscaleFactor , DEF_UPSCALE);
gallonm 3:454541a079f4 311 #endif
gallonm 3:454541a079f4 312
gallonm 3:454541a079f4 313 #ifdef VL6180x_HAVE_ALS_DATA
gallonm 3:454541a079f4 314 VL6180xDevDataSet(dev, IntegrationPeriod, DEF_INT_PEFRIOD);
gallonm 3:454541a079f4 315 VL6180xDevDataSet(dev, AlsGainCode, DEF_ALS_GAIN);
gallonm 3:454541a079f4 316 VL6180xDevDataSet(dev, AlsScaler, DEF_ALS_SCALER);
gallonm 3:454541a079f4 317 #endif
gallonm 3:454541a079f4 318
gallonm 3:454541a079f4 319 #ifdef VL6180x_HAVE_WRAP_AROUND_DATA
gallonm 3:454541a079f4 320 VL6180xDevDataSet(dev, WrapAroundFilterActive, (VL6180x_WRAP_AROUND_FILTER_SUPPORT >0));
gallonm 3:454541a079f4 321 VL6180xDevDataSet(dev, DMaxEnable, DEF_DMAX_ENABLE);
gallonm 3:454541a079f4 322 #endif
gallonm 3:454541a079f4 323
gallonm 3:454541a079f4 324 _DMax_OneTimeInit(dev);
gallonm 3:454541a079f4 325 do{
gallonm 3:454541a079f4 326
gallonm 3:454541a079f4 327 /* backup offset initial value from nvm these must be done prior any over call that use offset */
gallonm 7:2dc81120c917 328 status = VL6180X::VL6180x_RdByte(dev,SYSRANGE_PART_TO_PART_RANGE_OFFSET, (uint8_t*)&offset);
gallonm 3:454541a079f4 329 if( status ){
gallonm 3:454541a079f4 330 VL6180x_ErrLog("SYSRANGE_PART_TO_PART_RANGE_OFFSET rd fail");
gallonm 3:454541a079f4 331 break;
gallonm 3:454541a079f4 332 }
gallonm 3:454541a079f4 333 VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
gallonm 1:1de1ea2994d9 334
gallonm 7:2dc81120c917 335 status=VL6180x_RdDWord( dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &CalValue);
gallonm 3:454541a079f4 336 if( status ){
gallonm 3:454541a079f4 337 VL6180x_ErrLog("Part2PartAmbNVM rd fail");
gallonm 3:454541a079f4 338 break;
gallonm 3:454541a079f4 339 }
gallonm 3:454541a079f4 340 if( (CalValue&0xFFFF0000) == 0 ){
gallonm 3:454541a079f4 341 CalValue=0x00CE03F8;
gallonm 3:454541a079f4 342 }
gallonm 3:454541a079f4 343 VL6180xDevDataSet(dev, Part2PartAmbNVM, CalValue);
gallonm 3:454541a079f4 344
gallonm 7:2dc81120c917 345 status = VL6180x_RdWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE ,&u16);
gallonm 3:454541a079f4 346 if( status){
gallonm 3:454541a079f4 347 VL6180x_ErrLog("SYSRANGE_CROSSTALK_COMPENSATION_RATE rd fail ");
gallonm 3:454541a079f4 348 break;
gallonm 3:454541a079f4 349 }
gallonm 3:454541a079f4 350 XTalkCompRate_KCps = Fix7_2_KCPs(u16);
gallonm 3:454541a079f4 351 VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
gallonm 1:1de1ea2994d9 352
gallonm 3:454541a079f4 353 dmax_status = _DMax_InitData(dev);
gallonm 3:454541a079f4 354 if( dmax_status < 0 ){
gallonm 3:454541a079f4 355 VL6180x_ErrLog("DMax init failure");
gallonm 3:454541a079f4 356 break;
gallonm 3:454541a079f4 357 }
gallonm 3:454541a079f4 358
gallonm 3:454541a079f4 359 /* Read or wait for fresh out of reset */
gallonm 7:2dc81120c917 360 status = VL6180x_RdByte(dev,SYSTEM_FRESH_OUT_OF_RESET, &FreshOutReset);
gallonm 3:454541a079f4 361 if( status ) {
gallonm 3:454541a079f4 362 VL6180x_ErrLog("SYSTEM_FRESH_OUT_OF_RESET rd fail");
gallonm 3:454541a079f4 363 break;
gallonm 3:454541a079f4 364 }
gallonm 3:454541a079f4 365 if( FreshOutReset!= 1 || dmax_status )
gallonm 3:454541a079f4 366 status = CALIBRATION_WARNING;
gallonm 3:454541a079f4 367
gallonm 3:454541a079f4 368 }
gallonm 3:454541a079f4 369 while(0);
gallonm 3:454541a079f4 370
gallonm 3:454541a079f4 371 LOG_FUNCTION_END(status);
gallonm 3:454541a079f4 372 return status;
gallonm 1:1de1ea2994d9 373 }
gallonm 1:1de1ea2994d9 374
gallonm 7:2dc81120c917 375 int8_t VL6180X::VL6180x_GetOffsetCalibrationData(VL6180xDev_t dev)
gallonm 7:2dc81120c917 376 {
gallonm 7:2dc81120c917 377 int8_t offset;
gallonm 7:2dc81120c917 378 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 379 offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM);
gallonm 7:2dc81120c917 380 LOG_FUNCTION_END( offset );
gallonm 7:2dc81120c917 381 return offset;
gallonm 7:2dc81120c917 382 }
gallonm 7:2dc81120c917 383
gallonm 7:2dc81120c917 384 void VL6180X::VL6180x_SetOffsetCalibrationData(VL6180xDev_t dev, int8_t offset)
gallonm 7:2dc81120c917 385 {
gallonm 7:2dc81120c917 386 LOG_FUNCTION_START("%d", offset);
gallonm 7:2dc81120c917 387 VL6180xDevDataSet(dev, Part2PartOffsetNVM, offset);
gallonm 7:2dc81120c917 388 LOG_FUNCTION_END(0);
gallonm 7:2dc81120c917 389 }
gallonm 7:2dc81120c917 390
gallonm 7:2dc81120c917 391 int VL6180X::VL6180x_SetXTalkCompensationRate(VL6180xDev_t dev, FixPoint97_t Rate)
gallonm 7:2dc81120c917 392 {
gallonm 7:2dc81120c917 393 int status;
gallonm 7:2dc81120c917 394 LOG_FUNCTION_START("%d", Rate);
gallonm 7:2dc81120c917 395 status = VL6180x_WrWord(dev, SYSRANGE_CROSSTALK_COMPENSATION_RATE, Rate);
gallonm 7:2dc81120c917 396 if( status ==0 ){
gallonm 7:2dc81120c917 397 uint32_t XTalkCompRate_KCps;
gallonm 7:2dc81120c917 398 XTalkCompRate_KCps = Fix7_2_KCPs(Rate);
gallonm 7:2dc81120c917 399 VL6180xDevDataSet(dev, XTalkCompRate_KCps , XTalkCompRate_KCps );
gallonm 7:2dc81120c917 400 /* update dmax whenever xtalk rate changes */
gallonm 7:2dc81120c917 401 status = _DMax_InitData(dev);
gallonm 7:2dc81120c917 402 }
gallonm 7:2dc81120c917 403 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 404 return status;
gallonm 7:2dc81120c917 405 }
gallonm 7:2dc81120c917 406
gallonm 7:2dc81120c917 407 int VL6180X::VL6180x_SetI2CAddress(VL6180xDev_t dev, uint8_t NewAddress){
gallonm 7:2dc81120c917 408 int status;
gallonm 7:2dc81120c917 409 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 410
licio.mapelli@st.com 8:f943a1fca15f 411 status = VL6180x_WrByte(dev, I2C_SLAVE_DEVICE_ADDRESS, NewAddress);
gallonm 7:2dc81120c917 412 if( status ){
gallonm 7:2dc81120c917 413 VL6180x_ErrLog("new i2c addr Wr fail");
gallonm 7:2dc81120c917 414 }
gallonm 7:2dc81120c917 415 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 416 return status;
gallonm 7:2dc81120c917 417 }
gallonm 7:2dc81120c917 418
licio.mapelli@st.com 9:9cbc1736f148 419
gallonm 7:2dc81120c917 420 uint16_t VL6180X::VL6180x_GetUpperLimit(VL6180xDev_t dev) {
gallonm 7:2dc81120c917 421 uint16_t limit;
gallonm 7:2dc81120c917 422 int scaling;
gallonm 7:2dc81120c917 423
gallonm 7:2dc81120c917 424 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 425
gallonm 7:2dc81120c917 426 scaling = _GetUpscale(dev);
gallonm 7:2dc81120c917 427 /* FIXME we do assume here _GetUpscale is valid if user call us prior to init we may overflow the LUT mem area */
gallonm 7:2dc81120c917 428 limit = UpperLimitLookUP[scaling - 1];
gallonm 7:2dc81120c917 429
gallonm 7:2dc81120c917 430 LOG_FUNCTION_END((int )limit);
gallonm 7:2dc81120c917 431 return limit;
gallonm 7:2dc81120c917 432 }
gallonm 7:2dc81120c917 433
gallonm 7:2dc81120c917 434
gallonm 7:2dc81120c917 435
gallonm 7:2dc81120c917 436 int VL6180X::VL6180x_StaticInit(VL6180xDev_t dev){
gallonm 7:2dc81120c917 437 int status=0, init_status;
gallonm 7:2dc81120c917 438 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 439
gallonm 7:2dc81120c917 440 /* TODO doc When using configurable scaling but using 1x as start condition
gallonm 7:2dc81120c917 441 * load tunning upscale or not ??? */
gallonm 7:2dc81120c917 442 if( _GetUpscale(dev) == 1 && !(VL6180x_UPSCALE_SUPPORT<0))
gallonm 7:2dc81120c917 443 init_status=VL6180x_RangeStaticInit(dev);
gallonm 7:2dc81120c917 444 else
gallonm 7:2dc81120c917 445 init_status=VL6180x_UpscaleStaticInit(dev);
gallonm 7:2dc81120c917 446
gallonm 7:2dc81120c917 447 if( init_status <0 ){
gallonm 7:2dc81120c917 448 VL6180x_ErrLog("StaticInit fail");
gallonm 7:2dc81120c917 449 goto error;
gallonm 7:2dc81120c917 450 }
gallonm 7:2dc81120c917 451 else if(init_status > 0){
gallonm 7:2dc81120c917 452 VL6180x_ErrLog("StaticInit warning");
gallonm 7:2dc81120c917 453 }
gallonm 7:2dc81120c917 454
gallonm 7:2dc81120c917 455 #if REFRESH_CACHED_DATA_AFTER_INIT
gallonm 7:2dc81120c917 456 /* update cached value after tuning applied */
gallonm 7:2dc81120c917 457 do{
gallonm 7:2dc81120c917 458 #ifdef VL6180x_HAVE_ALS_DATA
gallonm 7:2dc81120c917 459 uint8_t data;
gallonm 7:2dc81120c917 460 status= VL6180x_RdByte(dev, FW_ALS_RESULT_SCALER, &data);
gallonm 7:2dc81120c917 461 if( status ) break;
gallonm 7:2dc81120c917 462 VL6180xDevDataSet(dev, AlsScaler, data);
gallonm 7:2dc81120c917 463
gallonm 7:2dc81120c917 464 status= VL6180x_RdByte(dev, SYSALS_ANALOGUE_GAIN, &data);
gallonm 7:2dc81120c917 465 if( status ) break;
gallonm 7:2dc81120c917 466 VL6180x_AlsSetAnalogueGain(dev, data);
gallonm 7:2dc81120c917 467 #endif
gallonm 7:2dc81120c917 468 }
gallonm 7:2dc81120c917 469 while(0);
gallonm 7:2dc81120c917 470 #endif /* REFRESH_CACHED_DATA_AFTER_INIT */
gallonm 7:2dc81120c917 471 if( status < 0 ){
gallonm 7:2dc81120c917 472 VL6180x_ErrLog("StaticInit fail");
gallonm 7:2dc81120c917 473 }
gallonm 7:2dc81120c917 474 if( !status && init_status){
gallonm 7:2dc81120c917 475 status = init_status;
gallonm 7:2dc81120c917 476 }
gallonm 7:2dc81120c917 477 error:
gallonm 7:2dc81120c917 478 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 479 return status;
gallonm 7:2dc81120c917 480 }
gallonm 7:2dc81120c917 481
gallonm 7:2dc81120c917 482
gallonm 7:2dc81120c917 483 int VL6180X::VL6180x_SetGroupParamHold(VL6180xDev_t dev, int Hold)
gallonm 7:2dc81120c917 484 {
gallonm 7:2dc81120c917 485 int status;
gallonm 7:2dc81120c917 486 uint8_t value;
gallonm 7:2dc81120c917 487
gallonm 7:2dc81120c917 488 LOG_FUNCTION_START("%d", Hold);
gallonm 7:2dc81120c917 489 if( Hold )
gallonm 7:2dc81120c917 490 value = 1;
gallonm 7:2dc81120c917 491 else
gallonm 7:2dc81120c917 492 value = 0;
gallonm 7:2dc81120c917 493 status = VL6180x_WrByte(dev, SYSTEM_GROUPED_PARAMETER_HOLD, value);
gallonm 7:2dc81120c917 494
gallonm 7:2dc81120c917 495 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 496 return status;
gallonm 7:2dc81120c917 497
gallonm 7:2dc81120c917 498 }
gallonm 7:2dc81120c917 499
gallonm 7:2dc81120c917 500 int VL6180X::VL6180x_Prepare(VL6180xDev_t dev)
gallonm 7:2dc81120c917 501 {
gallonm 7:2dc81120c917 502 int status;
gallonm 7:2dc81120c917 503 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 504
gallonm 7:2dc81120c917 505 do{
gallonm 7:2dc81120c917 506 status=VL6180x_StaticInit(dev);
gallonm 7:2dc81120c917 507 if( status<0) break;
gallonm 7:2dc81120c917 508
gallonm 7:2dc81120c917 509 /* set range InterruptMode to new sample */
gallonm 7:2dc81120c917 510 status=VL6180x_RangeConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY );
gallonm 7:2dc81120c917 511 if( status)
gallonm 7:2dc81120c917 512 break;
gallonm 7:2dc81120c917 513
gallonm 7:2dc81120c917 514 /* set default threshold */
gallonm 7:2dc81120c917 515 status=VL6180x_RangeSetRawThresholds(dev, 10, 200);
gallonm 7:2dc81120c917 516 if( status ){
gallonm 7:2dc81120c917 517 VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
gallonm 7:2dc81120c917 518 break;
gallonm 7:2dc81120c917 519 }
gallonm 7:2dc81120c917 520 #if VL6180x_ALS_SUPPORT
gallonm 7:2dc81120c917 521 status =VL6180x_AlsSetIntegrationPeriod(dev, 100);
gallonm 7:2dc81120c917 522 if( status ) break;
gallonm 7:2dc81120c917 523 status = VL6180x_AlsSetInterMeasurementPeriod(dev, 200);
gallonm 7:2dc81120c917 524 if( status ) break;
gallonm 7:2dc81120c917 525 status = VL6180x_AlsSetAnalogueGain(dev, 0);
gallonm 7:2dc81120c917 526 if( status ) break;
gallonm 7:2dc81120c917 527 status = VL6180x_AlsSetThresholds(dev, 0, 0xFF);
gallonm 7:2dc81120c917 528 if( status ) break;
gallonm 7:2dc81120c917 529 /* set Als InterruptMode to new sample */
gallonm 7:2dc81120c917 530 status=VL6180x_AlsConfigInterrupt(dev, CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY);
gallonm 7:2dc81120c917 531 if( status ) {
gallonm 7:2dc81120c917 532 VL6180x_ErrLog("VL6180x_AlsConfigInterrupt fail");
gallonm 7:2dc81120c917 533 break;
gallonm 7:2dc81120c917 534 }
gallonm 7:2dc81120c917 535 #endif
gallonm 7:2dc81120c917 536 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 537 _filter_Init(dev);
gallonm 7:2dc81120c917 538 #endif
gallonm 7:2dc81120c917 539 /* make sure to reset any left previous condition that can hangs first poll */
gallonm 7:2dc81120c917 540 status=VL6180x_ClearAllInterrupt(dev);
gallonm 7:2dc81120c917 541 }
gallonm 7:2dc81120c917 542 while(0);
gallonm 7:2dc81120c917 543 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 544
gallonm 7:2dc81120c917 545 return status;
gallonm 7:2dc81120c917 546 }
gallonm 7:2dc81120c917 547
gallonm 7:2dc81120c917 548 #if VL6180x_ALS_SUPPORT
gallonm 7:2dc81120c917 549 int VL6180X::VL6180x_AlsGetLux(VL6180xDev_t dev, lux_t *pLux)
gallonm 7:2dc81120c917 550 {
gallonm 7:2dc81120c917 551 int status;
gallonm 7:2dc81120c917 552 uint16_t RawAls;
gallonm 7:2dc81120c917 553 uint32_t luxValue = 0;
gallonm 7:2dc81120c917 554 uint32_t IntPeriod;
gallonm 7:2dc81120c917 555 uint32_t AlsAnGain;
gallonm 7:2dc81120c917 556 uint32_t GainFix;
gallonm 7:2dc81120c917 557 uint32_t AlsScaler;
gallonm 7:2dc81120c917 558
gallonm 7:2dc81120c917 559 #if LUXRES_FIX_PREC != GAIN_FIX_PREC
gallonm 7:2dc81120c917 560 #error "LUXRES_FIX_PREC != GAIN_FIX_PREC review these code to be correct"
gallonm 7:2dc81120c917 561 #endif
gallonm 7:2dc81120c917 562 const uint32_t LuxResxIntIme =(uint32_t)(0.56f* DEF_INT_PEFRIOD *(1<<LUXRES_FIX_PREC));
gallonm 7:2dc81120c917 563
gallonm 7:2dc81120c917 564 LOG_FUNCTION_START("%p", pLux);
gallonm 7:2dc81120c917 565
gallonm 7:2dc81120c917 566 status = VL6180x_RdWord( dev, RESULT_ALS_VAL, &RawAls);
gallonm 7:2dc81120c917 567 if( !status){
gallonm 7:2dc81120c917 568 /* wer are yet here at no fix point */
gallonm 7:2dc81120c917 569 IntPeriod=VL6180xDevDataGet(dev, IntegrationPeriod);
gallonm 7:2dc81120c917 570 AlsScaler=VL6180xDevDataGet(dev, AlsScaler);
gallonm 7:2dc81120c917 571 IntPeriod++; /* what stored is real time ms -1 and it can be 0 for or 0 or 1ms */
gallonm 7:2dc81120c917 572 luxValue = (uint32_t)RawAls * LuxResxIntIme; /* max # 16+8bits + 6bit (0.56*100) */
gallonm 7:2dc81120c917 573 luxValue /= IntPeriod; /* max # 16+8bits + 6bit 16+8+1 to 9 bit */
gallonm 7:2dc81120c917 574 /* between 29 - 21 bit */
gallonm 7:2dc81120c917 575 AlsAnGain = VL6180xDevDataGet(dev, AlsGainCode);
gallonm 7:2dc81120c917 576 GainFix = AlsGainLookUp[AlsAnGain];
gallonm 7:2dc81120c917 577 luxValue = luxValue / (AlsScaler * GainFix);
gallonm 7:2dc81120c917 578 *pLux=luxValue;
gallonm 7:2dc81120c917 579 }
gallonm 7:2dc81120c917 580
gallonm 7:2dc81120c917 581 LOG_FUNCTION_END_FMT(status, "%x",(int)*pLux);
gallonm 7:2dc81120c917 582 return status;
gallonm 7:2dc81120c917 583 }
gallonm 7:2dc81120c917 584
gallonm 7:2dc81120c917 585 int VL6180X::VL6180x_AlsGetMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData)
gallonm 7:2dc81120c917 586 {
gallonm 7:2dc81120c917 587 int status;
gallonm 7:2dc81120c917 588 uint8_t ErrStatus;
gallonm 7:2dc81120c917 589
gallonm 7:2dc81120c917 590 LOG_FUNCTION_START("%p", pAlsData);
gallonm 7:2dc81120c917 591
gallonm 7:2dc81120c917 592 status = VL6180x_AlsGetLux(dev, &pAlsData->lux);
gallonm 7:2dc81120c917 593 if( !status ){
gallonm 7:2dc81120c917 594 status = VL6180x_RdByte(dev, RESULT_ALS_STATUS, & ErrStatus);
gallonm 7:2dc81120c917 595 pAlsData->errorStatus = ErrStatus>>4;
gallonm 7:2dc81120c917 596 }
gallonm 7:2dc81120c917 597 LOG_FUNCTION_END_FMT(status,"%d %d", (int)pAlsData->lux, (int)pAlsData->errorStatus);
gallonm 7:2dc81120c917 598
gallonm 7:2dc81120c917 599 return status;
gallonm 7:2dc81120c917 600 }
gallonm 7:2dc81120c917 601
gallonm 7:2dc81120c917 602
gallonm 7:2dc81120c917 603 int VL6180X::VL6180x_AlsPollMeasurement(VL6180xDev_t dev, VL6180x_AlsData_t *pAlsData) {
gallonm 7:2dc81120c917 604 int status;
gallonm 7:2dc81120c917 605 int ClrStatus;
gallonm 7:2dc81120c917 606 uint8_t IntStatus;
gallonm 7:2dc81120c917 607
gallonm 7:2dc81120c917 608 LOG_FUNCTION_START("%p", pAlsData);
gallonm 7:2dc81120c917 609 #if VL6180X_SAFE_POLLING_ENTER
gallonm 7:2dc81120c917 610 /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
gallonm 7:2dc81120c917 611 status=VL6180x_AlsClearInterrupt(dev);
gallonm 7:2dc81120c917 612 if(status){
gallonm 7:2dc81120c917 613 VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
gallonm 7:2dc81120c917 614 goto over;
gallonm 7:2dc81120c917 615 }
gallonm 7:2dc81120c917 616 #endif
gallonm 7:2dc81120c917 617
gallonm 7:2dc81120c917 618 status=VL6180x_AlsSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
gallonm 7:2dc81120c917 619 if( status){
gallonm 7:2dc81120c917 620 VL6180x_ErrLog("VL6180x_AlsSetSystemMode fail");
gallonm 7:2dc81120c917 621 goto over;
gallonm 7:2dc81120c917 622 }
gallonm 7:2dc81120c917 623
gallonm 7:2dc81120c917 624 /* poll for new sample ready */
gallonm 7:2dc81120c917 625 while (1 ) {
gallonm 7:2dc81120c917 626 status = VL6180x_AlsGetInterruptStatus(dev, &IntStatus);
gallonm 7:2dc81120c917 627 if (status) {
gallonm 7:2dc81120c917 628 break;
gallonm 7:2dc81120c917 629 }
gallonm 7:2dc81120c917 630 if (IntStatus == RES_INT_STAT_GPIO_NEW_SAMPLE_READY) {
gallonm 7:2dc81120c917 631 break; /* break on new data (status is 0) */
gallonm 7:2dc81120c917 632 }
gallonm 7:2dc81120c917 633
gallonm 7:2dc81120c917 634 VL6180x_PollDelay(dev);
gallonm 7:2dc81120c917 635 };
gallonm 7:2dc81120c917 636
gallonm 7:2dc81120c917 637 if (!status) {
gallonm 7:2dc81120c917 638 status = VL6180x_AlsGetMeasurement(dev, pAlsData);
gallonm 7:2dc81120c917 639 }
gallonm 7:2dc81120c917 640
gallonm 7:2dc81120c917 641 ClrStatus = VL6180x_AlsClearInterrupt(dev);
gallonm 7:2dc81120c917 642 if (ClrStatus) {
gallonm 7:2dc81120c917 643 VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
gallonm 7:2dc81120c917 644 if (!status) {
gallonm 7:2dc81120c917 645 status = ClrStatus; /* leave previous if already on error */
gallonm 7:2dc81120c917 646 }
gallonm 7:2dc81120c917 647 }
gallonm 7:2dc81120c917 648 over:
gallonm 7:2dc81120c917 649 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 650
gallonm 7:2dc81120c917 651 return status;
gallonm 7:2dc81120c917 652 }
gallonm 7:2dc81120c917 653
gallonm 7:2dc81120c917 654 int VL6180X::VL6180x_AlsGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
gallonm 7:2dc81120c917 655 int status;
gallonm 7:2dc81120c917 656 uint8_t IntStatus;
gallonm 7:2dc81120c917 657 LOG_FUNCTION_START("%p", pIntStatus);
gallonm 7:2dc81120c917 658
gallonm 7:2dc81120c917 659 status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
gallonm 7:2dc81120c917 660 *pIntStatus= (IntStatus>>3)&0x07;
gallonm 7:2dc81120c917 661
gallonm 7:2dc81120c917 662 LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
gallonm 7:2dc81120c917 663 return status;
gallonm 7:2dc81120c917 664 }
gallonm 7:2dc81120c917 665
gallonm 7:2dc81120c917 666 int VL6180X::VL6180x_AlsWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
gallonm 7:2dc81120c917 667 int status;
gallonm 7:2dc81120c917 668 int n;
gallonm 7:2dc81120c917 669 uint8_t u8;
gallonm 7:2dc81120c917 670 LOG_FUNCTION_START("%d", (int)MaxLoop);
gallonm 7:2dc81120c917 671 if( MaxLoop<1){
gallonm 7:2dc81120c917 672 status=INVALID_PARAMS;
gallonm 7:2dc81120c917 673 }
gallonm 7:2dc81120c917 674 else{
gallonm 7:2dc81120c917 675 for( n=0; n < MaxLoop ; n++){
gallonm 7:2dc81120c917 676 status=VL6180x_RdByte(dev, RESULT_ALS_STATUS, &u8);
gallonm 7:2dc81120c917 677 if( status)
gallonm 7:2dc81120c917 678 break;
gallonm 7:2dc81120c917 679 u8 = u8 & ALS_DEVICE_READY_MASK;
gallonm 7:2dc81120c917 680 if( u8 )
gallonm 7:2dc81120c917 681 break;
gallonm 7:2dc81120c917 682
gallonm 7:2dc81120c917 683 }
gallonm 7:2dc81120c917 684 if( !status && !u8 ){
gallonm 7:2dc81120c917 685 status = TIME_OUT;
gallonm 7:2dc81120c917 686 }
gallonm 7:2dc81120c917 687 }
gallonm 7:2dc81120c917 688 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 689 return status;
gallonm 7:2dc81120c917 690 }
gallonm 7:2dc81120c917 691
gallonm 7:2dc81120c917 692 int VL6180X::VL6180x_AlsSetSystemMode(VL6180xDev_t dev, uint8_t mode)
gallonm 7:2dc81120c917 693 {
gallonm 7:2dc81120c917 694 int status;
gallonm 7:2dc81120c917 695 LOG_FUNCTION_START("%d", (int)mode);
gallonm 7:2dc81120c917 696 /* FIXME if we are called back to back real fast we are not checking
gallonm 7:2dc81120c917 697 * if previous mode "set" got absorbed => bit 0 must be 0 so that wr 1 work */
gallonm 7:2dc81120c917 698 if( mode <= 3){
gallonm 7:2dc81120c917 699 status=VL6180x_WrByte(dev, SYSALS_START, mode);
gallonm 7:2dc81120c917 700 }
gallonm 7:2dc81120c917 701 else{
gallonm 7:2dc81120c917 702 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 703 }
gallonm 7:2dc81120c917 704 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 705 return status;
gallonm 7:2dc81120c917 706 }
gallonm 7:2dc81120c917 707
gallonm 7:2dc81120c917 708 int VL6180X::VL6180x_AlsConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
gallonm 7:2dc81120c917 709 {
gallonm 7:2dc81120c917 710 int status;
gallonm 7:2dc81120c917 711
gallonm 7:2dc81120c917 712 if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
gallonm 7:2dc81120c917 713 status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_ALS_MASK), (ConfigGpioInt<<3));
gallonm 7:2dc81120c917 714 }
gallonm 7:2dc81120c917 715 else{
gallonm 7:2dc81120c917 716 VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
gallonm 7:2dc81120c917 717 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 718 }
gallonm 7:2dc81120c917 719 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 720 return status;
gallonm 7:2dc81120c917 721 }
gallonm 7:2dc81120c917 722
gallonm 7:2dc81120c917 723
gallonm 7:2dc81120c917 724
gallonm 7:2dc81120c917 725 int VL6180X::VL6180x_AlsSetThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high) {
gallonm 7:2dc81120c917 726 int status;
gallonm 7:2dc81120c917 727
gallonm 7:2dc81120c917 728 LOG_FUNCTION_START("%d %d", (int )low, (int)high);
gallonm 7:2dc81120c917 729
gallonm 7:2dc81120c917 730 status = VL6180x_WrByte(dev, SYSALS_THRESH_LOW, low);
gallonm 7:2dc81120c917 731 if(!status ){
gallonm 7:2dc81120c917 732 status = VL6180x_WrByte(dev, SYSALS_THRESH_HIGH, high);
gallonm 7:2dc81120c917 733 }
gallonm 7:2dc81120c917 734
gallonm 7:2dc81120c917 735 LOG_FUNCTION_END(status) ;
gallonm 7:2dc81120c917 736 return status;
gallonm 7:2dc81120c917 737 }
gallonm 7:2dc81120c917 738
gallonm 7:2dc81120c917 739
gallonm 7:2dc81120c917 740 int VL6180X::VL6180x_AlsSetAnalogueGain(VL6180xDev_t dev, uint8_t gain) {
gallonm 7:2dc81120c917 741 int status;
gallonm 7:2dc81120c917 742 uint8_t GainTotal;
gallonm 7:2dc81120c917 743
gallonm 7:2dc81120c917 744 LOG_FUNCTION_START("%d", (int )gain);
gallonm 7:2dc81120c917 745 gain&=~0x40;
gallonm 7:2dc81120c917 746 if (gain > 7) {
gallonm 7:2dc81120c917 747 gain = 7;
gallonm 7:2dc81120c917 748 }
gallonm 7:2dc81120c917 749 GainTotal = gain|0x40;
gallonm 7:2dc81120c917 750
gallonm 7:2dc81120c917 751 status = VL6180x_WrByte(dev, SYSALS_ANALOGUE_GAIN, GainTotal);
gallonm 7:2dc81120c917 752 if( !status){
gallonm 7:2dc81120c917 753 VL6180xDevDataSet(dev, AlsGainCode, gain);
gallonm 7:2dc81120c917 754 }
gallonm 7:2dc81120c917 755
gallonm 7:2dc81120c917 756 LOG_FUNCTION_END_FMT(status, "%d %d", (int ) gain, (int )GainTotal);
gallonm 7:2dc81120c917 757 return status;
gallonm 7:2dc81120c917 758 }
gallonm 7:2dc81120c917 759
gallonm 7:2dc81120c917 760 int VL6180X::VL6180x_AlsSetInterMeasurementPeriod(VL6180xDev_t dev, uint16_t intermeasurement_period_ms)
gallonm 7:2dc81120c917 761 {
gallonm 7:2dc81120c917 762 int status;
gallonm 7:2dc81120c917 763
gallonm 7:2dc81120c917 764 LOG_FUNCTION_START("%d",(int)intermeasurement_period_ms);
gallonm 7:2dc81120c917 765 /* clipping: range is 0-2550ms */
gallonm 7:2dc81120c917 766 if (intermeasurement_period_ms >= 255 *10)
gallonm 7:2dc81120c917 767 intermeasurement_period_ms = 255 *10;
gallonm 7:2dc81120c917 768 status=VL6180x_WrByte(dev, SYSALS_INTERMEASUREMENT_PERIOD, (uint8_t)(intermeasurement_period_ms/10));
gallonm 7:2dc81120c917 769
gallonm 7:2dc81120c917 770 LOG_FUNCTION_END_FMT(status, "%d", (int) intermeasurement_period_ms);
gallonm 7:2dc81120c917 771 return status;
gallonm 7:2dc81120c917 772 }
gallonm 7:2dc81120c917 773
gallonm 7:2dc81120c917 774
gallonm 7:2dc81120c917 775 int VL6180X::VL6180x_AlsSetIntegrationPeriod(VL6180xDev_t dev, uint16_t period_ms)
gallonm 7:2dc81120c917 776 {
gallonm 7:2dc81120c917 777 int status;
gallonm 7:2dc81120c917 778 uint16_t SetIntegrationPeriod;
gallonm 7:2dc81120c917 779
gallonm 7:2dc81120c917 780 LOG_FUNCTION_START("%d", (int)period_ms);
gallonm 7:2dc81120c917 781
gallonm 7:2dc81120c917 782 if( period_ms>=1 )
gallonm 7:2dc81120c917 783 SetIntegrationPeriod = period_ms - 1;
gallonm 7:2dc81120c917 784 else
gallonm 7:2dc81120c917 785 SetIntegrationPeriod = period_ms;
gallonm 7:2dc81120c917 786
gallonm 7:2dc81120c917 787 if (SetIntegrationPeriod > 464) {
gallonm 7:2dc81120c917 788 SetIntegrationPeriod = 464;
gallonm 7:2dc81120c917 789 }
gallonm 7:2dc81120c917 790 else if (SetIntegrationPeriod == 255) {
gallonm 7:2dc81120c917 791 SetIntegrationPeriod++; /* can't write 255 since this causes the device to lock out.*/
gallonm 7:2dc81120c917 792 }
gallonm 7:2dc81120c917 793
gallonm 7:2dc81120c917 794 status =VL6180x_WrWord(dev, SYSALS_INTEGRATION_PERIOD, SetIntegrationPeriod);
gallonm 7:2dc81120c917 795 if( !status ){
gallonm 7:2dc81120c917 796 VL6180xDevDataSet(dev, IntegrationPeriod, SetIntegrationPeriod) ;
gallonm 7:2dc81120c917 797 }
gallonm 7:2dc81120c917 798 LOG_FUNCTION_END_FMT(status, "%d", (int)SetIntegrationPeriod);
gallonm 7:2dc81120c917 799 return status;
gallonm 7:2dc81120c917 800 }
gallonm 7:2dc81120c917 801
gallonm 7:2dc81120c917 802 #endif /* HAVE_ALS_SUPPORT */
gallonm 7:2dc81120c917 803
gallonm 7:2dc81120c917 804
gallonm 7:2dc81120c917 805 int VL6180X::VL6180x_RangePollMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
gallonm 7:2dc81120c917 806 {
gallonm 7:2dc81120c917 807 int status;
gallonm 7:2dc81120c917 808 int ClrStatus;
gallonm 7:2dc81120c917 809 IntrStatus_t IntStatus;
gallonm 7:2dc81120c917 810
gallonm 7:2dc81120c917 811 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 812 /* start single range measurement */
gallonm 7:2dc81120c917 813
gallonm 7:2dc81120c917 814
gallonm 7:2dc81120c917 815 #if VL6180X_SAFE_POLLING_ENTER
gallonm 7:2dc81120c917 816 /* if device get stopped with left interrupt uncleared , it is required to clear them now or poll for new condition will never occur*/
gallonm 7:2dc81120c917 817 status=VL6180x_RangeClearInterrupt(dev);
gallonm 7:2dc81120c917 818 if(status){
gallonm 7:2dc81120c917 819 VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
gallonm 7:2dc81120c917 820 goto done;
gallonm 7:2dc81120c917 821 }
gallonm 7:2dc81120c917 822 #endif
gallonm 7:2dc81120c917 823 /* //![single_shot_snipet] */
gallonm 7:2dc81120c917 824 status=VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
gallonm 7:2dc81120c917 825 if( status ){
gallonm 7:2dc81120c917 826 VL6180x_ErrLog("VL6180x_RangeSetSystemMode fail");
gallonm 7:2dc81120c917 827 goto done;
gallonm 7:2dc81120c917 828 }
gallonm 7:2dc81120c917 829
gallonm 7:2dc81120c917 830 /* poll for new sample ready */
gallonm 7:2dc81120c917 831 while(1 ){
gallonm 7:2dc81120c917 832 status=VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
gallonm 7:2dc81120c917 833 if( status ){
gallonm 7:2dc81120c917 834 break;
gallonm 7:2dc81120c917 835 }
gallonm 7:2dc81120c917 836 if( IntStatus.status.Error !=0 ){
gallonm 7:2dc81120c917 837 VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
gallonm 7:2dc81120c917 838 status = RANGE_ERROR;
gallonm 7:2dc81120c917 839 break;
gallonm 7:2dc81120c917 840 }
gallonm 7:2dc81120c917 841 else
gallonm 7:2dc81120c917 842 if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
gallonm 7:2dc81120c917 843 break;
gallonm 7:2dc81120c917 844 }
gallonm 12:71d589e6fd2c 845
gallonm 7:2dc81120c917 846 VL6180x_PollDelay(dev);
gallonm 7:2dc81120c917 847 }
gallonm 7:2dc81120c917 848 /* //![single_shot_snipet] */
gallonm 7:2dc81120c917 849
gallonm 7:2dc81120c917 850 if ( !status ){
gallonm 7:2dc81120c917 851 status = VL6180x_RangeGetMeasurement(dev, pRangeData);
gallonm 7:2dc81120c917 852 }
gallonm 7:2dc81120c917 853
gallonm 7:2dc81120c917 854 /* clear range interrupt source */
gallonm 7:2dc81120c917 855 ClrStatus = VL6180x_RangeClearInterrupt(dev);
gallonm 7:2dc81120c917 856 if( ClrStatus ){
gallonm 7:2dc81120c917 857 VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
gallonm 7:2dc81120c917 858 /* leave initial status if already in error */
gallonm 7:2dc81120c917 859 if( !status ){
gallonm 7:2dc81120c917 860 status=ClrStatus;
gallonm 7:2dc81120c917 861 }
gallonm 7:2dc81120c917 862 }
gallonm 7:2dc81120c917 863 done:
gallonm 7:2dc81120c917 864 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 865 return status;
gallonm 7:2dc81120c917 866 }
gallonm 7:2dc81120c917 867
gallonm 7:2dc81120c917 868
gallonm 7:2dc81120c917 869
gallonm 7:2dc81120c917 870 int VL6180X::VL6180x_RangeGetMeasurement(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
gallonm 7:2dc81120c917 871 {
gallonm 7:2dc81120c917 872 int status;
gallonm 7:2dc81120c917 873 uint16_t RawRate;
gallonm 7:2dc81120c917 874 uint8_t RawStatus;
gallonm 7:2dc81120c917 875
gallonm 7:2dc81120c917 876 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 877
gallonm 7:2dc81120c917 878 status = VL6180x_RangeGetResult(dev, &pRangeData->range_mm);
gallonm 7:2dc81120c917 879 if( !status ){
gallonm 7:2dc81120c917 880 status = VL6180x_RdWord(dev,RESULT_RANGE_SIGNAL_RATE, &RawRate );
gallonm 7:2dc81120c917 881 if( !status ){
gallonm 7:2dc81120c917 882 pRangeData->signalRate_mcps = VL6180x_9to7Conv(RawRate);
gallonm 7:2dc81120c917 883 status = VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &RawStatus);
gallonm 7:2dc81120c917 884 if( !status ){
gallonm 7:2dc81120c917 885 pRangeData->errorStatus = RawStatus >>4;
gallonm 7:2dc81120c917 886 }
gallonm 7:2dc81120c917 887 else{
gallonm 7:2dc81120c917 888 VL6180x_ErrLog("Rd RESULT_RANGE_STATUS fail");
gallonm 7:2dc81120c917 889 }
gallonm 7:2dc81120c917 890 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT || VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 891 status = _GetRateResult(dev, pRangeData);
gallonm 7:2dc81120c917 892 if( status )
gallonm 7:2dc81120c917 893 goto error;
gallonm 7:2dc81120c917 894 #endif
gallonm 7:2dc81120c917 895 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 896 /* if enabled run filter */
gallonm 7:2dc81120c917 897 if( _IsWrapArroundActive(dev) ){
gallonm 7:2dc81120c917 898 status=_filter_GetResult(dev, pRangeData);
gallonm 7:2dc81120c917 899 if( !status){
gallonm 7:2dc81120c917 900 /* patch the range status and measure if it is filtered */
gallonm 7:2dc81120c917 901 if( pRangeData->range_mm != pRangeData->FilteredData.range_mm) {
gallonm 7:2dc81120c917 902 pRangeData->errorStatus=RangingFiltered;
gallonm 7:2dc81120c917 903 pRangeData->range_mm = pRangeData->FilteredData.range_mm;
gallonm 7:2dc81120c917 904 }
gallonm 7:2dc81120c917 905 }
gallonm 7:2dc81120c917 906 }
gallonm 7:2dc81120c917 907 #endif
gallonm 7:2dc81120c917 908
gallonm 7:2dc81120c917 909 #if VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 910 if(_IsDMaxActive(dev) ){
gallonm 7:2dc81120c917 911 _DMax_Compute(dev, pRangeData);
gallonm 7:2dc81120c917 912 }
gallonm 7:2dc81120c917 913 #endif
gallonm 7:2dc81120c917 914 }
gallonm 7:2dc81120c917 915 else{
gallonm 7:2dc81120c917 916 VL6180x_ErrLog("Rd RESULT_RANGE_SIGNAL_RATE fail");
gallonm 7:2dc81120c917 917 }
gallonm 7:2dc81120c917 918 }
gallonm 7:2dc81120c917 919 else{
gallonm 7:2dc81120c917 920 VL6180x_ErrLog("VL6180x_GetRangeResult fail");
gallonm 7:2dc81120c917 921 }
gallonm 7:2dc81120c917 922 error:
gallonm 7:2dc81120c917 923 LOG_FUNCTION_END_FMT(status, "%d %d %d", (int)pRangeData->range_mm, (int)pRangeData->signalRate_mcps, (int)pRangeData->errorStatus) ;
gallonm 7:2dc81120c917 924 return status;
gallonm 7:2dc81120c917 925 }
gallonm 7:2dc81120c917 926
gallonm 7:2dc81120c917 927
gallonm 7:2dc81120c917 928 int VL6180X::VL6180x_RangeGetMeasurementIfReady(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData)
gallonm 7:2dc81120c917 929 {
gallonm 7:2dc81120c917 930 int status;
gallonm 7:2dc81120c917 931 IntrStatus_t IntStatus;
gallonm 7:2dc81120c917 932
gallonm 7:2dc81120c917 933 LOG_FUNCTION_START();
gallonm 7:2dc81120c917 934
gallonm 7:2dc81120c917 935 status = VL6180x_RangeGetInterruptStatus(dev, &IntStatus.val);
gallonm 7:2dc81120c917 936 if( status ==0 ){
gallonm 7:2dc81120c917 937 if( IntStatus.status.Error !=0 ){
gallonm 7:2dc81120c917 938 VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
gallonm 7:2dc81120c917 939 status = RANGE_ERROR;
gallonm 7:2dc81120c917 940 }
gallonm 7:2dc81120c917 941 else
gallonm 7:2dc81120c917 942 if( IntStatus.status.Range == RES_INT_STAT_GPIO_NEW_SAMPLE_READY){
gallonm 7:2dc81120c917 943 status = VL6180x_RangeGetMeasurement(dev,pRangeData );
gallonm 7:2dc81120c917 944 if( status == 0){
gallonm 7:2dc81120c917 945 /* clear range interrupt source */
gallonm 7:2dc81120c917 946 status = VL6180x_RangeClearInterrupt(dev);
gallonm 7:2dc81120c917 947 if( status ){
gallonm 7:2dc81120c917 948 VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
gallonm 7:2dc81120c917 949 }
gallonm 7:2dc81120c917 950 }
gallonm 7:2dc81120c917 951 }
gallonm 7:2dc81120c917 952 else{
gallonm 7:2dc81120c917 953 status = NOT_READY;
gallonm 7:2dc81120c917 954 }
gallonm 7:2dc81120c917 955 }
gallonm 7:2dc81120c917 956 else{
gallonm 7:2dc81120c917 957 VL6180x_ErrLog("fail to get interrupt status");
gallonm 7:2dc81120c917 958 }
gallonm 7:2dc81120c917 959 LOG_FUNCTION_END(status) ;
gallonm 7:2dc81120c917 960 return status;
gallonm 7:2dc81120c917 961 }
gallonm 7:2dc81120c917 962
gallonm 7:2dc81120c917 963 int VL6180X::VL6180x_FilterSetState(VL6180xDev_t dev, int state){
gallonm 7:2dc81120c917 964 int status;
gallonm 7:2dc81120c917 965 LOG_FUNCTION_START("%d", state);
gallonm 7:2dc81120c917 966 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 967 VL6180xDevDataSet(dev,WrapAroundFilterActive, state);
gallonm 7:2dc81120c917 968 status = 0;
gallonm 7:2dc81120c917 969 #else
gallonm 7:2dc81120c917 970 status = NOT_SUPPORTED;
gallonm 7:2dc81120c917 971 #endif
gallonm 7:2dc81120c917 972 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 973 return status;
gallonm 7:2dc81120c917 974 }
gallonm 7:2dc81120c917 975
gallonm 7:2dc81120c917 976 int VL6180X::VL6180x_FilterGetState(VL6180xDev_t dev){
gallonm 7:2dc81120c917 977 int status;
gallonm 7:2dc81120c917 978 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 979 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 980 status = VL6180xDevDataGet(dev,WrapAroundFilterActive);
gallonm 7:2dc81120c917 981 #else
gallonm 7:2dc81120c917 982 status = 0;
gallonm 7:2dc81120c917 983 #endif
gallonm 7:2dc81120c917 984 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 985 return status;
gallonm 7:2dc81120c917 986 }
gallonm 7:2dc81120c917 987
gallonm 7:2dc81120c917 988 int VL6180X::VL6180x_RangeGetResult(VL6180xDev_t dev, int32_t *pRange_mm) {
gallonm 7:2dc81120c917 989 int status;
gallonm 7:2dc81120c917 990 uint8_t RawRange;
gallonm 7:2dc81120c917 991 int32_t Upscale;
gallonm 7:2dc81120c917 992
gallonm 7:2dc81120c917 993 LOG_FUNCTION_START("%p",pRange_mm);
gallonm 7:2dc81120c917 994
gallonm 7:2dc81120c917 995 status = VL6180x_RdByte(dev, RESULT_RANGE_VAL, &RawRange);
gallonm 7:2dc81120c917 996 if( !status ){
gallonm 10:4954b09b72d8 997 Upscale = _GetUpscale(dev);
gallonm 7:2dc81120c917 998 *pRange_mm= Upscale*(int32_t)RawRange;
gallonm 7:2dc81120c917 999 }
gallonm 7:2dc81120c917 1000 LOG_FUNCTION_END_FMT(status, "%d", (int)*pRange_mm);
gallonm 7:2dc81120c917 1001 return status;
gallonm 7:2dc81120c917 1002 }
gallonm 7:2dc81120c917 1003
gallonm 7:2dc81120c917 1004 int VL6180X::VL6180x_RangeSetRawThresholds(VL6180xDev_t dev, uint8_t low, uint8_t high)
gallonm 7:2dc81120c917 1005 {
gallonm 7:2dc81120c917 1006 int status;
gallonm 7:2dc81120c917 1007 LOG_FUNCTION_START("%d %d", (int) low, (int)high);
gallonm 7:2dc81120c917 1008 /* TODO we can optimize here grouping high/low in a word but that's cpu endianness dependent */
gallonm 7:2dc81120c917 1009 status=VL6180x_WrByte(dev, SYSRANGE_THRESH_HIGH,high);
gallonm 7:2dc81120c917 1010 if( !status){
gallonm 7:2dc81120c917 1011 status=VL6180x_WrByte(dev, SYSRANGE_THRESH_LOW, low);
gallonm 7:2dc81120c917 1012 }
gallonm 7:2dc81120c917 1013
gallonm 7:2dc81120c917 1014 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1015 return status;
gallonm 7:2dc81120c917 1016 }
gallonm 7:2dc81120c917 1017
gallonm 7:2dc81120c917 1018 int VL6180X::VL6180x_RangeSetThresholds(VL6180xDev_t dev, uint16_t low, uint16_t high, int UseSafeParamHold)
gallonm 7:2dc81120c917 1019 {
gallonm 7:2dc81120c917 1020 int status;
gallonm 7:2dc81120c917 1021 int scale;
gallonm 7:2dc81120c917 1022 LOG_FUNCTION_START("%d %d", (int) low, (int)high);
gallonm 7:2dc81120c917 1023 scale=_GetUpscale(dev,UpscaleFactor);
gallonm 7:2dc81120c917 1024 if( low>scale*255 || high >scale*255){
gallonm 7:2dc81120c917 1025 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1026 }
gallonm 7:2dc81120c917 1027 else{
gallonm 7:2dc81120c917 1028 do{
gallonm 7:2dc81120c917 1029 if( UseSafeParamHold ){
gallonm 7:2dc81120c917 1030 status=VL6180x_SetGroupParamHold(dev, 1);
gallonm 7:2dc81120c917 1031 if( status )
gallonm 7:2dc81120c917 1032 break;
gallonm 7:2dc81120c917 1033 }
gallonm 7:2dc81120c917 1034 status=VL6180x_RangeSetRawThresholds(dev, (uint8_t)(low/scale), (uint8_t)(high/scale));
gallonm 7:2dc81120c917 1035 if( status ){
gallonm 7:2dc81120c917 1036 VL6180x_ErrLog("VL6180x_RangeSetRawThresholds fail");
gallonm 7:2dc81120c917 1037 }
gallonm 7:2dc81120c917 1038 if( UseSafeParamHold ){
gallonm 7:2dc81120c917 1039 int HoldStatus;
gallonm 7:2dc81120c917 1040 /* tryt to unset param hold vene if previous fail */
gallonm 7:2dc81120c917 1041 HoldStatus=VL6180x_SetGroupParamHold(dev, 0);
gallonm 7:2dc81120c917 1042 if( !status)
gallonm 7:2dc81120c917 1043 status=HoldStatus;
gallonm 7:2dc81120c917 1044 }
gallonm 7:2dc81120c917 1045 }
gallonm 7:2dc81120c917 1046 while(0);
gallonm 7:2dc81120c917 1047 }
gallonm 7:2dc81120c917 1048
gallonm 7:2dc81120c917 1049 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1050 return status;
gallonm 7:2dc81120c917 1051 }
gallonm 7:2dc81120c917 1052
gallonm 7:2dc81120c917 1053
gallonm 7:2dc81120c917 1054 int VL6180X::VL6180x_RangeGetThresholds(VL6180xDev_t dev, uint16_t *low, uint16_t *high)
gallonm 7:2dc81120c917 1055 {
gallonm 7:2dc81120c917 1056 int status;
gallonm 7:2dc81120c917 1057 uint8_t RawLow, RawHigh;
gallonm 7:2dc81120c917 1058 int scale;
gallonm 7:2dc81120c917 1059
gallonm 7:2dc81120c917 1060 LOG_FUNCTION_START("%p %p", low , high);
gallonm 7:2dc81120c917 1061
gallonm 7:2dc81120c917 1062 scale=_GetUpscale(dev,UpscaleFactor);
gallonm 7:2dc81120c917 1063 do{
gallonm 7:2dc81120c917 1064 if( high != NULL ){
gallonm 7:2dc81120c917 1065 status=VL6180x_RdByte(dev, SYSRANGE_THRESH_HIGH,&RawHigh);
gallonm 7:2dc81120c917 1066 if( status ){
gallonm 7:2dc81120c917 1067 VL6180x_ErrLog("rd SYSRANGE_THRESH_HIGH fail");
gallonm 7:2dc81120c917 1068 break;
gallonm 7:2dc81120c917 1069 }
gallonm 7:2dc81120c917 1070 *high=(uint16_t)RawHigh*scale;
gallonm 7:2dc81120c917 1071 }
gallonm 7:2dc81120c917 1072 if( low != NULL ) {
gallonm 7:2dc81120c917 1073 status=VL6180x_RdByte(dev, SYSRANGE_THRESH_LOW, &RawLow);
gallonm 7:2dc81120c917 1074 if( status ){
gallonm 7:2dc81120c917 1075 VL6180x_ErrLog("rd SYSRANGE_THRESH_LOW fail");
gallonm 7:2dc81120c917 1076 break;
gallonm 7:2dc81120c917 1077 }
gallonm 7:2dc81120c917 1078 *low=(uint16_t)RawLow*scale;
gallonm 7:2dc81120c917 1079 }
gallonm 7:2dc81120c917 1080 }
gallonm 7:2dc81120c917 1081 while(0);
gallonm 7:2dc81120c917 1082 LOG_FUNCTION_END_FMT(status, "%d %d",(int)*low ,(int)*high);
gallonm 7:2dc81120c917 1083 return status;
gallonm 7:2dc81120c917 1084 }
gallonm 7:2dc81120c917 1085
gallonm 7:2dc81120c917 1086
gallonm 7:2dc81120c917 1087 int VL6180X::VL6180x_RangeGetInterruptStatus(VL6180xDev_t dev, uint8_t *pIntStatus) {
gallonm 7:2dc81120c917 1088 int status;
gallonm 7:2dc81120c917 1089 uint8_t IntStatus;
gallonm 7:2dc81120c917 1090 LOG_FUNCTION_START("%p", pIntStatus);
gallonm 7:2dc81120c917 1091 /* FIXME we are grouping "error" with over status the user must check implicitly for it
gallonm 7:2dc81120c917 1092 * not just new sample or over status , that will nevr show up in case of error*/
gallonm 7:2dc81120c917 1093 status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, &IntStatus);
gallonm 7:2dc81120c917 1094 *pIntStatus= IntStatus&0xC7;
gallonm 7:2dc81120c917 1095
gallonm 7:2dc81120c917 1096 LOG_FUNCTION_END_FMT(status, "%d", (int)*pIntStatus);
gallonm 7:2dc81120c917 1097 return status;
gallonm 7:2dc81120c917 1098 }
gallonm 7:2dc81120c917 1099
gallonm 7:2dc81120c917 1100
gallonm 7:2dc81120c917 1101 int VL6180X::VL6180x_GetInterruptStatus(VL6180xDev_t dev, uint8_t *IntStatus)
gallonm 7:2dc81120c917 1102 {
gallonm 7:2dc81120c917 1103 int status;
gallonm 7:2dc81120c917 1104 LOG_FUNCTION_START("%p" , IntStatus);
gallonm 7:2dc81120c917 1105 status = VL6180x_RdByte(dev, RESULT_INTERRUPT_STATUS_GPIO, IntStatus);
gallonm 7:2dc81120c917 1106 LOG_FUNCTION_END_FMT(status, "%d", (int)*IntStatus);
gallonm 7:2dc81120c917 1107 return status;
gallonm 7:2dc81120c917 1108 }
gallonm 7:2dc81120c917 1109
gallonm 7:2dc81120c917 1110 int VL6180X::VL6180x_ClearInterrupt(VL6180xDev_t dev, uint8_t IntClear )
gallonm 7:2dc81120c917 1111 {
gallonm 7:2dc81120c917 1112 int status;
gallonm 7:2dc81120c917 1113 LOG_FUNCTION_START("%d" ,(int)IntClear);
gallonm 7:2dc81120c917 1114 if( IntClear <= 7 ){
gallonm 7:2dc81120c917 1115 status=VL6180x_WrByte( dev, SYSTEM_INTERRUPT_CLEAR, IntClear);
gallonm 7:2dc81120c917 1116 }
gallonm 7:2dc81120c917 1117 else{
gallonm 7:2dc81120c917 1118 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1119 }
gallonm 7:2dc81120c917 1120 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1121 return status;
gallonm 7:2dc81120c917 1122 }
gallonm 7:2dc81120c917 1123
gallonm 7:2dc81120c917 1124
gallonm 7:2dc81120c917 1125 int VL6180X::VL6180x_RangeStaticInit(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1126 {
gallonm 7:2dc81120c917 1127 int status;
gallonm 7:2dc81120c917 1128 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1129
gallonm 7:2dc81120c917 1130 /* REGISTER_TUNING_SR03_270514_CustomerView.txt */
gallonm 7:2dc81120c917 1131 VL6180x_WrByte( dev, 0x0207, 0x01);
gallonm 7:2dc81120c917 1132 VL6180x_WrByte( dev, 0x0208, 0x01);
gallonm 7:2dc81120c917 1133 VL6180x_WrByte( dev, 0x0096, 0x00);
gallonm 7:2dc81120c917 1134 VL6180x_WrByte( dev, 0x0097, 0xfd);
gallonm 7:2dc81120c917 1135 VL6180x_WrByte( dev, 0x00e3, 0x00);
gallonm 7:2dc81120c917 1136 VL6180x_WrByte( dev, 0x00e4, 0x04);
gallonm 7:2dc81120c917 1137 VL6180x_WrByte( dev, 0x00e5, 0x02);
gallonm 7:2dc81120c917 1138 VL6180x_WrByte( dev, 0x00e6, 0x01);
gallonm 7:2dc81120c917 1139 VL6180x_WrByte( dev, 0x00e7, 0x03);
gallonm 7:2dc81120c917 1140 VL6180x_WrByte( dev, 0x00f5, 0x02);
gallonm 7:2dc81120c917 1141 VL6180x_WrByte( dev, 0x00d9, 0x05);
gallonm 7:2dc81120c917 1142 VL6180x_WrByte( dev, 0x00db, 0xce);
gallonm 7:2dc81120c917 1143 VL6180x_WrByte( dev, 0x00dc, 0x03);
gallonm 7:2dc81120c917 1144 VL6180x_WrByte( dev, 0x00dd, 0xf8);
gallonm 7:2dc81120c917 1145 VL6180x_WrByte( dev, 0x009f, 0x00);
gallonm 7:2dc81120c917 1146 VL6180x_WrByte( dev, 0x00a3, 0x3c);
gallonm 7:2dc81120c917 1147 VL6180x_WrByte( dev, 0x00b7, 0x00);
gallonm 7:2dc81120c917 1148 VL6180x_WrByte( dev, 0x00bb, 0x3c);
gallonm 7:2dc81120c917 1149 VL6180x_WrByte( dev, 0x00b2, 0x09);
gallonm 7:2dc81120c917 1150 VL6180x_WrByte( dev, 0x00ca, 0x09);
gallonm 7:2dc81120c917 1151 VL6180x_WrByte( dev, 0x0198, 0x01);
gallonm 7:2dc81120c917 1152 VL6180x_WrByte( dev, 0x01b0, 0x17);
gallonm 7:2dc81120c917 1153 VL6180x_WrByte( dev, 0x01ad, 0x00);
gallonm 7:2dc81120c917 1154 VL6180x_WrByte( dev, 0x00ff, 0x05);
gallonm 7:2dc81120c917 1155 VL6180x_WrByte( dev, 0x0100, 0x05);
gallonm 7:2dc81120c917 1156 VL6180x_WrByte( dev, 0x0199, 0x05);
gallonm 7:2dc81120c917 1157 VL6180x_WrByte( dev, 0x01a6, 0x1b);
gallonm 7:2dc81120c917 1158 VL6180x_WrByte( dev, 0x01ac, 0x3e);
gallonm 7:2dc81120c917 1159 VL6180x_WrByte( dev, 0x01a7, 0x1f);
gallonm 7:2dc81120c917 1160 VL6180x_WrByte( dev, 0x0030, 0x00);
gallonm 7:2dc81120c917 1161
gallonm 7:2dc81120c917 1162 /* Recommended : Public registers - See data sheet for more detail */
gallonm 7:2dc81120c917 1163 VL6180x_WrByte( dev, 0x0011, 0x10); /* Enables polling for New Sample ready when measurement completes */
gallonm 7:2dc81120c917 1164 VL6180x_WrByte( dev, 0x010a, 0x30); /* Set the averaging sample period (compromise between lower noise and increased execution time) */
gallonm 7:2dc81120c917 1165 VL6180x_WrByte( dev, 0x003f, 0x46); /* Sets the light and dark gain (upper nibble). Dark gain should not be changed.*/
gallonm 7:2dc81120c917 1166 VL6180x_WrByte( dev, 0x0031, 0xFF); /* sets the # of range measurements after which auto calibration of system is performed */
gallonm 7:2dc81120c917 1167 VL6180x_WrByte( dev, 0x0040, 0x63); /* Set ALS integration time to 100ms */
gallonm 7:2dc81120c917 1168 VL6180x_WrByte( dev, 0x002e, 0x01); /* perform a single temperature calibration of the ranging sensor */
gallonm 7:2dc81120c917 1169
gallonm 7:2dc81120c917 1170 /* Optional: Public registers - See data sheet for more detail */
gallonm 7:2dc81120c917 1171 VL6180x_WrByte( dev, 0x001b, 0x09); /* Set default ranging inter-measurement period to 100ms */
gallonm 7:2dc81120c917 1172 VL6180x_WrByte( dev, 0x003e, 0x31); /* Set default ALS inter-measurement period to 500ms */
gallonm 7:2dc81120c917 1173 VL6180x_WrByte( dev, 0x0014, 0x24); /* Configures interrupt on New sample ready */
gallonm 7:2dc81120c917 1174
gallonm 7:2dc81120c917 1175
gallonm 7:2dc81120c917 1176 status=VL6180x_RangeSetMaxConvergenceTime(dev, 50); /* Calculate ece value on initialization (use max conv) */
gallonm 7:2dc81120c917 1177 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1178
gallonm 7:2dc81120c917 1179 return status;
gallonm 7:2dc81120c917 1180 }
gallonm 7:2dc81120c917 1181
gallonm 7:2dc81120c917 1182 #if VL6180x_UPSCALE_SUPPORT != 1
gallonm 7:2dc81120c917 1183
gallonm 7:2dc81120c917 1184 int VL6180X::_UpscaleInitPatch0(VL6180xDev_t dev){
gallonm 7:2dc81120c917 1185 int status;
gallonm 7:2dc81120c917 1186 uint32_t CalValue=0;
gallonm 7:2dc81120c917 1187 CalValue= VL6180xDevDataGet(dev, Part2PartAmbNVM);
gallonm 7:2dc81120c917 1188 status=VL6180x_WrDWord( dev, 0xDA, CalValue);
gallonm 7:2dc81120c917 1189 return status;
gallonm 7:2dc81120c917 1190 }
gallonm 7:2dc81120c917 1191
gallonm 7:2dc81120c917 1192 /* only include up-scaling register setting when up-scale support is configured in */
gallonm 7:2dc81120c917 1193 int VL6180X::VL6180x_UpscaleRegInit(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1194 {
gallonm 7:2dc81120c917 1195 /* apply REGISTER_TUNING_ER02_100614_CustomerView.txt */
gallonm 7:2dc81120c917 1196 VL6180x_WrByte( dev, 0x0207, 0x01);
gallonm 7:2dc81120c917 1197 VL6180x_WrByte( dev, 0x0208, 0x01);
gallonm 7:2dc81120c917 1198 VL6180x_WrByte( dev, 0x0096, 0x00);
gallonm 7:2dc81120c917 1199 VL6180x_WrByte( dev, 0x0097, 0x54);
gallonm 7:2dc81120c917 1200 VL6180x_WrByte( dev, 0x00e3, 0x00);
gallonm 7:2dc81120c917 1201 VL6180x_WrByte( dev, 0x00e4, 0x04);
gallonm 7:2dc81120c917 1202 VL6180x_WrByte( dev, 0x00e5, 0x02);
gallonm 7:2dc81120c917 1203 VL6180x_WrByte( dev, 0x00e6, 0x01);
gallonm 7:2dc81120c917 1204 VL6180x_WrByte( dev, 0x00e7, 0x03);
gallonm 7:2dc81120c917 1205 VL6180x_WrByte( dev, 0x00f5, 0x02);
gallonm 7:2dc81120c917 1206 VL6180x_WrByte( dev, 0x00d9, 0x05);
gallonm 7:2dc81120c917 1207
gallonm 7:2dc81120c917 1208 _UpscaleInitPatch0(dev);
gallonm 7:2dc81120c917 1209
gallonm 7:2dc81120c917 1210 VL6180x_WrByte( dev, 0x009f, 0x00);
gallonm 7:2dc81120c917 1211 VL6180x_WrByte( dev, 0x00a3, 0x28);
gallonm 7:2dc81120c917 1212 VL6180x_WrByte( dev, 0x00b7, 0x00);
gallonm 7:2dc81120c917 1213 VL6180x_WrByte( dev, 0x00bb, 0x28);
gallonm 7:2dc81120c917 1214 VL6180x_WrByte( dev, 0x00b2, 0x09);
gallonm 7:2dc81120c917 1215 VL6180x_WrByte( dev, 0x00ca, 0x09);
gallonm 7:2dc81120c917 1216 VL6180x_WrByte( dev, 0x0198, 0x01);
gallonm 7:2dc81120c917 1217 VL6180x_WrByte( dev, 0x01b0, 0x17);
gallonm 7:2dc81120c917 1218 VL6180x_WrByte( dev, 0x01ad, 0x00);
gallonm 7:2dc81120c917 1219 VL6180x_WrByte( dev, 0x00ff, 0x05);
gallonm 7:2dc81120c917 1220 VL6180x_WrByte( dev, 0x0100, 0x05);
gallonm 7:2dc81120c917 1221 VL6180x_WrByte( dev, 0x0199, 0x05);
gallonm 7:2dc81120c917 1222 VL6180x_WrByte( dev, 0x01a6, 0x1b);
gallonm 7:2dc81120c917 1223 VL6180x_WrByte( dev, 0x01ac, 0x3e);
gallonm 7:2dc81120c917 1224 VL6180x_WrByte( dev, 0x01a7, 0x1f);
gallonm 7:2dc81120c917 1225 VL6180x_WrByte( dev, 0x0030, 0x00);
gallonm 7:2dc81120c917 1226 VL6180x_WrByte( dev, 0x0011, 0x10);
gallonm 7:2dc81120c917 1227 VL6180x_WrByte( dev, 0x010a, 0x30);
gallonm 7:2dc81120c917 1228 VL6180x_WrByte( dev, 0x003f, 0x46);
gallonm 7:2dc81120c917 1229 VL6180x_WrByte( dev, 0x0031, 0xFF);
gallonm 7:2dc81120c917 1230 VL6180x_WrByte( dev, 0x0040, 0x63);
gallonm 7:2dc81120c917 1231 VL6180x_WrByte( dev, 0x002e, 0x01);
gallonm 7:2dc81120c917 1232 VL6180x_WrByte( dev, 0x002c, 0xff);
gallonm 7:2dc81120c917 1233 VL6180x_WrByte( dev, 0x001b, 0x09);
gallonm 7:2dc81120c917 1234 VL6180x_WrByte( dev, 0x003e, 0x31);
gallonm 7:2dc81120c917 1235 VL6180x_WrByte( dev, 0x0014, 0x24);
gallonm 7:2dc81120c917 1236 #if VL6180x_EXTENDED_RANGE
gallonm 7:2dc81120c917 1237 VL6180x_RangeSetMaxConvergenceTime(dev, 63);
gallonm 7:2dc81120c917 1238 #else
gallonm 7:2dc81120c917 1239 VL6180x_RangeSetMaxConvergenceTime(dev, 50);
gallonm 7:2dc81120c917 1240 #endif
gallonm 7:2dc81120c917 1241 return 0;
gallonm 7:2dc81120c917 1242 }
gallonm 7:2dc81120c917 1243 #else
gallonm 7:2dc81120c917 1244 #define VL6180x_UpscaleRegInit(...) -1
gallonm 7:2dc81120c917 1245 #endif
gallonm 7:2dc81120c917 1246
gallonm 7:2dc81120c917 1247 int VL6180X::VL6180x_UpscaleSetScaling(VL6180xDev_t dev, uint8_t scaling)
gallonm 7:2dc81120c917 1248 {
gallonm 7:2dc81120c917 1249 int status;
gallonm 7:2dc81120c917 1250 uint16_t Scaler;
gallonm 7:2dc81120c917 1251 int8_t Offset;
gallonm 7:2dc81120c917 1252
gallonm 7:2dc81120c917 1253 LOG_FUNCTION_START("%d",(int) scaling);
gallonm 7:2dc81120c917 1254
gallonm 7:2dc81120c917 1255 #ifdef VL6180x_HAVE_UPSCALE_DATA
gallonm 7:2dc81120c917 1256 #define min_scaling 1
gallonm 7:2dc81120c917 1257 #define max_scaling sizeof(ScalerLookUP)/sizeof(ScalerLookUP[0])
gallonm 7:2dc81120c917 1258 #else
gallonm 7:2dc81120c917 1259 /* we are in fixed config so only allow configured factor */
gallonm 7:2dc81120c917 1260 #define min_scaling VL6180x_UPSCALE_SUPPORT
gallonm 7:2dc81120c917 1261 #define max_scaling VL6180x_UPSCALE_SUPPORT
gallonm 7:2dc81120c917 1262 #endif
gallonm 7:2dc81120c917 1263
gallonm 7:2dc81120c917 1264 if( scaling>=min_scaling && scaling<= max_scaling ){
gallonm 7:2dc81120c917 1265
gallonm 7:2dc81120c917 1266 Scaler = ScalerLookUP[scaling-1];
gallonm 7:2dc81120c917 1267 status = VL6180x_WrWord(dev, RANGE_SCALER, Scaler);
gallonm 7:2dc81120c917 1268 _SetUpscale(dev, scaling );
gallonm 7:2dc81120c917 1269
gallonm 7:2dc81120c917 1270 /* Apply scaling on part-2-part offset */
gallonm 7:2dc81120c917 1271 Offset = VL6180xDevDataGet(dev, Part2PartOffsetNVM)/scaling;
gallonm 7:2dc81120c917 1272 status = VL6180x_WrByte(dev, SYSRANGE_PART_TO_PART_RANGE_OFFSET, Offset);
gallonm 7:2dc81120c917 1273 #if ! VL6180x_EXTENDED_RANGE
gallonm 7:2dc81120c917 1274 if( status ==0 ){
gallonm 7:2dc81120c917 1275 status = VL6180x_RangeSetEceState(dev, scaling == 1); /* enable ece only at 1x scaling */
gallonm 7:2dc81120c917 1276 }
gallonm 7:2dc81120c917 1277 if( status == 0 && !VL6180x_EXTENDED_RANGE && scaling!=1 ){
gallonm 7:2dc81120c917 1278 status = NOT_GUARANTEED ;
gallonm 7:2dc81120c917 1279 }
gallonm 7:2dc81120c917 1280 #endif
gallonm 7:2dc81120c917 1281 }
gallonm 7:2dc81120c917 1282 else{
gallonm 7:2dc81120c917 1283 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1284 }
gallonm 7:2dc81120c917 1285 #undef min_scaling
gallonm 7:2dc81120c917 1286 #undef max_scaling
gallonm 7:2dc81120c917 1287 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1288 return status;
gallonm 7:2dc81120c917 1289 }
gallonm 7:2dc81120c917 1290
gallonm 7:2dc81120c917 1291
gallonm 7:2dc81120c917 1292 int VL6180X::VL6180x_UpscaleGetScaling(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1293 {
gallonm 7:2dc81120c917 1294 int status;
gallonm 7:2dc81120c917 1295 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1296 status=_GetUpscale(dev );
gallonm 7:2dc81120c917 1297 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1298
gallonm 7:2dc81120c917 1299 return status;
gallonm 7:2dc81120c917 1300 }
gallonm 7:2dc81120c917 1301
gallonm 7:2dc81120c917 1302
gallonm 7:2dc81120c917 1303 int VL6180X::VL6180x_UpscaleStaticInit(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1304 {
gallonm 7:2dc81120c917 1305 /* todo make these a fail macro in case only 1x is suppoted */
gallonm 7:2dc81120c917 1306 int status;
gallonm 7:2dc81120c917 1307
gallonm 7:2dc81120c917 1308 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1309 do{
gallonm 7:2dc81120c917 1310 status=VL6180x_UpscaleRegInit(dev);
gallonm 7:2dc81120c917 1311 if( status){
gallonm 7:2dc81120c917 1312 VL6180x_ErrLog("regInit fail");
gallonm 7:2dc81120c917 1313 break;
gallonm 7:2dc81120c917 1314 }
gallonm 7:2dc81120c917 1315 #if VL6180x_EXTENDED_RANGE
gallonm 7:2dc81120c917 1316 status = VL6180x_RangeSetEceState(dev, 0);
gallonm 7:2dc81120c917 1317 if( status){
gallonm 7:2dc81120c917 1318 VL6180x_ErrLog("VL6180x_RangeSetEceState fail");
gallonm 7:2dc81120c917 1319 break;
gallonm 7:2dc81120c917 1320 }
gallonm 7:2dc81120c917 1321 #endif
gallonm 7:2dc81120c917 1322 } while(0);
gallonm 7:2dc81120c917 1323 if( !status){
gallonm 7:2dc81120c917 1324 /* must write the scaler at least once to the device to ensure the scaler is in a known state. */
gallonm 7:2dc81120c917 1325 status=VL6180x_UpscaleSetScaling(dev, _GetUpscale(dev));
gallonm 7:2dc81120c917 1326 VL6180x_WrByte( dev, 0x016, 0x00); /* change fresh out of set status to 0 */
gallonm 7:2dc81120c917 1327 }
gallonm 7:2dc81120c917 1328 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1329 return status;
gallonm 7:2dc81120c917 1330 }
gallonm 7:2dc81120c917 1331
gallonm 7:2dc81120c917 1332
gallonm 7:2dc81120c917 1333 int VL6180X::VL6180x_SetGPIOxPolarity(VL6180xDev_t dev, int pin, int active_high)
gallonm 7:2dc81120c917 1334 {
gallonm 7:2dc81120c917 1335 int status;
gallonm 7:2dc81120c917 1336 LOG_FUNCTION_START("%d %d",(int) pin, (int)active_high);
gallonm 7:2dc81120c917 1337
gallonm 7:2dc81120c917 1338 if( pin ==0 || pin ==1 ){
gallonm 7:2dc81120c917 1339 uint16_t RegIndex;
gallonm 7:2dc81120c917 1340 uint8_t DataSet;
gallonm 7:2dc81120c917 1341 if( pin==0 )
gallonm 7:2dc81120c917 1342 RegIndex= SYSTEM_MODE_GPIO0;
gallonm 7:2dc81120c917 1343 else
gallonm 7:2dc81120c917 1344 RegIndex= SYSTEM_MODE_GPIO1;
gallonm 7:2dc81120c917 1345
gallonm 7:2dc81120c917 1346 if (active_high )
gallonm 7:2dc81120c917 1347 DataSet = GPIOx_POLARITY_SELECT_MASK;
gallonm 7:2dc81120c917 1348 else
gallonm 7:2dc81120c917 1349 DataSet = 0;
gallonm 7:2dc81120c917 1350
gallonm 7:2dc81120c917 1351 status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_POLARITY_SELECT_MASK, DataSet);
gallonm 7:2dc81120c917 1352 }
gallonm 7:2dc81120c917 1353 else{
gallonm 7:2dc81120c917 1354 VL6180x_ErrLog("Invalid pin param %d", (int)pin);
gallonm 7:2dc81120c917 1355 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1356 }
gallonm 7:2dc81120c917 1357
gallonm 7:2dc81120c917 1358 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1359
gallonm 7:2dc81120c917 1360 return status;
gallonm 7:2dc81120c917 1361 }
gallonm 7:2dc81120c917 1362
gallonm 7:2dc81120c917 1363 int VL6180X::VL6180x_SetGPIOxFunctionality(VL6180xDev_t dev, int pin, uint8_t functionality)
gallonm 7:2dc81120c917 1364 {
gallonm 7:2dc81120c917 1365 int status;
gallonm 7:2dc81120c917 1366
gallonm 7:2dc81120c917 1367 LOG_FUNCTION_START("%d %d",(int) pin, (int)functionality);
gallonm 7:2dc81120c917 1368
gallonm 7:2dc81120c917 1369 if( ((pin ==0) || (pin ==1)) && IsValidGPIOFunction(functionality) ){
gallonm 7:2dc81120c917 1370 uint16_t RegIndex;
gallonm 7:2dc81120c917 1371
gallonm 7:2dc81120c917 1372 if( pin==0 )
gallonm 7:2dc81120c917 1373 RegIndex= SYSTEM_MODE_GPIO0;
gallonm 7:2dc81120c917 1374 else
gallonm 7:2dc81120c917 1375 RegIndex= SYSTEM_MODE_GPIO1;
gallonm 7:2dc81120c917 1376
gallonm 7:2dc81120c917 1377 status = VL6180x_UpdateByte(dev, RegIndex, (uint8_t)~GPIOx_FUNCTIONALITY_SELECT_MASK, functionality<<GPIOx_FUNCTIONALITY_SELECT_SHIFT);
gallonm 7:2dc81120c917 1378 if( status){
gallonm 7:2dc81120c917 1379 VL6180x_ErrLog("Update SYSTEM_MODE_GPIO%d fail", (int)pin);
gallonm 7:2dc81120c917 1380 }
gallonm 7:2dc81120c917 1381 }
gallonm 7:2dc81120c917 1382 else{
gallonm 7:2dc81120c917 1383 VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, (int) functionality);
gallonm 7:2dc81120c917 1384 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1385 }
gallonm 7:2dc81120c917 1386
gallonm 7:2dc81120c917 1387 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1388 return status;
gallonm 7:2dc81120c917 1389 }
gallonm 7:2dc81120c917 1390
gallonm 7:2dc81120c917 1391
gallonm 7:2dc81120c917 1392 int VL6180X::VL6180x_SetupGPIOx(VL6180xDev_t dev, int pin, uint8_t IntFunction, int ActiveHigh)
gallonm 7:2dc81120c917 1393 {
gallonm 7:2dc81120c917 1394 int status;
gallonm 7:2dc81120c917 1395
gallonm 7:2dc81120c917 1396 LOG_FUNCTION_START("%d %d",(int) pin, (int)IntFunction);
gallonm 7:2dc81120c917 1397
gallonm 7:2dc81120c917 1398 if( ((pin ==0) || (pin ==1)) && IsValidGPIOFunction(IntFunction) ){
gallonm 7:2dc81120c917 1399 uint16_t RegIndex;
gallonm 7:2dc81120c917 1400 uint8_t value=0;
gallonm 7:2dc81120c917 1401
gallonm 7:2dc81120c917 1402 if( pin==0 )
gallonm 7:2dc81120c917 1403 RegIndex= SYSTEM_MODE_GPIO0;
gallonm 7:2dc81120c917 1404 else
gallonm 7:2dc81120c917 1405 RegIndex= SYSTEM_MODE_GPIO1;
gallonm 7:2dc81120c917 1406
gallonm 7:2dc81120c917 1407 if( ActiveHigh )
gallonm 7:2dc81120c917 1408 value|=GPIOx_POLARITY_SELECT_MASK;
gallonm 7:2dc81120c917 1409
gallonm 7:2dc81120c917 1410 value |= IntFunction<<GPIOx_FUNCTIONALITY_SELECT_SHIFT;
gallonm 7:2dc81120c917 1411 status = VL6180x_WrByte(dev, RegIndex, value);
gallonm 7:2dc81120c917 1412 if( status ){
gallonm 7:2dc81120c917 1413 VL6180x_ErrLog("SYSTEM_MODE_GPIO%d wr fail", (int)pin-SYSTEM_MODE_GPIO0);
gallonm 7:2dc81120c917 1414 }
gallonm 7:2dc81120c917 1415 }
gallonm 7:2dc81120c917 1416 else{
gallonm 7:2dc81120c917 1417 VL6180x_ErrLog("Invalid pin %d or function %d", (int)pin, (int) IntFunction);
gallonm 7:2dc81120c917 1418 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1419 }
gallonm 7:2dc81120c917 1420
gallonm 7:2dc81120c917 1421 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1422 return status;
gallonm 7:2dc81120c917 1423 }
gallonm 7:2dc81120c917 1424
gallonm 7:2dc81120c917 1425
gallonm 7:2dc81120c917 1426 int VL6180X::VL6180x_DisableGPIOxOut(VL6180xDev_t dev, int pin) {
gallonm 7:2dc81120c917 1427 int status;
gallonm 7:2dc81120c917 1428
gallonm 7:2dc81120c917 1429 LOG_FUNCTION_START("%d",(int)pin);
gallonm 7:2dc81120c917 1430
gallonm 7:2dc81120c917 1431 status=VL6180x_SetGPIOxFunctionality(dev, pin, GPIOx_SELECT_OFF);
gallonm 7:2dc81120c917 1432
gallonm 7:2dc81120c917 1433 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1434 return status;
gallonm 7:2dc81120c917 1435 }
gallonm 7:2dc81120c917 1436
gallonm 7:2dc81120c917 1437
gallonm 7:2dc81120c917 1438 int VL6180X::VL6180x_SetupGPIO1(VL6180xDev_t dev, uint8_t IntFunction, int ActiveHigh)
gallonm 7:2dc81120c917 1439 {
gallonm 7:2dc81120c917 1440 int status;
gallonm 7:2dc81120c917 1441 LOG_FUNCTION_START("%d %d",(int)IntFunction, (int)ActiveHigh );
gallonm 7:2dc81120c917 1442 status=VL6180x_SetupGPIOx(dev, 1 , IntFunction, ActiveHigh);
gallonm 7:2dc81120c917 1443 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1444 return status;
gallonm 7:2dc81120c917 1445 }
gallonm 7:2dc81120c917 1446
gallonm 7:2dc81120c917 1447 int VL6180X::VL6180x_RangeConfigInterrupt(VL6180xDev_t dev, uint8_t ConfigGpioInt)
gallonm 7:2dc81120c917 1448 {
gallonm 7:2dc81120c917 1449 int status;
gallonm 7:2dc81120c917 1450
gallonm 7:2dc81120c917 1451 if( ConfigGpioInt<= CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY){
gallonm 7:2dc81120c917 1452 status = VL6180x_UpdateByte(dev, SYSTEM_INTERRUPT_CONFIG_GPIO, (uint8_t)(~CONFIG_GPIO_RANGE_MASK), ConfigGpioInt);
gallonm 7:2dc81120c917 1453 }
gallonm 7:2dc81120c917 1454 else{
gallonm 7:2dc81120c917 1455 VL6180x_ErrLog("Invalid config mode param %d", (int)ConfigGpioInt);
gallonm 7:2dc81120c917 1456 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1457 }
gallonm 7:2dc81120c917 1458 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1459 return status;
gallonm 7:2dc81120c917 1460 }
gallonm 7:2dc81120c917 1461
gallonm 7:2dc81120c917 1462
gallonm 7:2dc81120c917 1463 int VL6180X::VL6180x_RangeSetEceFactor(VL6180xDev_t dev, uint16_t FactorM, uint16_t FactorD){
gallonm 7:2dc81120c917 1464 int status;
gallonm 7:2dc81120c917 1465 uint8_t u8;
gallonm 7:2dc81120c917 1466
gallonm 7:2dc81120c917 1467 LOG_FUNCTION_START("%d %d", (int)FactorM, (int)FactorD );
gallonm 7:2dc81120c917 1468 do{
gallonm 7:2dc81120c917 1469 /* D cannot be 0 M must be <=D and >= 0 */
gallonm 7:2dc81120c917 1470 if( FactorM <= FactorD && FactorD> 0){
gallonm 7:2dc81120c917 1471 VL6180xDevDataSet(dev, EceFactorM, FactorM);
gallonm 7:2dc81120c917 1472 VL6180xDevDataSet(dev, EceFactorD, FactorD);
gallonm 7:2dc81120c917 1473 /* read and re-apply max conv time to get new ece factor set */
gallonm 7:2dc81120c917 1474 status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
gallonm 7:2dc81120c917 1475 if( status){
gallonm 7:2dc81120c917 1476 VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
gallonm 7:2dc81120c917 1477 break;
gallonm 7:2dc81120c917 1478 }
gallonm 7:2dc81120c917 1479 status = VL6180x_RangeSetMaxConvergenceTime(dev, u8);
gallonm 7:2dc81120c917 1480 if( status <0 ){
gallonm 7:2dc81120c917 1481 VL6180x_ErrLog("fail to apply time after ece m/d change");
gallonm 7:2dc81120c917 1482 break;
gallonm 7:2dc81120c917 1483 }
gallonm 7:2dc81120c917 1484 }
gallonm 7:2dc81120c917 1485 else{
gallonm 7:2dc81120c917 1486 VL6180x_ErrLog("invalid factor %d/%d", (int)FactorM, (int)FactorD );
gallonm 7:2dc81120c917 1487 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1488 }
gallonm 7:2dc81120c917 1489 }
gallonm 7:2dc81120c917 1490 while(0);
gallonm 7:2dc81120c917 1491 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1492 return status;
gallonm 7:2dc81120c917 1493 }
gallonm 7:2dc81120c917 1494
gallonm 7:2dc81120c917 1495 int VL6180X::VL6180x_RangeSetEceState(VL6180xDev_t dev, int enable ){
gallonm 7:2dc81120c917 1496 int status;
gallonm 7:2dc81120c917 1497 uint8_t or_mask;
gallonm 7:2dc81120c917 1498
gallonm 7:2dc81120c917 1499 LOG_FUNCTION_START("%d", (int)enable);
gallonm 7:2dc81120c917 1500 if( enable )
gallonm 7:2dc81120c917 1501 or_mask = RANGE_CHECK_ECE_ENABLE_MASK;
gallonm 7:2dc81120c917 1502 else
gallonm 7:2dc81120c917 1503 or_mask = 0;
gallonm 7:2dc81120c917 1504
gallonm 7:2dc81120c917 1505 status =VL6180x_UpdateByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, ~RANGE_CHECK_ECE_ENABLE_MASK, or_mask);
gallonm 7:2dc81120c917 1506 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1507 return status;
gallonm 7:2dc81120c917 1508 }
gallonm 7:2dc81120c917 1509
gallonm 7:2dc81120c917 1510
gallonm 7:2dc81120c917 1511 int VL6180X::VL6180x_RangeSetMaxConvergenceTime(VL6180xDev_t dev, uint8_t MaxConTime_msec)
gallonm 7:2dc81120c917 1512 {
gallonm 7:2dc81120c917 1513 int status = 0;
gallonm 7:2dc81120c917 1514 LOG_FUNCTION_START("%d",(int)MaxConTime_msec);
gallonm 7:2dc81120c917 1515 do{
gallonm 7:2dc81120c917 1516 status=VL6180x_WrByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, MaxConTime_msec);
gallonm 7:2dc81120c917 1517 if( status ){
gallonm 7:2dc81120c917 1518 break;
gallonm 7:2dc81120c917 1519 }
gallonm 7:2dc81120c917 1520 status=VL6180x_RangeSetEarlyConvergenceEestimateThreshold(dev);
gallonm 7:2dc81120c917 1521 if( status){
gallonm 7:2dc81120c917 1522 break;
gallonm 7:2dc81120c917 1523 }
gallonm 7:2dc81120c917 1524 status = _DMax_InitData(dev);
gallonm 7:2dc81120c917 1525 }
gallonm 7:2dc81120c917 1526 while(0);
gallonm 7:2dc81120c917 1527 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1528 return status;
gallonm 7:2dc81120c917 1529 }
gallonm 7:2dc81120c917 1530
gallonm 7:2dc81120c917 1531 int VL6180X::VL6180x_RangeSetInterMeasPeriod(VL6180xDev_t dev, uint32_t InterMeasTime_msec){
gallonm 7:2dc81120c917 1532 uint8_t SetTime;
gallonm 7:2dc81120c917 1533 int status;
gallonm 7:2dc81120c917 1534
gallonm 7:2dc81120c917 1535 LOG_FUNCTION_START("%d",(int)InterMeasTime_msec);
gallonm 7:2dc81120c917 1536 do {
gallonm 7:2dc81120c917 1537 if( InterMeasTime_msec > 2550 ){
gallonm 7:2dc81120c917 1538 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1539 break;
gallonm 7:2dc81120c917 1540 }
gallonm 7:2dc81120c917 1541 /* doc in not 100% clear and confusing about the limit practically all value are OK but 0
gallonm 7:2dc81120c917 1542 * that can hang device in continuous mode */
gallonm 7:2dc81120c917 1543 if( InterMeasTime_msec < 10 ) {
gallonm 7:2dc81120c917 1544 InterMeasTime_msec=10;
gallonm 7:2dc81120c917 1545 }
gallonm 7:2dc81120c917 1546 SetTime=(uint8_t)(InterMeasTime_msec/10);
gallonm 7:2dc81120c917 1547 status=VL6180x_WrByte(dev, SYSRANGE_INTERMEASUREMENT_PERIOD, SetTime);
gallonm 7:2dc81120c917 1548 if( status ){
gallonm 7:2dc81120c917 1549 VL6180x_ErrLog("SYSRANGE_INTERMEASUREMENT_PERIOD wr fail");
gallonm 7:2dc81120c917 1550 }
gallonm 7:2dc81120c917 1551 else
gallonm 7:2dc81120c917 1552 if( SetTime != InterMeasTime_msec /10 ) {
gallonm 7:2dc81120c917 1553 status = MIN_CLIPED; /* on success change status to clip if it did */
gallonm 7:2dc81120c917 1554 }
gallonm 7:2dc81120c917 1555 }while(0);
gallonm 7:2dc81120c917 1556 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1557 return status;
gallonm 7:2dc81120c917 1558 }
gallonm 7:2dc81120c917 1559
gallonm 7:2dc81120c917 1560
gallonm 7:2dc81120c917 1561 int VL6180X::VL6180x_RangeGetDeviceReady(VL6180xDev_t dev, int * Ready){
gallonm 7:2dc81120c917 1562 int status;
gallonm 7:2dc81120c917 1563 uint8_t u8;
gallonm 7:2dc81120c917 1564 LOG_FUNCTION_START("%p", (int)Ready);
gallonm 7:2dc81120c917 1565 status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
gallonm 7:2dc81120c917 1566 if( !status)
gallonm 7:2dc81120c917 1567 *Ready = u8&RANGE_DEVICE_READY_MASK;
gallonm 7:2dc81120c917 1568 LOG_FUNCTION_END_FMT(status,"%d", *Ready);
gallonm 7:2dc81120c917 1569 return status;
gallonm 7:2dc81120c917 1570 }
gallonm 7:2dc81120c917 1571
gallonm 7:2dc81120c917 1572
gallonm 7:2dc81120c917 1573 int VL6180X::VL6180x_RangeWaitDeviceReady(VL6180xDev_t dev, int MaxLoop ){
gallonm 7:2dc81120c917 1574 int status; /* if user specify an invalid <=0 loop count we'll return error */
gallonm 7:2dc81120c917 1575 int n;
gallonm 7:2dc81120c917 1576 uint8_t u8;
gallonm 7:2dc81120c917 1577 LOG_FUNCTION_START("%d", (int)MaxLoop);
gallonm 7:2dc81120c917 1578 if( MaxLoop<1){
gallonm 7:2dc81120c917 1579 status=INVALID_PARAMS;
gallonm 7:2dc81120c917 1580 }
gallonm 7:2dc81120c917 1581 else{
gallonm 7:2dc81120c917 1582 for( n=0; n < MaxLoop ; n++){
gallonm 7:2dc81120c917 1583 status=VL6180x_RdByte(dev, RESULT_RANGE_STATUS, &u8);
gallonm 7:2dc81120c917 1584 if( status)
gallonm 7:2dc81120c917 1585 break;
gallonm 7:2dc81120c917 1586 u8 = u8 & RANGE_DEVICE_READY_MASK;
gallonm 7:2dc81120c917 1587 if( u8 )
gallonm 7:2dc81120c917 1588 break;
gallonm 7:2dc81120c917 1589
gallonm 7:2dc81120c917 1590 }
gallonm 7:2dc81120c917 1591 if( !status && !u8 ){
gallonm 7:2dc81120c917 1592 status = TIME_OUT;
gallonm 7:2dc81120c917 1593 }
gallonm 7:2dc81120c917 1594 }
gallonm 7:2dc81120c917 1595 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1596 return status;
gallonm 7:2dc81120c917 1597 }
gallonm 7:2dc81120c917 1598
gallonm 7:2dc81120c917 1599 int VL6180X::VL6180x_RangeSetSystemMode(VL6180xDev_t dev, uint8_t mode)
gallonm 7:2dc81120c917 1600 {
gallonm 7:2dc81120c917 1601 int status;
gallonm 7:2dc81120c917 1602 LOG_FUNCTION_START("%d", (int)mode);
gallonm 7:2dc81120c917 1603 /* FIXME we are not checking device is ready via @a VL6180x_RangeWaitDeviceReady
gallonm 7:2dc81120c917 1604 * so if called back to back real fast we are not checking
gallonm 7:2dc81120c917 1605 * if previous mode "set" got absorbed => bit 0 must be 0 so that it work
gallonm 7:2dc81120c917 1606 */
gallonm 7:2dc81120c917 1607 if( mode <= 3){
gallonm 7:2dc81120c917 1608 status=VL6180x_WrByte(dev, SYSRANGE_START, mode);
gallonm 7:2dc81120c917 1609 if( status ){
gallonm 7:2dc81120c917 1610 VL6180x_ErrLog("SYSRANGE_START wr fail");
gallonm 7:2dc81120c917 1611 }
gallonm 7:2dc81120c917 1612 }
gallonm 7:2dc81120c917 1613 else{
gallonm 7:2dc81120c917 1614 status = INVALID_PARAMS;
gallonm 7:2dc81120c917 1615 }
gallonm 7:2dc81120c917 1616 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1617 return status;
gallonm 7:2dc81120c917 1618 }
gallonm 7:2dc81120c917 1619
gallonm 7:2dc81120c917 1620
gallonm 7:2dc81120c917 1621 int VL6180X::VL6180x_RangeStartContinuousMode(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1622 {
gallonm 7:2dc81120c917 1623 int status;
gallonm 7:2dc81120c917 1624 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1625 status= VL6180x_RangeSetSystemMode(dev, MODE_START_STOP | MODE_CONTINUOUS);
gallonm 7:2dc81120c917 1626 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1627 return status;
gallonm 7:2dc81120c917 1628 }
gallonm 7:2dc81120c917 1629
gallonm 7:2dc81120c917 1630 int VL6180X::VL6180x_RangeStartSingleShot(VL6180xDev_t dev) {
gallonm 7:2dc81120c917 1631 int status;
gallonm 7:2dc81120c917 1632 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1633 status = VL6180x_RangeSetSystemMode(dev, MODE_START_STOP|MODE_SINGLESHOT);
gallonm 7:2dc81120c917 1634 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1635 return status;
gallonm 7:2dc81120c917 1636 }
gallonm 7:2dc81120c917 1637
gallonm 7:2dc81120c917 1638
gallonm 7:2dc81120c917 1639 int VL6180X::VL6180x_RangeSetEarlyConvergenceEestimateThreshold(VL6180xDev_t dev)
gallonm 7:2dc81120c917 1640 {
gallonm 7:2dc81120c917 1641 int status;
gallonm 7:2dc81120c917 1642
gallonm 7:2dc81120c917 1643 const uint32_t cMicroSecPerMilliSec = 1000;
gallonm 7:2dc81120c917 1644 const uint32_t cEceSampleTime_us = 500;
gallonm 7:2dc81120c917 1645 uint32_t ece_factor_m = VL6180xDevDataGet(dev, EceFactorM);
gallonm 7:2dc81120c917 1646 uint32_t ece_factor_d = VL6180xDevDataGet(dev, EceFactorD);
gallonm 7:2dc81120c917 1647 uint32_t convergTime_us;
gallonm 7:2dc81120c917 1648 uint32_t fineThresh;
gallonm 7:2dc81120c917 1649 uint32_t eceThresh;
gallonm 7:2dc81120c917 1650 uint8_t u8;
gallonm 7:2dc81120c917 1651 uint32_t maxConv_ms;
gallonm 7:2dc81120c917 1652 int32_t AveTime;
gallonm 7:2dc81120c917 1653
gallonm 7:2dc81120c917 1654 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1655
gallonm 7:2dc81120c917 1656 do{
gallonm 7:2dc81120c917 1657 status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &u8);
gallonm 7:2dc81120c917 1658 if( status ){
gallonm 7:2dc81120c917 1659 VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail");
gallonm 7:2dc81120c917 1660 break;
gallonm 7:2dc81120c917 1661 }
gallonm 7:2dc81120c917 1662 maxConv_ms = u8;
gallonm 7:2dc81120c917 1663 AveTime = _GetAveTotalTime(dev);
gallonm 7:2dc81120c917 1664 if( AveTime <0 ){
gallonm 7:2dc81120c917 1665 status=-1;
gallonm 7:2dc81120c917 1666 break;
gallonm 7:2dc81120c917 1667 }
gallonm 7:2dc81120c917 1668
gallonm 7:2dc81120c917 1669 convergTime_us = maxConv_ms * cMicroSecPerMilliSec - AveTime;
gallonm 7:2dc81120c917 1670 status = VL6180x_RdDWord(dev, 0xB8, &fineThresh);
gallonm 7:2dc81120c917 1671 if( status ) {
gallonm 7:2dc81120c917 1672 VL6180x_ErrLog("reg 0xB8 rd fail");
gallonm 7:2dc81120c917 1673 break;
gallonm 7:2dc81120c917 1674 }
gallonm 7:2dc81120c917 1675 fineThresh*=256;
gallonm 7:2dc81120c917 1676 eceThresh = ece_factor_m * cEceSampleTime_us * fineThresh/(convergTime_us * ece_factor_d);
gallonm 7:2dc81120c917 1677
gallonm 7:2dc81120c917 1678 status=VL6180x_WrWord(dev, SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, (uint16_t)eceThresh);
gallonm 7:2dc81120c917 1679 }
gallonm 7:2dc81120c917 1680 while(0);
gallonm 7:2dc81120c917 1681
gallonm 7:2dc81120c917 1682 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 1683 return status;
gallonm 7:2dc81120c917 1684 }
gallonm 7:2dc81120c917 1685
gallonm 7:2dc81120c917 1686 /*
gallonm 7:2dc81120c917 1687 * Return >0 = time
gallonm 7:2dc81120c917 1688 * <0 1 if fail to get read data from device to compute time
gallonm 7:2dc81120c917 1689 */
gallonm 7:2dc81120c917 1690 int32_t VL6180X::_GetAveTotalTime(VL6180xDev_t dev) {
gallonm 7:2dc81120c917 1691 uint32_t cFwOverhead_us = 24;
gallonm 7:2dc81120c917 1692 uint32_t cVcpSetupTime_us = 70;
gallonm 7:2dc81120c917 1693 uint32_t cPLL2_StartupDelay_us = 200;
gallonm 7:2dc81120c917 1694 uint8_t cMeasMask = 0x07;
gallonm 7:2dc81120c917 1695 uint32_t Samples;
gallonm 7:2dc81120c917 1696 uint32_t SamplePeriod;
gallonm 7:2dc81120c917 1697 uint32_t SingleTime_us;
gallonm 7:2dc81120c917 1698 int32_t TotalAveTime_us;
gallonm 7:2dc81120c917 1699 uint8_t u8;
gallonm 7:2dc81120c917 1700 int status;
gallonm 7:2dc81120c917 1701
gallonm 7:2dc81120c917 1702 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 1703
gallonm 7:2dc81120c917 1704 status = VL6180x_RdByte(dev, 0x109, &u8);
gallonm 7:2dc81120c917 1705 if (status) {
gallonm 7:2dc81120c917 1706 VL6180x_ErrLog("rd 0x109 fail");
gallonm 7:2dc81120c917 1707 return -1;
gallonm 7:2dc81120c917 1708 }
gallonm 7:2dc81120c917 1709 Samples = u8 & cMeasMask;
gallonm 7:2dc81120c917 1710 status = VL6180x_RdByte(dev, READOUT_AVERAGING_SAMPLE_PERIOD, &u8);
gallonm 7:2dc81120c917 1711 if (status) {
gallonm 7:2dc81120c917 1712 VL6180x_ErrLog("i2c READOUT_AVERAGING_SAMPLE_PERIOD fail");
gallonm 7:2dc81120c917 1713 return -1;
gallonm 7:2dc81120c917 1714 }
gallonm 7:2dc81120c917 1715 SamplePeriod = u8;
gallonm 7:2dc81120c917 1716 SingleTime_us = cFwOverhead_us + cVcpSetupTime_us + (SamplePeriod * 10);
gallonm 7:2dc81120c917 1717 TotalAveTime_us = (Samples + 1) * SingleTime_us + cPLL2_StartupDelay_us;
gallonm 7:2dc81120c917 1718
gallonm 7:2dc81120c917 1719 LOG_FUNCTION_END(TotalAveTime_us);
gallonm 7:2dc81120c917 1720 return TotalAveTime_us;
gallonm 7:2dc81120c917 1721 }
gallonm 7:2dc81120c917 1722
gallonm 7:2dc81120c917 1723 #if VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 1724 #define _GetDMaxDataRetSignalAt400mm(dev) VL6180xDevDataGet(dev, DMaxData.retSignalAt400mm)
gallonm 7:2dc81120c917 1725 #else
gallonm 7:2dc81120c917 1726 #define _GetDMaxDataRetSignalAt400mm(dev) 375 // Use a default high value
gallonm 7:2dc81120c917 1727 #endif
gallonm 7:2dc81120c917 1728
gallonm 7:2dc81120c917 1729
gallonm 7:2dc81120c917 1730 #if VL6180x_WRAP_AROUND_FILTER_SUPPORT
gallonm 7:2dc81120c917 1731
gallonm 7:2dc81120c917 1732 #define FILTER_STDDEV_SAMPLES 6
gallonm 7:2dc81120c917 1733 #define MIN_FILTER_STDDEV_SAMPLES 3
gallonm 7:2dc81120c917 1734 #define MIN_FILTER_VALID_STDDEV_SAMPLES 3
gallonm 7:2dc81120c917 1735 #define FILTER_INVALID_DISTANCE 65535
gallonm 7:2dc81120c917 1736
gallonm 7:2dc81120c917 1737 #define _FilterData(field) VL6180xDevDataGet(dev, FilterData.field)
gallonm 7:2dc81120c917 1738 /*
gallonm 7:2dc81120c917 1739 * One time init
gallonm 7:2dc81120c917 1740 */
gallonm 7:2dc81120c917 1741 int _filter_Init( VL6180xDev_t dev) {
gallonm 7:2dc81120c917 1742 int i;
gallonm 7:2dc81120c917 1743 _FilterData(MeasurementIndex) = 0;
gallonm 7:2dc81120c917 1744
gallonm 7:2dc81120c917 1745 _FilterData(Default_ZeroVal) = 0;
gallonm 7:2dc81120c917 1746 _FilterData(Default_VAVGVal) = 0;
gallonm 7:2dc81120c917 1747 _FilterData(NoDelay_ZeroVal) = 0;
gallonm 7:2dc81120c917 1748 _FilterData(NoDelay_VAVGVal) = 0;
gallonm 7:2dc81120c917 1749 _FilterData(Previous_VAVGDiff) = 0;
gallonm 7:2dc81120c917 1750
gallonm 7:2dc81120c917 1751 _FilterData(StdFilteredReads) = 0;
gallonm 7:2dc81120c917 1752
gallonm 7:2dc81120c917 1753 for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
gallonm 7:2dc81120c917 1754 _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
gallonm 7:2dc81120c917 1755 _FilterData(LastReturnRates)[i] = 0;
gallonm 7:2dc81120c917 1756 }
gallonm 7:2dc81120c917 1757 return 0;
gallonm 7:2dc81120c917 1758 }
gallonm 7:2dc81120c917 1759
gallonm 7:2dc81120c917 1760
gallonm 7:2dc81120c917 1761 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) {
gallonm 7:2dc81120c917 1762 uint32_t newStdDev;
gallonm 7:2dc81120c917 1763 uint16_t SNR;
gallonm 7:2dc81120c917 1764
gallonm 7:2dc81120c917 1765 if (AmbientRate > 0)
gallonm 7:2dc81120c917 1766 SNR = (uint16_t) ((100 * SignalRate) / AmbientRate);
gallonm 7:2dc81120c917 1767 else
gallonm 7:2dc81120c917 1768 SNR = 9999;
gallonm 7:2dc81120c917 1769
gallonm 7:2dc81120c917 1770 if (SNR >= StdDevLimitLowLightSNR) {
gallonm 7:2dc81120c917 1771 newStdDev = StdDevLimitLowLight;
gallonm 7:2dc81120c917 1772 } else {
gallonm 7:2dc81120c917 1773 if (SNR <= StdDevLimitHighLightSNR)
gallonm 7:2dc81120c917 1774 newStdDev = StdDevLimitHighLight;
gallonm 7:2dc81120c917 1775 else {
gallonm 7:2dc81120c917 1776 newStdDev = (uint32_t) (StdDevLimitHighLight + (SNR - StdDevLimitHighLightSNR) * (int) (StdDevLimitLowLight - StdDevLimitHighLight) / (StdDevLimitLowLightSNR - StdDevLimitHighLightSNR));
gallonm 7:2dc81120c917 1777 }
gallonm 7:2dc81120c917 1778 }
gallonm 7:2dc81120c917 1779
gallonm 7:2dc81120c917 1780 return newStdDev;
gallonm 7:2dc81120c917 1781 }
gallonm 7:2dc81120c917 1782
gallonm 7:2dc81120c917 1783
gallonm 7:2dc81120c917 1784 /*
gallonm 7:2dc81120c917 1785 * Return <0 on error
gallonm 7:2dc81120c917 1786 */
gallonm 7:2dc81120c917 1787 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) {
gallonm 7:2dc81120c917 1788 int status;
gallonm 7:2dc81120c917 1789 uint16_t m_newTrueRange_mm = 0;
gallonm 7:2dc81120c917 1790
gallonm 7:2dc81120c917 1791 uint16_t i;
gallonm 7:2dc81120c917 1792 uint16_t bypassFilter = 0;
gallonm 7:2dc81120c917 1793
gallonm 7:2dc81120c917 1794 uint16_t registerValue;
gallonm 7:2dc81120c917 1795
gallonm 7:2dc81120c917 1796 uint32_t register32BitsValue1;
gallonm 7:2dc81120c917 1797 uint32_t register32BitsValue2;
gallonm 7:2dc81120c917 1798
gallonm 7:2dc81120c917 1799 uint16_t ValidDistance = 0;
gallonm 7:2dc81120c917 1800
gallonm 7:2dc81120c917 1801 uint16_t WrapAroundFlag = 0;
gallonm 7:2dc81120c917 1802 uint16_t NoWrapAroundFlag = 0;
gallonm 7:2dc81120c917 1803 uint16_t NoWrapAroundHighConfidenceFlag = 0;
gallonm 7:2dc81120c917 1804
gallonm 7:2dc81120c917 1805 uint16_t FlushFilter = 0;
gallonm 7:2dc81120c917 1806 uint32_t RateChange = 0;
gallonm 7:2dc81120c917 1807
gallonm 7:2dc81120c917 1808 uint16_t StdDevSamples = 0;
gallonm 7:2dc81120c917 1809 uint32_t StdDevDistanceSum = 0;
gallonm 7:2dc81120c917 1810 uint32_t StdDevDistanceMean = 0;
gallonm 7:2dc81120c917 1811 uint32_t StdDevDistance = 0;
gallonm 7:2dc81120c917 1812 uint32_t StdDevRateSum = 0;
gallonm 7:2dc81120c917 1813 uint32_t StdDevRateMean = 0;
gallonm 7:2dc81120c917 1814 uint32_t StdDevRate = 0;
gallonm 7:2dc81120c917 1815 uint32_t StdDevLimitWithTargetMove = 0;
gallonm 7:2dc81120c917 1816
gallonm 7:2dc81120c917 1817 uint32_t VAVGDiff;
gallonm 7:2dc81120c917 1818 uint32_t IdealVAVGDiff;
gallonm 7:2dc81120c917 1819 uint32_t MinVAVGDiff;
gallonm 7:2dc81120c917 1820 uint32_t MaxVAVGDiff;
gallonm 7:2dc81120c917 1821
gallonm 7:2dc81120c917 1822 /* Filter Parameters */
gallonm 7:2dc81120c917 1823 static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit = 60;
gallonm 7:2dc81120c917 1824 static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit_ROM = 800; // Shall be adapted depending on crossTalk
gallonm 7:2dc81120c917 1825 static const uint16_t ROMABLE_DATA WrapAroundLowRawRangeLimit2 = 165;
gallonm 7:2dc81120c917 1826 static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateLimit2_ROM = 180; // Shall be adapted depending on crossTalk and device sensitivity
gallonm 7:2dc81120c917 1827
gallonm 7:2dc81120c917 1828 static const uint32_t ROMABLE_DATA WrapAroundLowReturnRateFilterLimit_ROM = 850; // Shall be adapted depending on crossTalk and device sensitivity
gallonm 7:2dc81120c917 1829 static const uint16_t ROMABLE_DATA WrapAroundHighRawRangeFilterLimit = 350;
gallonm 7:2dc81120c917 1830 static const uint32_t ROMABLE_DATA WrapAroundHighReturnRateFilterLimit_ROM = 1400; // Shall be adapted depending on crossTalk and device sensitivity
gallonm 7:2dc81120c917 1831
gallonm 7:2dc81120c917 1832 static const uint32_t ROMABLE_DATA WrapAroundMaximumAmbientRateFilterLimit = 7500;
gallonm 7:2dc81120c917 1833
gallonm 7:2dc81120c917 1834 /* Temporal filter data and flush values */
gallonm 7:2dc81120c917 1835 static const uint32_t ROMABLE_DATA MinReturnRateFilterFlush = 75;
gallonm 7:2dc81120c917 1836 static const uint32_t ROMABLE_DATA MaxReturnRateChangeFilterFlush = 50;
gallonm 7:2dc81120c917 1837
gallonm 7:2dc81120c917 1838 /* STDDEV values and damper values */
gallonm 7:2dc81120c917 1839
gallonm 7:2dc81120c917 1840 static const uint32_t ROMABLE_DATA StdDevLimitLowLight = 300;
gallonm 7:2dc81120c917 1841 static const uint32_t ROMABLE_DATA StdDevLimitLowLightSNR = 30; /* 0.3 */
gallonm 7:2dc81120c917 1842 static const uint32_t ROMABLE_DATA StdDevLimitHighLight = 2500;
gallonm 7:2dc81120c917 1843 static const uint32_t ROMABLE_DATA StdDevLimitHighLightSNR = 5; /* 0.05 */
gallonm 7:2dc81120c917 1844
gallonm 7:2dc81120c917 1845 static const uint32_t ROMABLE_DATA StdDevHighConfidenceSNRLimit = 8;
gallonm 7:2dc81120c917 1846
gallonm 7:2dc81120c917 1847 static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevLimit = 90000;
gallonm 7:2dc81120c917 1848
gallonm 7:2dc81120c917 1849 static const uint32_t ROMABLE_DATA StdDevMovingTargetReturnRateLimit = 3500;
gallonm 7:2dc81120c917 1850 static const uint32_t ROMABLE_DATA StdDevMovingTargetStdDevForReturnRateLimit = 5000;
gallonm 7:2dc81120c917 1851
gallonm 7:2dc81120c917 1852 static const uint32_t ROMABLE_DATA MAX_VAVGDiff = 1800;
gallonm 7:2dc81120c917 1853
gallonm 7:2dc81120c917 1854 /* WrapAroundDetection variables */
gallonm 7:2dc81120c917 1855 static const uint16_t ROMABLE_DATA WrapAroundNoDelayCheckPeriod = 2;
gallonm 7:2dc81120c917 1856 static const uint16_t ROMABLE_DATA StdFilteredReadsIncrement = 2;
gallonm 7:2dc81120c917 1857 static const uint16_t ROMABLE_DATA StdMaxFilteredReads = 4;
gallonm 7:2dc81120c917 1858
gallonm 7:2dc81120c917 1859 uint32_t SignalRateDMax;
gallonm 7:2dc81120c917 1860 uint32_t WrapAroundLowReturnRateLimit;
gallonm 7:2dc81120c917 1861 uint32_t WrapAroundLowReturnRateLimit2;
gallonm 7:2dc81120c917 1862 uint32_t WrapAroundLowReturnRateFilterLimit;
gallonm 7:2dc81120c917 1863 uint32_t WrapAroundHighReturnRateFilterLimit;
gallonm 7:2dc81120c917 1864
gallonm 7:2dc81120c917 1865 uint8_t u8, u8_2;
gallonm 7:2dc81120c917 1866 uint32_t XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1867 uint32_t StdDevLimit = 300;
gallonm 7:2dc81120c917 1868 uint32_t MaxOrInvalidDistance = 255*_GetUpscale(dev);
gallonm 7:2dc81120c917 1869 /* #define MaxOrInvalidDistance (uint16_t) (255 * 3) */
gallonm 7:2dc81120c917 1870
gallonm 7:2dc81120c917 1871 /* Check if distance is Valid or not */
gallonm 7:2dc81120c917 1872 switch (errorCode) {
gallonm 7:2dc81120c917 1873 case 0x0C:
gallonm 7:2dc81120c917 1874 m_trueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 1875 ValidDistance = 0;
gallonm 7:2dc81120c917 1876 break;
gallonm 7:2dc81120c917 1877 case 0x0D:
gallonm 7:2dc81120c917 1878 m_trueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 1879 ValidDistance = 1;
gallonm 7:2dc81120c917 1880 break;
gallonm 7:2dc81120c917 1881 case 0x0F:
gallonm 7:2dc81120c917 1882 m_trueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 1883 ValidDistance = 1;
gallonm 7:2dc81120c917 1884 break;
gallonm 7:2dc81120c917 1885 default:
gallonm 7:2dc81120c917 1886 if (m_rawRange_mm >= MaxOrInvalidDistance) {
gallonm 7:2dc81120c917 1887 ValidDistance = 0;
gallonm 7:2dc81120c917 1888 } else {
gallonm 7:2dc81120c917 1889 ValidDistance = 1;
gallonm 7:2dc81120c917 1890 }
gallonm 7:2dc81120c917 1891 break;
gallonm 7:2dc81120c917 1892 }
gallonm 7:2dc81120c917 1893 m_newTrueRange_mm = m_trueRange_mm;
gallonm 7:2dc81120c917 1894
gallonm 7:2dc81120c917 1895 XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps );
gallonm 7:2dc81120c917 1896
gallonm 7:2dc81120c917 1897
gallonm 7:2dc81120c917 1898 //Update signal rate limits depending on crosstalk
gallonm 7:2dc81120c917 1899 SignalRateDMax = (uint32_t)_GetDMaxDataRetSignalAt400mm(dev) + XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1900 WrapAroundLowReturnRateLimit = WrapAroundLowReturnRateLimit_ROM + XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1901 WrapAroundLowReturnRateLimit2 = ((WrapAroundLowReturnRateLimit2_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1902 WrapAroundLowReturnRateFilterLimit = ((WrapAroundLowReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1903 WrapAroundHighReturnRateFilterLimit = ((WrapAroundHighReturnRateFilterLimit_ROM * SignalRateDMax) / 312) + XTalkCompRate_KCps;
gallonm 7:2dc81120c917 1904
gallonm 7:2dc81120c917 1905
gallonm 7:2dc81120c917 1906 /* Checks on low range data */
gallonm 7:2dc81120c917 1907 if ((m_rawRange_mm < WrapAroundLowRawRangeLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit)) {
gallonm 7:2dc81120c917 1908 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 1909 bypassFilter = 1;
gallonm 7:2dc81120c917 1910 }
gallonm 7:2dc81120c917 1911 if ((m_rawRange_mm < WrapAroundLowRawRangeLimit2) && (m_rtnSignalRate < WrapAroundLowReturnRateLimit2)) {
gallonm 7:2dc81120c917 1912 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 1913 bypassFilter = 1;
gallonm 7:2dc81120c917 1914 }
gallonm 7:2dc81120c917 1915
gallonm 7:2dc81120c917 1916 /* Checks on Ambient rate level */
gallonm 7:2dc81120c917 1917 if (m_rtnAmbientRate > WrapAroundMaximumAmbientRateFilterLimit) {
gallonm 7:2dc81120c917 1918 /* Too high ambient rate */
gallonm 7:2dc81120c917 1919 FlushFilter = 1;
gallonm 7:2dc81120c917 1920 bypassFilter = 1;
gallonm 7:2dc81120c917 1921 }
gallonm 7:2dc81120c917 1922 /* Checks on Filter flush */
gallonm 7:2dc81120c917 1923 if (m_rtnSignalRate < MinReturnRateFilterFlush) {
gallonm 7:2dc81120c917 1924 /* Completely lost target, so flush the filter */
gallonm 7:2dc81120c917 1925 FlushFilter = 1;
gallonm 7:2dc81120c917 1926 bypassFilter = 1;
gallonm 7:2dc81120c917 1927 }
gallonm 7:2dc81120c917 1928 if (_FilterData(LastReturnRates)[0] != 0) {
gallonm 7:2dc81120c917 1929 if (m_rtnSignalRate > _FilterData(LastReturnRates)[0])
gallonm 7:2dc81120c917 1930 RateChange = (100 * (m_rtnSignalRate - _FilterData(LastReturnRates)[0])) / _FilterData(LastReturnRates)[0];
gallonm 7:2dc81120c917 1931 else
gallonm 7:2dc81120c917 1932 RateChange = (100 * (_FilterData(LastReturnRates)[0] - m_rtnSignalRate)) / _FilterData(LastReturnRates)[0];
gallonm 7:2dc81120c917 1933 } else
gallonm 7:2dc81120c917 1934 RateChange = 0;
gallonm 7:2dc81120c917 1935 if (RateChange > MaxReturnRateChangeFilterFlush) {
gallonm 7:2dc81120c917 1936 FlushFilter = 1;
gallonm 7:2dc81120c917 1937 }
gallonm 7:2dc81120c917 1938 /* TODO optimize filter using circular buffer */
gallonm 7:2dc81120c917 1939 if (FlushFilter == 1) {
gallonm 7:2dc81120c917 1940 _FilterData(MeasurementIndex) = 0;
gallonm 7:2dc81120c917 1941 for (i = 0; i < FILTER_NBOF_SAMPLES; i++) {
gallonm 7:2dc81120c917 1942 _FilterData(LastTrueRange)[i] = FILTER_INVALID_DISTANCE;
gallonm 7:2dc81120c917 1943 _FilterData(LastReturnRates)[i] = 0;
gallonm 7:2dc81120c917 1944 }
gallonm 7:2dc81120c917 1945 } else {
gallonm 7:2dc81120c917 1946 for (i = (uint16_t) (FILTER_NBOF_SAMPLES - 1); i > 0; i--) {
gallonm 7:2dc81120c917 1947 _FilterData(LastTrueRange)[i] = _FilterData(LastTrueRange)[i - 1];
gallonm 7:2dc81120c917 1948 _FilterData(LastReturnRates)[i] = _FilterData(LastReturnRates)[i - 1];
gallonm 7:2dc81120c917 1949 }
gallonm 7:2dc81120c917 1950 }
gallonm 7:2dc81120c917 1951 if (ValidDistance == 1)
gallonm 7:2dc81120c917 1952 _FilterData(LastTrueRange)[0] = m_trueRange_mm;
gallonm 7:2dc81120c917 1953 else
gallonm 7:2dc81120c917 1954 _FilterData(LastTrueRange)[0] = FILTER_INVALID_DISTANCE;
gallonm 7:2dc81120c917 1955 _FilterData(LastReturnRates)[0] = m_rtnSignalRate;
gallonm 7:2dc81120c917 1956
gallonm 7:2dc81120c917 1957 /* Check if we need to go through the filter or not */
gallonm 7:2dc81120c917 1958 if (!(((m_rawRange_mm < WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundLowReturnRateFilterLimit)) || ((m_rawRange_mm >= WrapAroundHighRawRangeFilterLimit) && (m_rtnSignalRate < WrapAroundHighReturnRateFilterLimit))))
gallonm 7:2dc81120c917 1959 bypassFilter = 1;
gallonm 7:2dc81120c917 1960
gallonm 7:2dc81120c917 1961 /* Check which kind of measurement has been made */
gallonm 7:2dc81120c917 1962 status = VL6180x_RdByte(dev, 0x01AC, &u8 );
gallonm 7:2dc81120c917 1963 if( status ){
gallonm 7:2dc81120c917 1964 VL6180x_ErrLog("0x01AC rd fail");
gallonm 7:2dc81120c917 1965 goto done_err;
gallonm 7:2dc81120c917 1966 }
gallonm 7:2dc81120c917 1967 registerValue =u8;
gallonm 7:2dc81120c917 1968
gallonm 7:2dc81120c917 1969 /* Read data for filtering */
gallonm 7:2dc81120c917 1970 status = VL6180x_RdByte(dev, 0x10C, &u8 ); /* read only 8 lsb bits */
gallonm 7:2dc81120c917 1971 if( status ){
gallonm 7:2dc81120c917 1972 VL6180x_ErrLog("0x010C rd fail");
gallonm 7:2dc81120c917 1973 goto done_err;
gallonm 7:2dc81120c917 1974 }
gallonm 7:2dc81120c917 1975 register32BitsValue1=u8;
gallonm 7:2dc81120c917 1976 status = VL6180x_RdByte(dev, 0x0110, &u8); /* read only 8 lsb bits */
gallonm 7:2dc81120c917 1977 if( status ){
gallonm 7:2dc81120c917 1978 VL6180x_ErrLog("0x0110 rd fail");
gallonm 7:2dc81120c917 1979 goto done_err;
gallonm 7:2dc81120c917 1980 }
gallonm 7:2dc81120c917 1981 register32BitsValue2 = u8;
gallonm 7:2dc81120c917 1982
gallonm 7:2dc81120c917 1983 if (registerValue == 0x3E) {
gallonm 7:2dc81120c917 1984 _FilterData(Default_ZeroVal) = register32BitsValue1;
gallonm 7:2dc81120c917 1985 _FilterData(Default_VAVGVal) = register32BitsValue2;
gallonm 7:2dc81120c917 1986 } else {
gallonm 7:2dc81120c917 1987 _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
gallonm 7:2dc81120c917 1988 _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
gallonm 7:2dc81120c917 1989 }
gallonm 7:2dc81120c917 1990
gallonm 7:2dc81120c917 1991 if (bypassFilter == 1) {
gallonm 7:2dc81120c917 1992 /* Do not go through the filter */
gallonm 7:2dc81120c917 1993 if (registerValue != 0x3E) {
gallonm 7:2dc81120c917 1994 status = VL6180x_WrByte(dev, 0x1AC, 0x3E);
gallonm 7:2dc81120c917 1995 if( status ){
gallonm 7:2dc81120c917 1996 VL6180x_ErrLog("0x01AC bypass wr fail");
gallonm 7:2dc81120c917 1997 goto done_err;
gallonm 7:2dc81120c917 1998 }
gallonm 7:2dc81120c917 1999 status = VL6180x_WrByte(dev, 0x0F2, 0x01);
gallonm 7:2dc81120c917 2000 if( status ){
gallonm 7:2dc81120c917 2001 VL6180x_ErrLog("0x0F2 bypass wr fail");
gallonm 7:2dc81120c917 2002 goto done_err;
gallonm 7:2dc81120c917 2003 }
gallonm 7:2dc81120c917 2004 }
gallonm 7:2dc81120c917 2005 /* Set both Default and NoDelay To same value */
gallonm 7:2dc81120c917 2006 _FilterData(Default_ZeroVal) = register32BitsValue1;
gallonm 7:2dc81120c917 2007 _FilterData(Default_VAVGVal) = register32BitsValue2;
gallonm 7:2dc81120c917 2008 _FilterData(NoDelay_ZeroVal) = register32BitsValue1;
gallonm 7:2dc81120c917 2009 _FilterData(NoDelay_VAVGVal) = register32BitsValue2;
gallonm 7:2dc81120c917 2010 _FilterData(MeasurementIndex) = 0;
gallonm 7:2dc81120c917 2011
gallonm 7:2dc81120c917 2012 return m_newTrueRange_mm;
gallonm 7:2dc81120c917 2013 }
gallonm 7:2dc81120c917 2014
gallonm 7:2dc81120c917 2015 if (_FilterData(MeasurementIndex) % WrapAroundNoDelayCheckPeriod == 0) {
gallonm 7:2dc81120c917 2016 u8=0x3C;
gallonm 7:2dc81120c917 2017 u8_2 = 0x05;
gallonm 7:2dc81120c917 2018 } else {
gallonm 7:2dc81120c917 2019 u8=0x3E;
gallonm 7:2dc81120c917 2020 u8_2 = 0x01;
gallonm 7:2dc81120c917 2021 }
gallonm 7:2dc81120c917 2022 status = VL6180x_WrByte(dev, 0x01AC, u8);
gallonm 7:2dc81120c917 2023 if( status ){
gallonm 7:2dc81120c917 2024 VL6180x_ErrLog("0x01AC wr fail");
gallonm 7:2dc81120c917 2025 goto done_err;
gallonm 7:2dc81120c917 2026 }
gallonm 7:2dc81120c917 2027 status = VL6180x_WrByte(dev, 0x0F2, u8_2);
gallonm 7:2dc81120c917 2028 if( status ){
gallonm 7:2dc81120c917 2029 VL6180x_ErrLog("0x0F2 wr fail");
gallonm 7:2dc81120c917 2030 goto done_err;
gallonm 7:2dc81120c917 2031 }
gallonm 7:2dc81120c917 2032
gallonm 7:2dc81120c917 2033
gallonm 7:2dc81120c917 2034 _FilterData(MeasurementIndex)++;
gallonm 7:2dc81120c917 2035
gallonm 7:2dc81120c917 2036 /* Computes current VAVGDiff */
gallonm 7:2dc81120c917 2037 if (_FilterData(Default_VAVGVal) > _FilterData(NoDelay_VAVGVal))
gallonm 7:2dc81120c917 2038 VAVGDiff = _FilterData(Default_VAVGVal) - _FilterData(NoDelay_VAVGVal);
gallonm 7:2dc81120c917 2039 else
gallonm 7:2dc81120c917 2040 VAVGDiff = 0;
gallonm 7:2dc81120c917 2041 _FilterData(Previous_VAVGDiff) = VAVGDiff;
gallonm 7:2dc81120c917 2042
gallonm 7:2dc81120c917 2043 /* Check the VAVGDiff */
gallonm 7:2dc81120c917 2044 if (_FilterData(Default_ZeroVal) > _FilterData(NoDelay_ZeroVal))
gallonm 7:2dc81120c917 2045 IdealVAVGDiff = _FilterData(Default_ZeroVal) - _FilterData(NoDelay_ZeroVal);
gallonm 7:2dc81120c917 2046 else
gallonm 7:2dc81120c917 2047 IdealVAVGDiff = _FilterData(NoDelay_ZeroVal) - _FilterData(Default_ZeroVal);
gallonm 7:2dc81120c917 2048 if (IdealVAVGDiff > MAX_VAVGDiff)
gallonm 7:2dc81120c917 2049 MinVAVGDiff = IdealVAVGDiff - MAX_VAVGDiff;
gallonm 7:2dc81120c917 2050 else
gallonm 7:2dc81120c917 2051 MinVAVGDiff = 0;
gallonm 7:2dc81120c917 2052 MaxVAVGDiff = IdealVAVGDiff + MAX_VAVGDiff;
gallonm 7:2dc81120c917 2053 if (VAVGDiff < MinVAVGDiff || VAVGDiff > MaxVAVGDiff) {
gallonm 7:2dc81120c917 2054 WrapAroundFlag = 1;
gallonm 7:2dc81120c917 2055 } else {
gallonm 7:2dc81120c917 2056 /* Go through filtering check */
gallonm 7:2dc81120c917 2057
gallonm 7:2dc81120c917 2058 /* StdDevLimit Damper on SNR */
gallonm 7:2dc81120c917 2059 StdDevLimit = _filter_StdDevDamper(m_rtnAmbientRate, m_rtnSignalRate, StdDevLimitLowLight, StdDevLimitLowLightSNR, StdDevLimitHighLight, StdDevLimitHighLightSNR);
gallonm 7:2dc81120c917 2060
gallonm 7:2dc81120c917 2061 /* Standard deviations computations */
gallonm 7:2dc81120c917 2062 StdDevSamples = 0;
gallonm 7:2dc81120c917 2063 StdDevDistanceSum = 0;
gallonm 7:2dc81120c917 2064 StdDevDistanceMean = 0;
gallonm 7:2dc81120c917 2065 StdDevDistance = 0;
gallonm 7:2dc81120c917 2066 StdDevRateSum = 0;
gallonm 7:2dc81120c917 2067 StdDevRateMean = 0;
gallonm 7:2dc81120c917 2068 StdDevRate = 0;
gallonm 7:2dc81120c917 2069 for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
gallonm 7:2dc81120c917 2070 if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
gallonm 7:2dc81120c917 2071 StdDevSamples = (uint16_t) (StdDevSamples + 1);
gallonm 7:2dc81120c917 2072 StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + _FilterData(LastTrueRange)[i]);
gallonm 7:2dc81120c917 2073 StdDevRateSum = (uint32_t) (StdDevRateSum + _FilterData(LastReturnRates)[i]);
gallonm 7:2dc81120c917 2074 }
gallonm 7:2dc81120c917 2075 }
gallonm 7:2dc81120c917 2076 if (StdDevSamples > 0) {
gallonm 7:2dc81120c917 2077 StdDevDistanceMean = (uint32_t) (StdDevDistanceSum / StdDevSamples);
gallonm 7:2dc81120c917 2078 StdDevRateMean = (uint32_t) (StdDevRateSum / StdDevSamples);
gallonm 7:2dc81120c917 2079 }
gallonm 7:2dc81120c917 2080 /* TODO optimize shorten Std dev in aisngle loop computation using sum of x2 - (sum of x)2 */
gallonm 7:2dc81120c917 2081 StdDevSamples = 0;
gallonm 7:2dc81120c917 2082 StdDevDistanceSum = 0;
gallonm 7:2dc81120c917 2083 StdDevRateSum = 0;
gallonm 7:2dc81120c917 2084 for (i = 0; (i < FILTER_NBOF_SAMPLES) && (StdDevSamples < FILTER_STDDEV_SAMPLES); i++) {
gallonm 7:2dc81120c917 2085 if (_FilterData(LastTrueRange)[i] != FILTER_INVALID_DISTANCE) {
gallonm 7:2dc81120c917 2086 StdDevSamples = (uint16_t) (StdDevSamples + 1);
gallonm 7:2dc81120c917 2087 StdDevDistanceSum = (uint32_t) (StdDevDistanceSum + (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean) * (int) (_FilterData(LastTrueRange)[i] - StdDevDistanceMean));
gallonm 7:2dc81120c917 2088 StdDevRateSum = (uint32_t) (StdDevRateSum + (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean) * (int) (_FilterData(LastReturnRates)[i] - StdDevRateMean));
gallonm 7:2dc81120c917 2089 }
gallonm 7:2dc81120c917 2090 }
gallonm 7:2dc81120c917 2091 if (StdDevSamples >= MIN_FILTER_STDDEV_SAMPLES) {
gallonm 7:2dc81120c917 2092 StdDevDistance = (uint16_t) (StdDevDistanceSum / StdDevSamples);
gallonm 7:2dc81120c917 2093 StdDevRate = (uint16_t) (StdDevRateSum / StdDevSamples);
gallonm 7:2dc81120c917 2094 } else {
gallonm 7:2dc81120c917 2095 StdDevDistance = 0;
gallonm 7:2dc81120c917 2096 StdDevRate = 0;
gallonm 7:2dc81120c917 2097 }
gallonm 7:2dc81120c917 2098
gallonm 7:2dc81120c917 2099 /* Check Return rate standard deviation */
gallonm 7:2dc81120c917 2100 if (StdDevRate < StdDevMovingTargetStdDevLimit) {
gallonm 7:2dc81120c917 2101 if (StdDevSamples < MIN_FILTER_VALID_STDDEV_SAMPLES) {
gallonm 7:2dc81120c917 2102 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 2103 } else {
gallonm 7:2dc81120c917 2104 /* Check distance standard deviation */
gallonm 7:2dc81120c917 2105 if (StdDevRate < StdDevMovingTargetReturnRateLimit)
gallonm 7:2dc81120c917 2106 StdDevLimitWithTargetMove = StdDevLimit + (((StdDevMovingTargetStdDevForReturnRateLimit - StdDevLimit) * StdDevRate) / StdDevMovingTargetReturnRateLimit);
gallonm 7:2dc81120c917 2107 else
gallonm 7:2dc81120c917 2108 StdDevLimitWithTargetMove = StdDevMovingTargetStdDevForReturnRateLimit;
gallonm 7:2dc81120c917 2109
gallonm 7:2dc81120c917 2110 if ((StdDevDistance * StdDevHighConfidenceSNRLimit) < StdDevLimitWithTargetMove) {
gallonm 7:2dc81120c917 2111 NoWrapAroundHighConfidenceFlag = 1;
gallonm 7:2dc81120c917 2112 } else {
gallonm 7:2dc81120c917 2113 if (StdDevDistance < StdDevLimitWithTargetMove) {
gallonm 7:2dc81120c917 2114 if (StdDevSamples >= MIN_FILTER_VALID_STDDEV_SAMPLES) {
gallonm 7:2dc81120c917 2115 NoWrapAroundFlag = 1;
gallonm 7:2dc81120c917 2116 } else {
gallonm 7:2dc81120c917 2117 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 2118 }
gallonm 7:2dc81120c917 2119 } else {
gallonm 7:2dc81120c917 2120 WrapAroundFlag = 1;
gallonm 7:2dc81120c917 2121 }
gallonm 7:2dc81120c917 2122 }
gallonm 7:2dc81120c917 2123 }
gallonm 7:2dc81120c917 2124 } else {
gallonm 7:2dc81120c917 2125 WrapAroundFlag = 1;
gallonm 7:2dc81120c917 2126 }
gallonm 7:2dc81120c917 2127 }
gallonm 7:2dc81120c917 2128
gallonm 7:2dc81120c917 2129 if (m_newTrueRange_mm == MaxOrInvalidDistance) {
gallonm 7:2dc81120c917 2130 if (_FilterData(StdFilteredReads) > 0)
gallonm 7:2dc81120c917 2131 _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - 1);
gallonm 7:2dc81120c917 2132 } else {
gallonm 7:2dc81120c917 2133 if (WrapAroundFlag == 1) {
gallonm 7:2dc81120c917 2134 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 2135 _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) + StdFilteredReadsIncrement);
gallonm 7:2dc81120c917 2136 if (_FilterData(StdFilteredReads) > StdMaxFilteredReads)
gallonm 7:2dc81120c917 2137 _FilterData(StdFilteredReads) = StdMaxFilteredReads;
gallonm 7:2dc81120c917 2138 } else {
gallonm 7:2dc81120c917 2139 if (NoWrapAroundFlag == 1) {
gallonm 7:2dc81120c917 2140 if (_FilterData(StdFilteredReads) > 0) {
gallonm 7:2dc81120c917 2141 m_newTrueRange_mm = MaxOrInvalidDistance;
gallonm 7:2dc81120c917 2142 if (_FilterData(StdFilteredReads) > StdFilteredReadsIncrement)
gallonm 7:2dc81120c917 2143 _FilterData(StdFilteredReads) = (uint16_t) (_FilterData(StdFilteredReads) - StdFilteredReadsIncrement);
gallonm 7:2dc81120c917 2144 else
gallonm 7:2dc81120c917 2145 _FilterData(StdFilteredReads) = 0;
gallonm 7:2dc81120c917 2146 }
gallonm 7:2dc81120c917 2147 } else {
gallonm 7:2dc81120c917 2148 if (NoWrapAroundHighConfidenceFlag == 1) {
gallonm 7:2dc81120c917 2149 _FilterData(StdFilteredReads) = 0;
gallonm 7:2dc81120c917 2150 }
gallonm 7:2dc81120c917 2151 }
gallonm 7:2dc81120c917 2152 }
gallonm 7:2dc81120c917 2153 }
gallonm 7:2dc81120c917 2154
gallonm 7:2dc81120c917 2155 return m_newTrueRange_mm;
gallonm 7:2dc81120c917 2156 done_err:
gallonm 7:2dc81120c917 2157 return -1;
gallonm 7:2dc81120c917 2158
gallonm 7:2dc81120c917 2159 #undef MaxOrInvalidDistance
gallonm 7:2dc81120c917 2160 }
gallonm 7:2dc81120c917 2161
gallonm 7:2dc81120c917 2162
gallonm 7:2dc81120c917 2163 int VL6180X::_filter_GetResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
gallonm 7:2dc81120c917 2164 uint32_t m_rawRange_mm = 0;
gallonm 7:2dc81120c917 2165 int32_t FilteredRange;
gallonm 7:2dc81120c917 2166 const uint8_t scaler = _GetUpscale(dev);
gallonm 7:2dc81120c917 2167 uint8_t u8;
gallonm 7:2dc81120c917 2168 int status;
gallonm 7:2dc81120c917 2169
gallonm 7:2dc81120c917 2170 do {
gallonm 7:2dc81120c917 2171 status = VL6180x_RdByte(dev, RESULT_RANGE_RAW, &u8);
gallonm 7:2dc81120c917 2172 if (status) {
gallonm 7:2dc81120c917 2173 VL6180x_ErrLog("RESULT_RANGE_RAW rd fail");
gallonm 7:2dc81120c917 2174 break;
gallonm 7:2dc81120c917 2175 }
gallonm 7:2dc81120c917 2176 m_rawRange_mm = u8;
gallonm 7:2dc81120c917 2177
gallonm 7:2dc81120c917 2178 FilteredRange = _filter_Start(dev, pRangeData->range_mm, (m_rawRange_mm * scaler), pRangeData->rtnRate, pRangeData->rtnAmbRate, pRangeData->errorStatus);
gallonm 7:2dc81120c917 2179 if( FilteredRange<0 ){
gallonm 7:2dc81120c917 2180 status = -1;
gallonm 7:2dc81120c917 2181 break;
gallonm 7:2dc81120c917 2182 }
gallonm 7:2dc81120c917 2183 pRangeData->FilteredData.range_mm= FilteredRange;
gallonm 7:2dc81120c917 2184 pRangeData->FilteredData.rawRange_mm = m_rawRange_mm * scaler;
gallonm 7:2dc81120c917 2185 } while (0);
gallonm 7:2dc81120c917 2186 return status;
gallonm 7:2dc81120c917 2187 }
gallonm 7:2dc81120c917 2188
gallonm 7:2dc81120c917 2189 #undef _FilterData
gallonm 7:2dc81120c917 2190 #undef FILTER_STDDEV_SAMPLES
gallonm 7:2dc81120c917 2191 #undef MIN_FILTER_STDDEV_SAMPLES
gallonm 7:2dc81120c917 2192 #undef MIN_FILTER_VALID_STDDEV_SAMPLES
gallonm 7:2dc81120c917 2193 #undef FILTER_INVALID_DISTANCE
gallonm 7:2dc81120c917 2194
gallonm 7:2dc81120c917 2195 #endif /* VL6180x_WRAP_AROUND_FILTER_SUPPORT */
gallonm 7:2dc81120c917 2196
gallonm 7:2dc81120c917 2197 #ifdef VL6180x_HAVE_RATE_DATA
gallonm 7:2dc81120c917 2198
gallonm 7:2dc81120c917 2199 int VL6180X::_GetRateResult(VL6180xDev_t dev, VL6180x_RangeData_t *pRangeData) {
gallonm 7:2dc81120c917 2200 uint32_t m_rtnConvTime = 0;
gallonm 7:2dc81120c917 2201 uint32_t m_rtnSignalRate = 0;
gallonm 7:2dc81120c917 2202 uint32_t m_rtnAmbientRate = 0;
gallonm 7:2dc81120c917 2203 uint32_t m_rtnSignalCount = 0;
gallonm 7:2dc81120c917 2204 uint32_t m_rtnAmbientCount = 0;
gallonm 7:2dc81120c917 2205 uint32_t m_refConvTime = 0;
gallonm 7:2dc81120c917 2206 uint32_t cRtnSignalCountMax = 0x7FFFFFFF;
gallonm 7:2dc81120c917 2207 uint32_t cDllPeriods = 6;
gallonm 7:2dc81120c917 2208 uint32_t calcConvTime = 0;
gallonm 7:2dc81120c917 2209
gallonm 7:2dc81120c917 2210 int status;
gallonm 7:2dc81120c917 2211
gallonm 7:2dc81120c917 2212 do {
gallonm 7:2dc81120c917 2213
gallonm 7:2dc81120c917 2214 status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_SIGNAL_COUNT, &m_rtnSignalCount);
gallonm 7:2dc81120c917 2215 if (status) {
gallonm 7:2dc81120c917 2216 VL6180x_ErrLog("RESULT_RANGE_RETURN_SIGNAL_COUNT rd fail");
gallonm 7:2dc81120c917 2217 break;
gallonm 7:2dc81120c917 2218 }
gallonm 7:2dc81120c917 2219 if (m_rtnSignalCount > cRtnSignalCountMax) {
gallonm 7:2dc81120c917 2220 m_rtnSignalCount = 0;
gallonm 7:2dc81120c917 2221 }
gallonm 7:2dc81120c917 2222
gallonm 7:2dc81120c917 2223 status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_AMB_COUNT, &m_rtnAmbientCount);
gallonm 7:2dc81120c917 2224 if (status) {
gallonm 7:2dc81120c917 2225 VL6180x_ErrLog("RESULT_RANGE_RETURN_AMB_COUNTrd fail");
gallonm 7:2dc81120c917 2226 break;
gallonm 7:2dc81120c917 2227 }
gallonm 7:2dc81120c917 2228
gallonm 7:2dc81120c917 2229
gallonm 7:2dc81120c917 2230 status = VL6180x_RdDWord(dev, RESULT_RANGE_RETURN_CONV_TIME, &m_rtnConvTime);
gallonm 7:2dc81120c917 2231 if (status) {
gallonm 7:2dc81120c917 2232 VL6180x_ErrLog("RESULT_RANGE_RETURN_CONV_TIME rd fail");
gallonm 7:2dc81120c917 2233 break;
gallonm 7:2dc81120c917 2234 }
gallonm 7:2dc81120c917 2235
gallonm 7:2dc81120c917 2236 status = VL6180x_RdDWord(dev, RESULT_RANGE_REFERENCE_CONV_TIME, &m_refConvTime);
gallonm 7:2dc81120c917 2237 if (status) {
gallonm 7:2dc81120c917 2238 VL6180x_ErrLog("RESULT_RANGE_REFERENCE_CONV_TIME rd fail");
gallonm 7:2dc81120c917 2239 break;
gallonm 7:2dc81120c917 2240 }
gallonm 7:2dc81120c917 2241
gallonm 7:2dc81120c917 2242 pRangeData->rtnConvTime = m_rtnConvTime;
gallonm 7:2dc81120c917 2243 pRangeData->refConvTime = m_refConvTime;
gallonm 7:2dc81120c917 2244
gallonm 7:2dc81120c917 2245 calcConvTime = m_refConvTime;
gallonm 7:2dc81120c917 2246 if (m_rtnConvTime > m_refConvTime) {
gallonm 7:2dc81120c917 2247 calcConvTime = m_rtnConvTime;
gallonm 7:2dc81120c917 2248 }
gallonm 7:2dc81120c917 2249 if (calcConvTime == 0)
gallonm 7:2dc81120c917 2250 calcConvTime = 63000;
gallonm 7:2dc81120c917 2251
gallonm 7:2dc81120c917 2252 m_rtnSignalRate = (m_rtnSignalCount * 1000) / calcConvTime;
gallonm 7:2dc81120c917 2253 m_rtnAmbientRate = (m_rtnAmbientCount * cDllPeriods * 1000) / calcConvTime;
gallonm 7:2dc81120c917 2254
gallonm 7:2dc81120c917 2255 pRangeData->rtnRate = m_rtnSignalRate;
gallonm 7:2dc81120c917 2256 pRangeData->rtnAmbRate = m_rtnAmbientRate;
gallonm 7:2dc81120c917 2257
gallonm 7:2dc81120c917 2258
gallonm 7:2dc81120c917 2259 } while (0);
gallonm 7:2dc81120c917 2260 return status;
gallonm 7:2dc81120c917 2261 }
gallonm 7:2dc81120c917 2262 #endif /* VL6180x_HAVE_RATE_DATA */
gallonm 7:2dc81120c917 2263
gallonm 7:2dc81120c917 2264
gallonm 7:2dc81120c917 2265 int VL6180X::VL6180x_DMaxSetState(VL6180xDev_t dev, int state){
gallonm 7:2dc81120c917 2266 int status;
gallonm 7:2dc81120c917 2267 LOG_FUNCTION_START("%d", state);
gallonm 7:2dc81120c917 2268 #if VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 2269 VL6180xDevDataSet(dev,DMaxEnable, state);
gallonm 7:2dc81120c917 2270 if( state ){
gallonm 7:2dc81120c917 2271 status = _DMax_InitData(dev);
gallonm 7:2dc81120c917 2272 }
gallonm 7:2dc81120c917 2273 else {
gallonm 7:2dc81120c917 2274 status = 0;
gallonm 7:2dc81120c917 2275 }
gallonm 7:2dc81120c917 2276 #else
gallonm 7:2dc81120c917 2277 status = NOT_SUPPORTED;
gallonm 7:2dc81120c917 2278 #endif
gallonm 7:2dc81120c917 2279 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 2280 return status;
gallonm 7:2dc81120c917 2281 }
gallonm 7:2dc81120c917 2282
gallonm 7:2dc81120c917 2283 int VL6180X::VL6180x_DMaxGetState(VL6180xDev_t dev){
gallonm 7:2dc81120c917 2284 int status;
gallonm 7:2dc81120c917 2285 LOG_FUNCTION_START("");
gallonm 7:2dc81120c917 2286 #if VL6180x_HAVE_DMAX_RANGING
gallonm 7:2dc81120c917 2287 status = VL6180xDevDataGet(dev,DMaxEnable);
gallonm 7:2dc81120c917 2288 #else
gallonm 7:2dc81120c917 2289 status = 0;
gallonm 7:2dc81120c917 2290 #endif
gallonm 7:2dc81120c917 2291 LOG_FUNCTION_END(status);
gallonm 7:2dc81120c917 2292 return status;
gallonm 7:2dc81120c917 2293 }
gallonm 7:2dc81120c917 2294
gallonm 7:2dc81120c917 2295
gallonm 7:2dc81120c917 2296 #if VL6180x_HAVE_DMAX_RANGING
gallonm 1:1de1ea2994d9 2297
gallonm 4:a5abf7757947 2298 #define _DMaxData(field) VL6180xDevDataGet(dev, DMaxData.field)
gallonm 7:2dc81120c917 2299 /*
gallonm 7:2dc81120c917 2300 * Convert fix point x.7 to KCpount per sec
gallonm 7:2dc81120c917 2301 */
gallonm 4:a5abf7757947 2302
gallonm 4:a5abf7757947 2303 #ifndef VL6180x_PLATFORM_PROVIDE_SQRT
gallonm 4:a5abf7757947 2304
gallonm 7:2dc81120c917 2305 /*
gallonm 7:2dc81120c917 2306 * 32 bit integer square root with not so bad precision (integer result) and is quite fast
gallonm 7:2dc81120c917 2307 * see http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
gallonm 7:2dc81120c917 2308 */
gallonm 7:2dc81120c917 2309 uint32_t VL6180x_SqrtUint32(uint32_t num) {
gallonm 4:a5abf7757947 2310 uint32_t res = 0;
gallonm 4:a5abf7757947 2311 uint32_t bit = 1 << 30; /* The second-to-top bit is set: 1 << 30 for 32 bits */
gallonm 4:a5abf7757947 2312
gallonm 4:a5abf7757947 2313 /* "bit" starts at the highest power of four <= the argument. */
gallonm 4:a5abf7757947 2314 while (bit > num)
gallonm 4:a5abf7757947 2315 bit >>= 2;
gallonm 1:1de1ea2994d9 2316
gallonm 4:a5abf7757947 2317 while (bit != 0) {
gallonm 4:a5abf7757947 2318 if (num >= res + bit) {
gallonm 4:a5abf7757947 2319 num -= res + bit;
gallonm 4:a5abf7757947 2320 res = (res >> 1) + bit;
gallonm 4:a5abf7757947 2321 }
gallonm 4:a5abf7757947 2322 else
gallonm 4:a5abf7757947 2323 res >>= 1;
gallonm 4:a5abf7757947 2324 bit >>= 2;
gallonm 1:1de1ea2994d9 2325 }
gallonm 4:a5abf7757947 2326 return res;
gallonm 4:a5abf7757947 2327 }
gallonm 4:a5abf7757947 2328 #endif
gallonm 4:a5abf7757947 2329
gallonm 4:a5abf7757947 2330
gallonm 7:2dc81120c917 2331 /* DMax one time init */
gallonm 7:2dc81120c917 2332 void _DMax_OneTimeInit(VL6180xDev_t dev){
gallonm 4:a5abf7757947 2333 _DMaxData(ambTuningWindowFactor_K)=DEF_AMBIENT_TUNING;
gallonm 1:1de1ea2994d9 2334 }
gallonm 1:1de1ea2994d9 2335
gallonm 1:1de1ea2994d9 2336
gallonm 7:2dc81120c917 2337 static uint32_t _DMax_RawValueAtRateKCps(VL6180xDev_t dev, int32_t rate){
gallonm 4:a5abf7757947 2338 uint32_t snrLimit_K;
gallonm 4:a5abf7757947 2339 int32_t DMaxSq;
gallonm 4:a5abf7757947 2340 uint32_t RawDMax;
gallonm 4:a5abf7757947 2341 DMaxFix_t retSignalAt400mm;
gallonm 4:a5abf7757947 2342 uint32_t ambTuningWindowFactor_K;
gallonm 3:454541a079f4 2343
gallonm 3:454541a079f4 2344
gallonm 4:a5abf7757947 2345 ambTuningWindowFactor_K = _DMaxData(ambTuningWindowFactor_K);
gallonm 4:a5abf7757947 2346 snrLimit_K = _DMaxData(snrLimit_K);
gallonm 4:a5abf7757947 2347 retSignalAt400mm = _DMaxData(retSignalAt400mm); /* 12 to 18 bits Kcps */
gallonm 4:a5abf7757947 2348 if( rate > 0 ){
gallonm 4:a5abf7757947 2349 DMaxSq = 400*400*1000 / rate -(400*400/330); /* K of (1/RtnAmb -1/330 )=> 30bit- (12-18)bit => 12-18 bits*/
gallonm 4:a5abf7757947 2350 if( DMaxSq<= 0){
gallonm 4:a5abf7757947 2351 RawDMax = 0;
gallonm 4:a5abf7757947 2352 }
gallonm 4:a5abf7757947 2353 else{
gallonm 4:a5abf7757947 2354 /* value can be more 32 bit so base on raneg apply *retSignalAt400mm before or after division to presevr accuracy */
gallonm 4:a5abf7757947 2355 if( DMaxSq< (2<<12) ){
gallonm 4:a5abf7757947 2356 DMaxSq = DMaxSq*retSignalAt400mm/(snrLimit_K+ambTuningWindowFactor_K); /* max 12 + 12 to 18 -10 => 12-26 bit */
gallonm 4:a5abf7757947 2357 }else{
gallonm 4:a5abf7757947 2358 DMaxSq = DMaxSq/(snrLimit_K+ambTuningWindowFactor_K)*retSignalAt400mm; /* 12 to 18 -10 + 12 to 18 *=> 12-26 bit */
gallonm 4:a5abf7757947 2359 }
gallonm 4:a5abf7757947 2360 RawDMax=VL6180x_SqrtUint32(DMaxSq);
gallonm 4:a5abf7757947 2361 }
gallonm 4:a5abf7757947 2362 }
gallonm 4:a5abf7757947 2363 else{
gallonm 4:a5abf7757947 2364 RawDMax = 0x7FFFFFFF; /* bigest possibmle 32bit signed value */
gallonm 4:a5abf7757947 2365 }
gallonm 4:a5abf7757947 2366 return RawDMax;
gallonm 4:a5abf7757947 2367 }
gallonm 3:454541a079f4 2368
gallonm 7:2dc81120c917 2369 /*
gallonm 7:2dc81120c917 2370 * fetch static data from register to avoid re-read
gallonm 7:2dc81120c917 2371 * precompute all intermediate constant and cliipings
gallonm 7:2dc81120c917 2372 *
gallonm 7:2dc81120c917 2373 * to be re-used/call on changes of :
gallonm 7:2dc81120c917 2374 * 0x2A
gallonm 7:2dc81120c917 2375 * SYSRANGE_MAX_AMBIENT_LEVEL_MULT
gallonm 7:2dc81120c917 2376 * Dev Data XtalkComRate_KCPs
gallonm 7:2dc81120c917 2377 * SYSRANGE_MAX_CONVERGENCE_TIME
gallonm 7:2dc81120c917 2378 * SYSRANGE_RANGE_CHECK_ENABLES mask RANGE_CHECK_RANGE_ENABLE_MASK
gallonm 7:2dc81120c917 2379 * range 0xb8-0xbb (0xbb)
gallonm 7:2dc81120c917 2380 */
gallonm 7:2dc81120c917 2381 int VL6180X::_DMax_InitData(VL6180xDev_t dev){
gallonm 3:454541a079f4 2382 int status, warning;
gallonm 3:454541a079f4 2383 uint8_t u8;
gallonm 3:454541a079f4 2384 uint16_t u16;
gallonm 3:454541a079f4 2385 uint32_t u32;
gallonm 3:454541a079f4 2386 uint32_t Reg2A_KCps;
gallonm 3:454541a079f4 2387 uint32_t RegB8;
gallonm 3:454541a079f4 2388 uint8_t MaxConvTime;
gallonm 3:454541a079f4 2389 uint32_t XTalkCompRate_KCps;
gallonm 3:454541a079f4 2390 uint32_t RangeIgnoreThreshold;
gallonm 3:454541a079f4 2391 int32_t minSignalNeeded;
gallonm 3:454541a079f4 2392 uint8_t SysRangeCheckEn;
gallonm 3:454541a079f4 2393 uint8_t snrLimit;
gallonm 3:454541a079f4 2394 warning=0;
gallonm 3:454541a079f4 2395
gallonm 3:454541a079f4 2396 static const int ROMABLE_DATA MaxConvTimeAdjust=-4;
gallonm 3:454541a079f4 2397
gallonm 3:454541a079f4 2398 LOG_FUNCTION_START("");
gallonm 3:454541a079f4 2399 do{
gallonm 7:2dc81120c917 2400 status = VL6180x_RdByte(dev, 0x02A ,&u8);
gallonm 3:454541a079f4 2401 if( status ){
gallonm 3:454541a079f4 2402 VL6180x_ErrLog("Reg 0x02A rd fail");
gallonm 3:454541a079f4 2403 break;
gallonm 3:454541a079f4 2404 }
gallonm 3:454541a079f4 2405
gallonm 3:454541a079f4 2406 if( u8 == 0 ) {
gallonm 3:454541a079f4 2407 warning = CALIBRATION_WARNING;
gallonm 3:454541a079f4 2408 u8 = 40; /* use a default average value */
gallonm 3:454541a079f4 2409 }
gallonm 3:454541a079f4 2410 Reg2A_KCps = Fix7_2_KCPs(u8); /* convert to KCPs */
gallonm 3:454541a079f4 2411
gallonm 7:2dc81120c917 2412 status = VL6180x_RdByte(dev, SYSRANGE_RANGE_CHECK_ENABLES, &SysRangeCheckEn);
gallonm 3:454541a079f4 2413 if (status) {
gallonm 3:454541a079f4 2414 VL6180x_ErrLog("SYSRANGE_RANGE_CHECK_ENABLES rd fail ");
gallonm 3:454541a079f4 2415 break;
gallonm 3:454541a079f4 2416 }
gallonm 3:454541a079f4 2417
gallonm 7:2dc81120c917 2418 status = VL6180x_RdByte(dev, SYSRANGE_MAX_CONVERGENCE_TIME, &MaxConvTime);
gallonm 3:454541a079f4 2419 if( status){
gallonm 3:454541a079f4 2420 VL6180x_ErrLog("SYSRANGE_MAX_CONVERGENCE_TIME rd fail ");
gallonm 3:454541a079f4 2421 break;
gallonm 3:454541a079f4 2422 }
gallonm 3:454541a079f4 2423
gallonm 7:2dc81120c917 2424 status = VL6180x_RdDWord(dev, 0x0B8, &RegB8);
gallonm 3:454541a079f4 2425 if( status ){
gallonm 3:454541a079f4 2426 VL6180x_ErrLog("reg 0x0B8 rd fail ");
gallonm 3:454541a079f4 2427 break;
gallonm 3:454541a079f4 2428 }
gallonm 3:454541a079f4 2429
gallonm 7:2dc81120c917 2430 status = VL6180x_RdByte(dev, SYSRANGE_MAX_AMBIENT_LEVEL_MULT, &snrLimit);
gallonm 3:454541a079f4 2431 if( status){
gallonm 3:454541a079f4 2432 VL6180x_ErrLog("SYSRANGE_MAX_AMBIENT_LEVEL_MULT rd fail ");
gallonm 3:454541a079f4 2433 break;
gallonm 3:454541a079f4 2434 }
gallonm 3:454541a079f4 2435 _DMaxData(snrLimit_K) = (int32_t)16*1000/snrLimit;
gallonm 3:454541a079f4 2436 XTalkCompRate_KCps = VL6180xDevDataGet(dev, XTalkCompRate_KCps );
gallonm 3:454541a079f4 2437
gallonm 3:454541a079f4 2438 if( Reg2A_KCps >= XTalkCompRate_KCps){
gallonm 3:454541a079f4 2439 _DMaxData(retSignalAt400mm)=( Reg2A_KCps - XTalkCompRate_KCps);
gallonm 3:454541a079f4 2440 }
gallonm 3:454541a079f4 2441 else{
gallonm 3:454541a079f4 2442 _DMaxData(retSignalAt400mm)=0; /* Reg2A_K - XTalkCompRate_KCp <0 is invalid */
gallonm 3:454541a079f4 2443 }
gallonm 3:454541a079f4 2444
gallonm 3:454541a079f4 2445 /* if xtalk range check is off omit it in snr clipping */
gallonm 3:454541a079f4 2446 if( SysRangeCheckEn&RANGE_CHECK_RANGE_ENABLE_MASK ){
gallonm 7:2dc81120c917 2447 status = VL6180x_RdWord(dev, SYSRANGE_RANGE_IGNORE_THRESHOLD, &u16);
gallonm 3:454541a079f4 2448 if( status){
gallonm 3:454541a079f4 2449 VL6180x_ErrLog("SYSRANGE_RANGE_IGNORE_THRESHOLD rd fail ");
gallonm 3:454541a079f4 2450 break;
gallonm 3:454541a079f4 2451 }
gallonm 3:454541a079f4 2452 RangeIgnoreThreshold = Fix7_2_KCPs(u16);
gallonm 3:454541a079f4 2453 }
gallonm 3:454541a079f4 2454 else{
gallonm 3:454541a079f4 2455 RangeIgnoreThreshold = 0;
gallonm 3:454541a079f4 2456 }
gallonm 3:454541a079f4 2457
gallonm 3:454541a079f4 2458 minSignalNeeded = (RegB8*256)/((int32_t)MaxConvTime+(int32_t)MaxConvTimeAdjust); /* KCps 8+8 bit -(1 to 6 bit) => 15-10 bit */
gallonm 3:454541a079f4 2459 /* minSignalNeeded = max ( minSignalNeeded, RangeIgnoreThreshold - XTalkCompRate_KCps) */
gallonm 3:454541a079f4 2460 if( minSignalNeeded <= RangeIgnoreThreshold - XTalkCompRate_KCps )
gallonm 3:454541a079f4 2461 minSignalNeeded = RangeIgnoreThreshold - XTalkCompRate_KCps;
gallonm 3:454541a079f4 2462
gallonm 3:454541a079f4 2463 u32 = (minSignalNeeded*(uint32_t)snrLimit)/16;
gallonm 3:454541a079f4 2464 _DMaxData(ClipSnrLimit ) = _DMax_RawValueAtRateKCps(dev, u32 ); /* clip to dmax to min signal snr limit rate*/
gallonm 3:454541a079f4 2465 }
gallonm 3:454541a079f4 2466 while(0);
gallonm 3:454541a079f4 2467 if( !status )
gallonm 3:454541a079f4 2468 status = warning;
gallonm 3:454541a079f4 2469 LOG_FUNCTION_END(status);
gallonm 3:454541a079f4 2470 return status;
gallonm 1:1de1ea2994d9 2471 }
gallonm 1:1de1ea2994d9 2472
gallonm 7:2dc81120c917 2473 static int _DMax_Compute(VL6180xDev_t dev, VL6180x_RangeData_t *pRange){
gallonm 7:2dc81120c917 2474 uint32_t rtnAmbRate;
gallonm 7:2dc81120c917 2475 int32_t DMax;
gallonm 7:2dc81120c917 2476 int scaling;
gallonm 7:2dc81120c917 2477 uint16_t HwLimitAtScale;
gallonm 7:2dc81120c917 2478 static const int ROMABLE_DATA rtnAmbLowLimit_KCps=330*1000;
gallonm 7:2dc81120c917 2479
gallonm 7:2dc81120c917 2480 rtnAmbRate = pRange->rtnAmbRate;
gallonm 7:2dc81120c917 2481 if( rtnAmbRate < rtnAmbLowLimit_KCps ){
gallonm 7:2dc81120c917 2482 DMax = _DMax_RawValueAtRateKCps( dev, rtnAmbRate);
gallonm 7:2dc81120c917 2483 scaling = _GetUpscale(dev);
gallonm 7:2dc81120c917 2484 HwLimitAtScale=UpperLimitLookUP[scaling - 1];
gallonm 7:2dc81120c917 2485
gallonm 7:2dc81120c917 2486 if( DMax > _DMaxData(ClipSnrLimit) ){
gallonm 7:2dc81120c917 2487 DMax=_DMaxData(ClipSnrLimit);
gallonm 7:2dc81120c917 2488 }
gallonm 7:2dc81120c917 2489 if( DMax > HwLimitAtScale ){
gallonm 7:2dc81120c917 2490 DMax=HwLimitAtScale;
gallonm 7:2dc81120c917 2491 }
gallonm 7:2dc81120c917 2492 pRange->DMax=DMax;
gallonm 7:2dc81120c917 2493 }
gallonm 7:2dc81120c917 2494 else{
gallonm 7:2dc81120c917 2495 pRange->DMax = 0;
gallonm 7:2dc81120c917 2496 }
gallonm 7:2dc81120c917 2497 return 0;
gallonm 7:2dc81120c917 2498 }
gallonm 7:2dc81120c917 2499
gallonm 7:2dc81120c917 2500 #undef _DMaxData
gallonm 3:454541a079f4 2501 #undef Fix7_2_KCPs
gallonm 1:1de1ea2994d9 2502
gallonm 7:2dc81120c917 2503 #endif /* VL6180x_HAVE_DMAX_RANGING */
gallonm 7:2dc81120c917 2504
gallonm 7:2dc81120c917 2505
gallonm 7:2dc81120c917 2506 /******************************************************************************/
gallonm 7:2dc81120c917 2507 /******************************************************************************/
gallonm 7:2dc81120c917 2508
gallonm 7:2dc81120c917 2509
gallonm 7:2dc81120c917 2510
gallonm 7:2dc81120c917 2511 /****************** Write and read functions from I2C *************************/
gallonm 4:a5abf7757947 2512
gallonm 4:a5abf7757947 2513 int VL6180X::VL6180x_WrByte(VL6180xDev_t dev, uint16_t index, uint8_t data)
gallonm 4:a5abf7757947 2514 {
gallonm 4:a5abf7757947 2515 int status;
licio.mapelli@st.com 8:f943a1fca15f 2516
gallonm 10:4954b09b72d8 2517 status=VL6180x_I2CWrite(Device->I2cAddr, index, &data,(uint8_t)1);
gallonm 4:a5abf7757947 2518 return status;
gallonm 4:a5abf7757947 2519 }
gallonm 4:a5abf7757947 2520
gallonm 4:a5abf7757947 2521 int VL6180X::VL6180x_WrWord(VL6180xDev_t dev, uint16_t index, uint16_t data)
gallonm 4:a5abf7757947 2522 {
gallonm 4:a5abf7757947 2523 int status;
gallonm 10:4954b09b72d8 2524 status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)2);
gallonm 4:a5abf7757947 2525 return status;
gallonm 4:a5abf7757947 2526 }
gallonm 4:a5abf7757947 2527
gallonm 4:a5abf7757947 2528 int VL6180X::VL6180x_WrDWord(VL6180xDev_t dev, uint16_t index, uint32_t data)
gallonm 4:a5abf7757947 2529 {
gallonm 4:a5abf7757947 2530 int status;
gallonm 10:4954b09b72d8 2531 status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)&data,(uint8_t)4);
gallonm 4:a5abf7757947 2532 return status;
gallonm 4:a5abf7757947 2533 }
gallonm 4:a5abf7757947 2534
gallonm 4:a5abf7757947 2535 int VL6180X::VL6180x_RdByte(VL6180xDev_t dev, uint16_t index, uint8_t *data)
gallonm 4:a5abf7757947 2536 {
gallonm 4:a5abf7757947 2537 int status;
gallonm 4:a5abf7757947 2538 uint8_t buffer;
gallonm 10:4954b09b72d8 2539 status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
gallonm 10:4954b09b72d8 2540 if( !status )
gallonm 10:4954b09b72d8 2541 {
gallonm 10:4954b09b72d8 2542 *data=buffer;
gallonm 4:a5abf7757947 2543 }
gallonm 4:a5abf7757947 2544 return status;
gallonm 4:a5abf7757947 2545 }
gallonm 4:a5abf7757947 2546
gallonm 4:a5abf7757947 2547 int VL6180X::VL6180x_RdWord(VL6180xDev_t dev, uint16_t index, uint16_t *data)
gallonm 4:a5abf7757947 2548 {
gallonm 4:a5abf7757947 2549 int status;
licio.mapelli@st.com 8:f943a1fca15f 2550 uint8_t buffer[2];
gallonm 10:4954b09b72d8 2551 status=VL6180x_I2CRead(Device->I2cAddr, index, buffer, 2);
gallonm 10:4954b09b72d8 2552 if( !status )
gallonm 10:4954b09b72d8 2553 {
gallonm 10:4954b09b72d8 2554 memcpy(data, buffer, 2);
gallonm 10:4954b09b72d8 2555 }
gallonm 4:a5abf7757947 2556 return status;
gallonm 4:a5abf7757947 2557 }
gallonm 4:a5abf7757947 2558
gallonm 4:a5abf7757947 2559 int VL6180X::VL6180x_RdDWord(VL6180xDev_t dev, uint16_t index, uint32_t *data)
gallonm 4:a5abf7757947 2560 {
gallonm 4:a5abf7757947 2561 int status;
licio.mapelli@st.com 8:f943a1fca15f 2562 uint8_t buffer[4];
gallonm 10:4954b09b72d8 2563 status=VL6180x_I2CRead(Device->I2cAddr, index, buffer,4);
gallonm 10:4954b09b72d8 2564 if( !status )
gallonm 10:4954b09b72d8 2565 {
gallonm 10:4954b09b72d8 2566 memcpy(data, buffer, 4);
gallonm 10:4954b09b72d8 2567 }
gallonm 4:a5abf7757947 2568 return status;
gallonm 4:a5abf7757947 2569 }
gallonm 4:a5abf7757947 2570
licio.mapelli@st.com 8:f943a1fca15f 2571 int VL6180X::VL6180x_UpdateByte(VL6180xDev_t dev, uint16_t index, uint8_t AndData, uint8_t OrData)
licio.mapelli@st.com 8:f943a1fca15f 2572 {
gallonm 7:2dc81120c917 2573 int status;
licio.mapelli@st.com 8:f943a1fca15f 2574 uint8_t buffer;
licio.mapelli@st.com 8:f943a1fca15f 2575
gallonm 10:4954b09b72d8 2576 status=VL6180x_I2CWrite(Device->I2cAddr, index, (uint8_t *)buffer,(uint8_t)0);
gallonm 7:2dc81120c917 2577 if( !status ){
gallonm 7:2dc81120c917 2578 /* read data direct onto buffer */
gallonm 10:4954b09b72d8 2579 status=VL6180x_I2CRead(Device->I2cAddr, index, &buffer,1);
gallonm 7:2dc81120c917 2580 if( !status ){
licio.mapelli@st.com 8:f943a1fca15f 2581 buffer=(buffer & AndData)|OrData;
gallonm 10:4954b09b72d8 2582 status=VL6180x_I2CWrite(Device->I2cAddr, index, &buffer, (uint8_t)1);
gallonm 7:2dc81120c917 2583 }
gallonm 7:2dc81120c917 2584 }
gallonm 7:2dc81120c917 2585
gallonm 7:2dc81120c917 2586 return status;
gallonm 7:2dc81120c917 2587 }
gallonm 7:2dc81120c917 2588
gallonm 4:a5abf7757947 2589 int VL6180X::VL6180x_I2CWrite(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToWrite)
gallonm 4:a5abf7757947 2590 {
gallonm 4:a5abf7757947 2591 int ret;
gallonm 4:a5abf7757947 2592 int i;
gallonm 4:a5abf7757947 2593 uint8_t tmp[TEMP_BUF_SIZE];
gallonm 4:a5abf7757947 2594 uint16_t myRegisterAddr = RegisterAddr;
gallonm 7:2dc81120c917 2595 uint16_t WriteDeviceAddr=0;
licio.mapelli@st.com 8:f943a1fca15f 2596 /* First, prepare 8 bits device address in 7bits i2ci format */
gallonm 7:2dc81120c917 2597 WriteDeviceAddr=DeviceAddr*2;
gallonm 4:a5abf7757947 2598 if(NumByteToWrite >= TEMP_BUF_SIZE) return -2;
gallonm 4:a5abf7757947 2599
licio.mapelli@st.com 8:f943a1fca15f 2600 /* then prepare 16 bits register address in BE format. Then, send data and STOP condition */
gallonm 4:a5abf7757947 2601 tmp[0] = *(((uint8_t*)&myRegisterAddr)+1);
gallonm 4:a5abf7757947 2602 tmp[1] = (uint8_t)RegisterAddr;
gallonm 4:a5abf7757947 2603
licio.mapelli@st.com 8:f943a1fca15f 2604 if(NumByteToWrite>1) /* swap data endianess */
gallonm 4:a5abf7757947 2605 {
gallonm 4:a5abf7757947 2606 for(i=0;i<NumByteToWrite;i++)
gallonm 4:a5abf7757947 2607 {
gallonm 10:4954b09b72d8 2608 tmp[NumByteToWrite+sizeof(RegisterAddr)-1-i]=pBuffer[i];
gallonm 4:a5abf7757947 2609 }
gallonm 4:a5abf7757947 2610 }
gallonm 7:2dc81120c917 2611 else
gallonm 7:2dc81120c917 2612 {
licio.mapelli@st.com 8:f943a1fca15f 2613 memcpy(tmp+sizeof(RegisterAddr), pBuffer, NumByteToWrite);
gallonm 7:2dc81120c917 2614 }
licio.mapelli@st.com 9:9cbc1736f148 2615 ret = dev_i2c.write(WriteDeviceAddr, (const char*)tmp, NumByteToWrite+sizeof(RegisterAddr), false);
gallonm 4:a5abf7757947 2616
gallonm 4:a5abf7757947 2617 if(ret) return -1;
gallonm 4:a5abf7757947 2618 return 0;
gallonm 4:a5abf7757947 2619 }
gallonm 4:a5abf7757947 2620
gallonm 4:a5abf7757947 2621 int VL6180X::VL6180x_I2CRead(uint8_t DeviceAddr, uint16_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToRead)
gallonm 4:a5abf7757947 2622 {
licio.mapelli@st.com 8:f943a1fca15f 2623 int ret,i;
licio.mapelli@st.com 8:f943a1fca15f 2624 uint8_t tmp[TEMP_BUF_SIZE];
gallonm 4:a5abf7757947 2625 uint16_t myRegisterAddr = RegisterAddr;
gallonm 4:a5abf7757947 2626 uint16_t myRegisterAddrBE;
gallonm 7:2dc81120c917 2627 uint16_t ReadDeviceAddr=DeviceAddr;
gallonm 7:2dc81120c917 2628
gallonm 7:2dc81120c917 2629 ReadDeviceAddr=DeviceAddr*2;
gallonm 4:a5abf7757947 2630 myRegisterAddrBE = *(((uint8_t*)&myRegisterAddr)+1);
gallonm 4:a5abf7757947 2631 *(((uint8_t*)&myRegisterAddrBE)+1) = (uint8_t)myRegisterAddr;
gallonm 4:a5abf7757947 2632
gallonm 4:a5abf7757947 2633 /* Send 8 bits device address and 16 bits register address in BE format, with no STOP condition */
gallonm 7:2dc81120c917 2634 ret = dev_i2c.write(ReadDeviceAddr, (const char*)&myRegisterAddrBE, sizeof(RegisterAddr), true);
gallonm 4:a5abf7757947 2635 if(!ret) {
gallonm 7:2dc81120c917 2636 ReadDeviceAddr|=0x001;
gallonm 4:a5abf7757947 2637 /* Read data, with STOP condition */
licio.mapelli@st.com 8:f943a1fca15f 2638 ret = dev_i2c.read(ReadDeviceAddr, (char*)tmp, NumByteToRead, false);
licio.mapelli@st.com 8:f943a1fca15f 2639 }
licio.mapelli@st.com 8:f943a1fca15f 2640 if(ret) return -1;
licio.mapelli@st.com 8:f943a1fca15f 2641
licio.mapelli@st.com 8:f943a1fca15f 2642 if(NumByteToRead>1) /* swap data endianess */
licio.mapelli@st.com 8:f943a1fca15f 2643 {
gallonm 10:4954b09b72d8 2644 for(i=0;i<NumByteToRead;i++)
gallonm 10:4954b09b72d8 2645 {
gallonm 10:4954b09b72d8 2646 pBuffer[i] = tmp[NumByteToRead-1-i];
gallonm 10:4954b09b72d8 2647 }
gallonm 4:a5abf7757947 2648 }
gallonm 10:4954b09b72d8 2649 else
gallonm 10:4954b09b72d8 2650 {
gallonm 10:4954b09b72d8 2651 memcpy(pBuffer, tmp, NumByteToRead);
licio.mapelli@st.com 8:f943a1fca15f 2652 }
gallonm 4:a5abf7757947 2653 return 0;
gallonm 4:a5abf7757947 2654 }
gallonm 4:a5abf7757947 2655
gallonm 10:4954b09b72d8 2656
gallonm 10:4954b09b72d8 2657 int VL6180X::ReadID()
gallonm 4:a5abf7757947 2658 {
gallonm 10:4954b09b72d8 2659 int status;
gallonm 10:4954b09b72d8 2660 uint8_t rl_id;
gallonm 10:4954b09b72d8 2661
gallonm 10:4954b09b72d8 2662 status=VL6180x_RdByte( Device, IDENTIFICATION_MODEL_ID, &rl_id);
gallonm 10:4954b09b72d8 2663 if((status==0)&&(rl_id==0xB4))
gallonm 10:4954b09b72d8 2664 return status;
gallonm 10:4954b09b72d8 2665 else
gallonm 10:4954b09b72d8 2666 return INVALID_PARAMS;
gallonm 4:a5abf7757947 2667 }
gallonm 4:a5abf7757947 2668
gallonm 4:a5abf7757947 2669
gallonm 12:71d589e6fd2c 2670 int VL6180X::InitSensor(uint8_t NewAddr) //FIXME printf da sostituire con VL6180x_ErrLog e poi specificare il contenuto di questa funzione
gallonm 12:71d589e6fd2c 2671 {
gallonm 12:71d589e6fd2c 2672 int status=0;
gallonm 12:71d589e6fd2c 2673
gallonm 12:71d589e6fd2c 2674 VL6180x_Off();
gallonm 12:71d589e6fd2c 2675 VL6180x_On();
gallonm 12:71d589e6fd2c 2676 status=IsPresent();
gallonm 12:71d589e6fd2c 2677 if(!status)
gallonm 12:71d589e6fd2c 2678 {
gallonm 12:71d589e6fd2c 2679 Device->Present=1;
gallonm 12:71d589e6fd2c 2680 status=Init();
gallonm 12:71d589e6fd2c 2681 if(status)
gallonm 12:71d589e6fd2c 2682 printf("Failed to init VL6180X sensor!\n");
gallonm 12:71d589e6fd2c 2683 status=Prepare();
gallonm 12:71d589e6fd2c 2684 if(status)
gallonm 12:71d589e6fd2c 2685 printf("Failed to prepare VL6180X!\n");
gallonm 12:71d589e6fd2c 2686 //status=SetI2CAddress(NewAddr);
gallonm 12:71d589e6fd2c 2687 if(status)
gallonm 12:71d589e6fd2c 2688 printf("Failed to change I2C address!\n");
gallonm 12:71d589e6fd2c 2689 /* disable early convergence estimate
gallonm 12:71d589e6fd2c 2690 status=VL6180x_RangeSetEceState(Device, 0);
gallonm 12:71d589e6fd2c 2691 if(status)
gallonm 12:71d589e6fd2c 2692 printf("Failed to disable ECE!");*/
gallonm 12:71d589e6fd2c 2693 Device->Ready=1;
gallonm 12:71d589e6fd2c 2694 }
gallonm 12:71d589e6fd2c 2695 return status;
gallonm 12:71d589e6fd2c 2696 }
gallonm 12:71d589e6fd2c 2697
gallonm 12:71d589e6fd2c 2698
gallonm 12:71d589e6fd2c 2699 int VL6180X::StartMeasurement(OperatingMode operating_mode, void (*fptr)(void), MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2700 {
gallonm 12:71d589e6fd2c 2701 int status;
gallonm 12:71d589e6fd2c 2702
gallonm 12:71d589e6fd2c 2703 switch(operating_mode)
gallonm 12:71d589e6fd2c 2704 {
gallonm 12:71d589e6fd2c 2705 case(1):
gallonm 12:71d589e6fd2c 2706 return RangeMeasPollSingleShot(Data);
gallonm 12:71d589e6fd2c 2707
gallonm 12:71d589e6fd2c 2708 case(2):
gallonm 12:71d589e6fd2c 2709 return AlsMeasPollSingleShot(Data);
gallonm 12:71d589e6fd2c 2710
gallonm 12:71d589e6fd2c 2711 case(3):
gallonm 12:71d589e6fd2c 2712 return RangeMeasPollContinuousMode(Data);
gallonm 12:71d589e6fd2c 2713
gallonm 12:71d589e6fd2c 2714 case(4):
gallonm 12:71d589e6fd2c 2715 return AlsMeasPollContinuousMode(Data);
gallonm 12:71d589e6fd2c 2716
gallonm 12:71d589e6fd2c 2717 case(5):
gallonm 12:71d589e6fd2c 2718 return RangeMeasIntContinuousMode(fptr);
gallonm 12:71d589e6fd2c 2719
gallonm 12:71d589e6fd2c 2720 case(6):
gallonm 12:71d589e6fd2c 2721 return AlsMeasIntContinuousMode(fptr);
gallonm 12:71d589e6fd2c 2722
gallonm 12:71d589e6fd2c 2723 case(7): break;
gallonm 12:71d589e6fd2c 2724
gallonm 12:71d589e6fd2c 2725 case(8): break;
gallonm 12:71d589e6fd2c 2726
gallonm 12:71d589e6fd2c 2727 case(9):
gallonm 12:71d589e6fd2c 2728 return InterleavedMode(fptr);
gallonm 12:71d589e6fd2c 2729
gallonm 12:71d589e6fd2c 2730 default:
gallonm 12:71d589e6fd2c 2731 return INVALID_PARAMS;
gallonm 12:71d589e6fd2c 2732 }
gallonm 12:71d589e6fd2c 2733 }
gallonm 12:71d589e6fd2c 2734
gallonm 12:71d589e6fd2c 2735
gallonm 12:71d589e6fd2c 2736 int VL6180X::GetRangeError(MeasureData_t *Data, VL6180x_RangeData_t RangeData)
gallonm 12:71d589e6fd2c 2737 {
gallonm 12:71d589e6fd2c 2738 IntrStatus_t IntStatus;
gallonm 12:71d589e6fd2c 2739 int status;
gallonm 12:71d589e6fd2c 2740
gallonm 12:71d589e6fd2c 2741 status=VL6180x_RangeGetInterruptStatus(Device, &IntStatus.val);
gallonm 12:71d589e6fd2c 2742 if(status)
gallonm 12:71d589e6fd2c 2743 return status;
gallonm 12:71d589e6fd2c 2744 Data->range_error=RangeData.errorStatus;
gallonm 12:71d589e6fd2c 2745 Data->int_error=IntStatus.status.Error;
gallonm 12:71d589e6fd2c 2746 if((Data->int_error!=0)||(Data->range_error!=0))
gallonm 12:71d589e6fd2c 2747 {
gallonm 12:71d589e6fd2c 2748 VL6180x_ErrLog("GPIO int Error report %d",(int)IntStatus.val);
gallonm 12:71d589e6fd2c 2749 status=RANGE_ERROR;
gallonm 12:71d589e6fd2c 2750 }
gallonm 12:71d589e6fd2c 2751 return status;
gallonm 12:71d589e6fd2c 2752 }
gallonm 12:71d589e6fd2c 2753
gallonm 12:71d589e6fd2c 2754
gallonm 12:71d589e6fd2c 2755 int VL6180X::GetAlsError(MeasureData_t *Data, VL6180x_AlsData_t AlsData)
gallonm 12:71d589e6fd2c 2756 {
gallonm 12:71d589e6fd2c 2757 Data->als_error=AlsData.errorStatus;
gallonm 12:71d589e6fd2c 2758 if(Data->als_error!=0)
gallonm 12:71d589e6fd2c 2759 return API_ERROR;
gallonm 12:71d589e6fd2c 2760 return API_NO_ERROR;
gallonm 12:71d589e6fd2c 2761 }
gallonm 12:71d589e6fd2c 2762
gallonm 12:71d589e6fd2c 2763
gallonm 12:71d589e6fd2c 2764 int VL6180X::RangeMeasPollSingleShot(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2765 {
gallonm 12:71d589e6fd2c 2766 VL6180x_RangeData_t RangeData;
gallonm 12:71d589e6fd2c 2767 int status;
gallonm 12:71d589e6fd2c 2768
gallonm 12:71d589e6fd2c 2769 status=RangePollMeasurement(&RangeData);
gallonm 12:71d589e6fd2c 2770 if(!status)
gallonm 12:71d589e6fd2c 2771 {
gallonm 12:71d589e6fd2c 2772 status=GetRangeError(Data, RangeData);
gallonm 12:71d589e6fd2c 2773 if(!status)
gallonm 12:71d589e6fd2c 2774 Data->range_mm=RangeData.range_mm;
gallonm 12:71d589e6fd2c 2775 }
gallonm 12:71d589e6fd2c 2776 return status;
gallonm 12:71d589e6fd2c 2777 }
gallonm 12:71d589e6fd2c 2778
gallonm 12:71d589e6fd2c 2779
gallonm 12:71d589e6fd2c 2780 int VL6180X::AlsMeasPollSingleShot(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2781 {
gallonm 12:71d589e6fd2c 2782 VL6180x_AlsData_t AlsData;
gallonm 12:71d589e6fd2c 2783 int status;
gallonm 12:71d589e6fd2c 2784
gallonm 12:71d589e6fd2c 2785 status=AlsPollMeasurement(&AlsData);
gallonm 12:71d589e6fd2c 2786 if(!status)
gallonm 12:71d589e6fd2c 2787 {
gallonm 12:71d589e6fd2c 2788 status=GetAlsError(Data, AlsData);
gallonm 12:71d589e6fd2c 2789 if(!status)
gallonm 12:71d589e6fd2c 2790 Data->lux=AlsData.lux;
gallonm 12:71d589e6fd2c 2791 }
gallonm 12:71d589e6fd2c 2792 return status;
gallonm 12:71d589e6fd2c 2793 }
gallonm 12:71d589e6fd2c 2794
gallonm 12:71d589e6fd2c 2795
gallonm 12:71d589e6fd2c 2796 int VL6180X::RangeMeasPollContinuousMode(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2797 {
gallonm 12:71d589e6fd2c 2798 int status;
gallonm 12:71d589e6fd2c 2799
gallonm 12:71d589e6fd2c 2800 status=VL6180x_RangeClearInterrupt(Device);
gallonm 12:71d589e6fd2c 2801 if(status)
gallonm 12:71d589e6fd2c 2802 {
gallonm 12:71d589e6fd2c 2803 VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
gallonm 12:71d589e6fd2c 2804 return status;
gallonm 12:71d589e6fd2c 2805 }
gallonm 12:71d589e6fd2c 2806 status=VL6180x_ClearErrorInterrupt(Device);
gallonm 12:71d589e6fd2c 2807 if(status)
gallonm 12:71d589e6fd2c 2808 {
gallonm 12:71d589e6fd2c 2809 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
gallonm 12:71d589e6fd2c 2810 return status;
gallonm 12:71d589e6fd2c 2811 }
gallonm 12:71d589e6fd2c 2812 return RangeStartContinuousMode();
gallonm 12:71d589e6fd2c 2813 }
gallonm 12:71d589e6fd2c 2814
gallonm 12:71d589e6fd2c 2815
gallonm 12:71d589e6fd2c 2816 int VL6180X::AlsMeasPollContinuousMode(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2817 {
gallonm 12:71d589e6fd2c 2818 int status;
gallonm 12:71d589e6fd2c 2819
gallonm 12:71d589e6fd2c 2820 status=VL6180x_AlsClearInterrupt(Device);
gallonm 12:71d589e6fd2c 2821 if(status)
gallonm 12:71d589e6fd2c 2822 {
gallonm 12:71d589e6fd2c 2823 VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
gallonm 12:71d589e6fd2c 2824 return status;
gallonm 12:71d589e6fd2c 2825 }
gallonm 12:71d589e6fd2c 2826 status=VL6180x_ClearErrorInterrupt(Device);
gallonm 12:71d589e6fd2c 2827 if(status)
gallonm 12:71d589e6fd2c 2828 {
gallonm 12:71d589e6fd2c 2829 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
gallonm 12:71d589e6fd2c 2830 return status;
gallonm 12:71d589e6fd2c 2831 }
gallonm 12:71d589e6fd2c 2832 return AlsStartContinuousMode();
gallonm 12:71d589e6fd2c 2833 }
gallonm 12:71d589e6fd2c 2834
gallonm 12:71d589e6fd2c 2835
gallonm 12:71d589e6fd2c 2836 int VL6180X::GetRangeMeasContinuousMode(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2837 {
gallonm 12:71d589e6fd2c 2838 VL6180x_RangeData_t RangeData;
gallonm 12:71d589e6fd2c 2839 int status;
gallonm 12:71d589e6fd2c 2840
gallonm 12:71d589e6fd2c 2841 status=VL6180x_RangeGetMeasurement(Device, &RangeData);
gallonm 12:71d589e6fd2c 2842 if(!status)
gallonm 12:71d589e6fd2c 2843 {
gallonm 12:71d589e6fd2c 2844 status=GetRangeError(Data, RangeData);
gallonm 12:71d589e6fd2c 2845 if(!status)
gallonm 12:71d589e6fd2c 2846 Data->range_mm=RangeData.range_mm;
gallonm 12:71d589e6fd2c 2847 }
gallonm 12:71d589e6fd2c 2848 return status;
gallonm 12:71d589e6fd2c 2849 }
gallonm 12:71d589e6fd2c 2850
gallonm 12:71d589e6fd2c 2851
gallonm 12:71d589e6fd2c 2852 int VL6180X::GetAlsMeasContinuousMode(MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2853 {
gallonm 12:71d589e6fd2c 2854 VL6180x_AlsData_t AlsData;
gallonm 12:71d589e6fd2c 2855 int status;
gallonm 12:71d589e6fd2c 2856
gallonm 12:71d589e6fd2c 2857 status=VL6180x_AlsGetMeasurement(Device, &AlsData);
gallonm 12:71d589e6fd2c 2858 if(!status)
gallonm 12:71d589e6fd2c 2859 {
gallonm 12:71d589e6fd2c 2860 status=GetAlsError(Data, AlsData);
gallonm 12:71d589e6fd2c 2861 if(!status)
gallonm 12:71d589e6fd2c 2862 Data->lux=AlsData.lux;
gallonm 12:71d589e6fd2c 2863 }
gallonm 12:71d589e6fd2c 2864 return status;
gallonm 12:71d589e6fd2c 2865 }
gallonm 12:71d589e6fd2c 2866
gallonm 12:71d589e6fd2c 2867
gallonm 12:71d589e6fd2c 2868 int VL6180X::RangeMeasIntContinuousMode(void (*fptr)(void))
gallonm 12:71d589e6fd2c 2869 {
gallonm 12:71d589e6fd2c 2870 int status;
gallonm 12:71d589e6fd2c 2871
gallonm 12:71d589e6fd2c 2872 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 2873 AttachInterruptMeasureDetectionIRQ(fptr);
gallonm 12:71d589e6fd2c 2874 status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
gallonm 12:71d589e6fd2c 2875 /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
gallonm 12:71d589e6fd2c 2876 if(ClrStatus)
gallonm 12:71d589e6fd2c 2877 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
gallonm 12:71d589e6fd2c 2878 if(!status)
gallonm 12:71d589e6fd2c 2879 return RangeStartContinuousMode();
gallonm 12:71d589e6fd2c 2880 }
gallonm 12:71d589e6fd2c 2881
gallonm 12:71d589e6fd2c 2882
gallonm 12:71d589e6fd2c 2883 int VL6180X::AlsMeasIntContinuousMode(void (*fptr)(void))
gallonm 12:71d589e6fd2c 2884 {
gallonm 12:71d589e6fd2c 2885 int status;
gallonm 12:71d589e6fd2c 2886
gallonm 12:71d589e6fd2c 2887 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 2888 AttachInterruptMeasureDetectionIRQ(fptr);
gallonm 12:71d589e6fd2c 2889 status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
gallonm 12:71d589e6fd2c 2890 /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
gallonm 12:71d589e6fd2c 2891 if(ClrStatus)
gallonm 12:71d589e6fd2c 2892 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
gallonm 12:71d589e6fd2c 2893 if(!status)
gallonm 12:71d589e6fd2c 2894 return AlsStartContinuousMode();
gallonm 12:71d589e6fd2c 2895 }
gallonm 12:71d589e6fd2c 2896
gallonm 12:71d589e6fd2c 2897
gallonm 12:71d589e6fd2c 2898 int VL6180X::StartInterleavedMode()
gallonm 12:71d589e6fd2c 2899 {
gallonm 12:71d589e6fd2c 2900 int status;
gallonm 12:71d589e6fd2c 2901 uint16_t integration_period, intermeasurement_period_ms;
gallonm 12:71d589e6fd2c 2902 uint8_t max_convergence_time;
gallonm 12:71d589e6fd2c 2903
gallonm 12:71d589e6fd2c 2904 status=VL6180x_WrByte(Device, 0x2A3, 1);
gallonm 12:71d589e6fd2c 2905 if(status)
gallonm 12:71d589e6fd2c 2906 {
gallonm 12:71d589e6fd2c 2907 VL6180x_ErrLog("Failed to read INTERLEAVED_MODE_ENABLE!\n\r");
gallonm 12:71d589e6fd2c 2908 return status;
gallonm 12:71d589e6fd2c 2909 }
gallonm 12:71d589e6fd2c 2910 status=VL6180x_RdByte(Device, SYSRANGE_MAX_CONVERGENCE_TIME, &max_convergence_time);
gallonm 12:71d589e6fd2c 2911 if(status)
gallonm 12:71d589e6fd2c 2912 {
gallonm 12:71d589e6fd2c 2913 VL6180x_ErrLog("Failed to read SYSRANGE_MAX_CONVERGENCE_TIME!\n\r");
gallonm 12:71d589e6fd2c 2914 return status;
gallonm 12:71d589e6fd2c 2915 }
gallonm 12:71d589e6fd2c 2916 status=VL6180x_RdWord(Device, SYSALS_INTEGRATION_PERIOD, &integration_period);
gallonm 12:71d589e6fd2c 2917 if(status)
gallonm 12:71d589e6fd2c 2918 {
gallonm 12:71d589e6fd2c 2919 VL6180x_ErrLog("Failed to read SYSALS_INTEGRATION_PERIOD!\n\r");
gallonm 12:71d589e6fd2c 2920 return status;
gallonm 12:71d589e6fd2c 2921 }
gallonm 12:71d589e6fd2c 2922 max_convergence_time&=0x3F;
gallonm 12:71d589e6fd2c 2923 integration_period&=0x01FF;
gallonm 12:71d589e6fd2c 2924 intermeasurement_period_ms=((max_convergence_time+5)+(integration_period*1.1));
gallonm 12:71d589e6fd2c 2925 intermeasurement_period_ms=(intermeasurement_period_ms/0.9)+10;
gallonm 12:71d589e6fd2c 2926 status=VL6180x_AlsSetInterMeasurementPeriod(Device, intermeasurement_period_ms);
gallonm 12:71d589e6fd2c 2927 if(status)
gallonm 12:71d589e6fd2c 2928 {
gallonm 12:71d589e6fd2c 2929 VL6180x_ErrLog("Failed to write SYSALS_INTERMEASUREMENT_PERIOD!\n\r");
gallonm 12:71d589e6fd2c 2930 return status;
gallonm 12:71d589e6fd2c 2931 }
gallonm 12:71d589e6fd2c 2932 return AlsStartContinuousMode();
gallonm 12:71d589e6fd2c 2933 }
gallonm 12:71d589e6fd2c 2934
gallonm 12:71d589e6fd2c 2935
gallonm 12:71d589e6fd2c 2936 int VL6180X::InterleavedMode(void (*fptr)(void))
gallonm 12:71d589e6fd2c 2937 {
gallonm 12:71d589e6fd2c 2938 int status;
gallonm 12:71d589e6fd2c 2939
gallonm 12:71d589e6fd2c 2940 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 2941 AttachInterruptMeasureDetectionIRQ(fptr);
gallonm 12:71d589e6fd2c 2942 status=SetupGPIO1(GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT, 1);
gallonm 12:71d589e6fd2c 2943 /*ClrStatus=VL6180x_ClearAllInterrupt(Device);
gallonm 12:71d589e6fd2c 2944 if(ClrStatus)
gallonm 12:71d589e6fd2c 2945 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");*/
gallonm 12:71d589e6fd2c 2946 if(!status)
gallonm 12:71d589e6fd2c 2947 return StartInterleavedMode();
gallonm 12:71d589e6fd2c 2948 }
gallonm 12:71d589e6fd2c 2949
gallonm 12:71d589e6fd2c 2950
gallonm 12:71d589e6fd2c 2951 void VL6180X::HandleIRQ(MeasureType measure_type, MeasureData_t *Data)
gallonm 12:71d589e6fd2c 2952 {
gallonm 12:71d589e6fd2c 2953 int status, ClrStatus;
gallonm 12:71d589e6fd2c 2954 /* range measure */
gallonm 12:71d589e6fd2c 2955 if(measure_type==1)
gallonm 12:71d589e6fd2c 2956 {
gallonm 12:71d589e6fd2c 2957 VL6180x_RangeData_t RangeData;
gallonm 12:71d589e6fd2c 2958 status=RangeGetMeasurement(&RangeData);
gallonm 12:71d589e6fd2c 2959 if(status)
gallonm 12:71d589e6fd2c 2960 VL6180x_ErrLog("Failed to get range measurement");
gallonm 12:71d589e6fd2c 2961 ClrStatus=VL6180x_RangeClearInterrupt(Device);
gallonm 12:71d589e6fd2c 2962 if(ClrStatus)
gallonm 12:71d589e6fd2c 2963 VL6180x_ErrLog("VL6180x_RangeClearInterrupt fail");
gallonm 12:71d589e6fd2c 2964 ClrStatus=VL6180x_ClearErrorInterrupt(Device);
gallonm 12:71d589e6fd2c 2965 if(ClrStatus)
gallonm 12:71d589e6fd2c 2966 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
gallonm 12:71d589e6fd2c 2967 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 2968 status=GetRangeError(Data, RangeData);
gallonm 12:71d589e6fd2c 2969 if(!status)
gallonm 12:71d589e6fd2c 2970 Data->range_mm=RangeData.range_mm;
gallonm 12:71d589e6fd2c 2971 }
gallonm 12:71d589e6fd2c 2972 /* light measure */
gallonm 12:71d589e6fd2c 2973 else if(measure_type==2)
gallonm 12:71d589e6fd2c 2974 {
gallonm 12:71d589e6fd2c 2975 VL6180x_AlsData_t AlsData;
gallonm 12:71d589e6fd2c 2976 status=AlsGetMeasurement(&AlsData);
gallonm 12:71d589e6fd2c 2977 if(status)
gallonm 12:71d589e6fd2c 2978 VL6180x_ErrLog("Failed to get light measurement");
gallonm 12:71d589e6fd2c 2979 ClrStatus=VL6180x_AlsClearInterrupt(Device);
gallonm 12:71d589e6fd2c 2980 if(ClrStatus)
gallonm 12:71d589e6fd2c 2981 VL6180x_ErrLog("VL6180x_AlsClearInterrupt fail");
gallonm 12:71d589e6fd2c 2982 ClrStatus=VL6180x_ClearErrorInterrupt(Device);
gallonm 12:71d589e6fd2c 2983 if(ClrStatus)
gallonm 12:71d589e6fd2c 2984 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
gallonm 12:71d589e6fd2c 2985 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 2986 status=GetAlsError(Data, AlsData);
gallonm 12:71d589e6fd2c 2987 if(!status)
gallonm 12:71d589e6fd2c 2988 Data->lux=AlsData.lux;
gallonm 12:71d589e6fd2c 2989 }
gallonm 12:71d589e6fd2c 2990 /* light and range measure */
gallonm 12:71d589e6fd2c 2991 else if(measure_type==3)
gallonm 12:71d589e6fd2c 2992 {
gallonm 12:71d589e6fd2c 2993 VL6180x_RangeData_t RangeData;
gallonm 12:71d589e6fd2c 2994 VL6180x_AlsData_t AlsData;
gallonm 12:71d589e6fd2c 2995 status=RangeGetMeasurement(&RangeData);
gallonm 12:71d589e6fd2c 2996 if(status)
gallonm 12:71d589e6fd2c 2997 VL6180x_ErrLog("Failed to get range measurement");
gallonm 12:71d589e6fd2c 2998 status=AlsGetMeasurement(&AlsData);
gallonm 12:71d589e6fd2c 2999 if(status)
gallonm 12:71d589e6fd2c 3000 VL6180x_ErrLog("Failed to get light measurement");
gallonm 12:71d589e6fd2c 3001 ClrStatus=VL6180x_ClearAllInterrupt(Device);
gallonm 12:71d589e6fd2c 3002 if(ClrStatus)
gallonm 12:71d589e6fd2c 3003 VL6180x_ErrLog("VL6180x_ClearErrorInterrupt fail");
gallonm 12:71d589e6fd2c 3004 EnableInterruptMeasureDetectionIRQ();
gallonm 12:71d589e6fd2c 3005 status=GetAlsError(Data, AlsData);
gallonm 12:71d589e6fd2c 3006 if(!status)
gallonm 12:71d589e6fd2c 3007 Data->lux=AlsData.lux;
gallonm 12:71d589e6fd2c 3008 status=GetRangeError(Data, RangeData);
gallonm 12:71d589e6fd2c 3009 if(!status)
gallonm 12:71d589e6fd2c 3010 Data->range_mm=RangeData.range_mm;
gallonm 12:71d589e6fd2c 3011 }
gallonm 12:71d589e6fd2c 3012 else
gallonm 12:71d589e6fd2c 3013 printf("Error! Invalid parameter!");
gallonm 12:71d589e6fd2c 3014 }
gallonm 12:71d589e6fd2c 3015
gallonm 12:71d589e6fd2c 3016
gallonm 12:71d589e6fd2c 3017
gallonm 12:71d589e6fd2c 3018
gallonm 1:1de1ea2994d9 3019 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/