ST / X_NUCLEO_6180XA1

Dependencies:   X_NUCLEO_COMMON ST_INTERFACES

Dependents:   HelloWorld_6180XA1 SunTracker_BLE Servo_6180XA1 BLE_HR_Light ... more

Fork of X_NUCLEO_6180XA1 by ST Expansion SW Team

X-NUCLEO-6180XA1 Proximity and Ambient Light Sensor Expansion Board Firmware Package

Introduction

This firmware package includes Components Device Drivers and Board Support Package for STMicroelectronics' X-NUCLEO-6180XA1 Proximity and ambient light sensor expansion board based on VL6180X.

Firmware Library

Class X_NUCLEO_6180XA1 is intended to represent the Proximity and ambient light sensor expansion board with the same name.

The expansion board is providing the support of the following components:

  1. on-board VL6180X proximity and ambient light sensor,
  2. up to three additional VL6180X Satellites,
  3. on-board 4-digit display

It is intentionally implemented as a singleton because only one X-NUCLEO-VL6180XA1 at a time might be deployed in a HW component stack. In order to get the singleton instance you have to call class method `Instance()`, e.g.:

// Sensors expansion board singleton instance
static X_NUCLEO_6180XA1 *6180X_expansion_board = X_NUCLEO_6180XA1::Instance();

Arduino Connector Compatibility Warning

Using the X-NUCLEO-6180XA1 expansion board with the NUCLEO-F429ZI requires adopting the following patch:

  • to remove R46 resistor connected to A3 pin;
  • to solder R47 resistor connected to A5 pin.

Alternatively, you can route the Nucleo board’s A5 pin directly to the expansion board’s A3 pin with a wire. In case you patch your expansion board or route the pin, the interrupt signal for the front sensor will be driven on A5 pin rather than on A3 pin.


Example Applications

Committer:
Davidroid
Date:
Fri Mar 03 15:06:18 2017 +0000
Revision:
55:a37f407230ca
Parent:
54:17f3bb228b13
Some modifications to fit mbed coding style.

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