Mike Fiore / X_NUCLEO_53L0A1

modified to work with MultiTech mDot on UDK2.0

Dependents:   HelloWorld_53L0A1 unh-hackathon-example unh-hackathon-example-raw

Fork of X_NUCLEO_53L0A1 by ST

Components/VL53L0X/vl53l0x_class.h@7:35ecf3e060c3, 2016-12-05 (annotated)

Committer:
johnAlexander
Date:
Mon Dec 05 11:50:38 2016 +0000
Revision:
7:35ecf3e060c3
Parent:
6:fa6944a8850f
Parent:
4:4e1576541eed
Child:
8:8d27ebb4e1eb
Replace STM32 HAL_delay call with equivalent mbed wait_ms, for cross processor compatibility.; Import mbed.h in VL53L0X class to ease finding InterruptIn.; Minor code tidy up.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
johnAlexander 0:c523920bcc09 1 /*******************************************************************************
johnAlexander 2:58b5e9097aa3 2 Copyright © 2016, STMicroelectronics International N.V.
johnAlexander 0:c523920bcc09 3 All rights reserved.
johnAlexander 0:c523920bcc09 4
johnAlexander 0:c523920bcc09 5 Redistribution and use in source and binary forms, with or without
johnAlexander 0:c523920bcc09 6 modification, are permitted provided that the following conditions are met:
johnAlexander 0:c523920bcc09 7 * Redistributions of source code must retain the above copyright
johnAlexander 0:c523920bcc09 8 notice, this list of conditions and the following disclaimer.
johnAlexander 0:c523920bcc09 9 * Redistributions in binary form must reproduce the above copyright
johnAlexander 0:c523920bcc09 10 notice, this list of conditions and the following disclaimer in the
johnAlexander 0:c523920bcc09 11 documentation and/or other materials provided with the distribution.
johnAlexander 0:c523920bcc09 12 * Neither the name of STMicroelectronics nor the
johnAlexander 0:c523920bcc09 13 names of its contributors may be used to endorse or promote products
johnAlexander 0:c523920bcc09 14 derived from this software without specific prior written permission.
johnAlexander 0:c523920bcc09 15
johnAlexander 0:c523920bcc09 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
johnAlexander 0:c523920bcc09 17 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
johnAlexander 0:c523920bcc09 18 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
johnAlexander 0:c523920bcc09 19 NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
johnAlexander 0:c523920bcc09 20 IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
johnAlexander 0:c523920bcc09 21 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
johnAlexander 0:c523920bcc09 22 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
johnAlexander 0:c523920bcc09 23 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
johnAlexander 0:c523920bcc09 24 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
johnAlexander 0:c523920bcc09 25 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
johnAlexander 0:c523920bcc09 26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
johnAlexander 0:c523920bcc09 27 *****************************************************************************/
johnAlexander 0:c523920bcc09 28
johnAlexander 0:c523920bcc09 29 #ifndef __VL53L0X_CLASS_H
johnAlexander 0:c523920bcc09 30 #define __VL53L0X_CLASS_H
johnAlexander 0:c523920bcc09 31
johnAlexander 0:c523920bcc09 32
johnAlexander 0:c523920bcc09 33 #ifdef _MSC_VER
johnAlexander 0:c523920bcc09 34 # ifdef VL53L0X_API_EXPORTS
johnAlexander 0:c523920bcc09 35 # define VL53L0X_API __declspec(dllexport)
johnAlexander 0:c523920bcc09 36 # else
johnAlexander 0:c523920bcc09 37 # define VL53L0X_API
johnAlexander 0:c523920bcc09 38 # endif
johnAlexander 0:c523920bcc09 39 #else
johnAlexander 0:c523920bcc09 40 # define VL53L0X_API
johnAlexander 0:c523920bcc09 41 #endif
johnAlexander 0:c523920bcc09 42
johnAlexander 0:c523920bcc09 43
johnAlexander 0:c523920bcc09 44 /* Includes ------------------------------------------------------------------*/
johnAlexander 4:4e1576541eed 45 #include "mbed.h"
johnAlexander 0:c523920bcc09 46 #include "RangeSensor.h"
johnAlexander 0:c523920bcc09 47 #include "DevI2C.h"
johnAlexander 0:c523920bcc09 48
johnAlexander 0:c523920bcc09 49 #include "vl53l0x_def.h"
johnAlexander 0:c523920bcc09 50 #include "vl53l0x_platform.h"
johnAlexander 0:c523920bcc09 51 #include "stmpe1600_class.h"
johnAlexander 0:c523920bcc09 52
johnAlexander 0:c523920bcc09 53
johnAlexander 0:c523920bcc09 54 /**
johnAlexander 0:c523920bcc09 55 * The device model ID
johnAlexander 0:c523920bcc09 56 */
johnAlexander 0:c523920bcc09 57 #define IDENTIFICATION_MODEL_ID 0x000
johnAlexander 0:c523920bcc09 58
johnAlexander 0:c523920bcc09 59
johnAlexander 0:c523920bcc09 60 #define STATUS_OK 0x00
johnAlexander 0:c523920bcc09 61 #define STATUS_FAIL 0x01
johnAlexander 0:c523920bcc09 62
johnAlexander 0:c523920bcc09 63
johnAlexander 6:fa6944a8850f 64 #define VL53L0X_OsDelay(...) wait_ms(2) // 2 msec delay. can also use wait(float secs)/wait_us(int)
johnAlexander 0:c523920bcc09 65
johnAlexander 0:c523920bcc09 66 #ifdef USE_EMPTY_STRING
johnAlexander 0:c523920bcc09 67 #define VL53L0X_STRING_DEVICE_INFO_NAME ""
johnAlexander 0:c523920bcc09 68 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS0 ""
johnAlexander 0:c523920bcc09 69 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS1 ""
johnAlexander 0:c523920bcc09 70 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS2 ""
johnAlexander 0:c523920bcc09 71 #define VL53L0X_STRING_DEVICE_INFO_NAME_ES1 ""
johnAlexander 0:c523920bcc09 72 #define VL53L0X_STRING_DEVICE_INFO_TYPE ""
johnAlexander 0:c523920bcc09 73
johnAlexander 0:c523920bcc09 74 /* PAL ERROR strings */
johnAlexander 0:c523920bcc09 75 #define VL53L0X_STRING_ERROR_NONE ""
johnAlexander 0:c523920bcc09 76 #define VL53L0X_STRING_ERROR_CALIBRATION_WARNING ""
johnAlexander 0:c523920bcc09 77 #define VL53L0X_STRING_ERROR_MIN_CLIPPED ""
johnAlexander 0:c523920bcc09 78 #define VL53L0X_STRING_ERROR_UNDEFINED ""
johnAlexander 0:c523920bcc09 79 #define VL53L0X_STRING_ERROR_INVALID_PARAMS ""
johnAlexander 0:c523920bcc09 80 #define VL53L0X_STRING_ERROR_NOT_SUPPORTED ""
johnAlexander 0:c523920bcc09 81 #define VL53L0X_STRING_ERROR_RANGE_ERROR ""
johnAlexander 0:c523920bcc09 82 #define VL53L0X_STRING_ERROR_TIME_OUT ""
johnAlexander 0:c523920bcc09 83 #define VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED ""
johnAlexander 0:c523920bcc09 84 #define VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL ""
johnAlexander 0:c523920bcc09 85 #define VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING ""
johnAlexander 0:c523920bcc09 86 #define VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED ""
johnAlexander 0:c523920bcc09 87 #define VL53L0X_STRING_ERROR_CONTROL_INTERFACE ""
johnAlexander 0:c523920bcc09 88 #define VL53L0X_STRING_ERROR_INVALID_COMMAND ""
johnAlexander 0:c523920bcc09 89 #define VL53L0X_STRING_ERROR_DIVISION_BY_ZERO ""
johnAlexander 0:c523920bcc09 90 #define VL53L0X_STRING_ERROR_REF_SPAD_INIT ""
johnAlexander 0:c523920bcc09 91 #define VL53L0X_STRING_ERROR_NOT_IMPLEMENTED ""
johnAlexander 0:c523920bcc09 92
johnAlexander 0:c523920bcc09 93 #define VL53L0X_STRING_UNKNOW_ERROR_CODE ""
johnAlexander 0:c523920bcc09 94
johnAlexander 0:c523920bcc09 95
johnAlexander 0:c523920bcc09 96
johnAlexander 0:c523920bcc09 97 /* Range Status */
johnAlexander 0:c523920bcc09 98 #define VL53L0X_STRING_RANGESTATUS_NONE ""
johnAlexander 0:c523920bcc09 99 #define VL53L0X_STRING_RANGESTATUS_RANGEVALID ""
johnAlexander 0:c523920bcc09 100 #define VL53L0X_STRING_RANGESTATUS_SIGMA ""
johnAlexander 0:c523920bcc09 101 #define VL53L0X_STRING_RANGESTATUS_SIGNAL ""
johnAlexander 0:c523920bcc09 102 #define VL53L0X_STRING_RANGESTATUS_MINRANGE ""
johnAlexander 0:c523920bcc09 103 #define VL53L0X_STRING_RANGESTATUS_PHASE ""
johnAlexander 0:c523920bcc09 104 #define VL53L0X_STRING_RANGESTATUS_HW ""
johnAlexander 0:c523920bcc09 105
johnAlexander 0:c523920bcc09 106
johnAlexander 0:c523920bcc09 107 /* Range Status */
johnAlexander 0:c523920bcc09 108 #define VL53L0X_STRING_STATE_POWERDOWN ""
johnAlexander 0:c523920bcc09 109 #define VL53L0X_STRING_STATE_WAIT_STATICINIT ""
johnAlexander 0:c523920bcc09 110 #define VL53L0X_STRING_STATE_STANDBY ""
johnAlexander 0:c523920bcc09 111 #define VL53L0X_STRING_STATE_IDLE ""
johnAlexander 0:c523920bcc09 112 #define VL53L0X_STRING_STATE_RUNNING ""
johnAlexander 0:c523920bcc09 113 #define VL53L0X_STRING_STATE_UNKNOWN ""
johnAlexander 0:c523920bcc09 114 #define VL53L0X_STRING_STATE_ERROR ""
johnAlexander 0:c523920bcc09 115
johnAlexander 0:c523920bcc09 116
johnAlexander 0:c523920bcc09 117 /* Device Specific */
johnAlexander 0:c523920bcc09 118 #define VL53L0X_STRING_DEVICEERROR_NONE ""
johnAlexander 0:c523920bcc09 119 #define VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE ""
johnAlexander 0:c523920bcc09 120 #define VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE ""
johnAlexander 0:c523920bcc09 121 #define VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND ""
johnAlexander 0:c523920bcc09 122 #define VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET ""
johnAlexander 0:c523920bcc09 123 #define VL53L0X_STRING_DEVICEERROR_SNRCHECK ""
johnAlexander 0:c523920bcc09 124 #define VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK ""
johnAlexander 0:c523920bcc09 125 #define VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK ""
johnAlexander 0:c523920bcc09 126 #define VL53L0X_STRING_DEVICEERROR_TCC ""
johnAlexander 0:c523920bcc09 127 #define VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY ""
johnAlexander 0:c523920bcc09 128 #define VL53L0X_STRING_DEVICEERROR_MINCLIP ""
johnAlexander 0:c523920bcc09 129 #define VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE ""
johnAlexander 0:c523920bcc09 130 #define VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW ""
johnAlexander 0:c523920bcc09 131 #define VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW ""
johnAlexander 0:c523920bcc09 132 #define VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD ""
johnAlexander 0:c523920bcc09 133 #define VL53L0X_STRING_DEVICEERROR_UNKNOWN ""
johnAlexander 0:c523920bcc09 134
johnAlexander 0:c523920bcc09 135 /* Check Enable */
johnAlexander 0:c523920bcc09 136 #define VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE ""
johnAlexander 0:c523920bcc09 137 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE ""
johnAlexander 0:c523920bcc09 138 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP ""
johnAlexander 0:c523920bcc09 139 #define VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD ""
johnAlexander 0:c523920bcc09 140
johnAlexander 0:c523920bcc09 141 /* Sequence Step */
johnAlexander 0:c523920bcc09 142 #define VL53L0X_STRING_SEQUENCESTEP_TCC ""
johnAlexander 0:c523920bcc09 143 #define VL53L0X_STRING_SEQUENCESTEP_DSS ""
johnAlexander 0:c523920bcc09 144 #define VL53L0X_STRING_SEQUENCESTEP_MSRC ""
johnAlexander 0:c523920bcc09 145 #define VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE ""
johnAlexander 0:c523920bcc09 146 #define VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE ""
johnAlexander 0:c523920bcc09 147 #else
johnAlexander 0:c523920bcc09 148 #define VL53L0X_STRING_DEVICE_INFO_NAME "VL53L0X cut1.0"
johnAlexander 0:c523920bcc09 149 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS0 "VL53L0X TS0"
johnAlexander 0:c523920bcc09 150 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS1 "VL53L0X TS1"
johnAlexander 0:c523920bcc09 151 #define VL53L0X_STRING_DEVICE_INFO_NAME_TS2 "VL53L0X TS2"
johnAlexander 0:c523920bcc09 152 #define VL53L0X_STRING_DEVICE_INFO_NAME_ES1 "VL53L0X ES1 or later"
johnAlexander 0:c523920bcc09 153 #define VL53L0X_STRING_DEVICE_INFO_TYPE "VL53L0X"
johnAlexander 0:c523920bcc09 154
johnAlexander 0:c523920bcc09 155 /* PAL ERROR strings */
johnAlexander 0:c523920bcc09 156 #define VL53L0X_STRING_ERROR_NONE \
johnAlexander 0:c523920bcc09 157 "No Error"
johnAlexander 0:c523920bcc09 158 #define VL53L0X_STRING_ERROR_CALIBRATION_WARNING \
johnAlexander 0:c523920bcc09 159 "Calibration Warning Error"
johnAlexander 0:c523920bcc09 160 #define VL53L0X_STRING_ERROR_MIN_CLIPPED \
johnAlexander 0:c523920bcc09 161 "Min clipped error"
johnAlexander 0:c523920bcc09 162 #define VL53L0X_STRING_ERROR_UNDEFINED \
johnAlexander 0:c523920bcc09 163 "Undefined error"
johnAlexander 0:c523920bcc09 164 #define VL53L0X_STRING_ERROR_INVALID_PARAMS \
johnAlexander 0:c523920bcc09 165 "Invalid parameters error"
johnAlexander 0:c523920bcc09 166 #define VL53L0X_STRING_ERROR_NOT_SUPPORTED \
johnAlexander 0:c523920bcc09 167 "Not supported error"
johnAlexander 0:c523920bcc09 168 #define VL53L0X_STRING_ERROR_RANGE_ERROR \
johnAlexander 0:c523920bcc09 169 "Range error"
johnAlexander 0:c523920bcc09 170 #define VL53L0X_STRING_ERROR_TIME_OUT \
johnAlexander 0:c523920bcc09 171 "Time out error"
johnAlexander 0:c523920bcc09 172 #define VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED \
johnAlexander 0:c523920bcc09 173 "Mode not supported error"
johnAlexander 0:c523920bcc09 174 #define VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL \
johnAlexander 0:c523920bcc09 175 "Buffer too small"
johnAlexander 0:c523920bcc09 176 #define VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING \
johnAlexander 0:c523920bcc09 177 "GPIO not existing"
johnAlexander 0:c523920bcc09 178 #define VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED \
johnAlexander 0:c523920bcc09 179 "GPIO funct not supported"
johnAlexander 0:c523920bcc09 180 #define VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED \
johnAlexander 0:c523920bcc09 181 "Interrupt not Cleared"
johnAlexander 0:c523920bcc09 182 #define VL53L0X_STRING_ERROR_CONTROL_INTERFACE \
johnAlexander 0:c523920bcc09 183 "Control Interface Error"
johnAlexander 0:c523920bcc09 184 #define VL53L0X_STRING_ERROR_INVALID_COMMAND \
johnAlexander 0:c523920bcc09 185 "Invalid Command Error"
johnAlexander 0:c523920bcc09 186 #define VL53L0X_STRING_ERROR_DIVISION_BY_ZERO \
johnAlexander 0:c523920bcc09 187 "Division by zero Error"
johnAlexander 0:c523920bcc09 188 #define VL53L0X_STRING_ERROR_REF_SPAD_INIT \
johnAlexander 0:c523920bcc09 189 "Reference Spad Init Error"
johnAlexander 0:c523920bcc09 190 #define VL53L0X_STRING_ERROR_NOT_IMPLEMENTED \
johnAlexander 0:c523920bcc09 191 "Not implemented error"
johnAlexander 0:c523920bcc09 192
johnAlexander 0:c523920bcc09 193 #define VL53L0X_STRING_UNKNOW_ERROR_CODE \
johnAlexander 0:c523920bcc09 194 "Unknown Error Code"
johnAlexander 0:c523920bcc09 195
johnAlexander 0:c523920bcc09 196
johnAlexander 0:c523920bcc09 197
johnAlexander 0:c523920bcc09 198 /* Range Status */
johnAlexander 0:c523920bcc09 199 #define VL53L0X_STRING_RANGESTATUS_NONE "No Update"
johnAlexander 0:c523920bcc09 200 #define VL53L0X_STRING_RANGESTATUS_RANGEVALID "Range Valid"
johnAlexander 0:c523920bcc09 201 #define VL53L0X_STRING_RANGESTATUS_SIGMA "Sigma Fail"
johnAlexander 0:c523920bcc09 202 #define VL53L0X_STRING_RANGESTATUS_SIGNAL "Signal Fail"
johnAlexander 0:c523920bcc09 203 #define VL53L0X_STRING_RANGESTATUS_MINRANGE "Min Range Fail"
johnAlexander 0:c523920bcc09 204 #define VL53L0X_STRING_RANGESTATUS_PHASE "Phase Fail"
johnAlexander 0:c523920bcc09 205 #define VL53L0X_STRING_RANGESTATUS_HW "Hardware Fail"
johnAlexander 0:c523920bcc09 206
johnAlexander 0:c523920bcc09 207
johnAlexander 0:c523920bcc09 208 /* Range Status */
johnAlexander 0:c523920bcc09 209 #define VL53L0X_STRING_STATE_POWERDOWN "POWERDOWN State"
johnAlexander 0:c523920bcc09 210 #define VL53L0X_STRING_STATE_WAIT_STATICINIT \
johnAlexander 0:c523920bcc09 211 "Wait for staticinit State"
johnAlexander 0:c523920bcc09 212 #define VL53L0X_STRING_STATE_STANDBY "STANDBY State"
johnAlexander 0:c523920bcc09 213 #define VL53L0X_STRING_STATE_IDLE "IDLE State"
johnAlexander 0:c523920bcc09 214 #define VL53L0X_STRING_STATE_RUNNING "RUNNING State"
johnAlexander 0:c523920bcc09 215 #define VL53L0X_STRING_STATE_UNKNOWN "UNKNOWN State"
johnAlexander 0:c523920bcc09 216 #define VL53L0X_STRING_STATE_ERROR "ERROR State"
johnAlexander 0:c523920bcc09 217
johnAlexander 0:c523920bcc09 218
johnAlexander 0:c523920bcc09 219 /* Device Specific */
johnAlexander 0:c523920bcc09 220 #define VL53L0X_STRING_DEVICEERROR_NONE "No Update"
johnAlexander 0:c523920bcc09 221 #define VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE \
johnAlexander 0:c523920bcc09 222 "VCSEL Continuity Test Failure"
johnAlexander 0:c523920bcc09 223 #define VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE \
johnAlexander 0:c523920bcc09 224 "VCSEL Watchdog Test Failure"
johnAlexander 0:c523920bcc09 225 #define VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND \
johnAlexander 0:c523920bcc09 226 "No VHV Value found"
johnAlexander 0:c523920bcc09 227 #define VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET \
johnAlexander 0:c523920bcc09 228 "MSRC No Target Error"
johnAlexander 0:c523920bcc09 229 #define VL53L0X_STRING_DEVICEERROR_SNRCHECK \
johnAlexander 0:c523920bcc09 230 "SNR Check Exit"
johnAlexander 0:c523920bcc09 231 #define VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK \
johnAlexander 0:c523920bcc09 232 "Range Phase Check Error"
johnAlexander 0:c523920bcc09 233 #define VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK \
johnAlexander 0:c523920bcc09 234 "Sigma Threshold Check Error"
johnAlexander 0:c523920bcc09 235 #define VL53L0X_STRING_DEVICEERROR_TCC \
johnAlexander 0:c523920bcc09 236 "TCC Error"
johnAlexander 0:c523920bcc09 237 #define VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY \
johnAlexander 0:c523920bcc09 238 "Phase Consistency Error"
johnAlexander 0:c523920bcc09 239 #define VL53L0X_STRING_DEVICEERROR_MINCLIP \
johnAlexander 0:c523920bcc09 240 "Min Clip Error"
johnAlexander 0:c523920bcc09 241 #define VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE \
johnAlexander 0:c523920bcc09 242 "Range Complete"
johnAlexander 0:c523920bcc09 243 #define VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW \
johnAlexander 0:c523920bcc09 244 "Range Algo Underflow Error"
johnAlexander 0:c523920bcc09 245 #define VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW \
johnAlexander 0:c523920bcc09 246 "Range Algo Overlow Error"
johnAlexander 0:c523920bcc09 247 #define VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD \
johnAlexander 0:c523920bcc09 248 "Range Ignore Threshold Error"
johnAlexander 0:c523920bcc09 249 #define VL53L0X_STRING_DEVICEERROR_UNKNOWN \
johnAlexander 0:c523920bcc09 250 "Unknown error code"
johnAlexander 0:c523920bcc09 251
johnAlexander 0:c523920bcc09 252 /* Check Enable */
johnAlexander 0:c523920bcc09 253 #define VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE \
johnAlexander 0:c523920bcc09 254 "SIGMA FINAL RANGE"
johnAlexander 0:c523920bcc09 255 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE \
johnAlexander 0:c523920bcc09 256 "SIGNAL RATE FINAL RANGE"
johnAlexander 0:c523920bcc09 257 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP \
johnAlexander 0:c523920bcc09 258 "SIGNAL REF CLIP"
johnAlexander 0:c523920bcc09 259 #define VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD \
johnAlexander 0:c523920bcc09 260 "RANGE IGNORE THRESHOLD"
johnAlexander 0:c523920bcc09 261 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC \
johnAlexander 0:c523920bcc09 262 "SIGNAL RATE MSRC"
johnAlexander 0:c523920bcc09 263 #define VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE \
johnAlexander 0:c523920bcc09 264 "SIGNAL RATE PRE RANGE"
johnAlexander 0:c523920bcc09 265
johnAlexander 0:c523920bcc09 266 /* Sequence Step */
johnAlexander 0:c523920bcc09 267 #define VL53L0X_STRING_SEQUENCESTEP_TCC "TCC"
johnAlexander 0:c523920bcc09 268 #define VL53L0X_STRING_SEQUENCESTEP_DSS "DSS"
johnAlexander 0:c523920bcc09 269 #define VL53L0X_STRING_SEQUENCESTEP_MSRC "MSRC"
johnAlexander 0:c523920bcc09 270 #define VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE "PRE RANGE"
johnAlexander 0:c523920bcc09 271 #define VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE "FINAL RANGE"
johnAlexander 0:c523920bcc09 272 #endif /* USE_EMPTY_STRING */
johnAlexander 0:c523920bcc09 273
johnAlexander 0:c523920bcc09 274
johnAlexander 0:c523920bcc09 275
johnAlexander 0:c523920bcc09 276
johnAlexander 0:c523920bcc09 277
johnAlexander 0:c523920bcc09 278 /* sensor operating modes */
johnAlexander 0:c523920bcc09 279 typedef enum
johnAlexander 0:c523920bcc09 280 {
johnAlexander 0:c523920bcc09 281 range_single_shot_polling=1,
johnAlexander 0:c523920bcc09 282 range_continuous_polling,
johnAlexander 0:c523920bcc09 283 range_continuous_interrupt,
johnAlexander 0:c523920bcc09 284 range_continuous_polling_low_threshold,
johnAlexander 0:c523920bcc09 285 range_continuous_polling_high_threshold,
johnAlexander 0:c523920bcc09 286 range_continuous_polling_out_of_window,
johnAlexander 0:c523920bcc09 287 range_continuous_interrupt_low_threshold,
johnAlexander 0:c523920bcc09 288 range_continuous_interrupt_high_threshold,
johnAlexander 0:c523920bcc09 289 range_continuous_interrupt_out_of_window,
johnAlexander 0:c523920bcc09 290 }OperatingMode;
johnAlexander 0:c523920bcc09 291
johnAlexander 0:c523920bcc09 292 /** default device address */
johnAlexander 0:c523920bcc09 293 #define DEFAULT_DEVICE_ADDRESS 0x52 /* (8-bit) */
johnAlexander 0:c523920bcc09 294
johnAlexander 0:c523920bcc09 295 /* Classes -------------------------------------------------------------------*/
johnAlexander 0:c523920bcc09 296 /** Class representing a VL53L0 sensor component
johnAlexander 0:c523920bcc09 297 */
johnAlexander 0:c523920bcc09 298 class VL53L0X : public RangeSensor
johnAlexander 0:c523920bcc09 299 {
johnAlexander 0:c523920bcc09 300 public:
johnAlexander 0:c523920bcc09 301 /** Constructor
johnAlexander 0:c523920bcc09 302 * @param[in] &i2c device I2C to be used for communication
johnAlexander 0:c523920bcc09 303 * @param[in] &pin_gpio1 pin Mbed InterruptIn PinName to be used as component GPIO_1 INT
johnAlexander 0:c523920bcc09 304 * @param[in] DevAddr device address, 0x29 by default
johnAlexander 0:c523920bcc09 305 */
johnAlexander 0:c523920bcc09 306 VL53L0X(DevI2C &i2c, DigitalOut &pin, PinName pin_gpio1, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), dev_i2c(i2c), gpio0(&pin)
johnAlexander 0:c523920bcc09 307 {
johnAlexander 0:c523920bcc09 308 MyDevice.I2cDevAddr=DevAddr;
johnAlexander 0:c523920bcc09 309 MyDevice.comms_type=1; // VL53L0X_COMMS_I2C
johnAlexander 0:c523920bcc09 310 MyDevice.comms_speed_khz=400;
johnAlexander 0:c523920bcc09 311 Device=&MyDevice;
johnAlexander 0:c523920bcc09 312 expgpio0=NULL;
johnAlexander 0:c523920bcc09 313 if (pin_gpio1 != NC) { gpio1Int = new InterruptIn(pin_gpio1); }
johnAlexander 0:c523920bcc09 314 else { gpio1Int = NULL; }
johnAlexander 0:c523920bcc09 315 }
johnAlexander 0:c523920bcc09 316
johnAlexander 0:c523920bcc09 317 /** Constructor 2 (STMPE1600DigiOut)
johnAlexander 0:c523920bcc09 318 * @param[in] i2c device I2C to be used for communication
johnAlexander 0:c523920bcc09 319 * @param[in] &pin Gpio Expander STMPE1600DigiOut pin to be used as component GPIO_0 CE
johnAlexander 0:c523920bcc09 320 * @param[in] pin_gpio1 pin Mbed InterruptIn PinName to be used as component GPIO_1 INT
johnAlexander 0:c523920bcc09 321 * @param[in] device address, 0x29 by default
johnAlexander 0:c523920bcc09 322 */
johnAlexander 0:c523920bcc09 323 VL53L0X(DevI2C &i2c, STMPE1600DigiOut &pin, PinName pin_gpio1, uint8_t DevAddr=DEFAULT_DEVICE_ADDRESS) : RangeSensor(), dev_i2c(i2c), expgpio0(&pin)
johnAlexander 0:c523920bcc09 324 {
johnAlexander 0:c523920bcc09 325 MyDevice.I2cDevAddr=DevAddr;
johnAlexander 0:c523920bcc09 326 MyDevice.comms_type=1; // VL53L0X_COMMS_I2C
johnAlexander 0:c523920bcc09 327 MyDevice.comms_speed_khz=400;
johnAlexander 0:c523920bcc09 328 Device=&MyDevice;
johnAlexander 0:c523920bcc09 329 gpio0=NULL;
johnAlexander 0:c523920bcc09 330 if (pin_gpio1 != NC) { gpio1Int = new InterruptIn(pin_gpio1); }
johnAlexander 2:58b5e9097aa3 331 else { gpio1Int = NULL; }
johnAlexander 0:c523920bcc09 332 }
johnAlexander 0:c523920bcc09 333
johnAlexander 0:c523920bcc09 334 /** Destructor
johnAlexander 0:c523920bcc09 335 */
johnAlexander 0:c523920bcc09 336 virtual ~VL53L0X(){
johnAlexander 0:c523920bcc09 337 if (gpio1Int != NULL) delete gpio1Int;
johnAlexander 0:c523920bcc09 338 }
johnAlexander 0:c523920bcc09 339 /* warning: VL53L0X class inherits from GenericSensor, RangeSensor and LightSensor, that haven`t a destructor.
johnAlexander 0:c523920bcc09 340 The warning should request to introduce a virtual destructor to make sure to delete the object */
johnAlexander 0:c523920bcc09 341
johnAlexander 0:c523920bcc09 342 /*** Interface Methods ***/
johnAlexander 0:c523920bcc09 343 /*** High level API ***/
johnAlexander 0:c523920bcc09 344 /**
johnAlexander 0:c523920bcc09 345 * @brief PowerOn the sensor
johnAlexander 0:c523920bcc09 346 * @return void
johnAlexander 0:c523920bcc09 347 */
johnAlexander 0:c523920bcc09 348 /* turns on the sensor */
johnAlexander 0:c523920bcc09 349 void VL53L0X_On(void)
johnAlexander 0:c523920bcc09 350 {
johnAlexander 0:c523920bcc09 351 if (gpio0)
johnAlexander 0:c523920bcc09 352 *gpio0 = 1;
johnAlexander 0:c523920bcc09 353 else if (expgpio0)
johnAlexander 0:c523920bcc09 354 *expgpio0 = 1;
johnAlexander 0:c523920bcc09 355 }
johnAlexander 0:c523920bcc09 356
johnAlexander 0:c523920bcc09 357 /**
johnAlexander 0:c523920bcc09 358 * @brief PowerOff the sensor
johnAlexander 0:c523920bcc09 359 * @return void
johnAlexander 0:c523920bcc09 360 */
johnAlexander 0:c523920bcc09 361 /* turns off the sensor */
johnAlexander 0:c523920bcc09 362 void VL53L0X_Off(void)
johnAlexander 0:c523920bcc09 363 {
johnAlexander 0:c523920bcc09 364 if (gpio0)
johnAlexander 0:c523920bcc09 365 *gpio0 = 0;
johnAlexander 0:c523920bcc09 366 else if (expgpio0)
johnAlexander 0:c523920bcc09 367 *expgpio0 = 0;
johnAlexander 0:c523920bcc09 368 }
johnAlexander 0:c523920bcc09 369
johnAlexander 0:c523920bcc09 370 /**
johnAlexander 0:c523920bcc09 371 * @brief Initialize the sensor with default values
johnAlexander 0:c523920bcc09 372 * @return 0 on Success
johnAlexander 2:58b5e9097aa3 373 */
johnAlexander 0:c523920bcc09 374 int InitSensor(uint8_t NewAddr);
johnAlexander 0:c523920bcc09 375
johnAlexander 0:c523920bcc09 376 /**
johnAlexander 0:c523920bcc09 377 * @brief Start the measure indicated by operating mode
johnAlexander 0:c523920bcc09 378 * @param[in] operating_mode specifies requested measure
johnAlexander 0:c523920bcc09 379 * @param[in] fptr specifies call back function must be !NULL in case of interrupt measure
johnAlexander 0:c523920bcc09 380 * @return 0 on Success
johnAlexander 0:c523920bcc09 381 */
johnAlexander 0:c523920bcc09 382 int StartMeasurement(OperatingMode operating_mode, void (*fptr)(void));
johnAlexander 0:c523920bcc09 383
johnAlexander 0:c523920bcc09 384 /**
johnAlexander 0:c523920bcc09 385 * @brief Get results for the measure indicated by operating mode
johnAlexander 0:c523920bcc09 386 * @param[in] operating_mode specifies requested measure results
johnAlexander 0:c523920bcc09 387 * @param[out] Data pointer to the MeasureData_t structure to read data in to
johnAlexander 0:c523920bcc09 388 * @return 0 on Success
johnAlexander 0:c523920bcc09 389 */
johnAlexander 0:c523920bcc09 390 int GetMeasurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 391
johnAlexander 0:c523920bcc09 392 /**
johnAlexander 0:c523920bcc09 393 * @brief Stop the currently running measure indicate by operating_mode
johnAlexander 0:c523920bcc09 394 * @param[in] operating_mode specifies requested measure to stop
johnAlexander 0:c523920bcc09 395 * @return 0 on Success
johnAlexander 0:c523920bcc09 396 */
johnAlexander 0:c523920bcc09 397 int StopMeasurement(OperatingMode operating_mode);
johnAlexander 0:c523920bcc09 398
johnAlexander 0:c523920bcc09 399 /**
johnAlexander 0:c523920bcc09 400 * @brief Interrupt handling func to be called by user after an INT is occourred
johnAlexander 0:c523920bcc09 401 * @param[in] opeating_mode indicating the in progress measure
johnAlexander 0:c523920bcc09 402 * @param[out] Data pointer to the MeasureData_t structure to read data in to
johnAlexander 0:c523920bcc09 403 * @return 0 on Success
johnAlexander 0:c523920bcc09 404 */
johnAlexander 0:c523920bcc09 405 int HandleIRQ(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 406
johnAlexander 0:c523920bcc09 407 /**
johnAlexander 0:c523920bcc09 408 * @brief Enable interrupt measure IRQ
johnAlexander 0:c523920bcc09 409 * @return 0 on Success
johnAlexander 0:c523920bcc09 410 */
johnAlexander 0:c523920bcc09 411 void EnableInterruptMeasureDetectionIRQ(void)
johnAlexander 0:c523920bcc09 412 {
johnAlexander 0:c523920bcc09 413 if (gpio1Int != NULL) gpio1Int->enable_irq();
johnAlexander 0:c523920bcc09 414 }
johnAlexander 0:c523920bcc09 415
johnAlexander 0:c523920bcc09 416 /**
johnAlexander 0:c523920bcc09 417 * @brief Disable interrupt measure IRQ
johnAlexander 0:c523920bcc09 418 * @return 0 on Success
johnAlexander 0:c523920bcc09 419 */
johnAlexander 0:c523920bcc09 420 void DisableInterruptMeasureDetectionIRQ(void)
johnAlexander 0:c523920bcc09 421 {
johnAlexander 0:c523920bcc09 422 if (gpio1Int != NULL) gpio1Int->disable_irq();
johnAlexander 0:c523920bcc09 423 }
johnAlexander 0:c523920bcc09 424 /*** End High level API ***/
johnAlexander 0:c523920bcc09 425
johnAlexander 0:c523920bcc09 426 /**
johnAlexander 0:c523920bcc09 427 * @brief Attach a function to call when an interrupt is detected, i.e. measurement is ready
johnAlexander 0:c523920bcc09 428 * @param[in] fptr pointer to call back function to be called whenever an interrupt occours
johnAlexander 0:c523920bcc09 429 * @return 0 on Success
johnAlexander 0:c523920bcc09 430 */
johnAlexander 0:c523920bcc09 431 void AttachInterruptMeasureDetectionIRQ(void (*fptr)(void))
johnAlexander 0:c523920bcc09 432 {
johnAlexander 0:c523920bcc09 433 if (gpio1Int != NULL) gpio1Int->rise(fptr);
johnAlexander 0:c523920bcc09 434 }
johnAlexander 0:c523920bcc09 435
johnAlexander 0:c523920bcc09 436 /**
johnAlexander 0:c523920bcc09 437 * @brief Check the sensor presence
johnAlexander 0:c523920bcc09 438 * @return 1 when device is present
johnAlexander 0:c523920bcc09 439 */
johnAlexander 0:c523920bcc09 440 unsigned Present()
johnAlexander 0:c523920bcc09 441 {
johnAlexander 0:c523920bcc09 442 // return Device->Present;
johnAlexander 0:c523920bcc09 443 return 1;
johnAlexander 0:c523920bcc09 444 }
johnAlexander 0:c523920bcc09 445
johnAlexander 0:c523920bcc09 446 /** Wrapper functions */
johnAlexander 0:c523920bcc09 447 /** @defgroup api_init Init functions
johnAlexander 0:c523920bcc09 448 * @brief API init functions
johnAlexander 0:c523920bcc09 449 * @ingroup api_hl
johnAlexander 0:c523920bcc09 450 * @{
johnAlexander 0:c523920bcc09 451 */
johnAlexander 0:c523920bcc09 452 /**
johnAlexander 0:c523920bcc09 453 * @brief Wait for device booted after chip enable (hardware standby)
johnAlexander 0:c523920bcc09 454 * @par Function Description
johnAlexander 0:c523920bcc09 455 * After Chip enable Application you can also simply wait at least 1ms to ensure device is ready
johnAlexander 0:c523920bcc09 456 * @warning After device chip enable (gpio0) de-asserted user must wait gpio1 to get asserted (hardware standby).
johnAlexander 0:c523920bcc09 457 * or wait at least 400usec prior to do any low level access or api call .
johnAlexander 0:c523920bcc09 458 *
johnAlexander 0:c523920bcc09 459 * This function implements polling for standby but you must ensure 400usec from chip enable passed\n
johnAlexander 0:c523920bcc09 460 * @warning if device get prepared @a VL53L0X_Prepare() re-using these function can hold indefinitely\n
johnAlexander 0:c523920bcc09 461 *
johnAlexander 0:c523920bcc09 462 * @param void
johnAlexander 0:c523920bcc09 463 * @return 0 on success
johnAlexander 0:c523920bcc09 464 */
johnAlexander 0:c523920bcc09 465 int WaitDeviceBooted()
johnAlexander 0:c523920bcc09 466 {
johnAlexander 0:c523920bcc09 467 return VL53L0X_WaitDeviceBooted(Device);
johnAlexander 0:c523920bcc09 468 // return 1;
johnAlexander 0:c523920bcc09 469 }
johnAlexander 0:c523920bcc09 470
johnAlexander 0:c523920bcc09 471 /**
johnAlexander 0:c523920bcc09 472 *
johnAlexander 0:c523920bcc09 473 * @brief One time device initialization
johnAlexander 0:c523920bcc09 474 *
johnAlexander 0:c523920bcc09 475 * To be called once and only once after device is brought out of reset (Chip enable) and booted see @a VL6180x_WaitDeviceBooted()
johnAlexander 0:c523920bcc09 476 *
johnAlexander 0:c523920bcc09 477 * @par Function Description
johnAlexander 0:c523920bcc09 478 * When not used after a fresh device "power up" or reset, it may return @a #CALIBRATION_WARNING
johnAlexander 0:c523920bcc09 479 * meaning wrong calibration data may have been fetched from device that can result in ranging offset error\n
johnAlexander 0:c523920bcc09 480 * If application cannot execute device reset or need to run VL6180x_InitData multiple time
johnAlexander 0:c523920bcc09 481 * then it must ensure proper offset calibration saving and restore on its own
johnAlexander 0:c523920bcc09 482 * by using @a VL6180x_GetOffsetCalibrationData() on first power up and then @a VL6180x_SetOffsetCalibrationData() all all subsequent init
johnAlexander 0:c523920bcc09 483 *
johnAlexander 0:c523920bcc09 484 * @param void
johnAlexander 0:c523920bcc09 485 * @return 0 on success, @a #CALIBRATION_WARNING if failed
johnAlexander 0:c523920bcc09 486 */
johnAlexander 2:58b5e9097aa3 487 virtual int Init(void * NewAddr)
johnAlexander 0:c523920bcc09 488 {
johnAlexander 4:4e1576541eed 489 return VL53L0X_DataInit(Device);
johnAlexander 0:c523920bcc09 490 }
johnAlexander 0:c523920bcc09 491
johnAlexander 0:c523920bcc09 492 /**
johnAlexander 0:c523920bcc09 493 * @brief Configure GPIO1 function and set polarity.
johnAlexander 0:c523920bcc09 494 * @par Function Description
johnAlexander 0:c523920bcc09 495 * To be used prior to arm single shot measure or start continuous mode.
johnAlexander 0:c523920bcc09 496 *
johnAlexander 0:c523920bcc09 497 * The function uses @a VL6180x_SetupGPIOx() for setting gpio 1.
johnAlexander 0:c523920bcc09 498 * @warning changing polarity can generate a spurious interrupt on pins.
johnAlexander 0:c523920bcc09 499 * It sets an interrupt flags condition that must be cleared to avoid polling hangs. \n
johnAlexander 0:c523920bcc09 500 * It is safe to run VL6180x_ClearAllInterrupt() just after.
johnAlexander 0:c523920bcc09 501 *
johnAlexander 0:c523920bcc09 502 * @param IntFunction The interrupt functionality to use one of :\n
johnAlexander 0:c523920bcc09 503 * @a #GPIOx_SELECT_OFF \n
johnAlexander 0:c523920bcc09 504 * @a #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT
johnAlexander 0:c523920bcc09 505 * @param ActiveHigh The interrupt line polarity see ::IntrPol_e
johnAlexander 0:c523920bcc09 506 * use @a #INTR_POL_LOW (falling edge) or @a #INTR_POL_HIGH (rising edge)
johnAlexander 0:c523920bcc09 507 * @return 0 on success
johnAlexander 0:c523920bcc09 508 */
johnAlexander 0:c523920bcc09 509 int SetupGPIO1(uint8_t InitFunction, int ActiveHigh)
johnAlexander 0:c523920bcc09 510 {
johnAlexander 0:c523920bcc09 511 // return VL6180x_SetupGPIO1(Device, InitFunction, ActiveHigh);
johnAlexander 0:c523920bcc09 512 return 1;
johnAlexander 0:c523920bcc09 513 }
johnAlexander 0:c523920bcc09 514
johnAlexander 0:c523920bcc09 515 /**
johnAlexander 0:c523920bcc09 516 * @brief Prepare device for operation
johnAlexander 0:c523920bcc09 517 * @par Function Description
johnAlexander 0:c523920bcc09 518 * Does static initialization and reprogram common default settings \n
johnAlexander 0:c523920bcc09 519 * Device is prepared for new measure, ready single shot ranging or ALS typical polling operation\n
johnAlexander 0:c523920bcc09 520 * After prepare user can : \n
johnAlexander 0:c523920bcc09 521 * @li Call other API function to set other settings\n
johnAlexander 0:c523920bcc09 522 * @li Configure the interrupt pins, etc... \n
johnAlexander 0:c523920bcc09 523 * @li Then start ranging or ALS operations in single shot or continuous mode
johnAlexander 0:c523920bcc09 524 *
johnAlexander 0:c523920bcc09 525 * @param void
johnAlexander 0:c523920bcc09 526 * @return 0 on success
johnAlexander 0:c523920bcc09 527 */
johnAlexander 0:c523920bcc09 528 int Prepare()
johnAlexander 0:c523920bcc09 529 {
johnAlexander 0:c523920bcc09 530 // taken from rangingTest() in vl53l0x_SingleRanging_Example.c
johnAlexander 0:c523920bcc09 531 VL53L0X_Error Status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 532 uint32_t refSpadCount;
johnAlexander 0:c523920bcc09 533 uint8_t isApertureSpads;
johnAlexander 0:c523920bcc09 534 uint8_t VhvSettings;
johnAlexander 0:c523920bcc09 535 uint8_t PhaseCal;
johnAlexander 0:c523920bcc09 536
johnAlexander 0:c523920bcc09 537 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 538 {
johnAlexander 0:c523920bcc09 539 printf ("Call of VL53L0X_StaticInit\n");
johnAlexander 0:c523920bcc09 540 Status = VL53L0X_StaticInit(Device); // Device Initialization
johnAlexander 0:c523920bcc09 541 }
johnAlexander 0:c523920bcc09 542
johnAlexander 0:c523920bcc09 543 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 544 {
johnAlexander 0:c523920bcc09 545 printf ("Call of VL53L0X_PerformRefCalibration\n");
johnAlexander 0:c523920bcc09 546 Status = VL53L0X_PerformRefCalibration(Device,
johnAlexander 0:c523920bcc09 547 &VhvSettings, &PhaseCal); // Device Initialization
johnAlexander 0:c523920bcc09 548 }
johnAlexander 0:c523920bcc09 549
johnAlexander 0:c523920bcc09 550 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 551 {
johnAlexander 0:c523920bcc09 552 printf ("Call of VL53L0X_PerformRefSpadManagement\n");
johnAlexander 0:c523920bcc09 553 Status = VL53L0X_PerformRefSpadManagement(Device,
johnAlexander 0:c523920bcc09 554 &refSpadCount, &isApertureSpads); // Device Initialization
johnAlexander 0:c523920bcc09 555 // printf ("refSpadCount = %d, isApertureSpads = %d\n", refSpadCount, isApertureSpads);
johnAlexander 0:c523920bcc09 556 }
johnAlexander 0:c523920bcc09 557
johnAlexander 0:c523920bcc09 558 return Status;
johnAlexander 0:c523920bcc09 559 }
johnAlexander 0:c523920bcc09 560
johnAlexander 0:c523920bcc09 561 /**
johnAlexander 0:c523920bcc09 562 * @brief Start continuous ranging mode
johnAlexander 0:c523920bcc09 563 *
johnAlexander 0:c523920bcc09 564 * @details End user should ensure device is in idle state and not already running
johnAlexander 0:c523920bcc09 565 * @return 0 on success
johnAlexander 0:c523920bcc09 566 */
johnAlexander 0:c523920bcc09 567 int RangeStartContinuousMode()
johnAlexander 0:c523920bcc09 568 {
johnAlexander 0:c523920bcc09 569 // return VL6180x_RangeStartContinuousMode(Device);
johnAlexander 0:c523920bcc09 570 return 1;
johnAlexander 0:c523920bcc09 571 }
johnAlexander 0:c523920bcc09 572
johnAlexander 0:c523920bcc09 573 /**
johnAlexander 0:c523920bcc09 574 * @brief Start single shot ranging measure
johnAlexander 0:c523920bcc09 575 *
johnAlexander 0:c523920bcc09 576 * @details End user should ensure device is in idle state and not already running
johnAlexander 0:c523920bcc09 577 * @return 0 on success
johnAlexander 0:c523920bcc09 578 */
johnAlexander 0:c523920bcc09 579 int RangeStartSingleShot()
johnAlexander 0:c523920bcc09 580 {
johnAlexander 0:c523920bcc09 581 // return VL6180x_RangeStartSingleShot(Device);
johnAlexander 0:c523920bcc09 582 return 1;
johnAlexander 0:c523920bcc09 583 }
johnAlexander 0:c523920bcc09 584
johnAlexander 0:c523920bcc09 585 /**
johnAlexander 0:c523920bcc09 586 * @brief Set maximum convergence time
johnAlexander 0:c523920bcc09 587 *
johnAlexander 0:c523920bcc09 588 * @par Function Description
johnAlexander 0:c523920bcc09 589 * Setting a low convergence time can impact maximal detectable distance.
johnAlexander 0:c523920bcc09 590 * Refer to VL6180x Datasheet Table 7 : Typical range convergence time.
johnAlexander 0:c523920bcc09 591 * A typical value for up to x3 scaling is 50 ms
johnAlexander 0:c523920bcc09 592 *
johnAlexander 0:c523920bcc09 593 * @param MaxConTime_msec
johnAlexander 0:c523920bcc09 594 * @return 0 on success. <0 on error. >0 for calibration warning status
johnAlexander 0:c523920bcc09 595 */
johnAlexander 0:c523920bcc09 596 int RangeSetMaxConvergenceTime(uint8_t MaxConTime_msec)
johnAlexander 0:c523920bcc09 597 {
johnAlexander 0:c523920bcc09 598 // return VL6180x_RangeSetMaxConvergenceTime(Device, MaxConTime_msec);
johnAlexander 0:c523920bcc09 599 return 1;
johnAlexander 0:c523920bcc09 600 }
johnAlexander 0:c523920bcc09 601
johnAlexander 0:c523920bcc09 602 /**
johnAlexander 0:c523920bcc09 603 * @brief Single shot Range measurement in polling mode.
johnAlexander 0:c523920bcc09 604 *
johnAlexander 0:c523920bcc09 605 * @par Function Description
johnAlexander 0:c523920bcc09 606 * Kick off a new single shot range then wait for ready to retrieve it by polling interrupt status \n
johnAlexander 0:c523920bcc09 607 * Ranging must be prepared by a first call to @a VL6180x_Prepare() and it is safer to clear very first poll call \n
johnAlexander 0:c523920bcc09 608 * This function reference VL6180x_PollDelay(dev) porting macro/call on each polling loop,
johnAlexander 0:c523920bcc09 609 * but PollDelay(dev) may never be called if measure in ready on first poll loop \n
johnAlexander 0:c523920bcc09 610 * Should not be use in continuous mode operation as it will stop it and cause stop/start misbehaviour \n
johnAlexander 0:c523920bcc09 611 * \n This function clears Range Interrupt status , but not error one. For that uses @a VL6180x_ClearErrorInterrupt() \n
johnAlexander 0:c523920bcc09 612 * This range error is not related VL6180x_RangeData_t::errorStatus that refer measure status \n
johnAlexander 0:c523920bcc09 613 *
johnAlexander 0:c523920bcc09 614 * @param pRangeData Will be populated with the result ranging data @a VL6180x_RangeData_t
johnAlexander 0:c523920bcc09 615 * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use
johnAlexander 0:c523920bcc09 616 *
johnAlexander 0:c523920bcc09 617 * \sa ::VL6180x_RangeData_t
johnAlexander 0:c523920bcc09 618 */
johnAlexander 0:c523920bcc09 619 int RangePollMeasurement(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 620 {
johnAlexander 0:c523920bcc09 621 // return VL6180x_RangePollMeasurement(Device, pRangeData);
johnAlexander 0:c523920bcc09 622 return 1;
johnAlexander 0:c523920bcc09 623 }
johnAlexander 0:c523920bcc09 624
johnAlexander 0:c523920bcc09 625 /**
johnAlexander 0:c523920bcc09 626 * @brief Check for measure readiness and get it if ready
johnAlexander 0:c523920bcc09 627 *
johnAlexander 0:c523920bcc09 628 * @par Function Description
johnAlexander 0:c523920bcc09 629 * Using this function is an alternative to @a VL6180x_RangePollMeasurement() to avoid polling operation. This is suitable for applications
johnAlexander 0:c523920bcc09 630 * where host CPU is triggered on a interrupt (not from VL6180X) to perform ranging operation. In this scenario, we assume that the very first ranging
johnAlexander 0:c523920bcc09 631 * operation is triggered by a call to @a VL6180x_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180x_RangeGetMeasurementIfReady() to
johnAlexander 0:c523920bcc09 632 * get a distance measure if ready. In case the distance is not ready, host may get it at the next call.\n
johnAlexander 0:c523920bcc09 633 *
johnAlexander 0:c523920bcc09 634 * @warning
johnAlexander 0:c523920bcc09 635 * This function does not re-start a new measurement : this is up to the host CPU to do it.\n
johnAlexander 0:c523920bcc09 636 * This function clears Range Interrupt for measure ready , but not error interrupts. For that, uses @a VL6180x_ClearErrorInterrupt() \n
johnAlexander 0:c523920bcc09 637 *
johnAlexander 0:c523920bcc09 638 * @param pRangeData Will be populated with the result ranging data if available
johnAlexander 0:c523920bcc09 639 * @return 0 when measure is ready pRange data is updated (untouched when not ready), >0 for warning and @a #NOT_READY if measurement not yet ready, <0 for error @a #RANGE_ERROR if device report an error,
johnAlexander 0:c523920bcc09 640 */
johnAlexander 0:c523920bcc09 641 int RangeGetMeasurementIfReady(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 642 {
johnAlexander 0:c523920bcc09 643 // return VL6180x_RangeGetMeasurementIfReady(Device, pRangeData);
johnAlexander 0:c523920bcc09 644 return 1;
johnAlexander 0:c523920bcc09 645 }
johnAlexander 0:c523920bcc09 646
johnAlexander 0:c523920bcc09 647 /**
johnAlexander 0:c523920bcc09 648 * @brief Retrieve range measurements set from device
johnAlexander 0:c523920bcc09 649 *
johnAlexander 0:c523920bcc09 650 * @par Function Description
johnAlexander 0:c523920bcc09 651 * The measurement is made of range_mm status and error code @a VL6180x_RangeData_t \n
johnAlexander 0:c523920bcc09 652 * Based on configuration selected extra measures are included.
johnAlexander 0:c523920bcc09 653 *
johnAlexander 0:c523920bcc09 654 * @warning should not be used in continuous if wrap around filter is active \n
johnAlexander 0:c523920bcc09 655 * Does not perform any wait nor check for result availability or validity.
johnAlexander 0:c523920bcc09 656 *\sa VL6180x_RangeGetResult for "range only" measurement
johnAlexander 0:c523920bcc09 657 *
johnAlexander 0:c523920bcc09 658 * @param pRangeData Pointer to the data structure to fill up
johnAlexander 0:c523920bcc09 659 * @return 0 on success
johnAlexander 0:c523920bcc09 660 */
johnAlexander 0:c523920bcc09 661 int RangeGetMeasurement(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 662 {
johnAlexander 0:c523920bcc09 663 // return VL6180x_RangeGetMeasurement(Device, pRangeData);
johnAlexander 0:c523920bcc09 664 return 1;
johnAlexander 0:c523920bcc09 665 }
johnAlexander 0:c523920bcc09 666
johnAlexander 0:c523920bcc09 667 /**
johnAlexander 0:c523920bcc09 668 * @brief Get ranging result and only that
johnAlexander 0:c523920bcc09 669 *
johnAlexander 0:c523920bcc09 670 * @par Function Description
johnAlexander 0:c523920bcc09 671 * Unlike @a VL6180x_RangeGetMeasurement() this function only retrieves the range in millimeter \n
johnAlexander 0:c523920bcc09 672 * It does any required up-scale translation\n
johnAlexander 0:c523920bcc09 673 * It can be called after success status polling or in interrupt mode \n
johnAlexander 0:c523920bcc09 674 * @warning these function is not doing wrap around filtering \n
johnAlexander 0:c523920bcc09 675 * This function doesn't perform any data ready check!
johnAlexander 0:c523920bcc09 676 *
johnAlexander 0:c523920bcc09 677 * @param pRange_mm Pointer to range distance
johnAlexander 0:c523920bcc09 678 * @return 0 on success
johnAlexander 0:c523920bcc09 679 */
johnAlexander 4:4e1576541eed 680 virtual int GetDistance(uint32_t *piData)
johnAlexander 0:c523920bcc09 681 {
johnAlexander 4:4e1576541eed 682 int status=0;
johnAlexander 4:4e1576541eed 683 VL53L0X_RangingMeasurementData_t pRangingMeasurementData;
johnAlexander 4:4e1576541eed 684
johnAlexander 4:4e1576541eed 685 status=StartMeasurement(range_single_shot_polling, NULL);
johnAlexander 4:4e1576541eed 686 if (!status) {
johnAlexander 4:4e1576541eed 687 status=GetMeasurement(range_single_shot_polling, &pRangingMeasurementData);
johnAlexander 4:4e1576541eed 688 }
johnAlexander 4:4e1576541eed 689 if (pRangingMeasurementData.RangeStatus == 0) {
johnAlexander 4:4e1576541eed 690 // we have a valid range.
johnAlexander 4:4e1576541eed 691 *piData = pRangingMeasurementData.RangeMilliMeter;
johnAlexander 4:4e1576541eed 692 }
johnAlexander 4:4e1576541eed 693 else {
johnAlexander 4:4e1576541eed 694 *piData = 0;
johnAlexander 4:4e1576541eed 695 status = VL53L0X_ERROR_RANGE_ERROR;
johnAlexander 4:4e1576541eed 696 }
johnAlexander 4:4e1576541eed 697 StopMeasurement(range_single_shot_polling);
johnAlexander 4:4e1576541eed 698 return status;
johnAlexander 0:c523920bcc09 699 }
johnAlexander 0:c523920bcc09 700
johnAlexander 0:c523920bcc09 701 /**
johnAlexander 0:c523920bcc09 702 * @brief Configure ranging interrupt reported to application
johnAlexander 0:c523920bcc09 703 *
johnAlexander 0:c523920bcc09 704 * @param ConfigGpioInt Select ranging report\n select one (and only one) of:\n
johnAlexander 0:c523920bcc09 705 * @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
johnAlexander 0:c523920bcc09 706 * @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
johnAlexander 0:c523920bcc09 707 * @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
johnAlexander 0:c523920bcc09 708 * @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
johnAlexander 0:c523920bcc09 709 * @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
johnAlexander 0:c523920bcc09 710 * @return 0 on success
johnAlexander 0:c523920bcc09 711 */
johnAlexander 0:c523920bcc09 712 int RangeConfigInterrupt(uint8_t ConfigGpioInt)
johnAlexander 0:c523920bcc09 713 {
johnAlexander 0:c523920bcc09 714 // return VL6180x_RangeConfigInterrupt(Device, ConfigGpioInt);
johnAlexander 0:c523920bcc09 715 return 1;
johnAlexander 0:c523920bcc09 716 }
johnAlexander 0:c523920bcc09 717
johnAlexander 0:c523920bcc09 718 /**
johnAlexander 0:c523920bcc09 719 * @brief Return ranging error interrupt status
johnAlexander 0:c523920bcc09 720 *
johnAlexander 0:c523920bcc09 721 * @par Function Description
johnAlexander 0:c523920bcc09 722 * Appropriate Interrupt report must have been selected first by @a VL6180x_RangeConfigInterrupt() or @a VL6180x_Prepare() \n
johnAlexander 0:c523920bcc09 723 *
johnAlexander 0:c523920bcc09 724 * Can be used in polling loop to wait for a given ranging event or in interrupt to read the trigger \n
johnAlexander 0:c523920bcc09 725 * Events triggers are : \n
johnAlexander 0:c523920bcc09 726 * @a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
johnAlexander 0:c523920bcc09 727 * @a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
johnAlexander 0:c523920bcc09 728 * @a #RES_INT_STAT_GPIO_OUT_OF_WINDOW \n (RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD|RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD)
johnAlexander 0:c523920bcc09 729 * @a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY \n
johnAlexander 0:c523920bcc09 730 *
johnAlexander 0:c523920bcc09 731 * @sa IntrStatus_t
johnAlexander 0:c523920bcc09 732 * @param pIntStatus Pointer to status variable to update
johnAlexander 0:c523920bcc09 733 * @return 0 on success
johnAlexander 0:c523920bcc09 734 */
johnAlexander 0:c523920bcc09 735 int RangeGetInterruptStatus(uint8_t *pIntStatus)
johnAlexander 0:c523920bcc09 736 {
johnAlexander 0:c523920bcc09 737 // return VL6180x_RangeGetInterruptStatus(Device, pIntStatus);
johnAlexander 0:c523920bcc09 738 return 1;
johnAlexander 0:c523920bcc09 739 }
johnAlexander 0:c523920bcc09 740
johnAlexander 0:c523920bcc09 741 /**
johnAlexander 0:c523920bcc09 742 * @brief Low level ranging and ALS register static settings (you should call @a VL6180x_Prepare() function instead)
johnAlexander 0:c523920bcc09 743 *
johnAlexander 0:c523920bcc09 744 * @return 0 on success
johnAlexander 0:c523920bcc09 745 */
johnAlexander 0:c523920bcc09 746 int StaticInit()
johnAlexander 0:c523920bcc09 747 {
johnAlexander 0:c523920bcc09 748 // return VL6180x_StaticInit(Device);
johnAlexander 0:c523920bcc09 749 return 1;
johnAlexander 0:c523920bcc09 750 }
johnAlexander 0:c523920bcc09 751
johnAlexander 0:c523920bcc09 752 /**
johnAlexander 0:c523920bcc09 753 * @brief Wait for device to be ready (before a new ranging command can be issued by application)
johnAlexander 0:c523920bcc09 754 * @param MaxLoop Max Number of i2c polling loop see @a #msec_2_i2cloop
johnAlexander 0:c523920bcc09 755 * @return 0 on success. <0 when fail \n
johnAlexander 0:c523920bcc09 756 * @ref VL6180x_ErrCode_t::TIME_OUT for time out \n
johnAlexander 0:c523920bcc09 757 * @ref VL6180x_ErrCode_t::INVALID_PARAMS if MaxLop<1
johnAlexander 0:c523920bcc09 758 */
johnAlexander 0:c523920bcc09 759 int RangeWaitDeviceReady(int MaxLoop )
johnAlexander 0:c523920bcc09 760 {
johnAlexander 0:c523920bcc09 761 // return VL6180x_RangeWaitDeviceReady(Device, MaxLoop);
johnAlexander 0:c523920bcc09 762 return 1;
johnAlexander 0:c523920bcc09 763 }
johnAlexander 0:c523920bcc09 764
johnAlexander 0:c523920bcc09 765 /**
johnAlexander 0:c523920bcc09 766 * @brief Program Inter measurement period (used only in continuous mode)
johnAlexander 0:c523920bcc09 767 *
johnAlexander 0:c523920bcc09 768 * @par Function Description
johnAlexander 0:c523920bcc09 769 * When trying to set too long time, it returns #INVALID_PARAMS
johnAlexander 0:c523920bcc09 770 *
johnAlexander 0:c523920bcc09 771 * @param InterMeasTime_msec Requires inter-measurement time in msec
johnAlexander 0:c523920bcc09 772 * @return 0 on success
johnAlexander 0:c523920bcc09 773 */
johnAlexander 0:c523920bcc09 774 int RangeSetInterMeasPeriod(uint32_t InterMeasTime_msec)
johnAlexander 0:c523920bcc09 775 {
johnAlexander 0:c523920bcc09 776 // return VL6180x_RangeSetInterMeasPeriod(Device, InterMeasTime_msec);
johnAlexander 0:c523920bcc09 777 return 1;
johnAlexander 0:c523920bcc09 778 }
johnAlexander 0:c523920bcc09 779
johnAlexander 0:c523920bcc09 780 /**
johnAlexander 0:c523920bcc09 781 * @brief Set device ranging scaling factor
johnAlexander 0:c523920bcc09 782 *
johnAlexander 0:c523920bcc09 783 * @par Function Description
johnAlexander 0:c523920bcc09 784 * The ranging scaling factor is applied on the raw distance measured by the device to increase operating ranging at the price of the precision.
johnAlexander 0:c523920bcc09 785 * Changing the scaling factor when device is not in f/w standby state (free running) is not safe.
johnAlexander 0:c523920bcc09 786 * It can be source of spurious interrupt, wrongly scaled range etc ...
johnAlexander 0:c523920bcc09 787 * @warning __This function doesns't update high/low threshold and other programmed settings linked to scaling factor__.
johnAlexander 0:c523920bcc09 788 * To ensure proper operation, threshold and scaling changes should be done following this procedure: \n
johnAlexander 0:c523920bcc09 789 * @li Set Group hold : @a VL6180x_SetGroupParamHold() \n
johnAlexander 0:c523920bcc09 790 * @li Get Threshold @a VL6180x_RangeGetThresholds() \n
johnAlexander 0:c523920bcc09 791 * @li Change scaling : @a VL6180x_UpscaleSetScaling() \n
johnAlexander 0:c523920bcc09 792 * @li Set Threshold : @a VL6180x_RangeSetThresholds() \n
johnAlexander 0:c523920bcc09 793 * @li Unset Group Hold : @a VL6180x_SetGroupParamHold()
johnAlexander 0:c523920bcc09 794 *
johnAlexander 0:c523920bcc09 795 * @param scaling Scaling factor to apply (1,2 or 3)
johnAlexander 0:c523920bcc09 796 * @return 0 on success when up-scale support is not configured it fail for any
johnAlexander 0:c523920bcc09 797 * scaling than the one statically configured.
johnAlexander 0:c523920bcc09 798 */
johnAlexander 0:c523920bcc09 799 int UpscaleSetScaling(uint8_t scaling)
johnAlexander 0:c523920bcc09 800 {
johnAlexander 0:c523920bcc09 801 // return VL6180x_UpscaleSetScaling(Device, scaling);
johnAlexander 0:c523920bcc09 802 return 1;
johnAlexander 0:c523920bcc09 803 }
johnAlexander 0:c523920bcc09 804
johnAlexander 0:c523920bcc09 805 /**
johnAlexander 0:c523920bcc09 806 * @brief Get current ranging scaling factor
johnAlexander 0:c523920bcc09 807 *
johnAlexander 0:c523920bcc09 808 * @return The current scaling factor
johnAlexander 0:c523920bcc09 809 */
johnAlexander 0:c523920bcc09 810 int UpscaleGetScaling()
johnAlexander 0:c523920bcc09 811 {
johnAlexander 0:c523920bcc09 812 // return VL6180x_UpscaleGetScaling(Device);
johnAlexander 0:c523920bcc09 813 return 1;
johnAlexander 0:c523920bcc09 814 }
johnAlexander 0:c523920bcc09 815
johnAlexander 0:c523920bcc09 816 /**
johnAlexander 0:c523920bcc09 817 * @brief Get the maximal distance for actual scaling
johnAlexander 0:c523920bcc09 818 * @par Function Description
johnAlexander 0:c523920bcc09 819 * Do not use prior to @a VL6180x_Prepare() or at least @a VL6180x_InitData()
johnAlexander 0:c523920bcc09 820 *
johnAlexander 0:c523920bcc09 821 * Any range value more than the value returned by this function is to be considered as "no target detected"
johnAlexander 0:c523920bcc09 822 * or "no target in detectable range" \n
johnAlexander 0:c523920bcc09 823 * @warning The maximal distance depends on the scaling
johnAlexander 0:c523920bcc09 824 *
johnAlexander 0:c523920bcc09 825 * @return The maximal range limit for actual mode and scaling
johnAlexander 0:c523920bcc09 826 */
johnAlexander 0:c523920bcc09 827 uint16_t GetUpperLimit()
johnAlexander 0:c523920bcc09 828 {
johnAlexander 0:c523920bcc09 829 // return VL6180x_GetUpperLimit(Device);
johnAlexander 0:c523920bcc09 830 return 1;
johnAlexander 0:c523920bcc09 831 }
johnAlexander 0:c523920bcc09 832
johnAlexander 0:c523920bcc09 833 /**
johnAlexander 0:c523920bcc09 834 * @brief Apply low and high ranging thresholds that are considered only in continuous mode
johnAlexander 0:c523920bcc09 835 *
johnAlexander 0:c523920bcc09 836 * @par Function Description
johnAlexander 0:c523920bcc09 837 * This function programs low and high ranging thresholds that are considered in continuous mode :
johnAlexander 0:c523920bcc09 838 * interrupt will be raised only when an object is detected at a distance inside this [low:high] range.
johnAlexander 0:c523920bcc09 839 * The function takes care of applying current scaling factor if any.\n
johnAlexander 0:c523920bcc09 840 * To be safe, in continuous operation, thresholds must be changed under "group parameter hold" cover.
johnAlexander 0:c523920bcc09 841 * Group hold can be activated/deactivated directly in the function or externally (then set 0)
johnAlexander 0:c523920bcc09 842 * using /a VL6180x_SetGroupParamHold() function.
johnAlexander 0:c523920bcc09 843 *
johnAlexander 0:c523920bcc09 844 * @param low Low threshold in mm
johnAlexander 0:c523920bcc09 845 * @param high High threshold in mm
johnAlexander 0:c523920bcc09 846 * @param SafeHold Use of group parameters hold to surround threshold programming.
johnAlexander 0:c523920bcc09 847 * @return 0 On success
johnAlexander 0:c523920bcc09 848 */
johnAlexander 0:c523920bcc09 849 int RangeSetThresholds(uint16_t low, uint16_t high, int SafeHold)
johnAlexander 0:c523920bcc09 850 {
johnAlexander 0:c523920bcc09 851 // return VL6180x_RangeSetThresholds(Device, low, high, SafeHold);
johnAlexander 0:c523920bcc09 852 return 1;
johnAlexander 0:c523920bcc09 853 }
johnAlexander 0:c523920bcc09 854
johnAlexander 0:c523920bcc09 855 /**
johnAlexander 0:c523920bcc09 856 * @brief Get scaled high and low threshold from device
johnAlexander 0:c523920bcc09 857 *
johnAlexander 0:c523920bcc09 858 * @par Function Description
johnAlexander 0:c523920bcc09 859 * Due to scaling factor, the returned value may be different from what has been programmed first (precision lost).
johnAlexander 0:c523920bcc09 860 * For instance VL6180x_RangeSetThresholds(dev,11,22) with scale 3
johnAlexander 0:c523920bcc09 861 * will read back 9 ((11/3)x3) and 21 ((22/3)x3).
johnAlexander 0:c523920bcc09 862 *
johnAlexander 0:c523920bcc09 863 * @param low scaled low Threshold ptr can be NULL if not needed
johnAlexander 0:c523920bcc09 864 * @param high scaled High Threshold ptr can be NULL if not needed
johnAlexander 0:c523920bcc09 865 * @return 0 on success, return value is undefined if both low and high are NULL
johnAlexander 0:c523920bcc09 866 * @warning return value is undefined if both low and high are NULL
johnAlexander 0:c523920bcc09 867 */
johnAlexander 0:c523920bcc09 868 int RangeGetThresholds(uint16_t *low, uint16_t *high)
johnAlexander 0:c523920bcc09 869 {
johnAlexander 0:c523920bcc09 870 // return VL6180x_RangeGetThresholds(Device, low, high);
johnAlexander 0:c523920bcc09 871 return 1;
johnAlexander 0:c523920bcc09 872 }
johnAlexander 0:c523920bcc09 873
johnAlexander 0:c523920bcc09 874 /**
johnAlexander 0:c523920bcc09 875 * @brief Set ranging raw thresholds (scaling not considered so not recommended to use it)
johnAlexander 0:c523920bcc09 876 *
johnAlexander 0:c523920bcc09 877 * @param low raw low threshold set to raw register
johnAlexander 0:c523920bcc09 878 * @param high raw high threshold set to raw register
johnAlexander 0:c523920bcc09 879 * @return 0 on success
johnAlexander 0:c523920bcc09 880 */
johnAlexander 0:c523920bcc09 881 int RangeSetRawThresholds(uint8_t low, uint8_t high)
johnAlexander 0:c523920bcc09 882 {
johnAlexander 0:c523920bcc09 883 // return VL6180x_RangeSetRawThresholds(Device, low, high);
johnAlexander 0:c523920bcc09 884 return 1;
johnAlexander 0:c523920bcc09 885 }
johnAlexander 0:c523920bcc09 886
johnAlexander 0:c523920bcc09 887 /**
johnAlexander 0:c523920bcc09 888 * @brief Set Early Convergence Estimate ratio
johnAlexander 0:c523920bcc09 889 * @par Function Description
johnAlexander 0:c523920bcc09 890 * For more information on ECE check datasheet
johnAlexander 0:c523920bcc09 891 * @warning May return a calibration warning in some use cases
johnAlexander 0:c523920bcc09 892 *
johnAlexander 0:c523920bcc09 893 * @param FactorM ECE factor M in M/D
johnAlexander 0:c523920bcc09 894 * @param FactorD ECE factor D in M/D
johnAlexander 0:c523920bcc09 895 * @return 0 on success. <0 on error. >0 on warning
johnAlexander 0:c523920bcc09 896 */
johnAlexander 0:c523920bcc09 897 int RangeSetEceFactor(uint16_t FactorM, uint16_t FactorD)
johnAlexander 0:c523920bcc09 898 {
johnAlexander 0:c523920bcc09 899 // return VL6180x_RangeSetEceFactor(Device, FactorM, FactorD);
johnAlexander 0:c523920bcc09 900 return 1;
johnAlexander 0:c523920bcc09 901 }
johnAlexander 0:c523920bcc09 902
johnAlexander 0:c523920bcc09 903 /**
johnAlexander 0:c523920bcc09 904 * @brief Set Early Convergence Estimate state (See #SYSRANGE_RANGE_CHECK_ENABLES register)
johnAlexander 0:c523920bcc09 905 * @param enable State to be set 0=disabled, otherwise enabled
johnAlexander 0:c523920bcc09 906 * @return 0 on success
johnAlexander 0:c523920bcc09 907 */
johnAlexander 0:c523920bcc09 908 int RangeSetEceState(int enable)
johnAlexander 0:c523920bcc09 909 {
johnAlexander 0:c523920bcc09 910 // return VL6180x_RangeSetEceState(Device, enable);
johnAlexander 0:c523920bcc09 911 return 1;
johnAlexander 0:c523920bcc09 912 }
johnAlexander 0:c523920bcc09 913
johnAlexander 0:c523920bcc09 914 /**
johnAlexander 0:c523920bcc09 915 * @brief Set activation state of the wrap around filter
johnAlexander 0:c523920bcc09 916 * @param state New activation state (0=off, otherwise on)
johnAlexander 0:c523920bcc09 917 * @return 0 on success
johnAlexander 0:c523920bcc09 918 */
johnAlexander 0:c523920bcc09 919 int FilterSetState(int state)
johnAlexander 0:c523920bcc09 920 {
johnAlexander 0:c523920bcc09 921 // return VL6180x_FilterSetState(Device, state);
johnAlexander 0:c523920bcc09 922 return 1;
johnAlexander 0:c523920bcc09 923 }
johnAlexander 0:c523920bcc09 924
johnAlexander 0:c523920bcc09 925 /**
johnAlexander 0:c523920bcc09 926 * Get activation state of the wrap around filter
johnAlexander 0:c523920bcc09 927 * @return Filter enabled or not, when filter is not supported it always returns 0S
johnAlexander 0:c523920bcc09 928 */
johnAlexander 0:c523920bcc09 929 int FilterGetState()
johnAlexander 0:c523920bcc09 930 {
johnAlexander 0:c523920bcc09 931 // return VL6180x_FilterGetState(Device);
johnAlexander 0:c523920bcc09 932 return 1;
johnAlexander 0:c523920bcc09 933 }
johnAlexander 0:c523920bcc09 934
johnAlexander 0:c523920bcc09 935 /**
johnAlexander 0:c523920bcc09 936 * @brief Set activation state of DMax computation
johnAlexander 0:c523920bcc09 937 * @param state New activation state (0=off, otherwise on)
johnAlexander 0:c523920bcc09 938 * @return 0 on success
johnAlexander 0:c523920bcc09 939 */
johnAlexander 0:c523920bcc09 940 int DMaxSetState(int state)
johnAlexander 0:c523920bcc09 941 {
johnAlexander 0:c523920bcc09 942 // return VL6180x_DMaxSetState(Device, state);
johnAlexander 0:c523920bcc09 943 return 1;
johnAlexander 0:c523920bcc09 944 }
johnAlexander 0:c523920bcc09 945
johnAlexander 0:c523920bcc09 946 /**
johnAlexander 0:c523920bcc09 947 * Get activation state of DMax computation
johnAlexander 0:c523920bcc09 948 * @return Filter enabled or not, when filter is not supported it always returns 0S
johnAlexander 0:c523920bcc09 949 */
johnAlexander 0:c523920bcc09 950 int DMaxGetState()
johnAlexander 0:c523920bcc09 951 {
johnAlexander 0:c523920bcc09 952 // return VL6180x_DMaxGetState(Device);
johnAlexander 0:c523920bcc09 953 return 1;
johnAlexander 0:c523920bcc09 954 }
johnAlexander 0:c523920bcc09 955
johnAlexander 0:c523920bcc09 956 /**
johnAlexander 0:c523920bcc09 957 * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180x_RangeStartSingleShot() or @a VL6180x_RangeStartContinuousMode())
johnAlexander 0:c523920bcc09 958 *
johnAlexander 0:c523920bcc09 959 * @par Function Description
johnAlexander 0:c523920bcc09 960 * When used outside scope of known polling single shot stopped state, \n
johnAlexander 0:c523920bcc09 961 * user must ensure the device state is "idle" before to issue a new command.
johnAlexander 0:c523920bcc09 962 *
johnAlexander 0:c523920bcc09 963 * @param mode A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start/stop condition (#MODE_START_STOP) \n
johnAlexander 0:c523920bcc09 964 * @return 0 on success
johnAlexander 0:c523920bcc09 965 */
johnAlexander 0:c523920bcc09 966 int RangeSetSystemMode(uint8_t mode)
johnAlexander 0:c523920bcc09 967 {
johnAlexander 0:c523920bcc09 968 // return VL6180x_RangeSetSystemMode(Device, mode);
johnAlexander 0:c523920bcc09 969 return 1;
johnAlexander 0:c523920bcc09 970 }
johnAlexander 0:c523920bcc09 971
johnAlexander 0:c523920bcc09 972 /** @} */
johnAlexander 0:c523920bcc09 973
johnAlexander 0:c523920bcc09 974 /** @defgroup api_ll_range_calibration Ranging calibration functions
johnAlexander 0:c523920bcc09 975 * @brief Ranging calibration functions
johnAlexander 0:c523920bcc09 976 * @ingroup api_ll
johnAlexander 0:c523920bcc09 977 * @{
johnAlexander 0:c523920bcc09 978 */
johnAlexander 0:c523920bcc09 979 /**
johnAlexander 0:c523920bcc09 980 * @brief Get part to part calibration offset
johnAlexander 0:c523920bcc09 981 *
johnAlexander 0:c523920bcc09 982 * @par Function Description
johnAlexander 0:c523920bcc09 983 * Should only be used after a successful call to @a VL6180x_InitData to backup device nvm value
johnAlexander 0:c523920bcc09 984 *
johnAlexander 0:c523920bcc09 985 * @return part to part calibration offset from device
johnAlexander 0:c523920bcc09 986 */
johnAlexander 0:c523920bcc09 987 int8_t GetOffsetCalibrationData()
johnAlexander 0:c523920bcc09 988 {
johnAlexander 0:c523920bcc09 989 // return VL6180x_GetOffsetCalibrationData(Device);
johnAlexander 0:c523920bcc09 990 return 1;
johnAlexander 0:c523920bcc09 991 }
johnAlexander 0:c523920bcc09 992
johnAlexander 0:c523920bcc09 993 /**
johnAlexander 0:c523920bcc09 994 * Set or over-write part to part calibration offset
johnAlexander 0:c523920bcc09 995 * \sa VL6180x_InitData(), VL6180x_GetOffsetCalibrationData()
johnAlexander 0:c523920bcc09 996 * @param offset Offset
johnAlexander 0:c523920bcc09 997 */
johnAlexander 0:c523920bcc09 998 void SetOffsetCalibrationData(int8_t offset)
johnAlexander 0:c523920bcc09 999 {
johnAlexander 0:c523920bcc09 1000 // return VL6180x_SetOffsetCalibrationData(Device, offset);
johnAlexander 0:c523920bcc09 1001 return;
johnAlexander 0:c523920bcc09 1002 }
johnAlexander 0:c523920bcc09 1003
johnAlexander 0:c523920bcc09 1004 /**
johnAlexander 0:c523920bcc09 1005 * @brief Set Cross talk compensation rate
johnAlexander 0:c523920bcc09 1006 *
johnAlexander 0:c523920bcc09 1007 * @par Function Description
johnAlexander 0:c523920bcc09 1008 * It programs register @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE
johnAlexander 0:c523920bcc09 1009 *
johnAlexander 0:c523920bcc09 1010 * @param Rate Compensation rate (9.7 fix point) see datasheet for details
johnAlexander 0:c523920bcc09 1011 * @return 0 on success
johnAlexander 0:c523920bcc09 1012 */
johnAlexander 0:c523920bcc09 1013 int SetXTalkCompensationRate(uint16_t Rate)
johnAlexander 0:c523920bcc09 1014 {
johnAlexander 0:c523920bcc09 1015 // return VL6180x_SetXTalkCompensationRate(Device, Rate);
johnAlexander 0:c523920bcc09 1016 return 1;
johnAlexander 0:c523920bcc09 1017 }
johnAlexander 0:c523920bcc09 1018 /** @} */
johnAlexander 0:c523920bcc09 1019
johnAlexander 0:c523920bcc09 1020 /**
johnAlexander 0:c523920bcc09 1021 * @brief Set new device i2c address
johnAlexander 0:c523920bcc09 1022 *
johnAlexander 0:c523920bcc09 1023 * After completion the device will answer to the new address programmed.
johnAlexander 0:c523920bcc09 1024 *
johnAlexander 0:c523920bcc09 1025 * @sa AN4478: Using multiple VL6180X's in a single design
johnAlexander 0:c523920bcc09 1026 * @param NewAddr The new i2c address (7bit)
johnAlexander 0:c523920bcc09 1027 * @return 0 on success
johnAlexander 0:c523920bcc09 1028 */
johnAlexander 0:c523920bcc09 1029 int SetDeviceAddress(int NewAddr)
johnAlexander 0:c523920bcc09 1030 {
johnAlexander 0:c523920bcc09 1031 int status;
johnAlexander 0:c523920bcc09 1032
johnAlexander 0:c523920bcc09 1033 status=VL53L0X_SetDeviceAddress(Device, NewAddr);
johnAlexander 0:c523920bcc09 1034 if(!status)
johnAlexander 0:c523920bcc09 1035 Device->I2cDevAddr=NewAddr;
johnAlexander 0:c523920bcc09 1036 return status;
johnAlexander 0:c523920bcc09 1037
johnAlexander 0:c523920bcc09 1038 // return 1;
johnAlexander 0:c523920bcc09 1039 }
johnAlexander 0:c523920bcc09 1040
johnAlexander 0:c523920bcc09 1041 /**
johnAlexander 0:c523920bcc09 1042 * @brief Fully configure gpio 0/1 pin : polarity and functionality
johnAlexander 0:c523920bcc09 1043 *
johnAlexander 0:c523920bcc09 1044 * @param pin gpio pin 0 or 1
johnAlexander 0:c523920bcc09 1045 * @param IntFunction Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
johnAlexander 0:c523920bcc09 1046 * @param ActiveHigh Set active high polarity, or active low see @a ::IntrPol_e
johnAlexander 0:c523920bcc09 1047 * @return 0 on success
johnAlexander 0:c523920bcc09 1048 */
johnAlexander 0:c523920bcc09 1049 int SetupGPIOx(int pin, uint8_t IntFunction, int ActiveHigh)
johnAlexander 0:c523920bcc09 1050 {
johnAlexander 0:c523920bcc09 1051 // return VL6180x_SetupGPIOx(Device, pin, IntFunction, ActiveHigh);
johnAlexander 0:c523920bcc09 1052 return 1;
johnAlexander 0:c523920bcc09 1053 }
johnAlexander 0:c523920bcc09 1054
johnAlexander 0:c523920bcc09 1055 /**
johnAlexander 0:c523920bcc09 1056 * @brief Set interrupt pin polarity for the given GPIO
johnAlexander 0:c523920bcc09 1057 *
johnAlexander 0:c523920bcc09 1058 * @param pin Pin 0 or 1
johnAlexander 0:c523920bcc09 1059 * @param active_high select active high or low polarity using @ref IntrPol_e
johnAlexander 0:c523920bcc09 1060 * @return 0 on success
johnAlexander 0:c523920bcc09 1061 */
johnAlexander 0:c523920bcc09 1062 int SetGPIOxPolarity(int pin, int active_high)
johnAlexander 0:c523920bcc09 1063 {
johnAlexander 0:c523920bcc09 1064 // return VL6180x_SetGPIOxPolarity(Device, pin, active_high);
johnAlexander 0:c523920bcc09 1065 return 1;
johnAlexander 0:c523920bcc09 1066 }
johnAlexander 0:c523920bcc09 1067
johnAlexander 0:c523920bcc09 1068 /**
johnAlexander 0:c523920bcc09 1069 * Select interrupt functionality for the given GPIO
johnAlexander 0:c523920bcc09 1070 *
johnAlexander 0:c523920bcc09 1071 * @par Function Description
johnAlexander 0:c523920bcc09 1072 * Functionality refer to @a SYSTEM_MODE_GPIO0
johnAlexander 0:c523920bcc09 1073 *
johnAlexander 0:c523920bcc09 1074 * @param pin Pin to configure 0 or 1 (gpio0 or gpio1)\nNote that gpio0 is chip enable at power up !
johnAlexander 0:c523920bcc09 1075 * @param functionality Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
johnAlexander 0:c523920bcc09 1076 * @return 0 on success
johnAlexander 0:c523920bcc09 1077 */
johnAlexander 0:c523920bcc09 1078 int SetGPIOxFunctionality(int pin, uint8_t functionality)
johnAlexander 0:c523920bcc09 1079 {
johnAlexander 0:c523920bcc09 1080 // return VL6180x_SetGPIOxFunctionality(Device, pin, functionality);
johnAlexander 0:c523920bcc09 1081 return 1;
johnAlexander 0:c523920bcc09 1082 }
johnAlexander 0:c523920bcc09 1083
johnAlexander 0:c523920bcc09 1084 /**
johnAlexander 0:c523920bcc09 1085 * #brief Disable and turn to Hi-Z gpio output pin
johnAlexander 0:c523920bcc09 1086 *
johnAlexander 0:c523920bcc09 1087 * @param pin The pin number to disable 0 or 1
johnAlexander 0:c523920bcc09 1088 * @return 0 on success
johnAlexander 0:c523920bcc09 1089 */
johnAlexander 0:c523920bcc09 1090 int DisableGPIOxOut(int pin)
johnAlexander 0:c523920bcc09 1091 {
johnAlexander 0:c523920bcc09 1092 // return VL6180x_DisableGPIOxOut(Device, pin);
johnAlexander 0:c523920bcc09 1093 return 1;
johnAlexander 0:c523920bcc09 1094 }
johnAlexander 0:c523920bcc09 1095
johnAlexander 0:c523920bcc09 1096 /** @} */
johnAlexander 0:c523920bcc09 1097
johnAlexander 0:c523920bcc09 1098 /** @defgroup api_ll_intr Interrupts management functions
johnAlexander 0:c523920bcc09 1099 * @brief Interrupts management functions
johnAlexander 0:c523920bcc09 1100 * @ingroup api_ll
johnAlexander 0:c523920bcc09 1101 * @{
johnAlexander 0:c523920bcc09 1102 */
johnAlexander 0:c523920bcc09 1103
johnAlexander 0:c523920bcc09 1104 /**
johnAlexander 0:c523920bcc09 1105 * @brief Get all interrupts cause
johnAlexander 0:c523920bcc09 1106 *
johnAlexander 0:c523920bcc09 1107 * @param status Ptr to interrupt status. You can use @a IntrStatus_t::val
johnAlexander 0:c523920bcc09 1108 * @return 0 on success
johnAlexander 0:c523920bcc09 1109 */
johnAlexander 0:c523920bcc09 1110 int GetInterruptStatus(uint8_t *status)
johnAlexander 0:c523920bcc09 1111 {
johnAlexander 0:c523920bcc09 1112 // return VL6180x_GetInterruptStatus(Device, status);
johnAlexander 0:c523920bcc09 1113 return 1;
johnAlexander 0:c523920bcc09 1114 }
johnAlexander 0:c523920bcc09 1115
johnAlexander 0:c523920bcc09 1116 /**
johnAlexander 0:c523920bcc09 1117 * @brief Clear given system interrupt condition
johnAlexander 0:c523920bcc09 1118 *
johnAlexander 0:c523920bcc09 1119 * @par Function Description
johnAlexander 0:c523920bcc09 1120 * Clear given interrupt cause by writing into register #SYSTEM_INTERRUPT_CLEAR register.
johnAlexander 0:c523920bcc09 1121 * @param dev The device
johnAlexander 0:c523920bcc09 1122 * @param IntClear Which interrupt source to clear. Use any combinations of #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR.
johnAlexander 0:c523920bcc09 1123 * @return 0 On success
johnAlexander 0:c523920bcc09 1124 */
johnAlexander 0:c523920bcc09 1125 int ClearInterrupt(uint8_t IntClear)
johnAlexander 0:c523920bcc09 1126 {
johnAlexander 0:c523920bcc09 1127 // return VL6180x_ClearInterrupt(Device, IntClear );
johnAlexander 0:c523920bcc09 1128 return 1;
johnAlexander 0:c523920bcc09 1129 }
johnAlexander 0:c523920bcc09 1130
johnAlexander 0:c523920bcc09 1131 /**
johnAlexander 0:c523920bcc09 1132 * @brief Clear error interrupt
johnAlexander 0:c523920bcc09 1133 *
johnAlexander 0:c523920bcc09 1134 * @param dev The device
johnAlexander 0:c523920bcc09 1135 * @return 0 On success
johnAlexander 0:c523920bcc09 1136 */
johnAlexander 0:c523920bcc09 1137 #define VL6180x_ClearErrorInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR)
johnAlexander 0:c523920bcc09 1138
johnAlexander 0:c523920bcc09 1139 /**
johnAlexander 0:c523920bcc09 1140 * @brief Clear All interrupt causes (als+range+error)
johnAlexander 0:c523920bcc09 1141 *
johnAlexander 0:c523920bcc09 1142 * @param dev The device
johnAlexander 0:c523920bcc09 1143 * @return 0 On success
johnAlexander 0:c523920bcc09 1144 */
johnAlexander 0:c523920bcc09 1145 #define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
johnAlexander 0:c523920bcc09 1146
johnAlexander 0:c523920bcc09 1147
johnAlexander 0:c523920bcc09 1148 private:
johnAlexander 0:c523920bcc09 1149 /* api.h functions */
johnAlexander 0:c523920bcc09 1150 VL53L0X_Error VL53L0X_DataInit(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1151 VL53L0X_Error VL53L0X_GetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev, int32_t *pOffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1152 VL53L0X_Error VL53L0X_SetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1153 int32_t OffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1154 VL53L0X_Error VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1155 VL53L0X_DeviceParameters_t *pDeviceParameters);
johnAlexander 0:c523920bcc09 1156 VL53L0X_Error VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1157 VL53L0X_DeviceModes *pDeviceMode);
johnAlexander 0:c523920bcc09 1158 VL53L0X_Error VL53L0X_GetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1159 uint32_t *pInterMeasurementPeriodMilliSeconds);
johnAlexander 0:c523920bcc09 1160 VL53L0X_Error VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1161 FixPoint1616_t *pXTalkCompensationRateMegaCps);
johnAlexander 0:c523920bcc09 1162 VL53L0X_Error VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1163 FixPoint1616_t *pLimitCheckValue);
johnAlexander 0:c523920bcc09 1164 VL53L0X_Error VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1165 uint8_t *pLimitCheckEnable);
johnAlexander 0:c523920bcc09 1166 VL53L0X_Error VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1167 uint8_t *pWrapAroundCheckEnable);
johnAlexander 0:c523920bcc09 1168 VL53L0X_Error VL53L0X_GetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1169 uint32_t *pMeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1170 VL53L0X_Error VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1171 VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps);
johnAlexander 0:c523920bcc09 1172 VL53L0X_Error sequence_step_enabled(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1173 VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceConfig,
johnAlexander 0:c523920bcc09 1174 uint8_t *pSequenceStepEnabled);
johnAlexander 0:c523920bcc09 1175 VL53L0X_Error VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1176 VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1177 VL53L0X_Error VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1178 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1179 VL53L0X_Error VL53L0X_StaticInit(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1180 VL53L0X_Error VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1181 uint8_t *pMeasurementDataReady);
johnAlexander 0:c523920bcc09 1182 VL53L0X_Error VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1183 uint32_t *pInterruptMaskStatus);
johnAlexander 0:c523920bcc09 1184 VL53L0X_Error VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask);
johnAlexander 0:c523920bcc09 1185 VL53L0X_Error VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1186 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
johnAlexander 0:c523920bcc09 1187 VL53L0X_Error VL53L0X_SetDeviceMode(VL53L0X_DEV Dev, VL53L0X_DeviceModes DeviceMode);
johnAlexander 0:c523920bcc09 1188 VL53L0X_Error VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1189 VL53L0X_Error VL53L0X_StartMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1190 VL53L0X_Error VL53L0X_CheckAndLoadInterruptSettings(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1191 uint8_t StartNotStopFlag);
johnAlexander 0:c523920bcc09 1192 VL53L0X_Error VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1193 VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
johnAlexander 0:c523920bcc09 1194 FixPoint1616_t *pThresholdHigh);
johnAlexander 0:c523920bcc09 1195 VL53L0X_Error VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1196 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
johnAlexander 0:c523920bcc09 1197 VL53L0X_Error VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1198 uint8_t *pXTalkCompensationEnable);
johnAlexander 0:c523920bcc09 1199 VL53L0X_Error VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1200 VL53L0X_Error VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
johnAlexander 0:c523920bcc09 1201 uint8_t *pPhaseCal);
johnAlexander 0:c523920bcc09 1202 VL53L0X_Error VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1203 uint32_t *refSpadCount, uint8_t *isApertureSpads);
johnAlexander 0:c523920bcc09 1204 VL53L0X_Error VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev, uint8_t DeviceAddress);
johnAlexander 0:c523920bcc09 1205 VL53L0X_Error VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
johnAlexander 0:c523920bcc09 1206 VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
johnAlexander 0:c523920bcc09 1207 VL53L0X_InterruptPolarity Polarity);
johnAlexander 0:c523920bcc09 1208 VL53L0X_Error VL53L0X_GetFractionEnable(VL53L0X_DEV Dev, uint8_t *pEnabled);
johnAlexander 0:c523920bcc09 1209 VL53L0X_Error VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1210 VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled);
johnAlexander 0:c523920bcc09 1211 VL53L0X_Error VL53L0X_SetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1212 uint32_t MeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1213 VL53L0X_Error VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1214 uint8_t LimitCheckEnable);
johnAlexander 0:c523920bcc09 1215 VL53L0X_Error VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1216 FixPoint1616_t LimitCheckValue);
johnAlexander 0:c523920bcc09 1217 VL53L0X_Error VL53L0X_StopMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1218 VL53L0X_Error VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1219 uint32_t *pStopStatus);
johnAlexander 0:c523920bcc09 1220 VL53L0X_Error VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1221 VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriod);
johnAlexander 0:c523920bcc09 1222
johnAlexander 0:c523920bcc09 1223 /* api_core.h functions */
johnAlexander 0:c523920bcc09 1224 VL53L0X_Error VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option);
johnAlexander 0:c523920bcc09 1225 VL53L0X_Error VL53L0X_device_read_strobe(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1226 VL53L0X_Error VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1227 uint32_t *pMeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1228 VL53L0X_Error VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1229 VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1230 uint8_t VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg);
johnAlexander 0:c523920bcc09 1231 uint32_t VL53L0X_decode_timeout(uint16_t encoded_timeout);
johnAlexander 0:c523920bcc09 1232 uint32_t VL53L0X_calc_timeout_us(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1233 uint16_t timeout_period_mclks,
johnAlexander 0:c523920bcc09 1234 uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1235 uint32_t VL53L0X_calc_macro_period_ps(VL53L0X_DEV Dev, uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1236 VL53L0X_Error VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1237 VL53L0X_Error VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1238 uint8_t *pTuningSettingBuffer);
johnAlexander 0:c523920bcc09 1239 VL53L0X_Error VL53L0X_get_pal_range_status(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1240 uint8_t DeviceRangeStatus,
johnAlexander 0:c523920bcc09 1241 FixPoint1616_t SignalRate,
johnAlexander 0:c523920bcc09 1242 uint16_t EffectiveSpadRtnCount,
johnAlexander 0:c523920bcc09 1243 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1244 uint8_t *pPalRangeStatus);
johnAlexander 0:c523920bcc09 1245 VL53L0X_Error VL53L0X_calc_sigma_estimate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1246 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1247 FixPoint1616_t *pSigmaEstimate,
johnAlexander 0:c523920bcc09 1248 uint32_t *pDmax_mm);
johnAlexander 0:c523920bcc09 1249 VL53L0X_Error VL53L0X_get_total_signal_rate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1250 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1251 FixPoint1616_t *ptotal_signal_rate_mcps);
johnAlexander 0:c523920bcc09 1252 VL53L0X_Error VL53L0X_get_total_xtalk_rate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1253 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1254 FixPoint1616_t *ptotal_xtalk_rate_mcps);
johnAlexander 0:c523920bcc09 1255 uint32_t VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1256 uint32_t timeout_period_us,
johnAlexander 0:c523920bcc09 1257 uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1258 uint32_t VL53L0X_isqrt(uint32_t num);
johnAlexander 0:c523920bcc09 1259 VL53L0X_Error VL53L0X_calc_dmax(
johnAlexander 0:c523920bcc09 1260 VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1261 FixPoint1616_t totalSignalRate_mcps,
johnAlexander 0:c523920bcc09 1262 FixPoint1616_t totalCorrSignalRate_mcps,
johnAlexander 0:c523920bcc09 1263 FixPoint1616_t pwMult,
johnAlexander 0:c523920bcc09 1264 uint32_t sigmaEstimateP1,
johnAlexander 0:c523920bcc09 1265 FixPoint1616_t sigmaEstimateP2,
johnAlexander 0:c523920bcc09 1266 uint32_t peakVcselDuration_us,
johnAlexander 0:c523920bcc09 1267 uint32_t *pdmax_mm);
johnAlexander 0:c523920bcc09 1268 VL53L0X_Error VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1269 uint32_t MeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1270 VL53L0X_Error get_sequence_step_timeout(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1271 VL53L0X_SequenceStepId SequenceStepId,
johnAlexander 0:c523920bcc09 1272 uint32_t *pTimeOutMicroSecs);
johnAlexander 0:c523920bcc09 1273 VL53L0X_Error set_sequence_step_timeout(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1274 VL53L0X_SequenceStepId SequenceStepId,
johnAlexander 0:c523920bcc09 1275 uint32_t TimeOutMicroSecs);
johnAlexander 0:c523920bcc09 1276 uint16_t VL53L0X_encode_timeout(uint32_t timeout_macro_clks);
johnAlexander 0:c523920bcc09 1277 VL53L0X_Error VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1278 VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1279 uint8_t VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1280
johnAlexander 0:c523920bcc09 1281 /* api_calibration.h functions */
johnAlexander 0:c523920bcc09 1282 VL53L0X_Error VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1283 VL53L0X_Error VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1284 int32_t *pOffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1285 VL53L0X_Error VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1286 int32_t OffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1287 VL53L0X_Error VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1288 uint32_t *refSpadCount,
johnAlexander 0:c523920bcc09 1289 uint8_t *isApertureSpads);
johnAlexander 0:c523920bcc09 1290 VL53L0X_Error VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1291 uint8_t *pVhvSettings, uint8_t *pPhaseCal, uint8_t get_data_enable);
johnAlexander 0:c523920bcc09 1292 VL53L0X_Error VL53L0X_perform_vhv_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1293 uint8_t *pVhvSettings, const uint8_t get_data_enable,
johnAlexander 0:c523920bcc09 1294 const uint8_t restore_config);
johnAlexander 0:c523920bcc09 1295 VL53L0X_Error VL53L0X_perform_single_ref_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1296 uint8_t vhv_init_byte);
johnAlexander 0:c523920bcc09 1297 VL53L0X_Error VL53L0X_ref_calibration_io(VL53L0X_DEV Dev, uint8_t read_not_write,
johnAlexander 0:c523920bcc09 1298 uint8_t VhvSettings, uint8_t PhaseCal,
johnAlexander 0:c523920bcc09 1299 uint8_t *pVhvSettings, uint8_t *pPhaseCal,
johnAlexander 0:c523920bcc09 1300 const uint8_t vhv_enable, const uint8_t phase_enable);
johnAlexander 0:c523920bcc09 1301 VL53L0X_Error VL53L0X_perform_phase_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1302 uint8_t *pPhaseCal, const uint8_t get_data_enable,
johnAlexander 0:c523920bcc09 1303 const uint8_t restore_config);
johnAlexander 0:c523920bcc09 1304 VL53L0X_Error enable_ref_spads(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1305 uint8_t apertureSpads,
johnAlexander 0:c523920bcc09 1306 uint8_t goodSpadArray[],
johnAlexander 0:c523920bcc09 1307 uint8_t spadArray[],
johnAlexander 0:c523920bcc09 1308 uint32_t size,
johnAlexander 0:c523920bcc09 1309 uint32_t start,
johnAlexander 0:c523920bcc09 1310 uint32_t offset,
johnAlexander 0:c523920bcc09 1311 uint32_t spadCount,
johnAlexander 0:c523920bcc09 1312 uint32_t *lastSpad);
johnAlexander 0:c523920bcc09 1313 void get_next_good_spad(uint8_t goodSpadArray[], uint32_t size,
johnAlexander 0:c523920bcc09 1314 uint32_t curr, int32_t *next);
johnAlexander 0:c523920bcc09 1315 uint8_t is_aperture(uint32_t spadIndex);
johnAlexander 0:c523920bcc09 1316 VL53L0X_Error enable_spad_bit(uint8_t spadArray[], uint32_t size,
johnAlexander 0:c523920bcc09 1317 uint32_t spadIndex);
johnAlexander 0:c523920bcc09 1318 VL53L0X_Error set_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray);
johnAlexander 0:c523920bcc09 1319 VL53L0X_Error get_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray);
johnAlexander 0:c523920bcc09 1320 VL53L0X_Error perform_ref_signal_measurement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1321 uint16_t *refSignalRate);
johnAlexander 0:c523920bcc09 1322 VL53L0X_Error VL53L0X_set_reference_spads(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1323 uint32_t count, uint8_t isApertureSpads);
johnAlexander 0:c523920bcc09 1324
johnAlexander 0:c523920bcc09 1325 /* api_strings.h functions */
johnAlexander 0:c523920bcc09 1326 VL53L0X_Error VL53L0X_get_device_info(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1327 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1328 VL53L0X_Error VL53L0X_check_part_used(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1329 uint8_t *Revision,
johnAlexander 0:c523920bcc09 1330 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1331
johnAlexander 0:c523920bcc09 1332 /* Read function of the ID device */
johnAlexander 4:4e1576541eed 1333 virtual int ReadID(uint8_t *id);
johnAlexander 0:c523920bcc09 1334
johnAlexander 0:c523920bcc09 1335 VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1336 VL53L0X_Error WaitStopCompleted(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1337
johnAlexander 0:c523920bcc09 1338 /* Write and read functions from I2C */
johnAlexander 0:c523920bcc09 1339
johnAlexander 0:c523920bcc09 1340 VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV dev, uint8_t index, uint8_t data);
johnAlexander 0:c523920bcc09 1341 VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV dev, uint8_t index, uint16_t data);
johnAlexander 0:c523920bcc09 1342 VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV dev, uint8_t index, uint32_t data);
johnAlexander 0:c523920bcc09 1343 VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV dev, uint8_t index, uint8_t *data);
johnAlexander 0:c523920bcc09 1344 VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV dev, uint8_t index, uint16_t *data);
johnAlexander 0:c523920bcc09 1345 VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV dev, uint8_t index, uint32_t *data);
johnAlexander 0:c523920bcc09 1346 VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV dev, uint8_t index, uint8_t AndData, uint8_t OrData);
johnAlexander 0:c523920bcc09 1347
johnAlexander 0:c523920bcc09 1348 VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
johnAlexander 0:c523920bcc09 1349 VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
johnAlexander 0:c523920bcc09 1350
johnAlexander 0:c523920bcc09 1351 VL53L0X_Error VL53L0X_I2CWrite(uint8_t dev, uint8_t index, uint8_t *data, uint16_t number_of_bytes);
johnAlexander 0:c523920bcc09 1352 VL53L0X_Error VL53L0X_I2CRead(uint8_t dev, uint8_t index, uint8_t *data, uint16_t number_of_bytes);
johnAlexander 0:c523920bcc09 1353
johnAlexander 0:c523920bcc09 1354 VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev); /* usually best implemented as a real function */
johnAlexander 0:c523920bcc09 1355
johnAlexander 0:c523920bcc09 1356 int IsPresent()
johnAlexander 0:c523920bcc09 1357 {
johnAlexander 0:c523920bcc09 1358 int status;
johnAlexander 0:c523920bcc09 1359
johnAlexander 4:4e1576541eed 1360 status=ReadID((uint8_t *)MyDevice.I2cDevAddr);
johnAlexander 0:c523920bcc09 1361 if(status)
johnAlexander 0:c523920bcc09 1362 VL53L0X_ErrLog("Failed to read ID device. Device not present!\n\r");
johnAlexander 0:c523920bcc09 1363 return status;
johnAlexander 0:c523920bcc09 1364 }
johnAlexander 0:c523920bcc09 1365 int StopRangeMeasurement(OperatingMode operating_mode);
johnAlexander 0:c523920bcc09 1366 int GetRangeMeas(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 1367 int RangeSetLowThreshold(uint16_t threshold);
johnAlexander 0:c523920bcc09 1368 int RangeSetHighThreshold(uint16_t threshold);
johnAlexander 0:c523920bcc09 1369 int GetRangeError(VL53L0X_RangingMeasurementData_t *Data, VL53L0X_RangingMeasurementData_t RangeData);
johnAlexander 0:c523920bcc09 1370 int RangeMeasPollSingleShot();
johnAlexander 0:c523920bcc09 1371 int RangeMeasPollContinuousMode();
johnAlexander 0:c523920bcc09 1372 int RangeMeasIntContinuousMode(void (*fptr)(void));
johnAlexander 0:c523920bcc09 1373
johnAlexander 0:c523920bcc09 1374
johnAlexander 0:c523920bcc09 1375 VL53L0X_DeviceInfo_t DeviceInfo;
johnAlexander 0:c523920bcc09 1376
johnAlexander 0:c523920bcc09 1377 /* IO Device */
johnAlexander 0:c523920bcc09 1378 DevI2C &dev_i2c;
johnAlexander 0:c523920bcc09 1379 /* Digital out pin */
johnAlexander 0:c523920bcc09 1380 DigitalOut *gpio0;
johnAlexander 0:c523920bcc09 1381 /* GPIO expander */
johnAlexander 0:c523920bcc09 1382 STMPE1600DigiOut *expgpio0;
johnAlexander 0:c523920bcc09 1383 /* Measure detection IRQ */
johnAlexander 0:c523920bcc09 1384 InterruptIn *gpio1Int;
johnAlexander 0:c523920bcc09 1385 /* Device data */
johnAlexander 0:c523920bcc09 1386 VL53L0X_Dev_t MyDevice;
johnAlexander 0:c523920bcc09 1387 VL53L0X_DEV Device;
johnAlexander 0:c523920bcc09 1388 };
johnAlexander 0:c523920bcc09 1389
johnAlexander 0:c523920bcc09 1390
johnAlexander 0:c523920bcc09 1391 #endif /* _VL53L0X_CLASS_H_ */
johnAlexander 0:c523920bcc09 1392
johnAlexander 0:c523920bcc09 1393