ST / X_NUCLEO_53L1A1

Library for use with VL53L1X, intended to represent the Proximity sensor expansion board with the same name.

Dependencies:   VL53L1X_mbed

Dependents:   HelloWorld_53L1A1 VL53L1A1_Simple_Ranging_With_One_Device VL53L1A1_Simple_Ranging_With_All_Devices VL53L1X_Ranging_With_Multiple_Devices_MbedOS ... more

Components/VL53L0X/vl53l0x_class.h@9:367d1f390cb2, 2017-06-07 (annotated)

Committer:
johnAlexander
Date:
Wed Jun 07 12:53:53 2017 +0000
Revision:
9:367d1f390cb2
Parent:
8:8d27ebb4e1eb
Child:
10:faf8d62ce6d1
Enable support for left and right sensors. Tested with mbed_143.

Who changed what in which revision?

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