Mike Fiore / X_NUCLEO_53L0A1

modified to work with MultiTech mDot on UDK2.0

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

Fork of X_NUCLEO_53L0A1 by ST

Components/VL53L0X/vl53l0x_class.h@2:58b5e9097aa3, 2016-12-01 (annotated)

Committer:
johnAlexander
Date:
Thu Dec 01 14:17:46 2016 +0000
Revision:
2:58b5e9097aa3
Parent:
0:c523920bcc09
Child:
3:613d7f1ef60e
Use ST_INTERFACES package to access RangeSensor abstract class.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
johnAlexander 0:c523920bcc09 1 /*******************************************************************************
johnAlexander 2:58b5e9097aa3 2 Copyright © 2016, STMicroelectronics International N.V.
johnAlexander 0:c523920bcc09 3 All rights reserved.
johnAlexander 0:c523920bcc09 4
johnAlexander 0:c523920bcc09 5 Redistribution and use in source and binary forms, with or without
johnAlexander 0:c523920bcc09 6 modification, are permitted provided that the following conditions are met:
johnAlexander 0:c523920bcc09 7 * Redistributions of source code must retain the above copyright
johnAlexander 0:c523920bcc09 8 notice, this list of conditions and the following disclaimer.
johnAlexander 0:c523920bcc09 9 * Redistributions in binary form must reproduce the above copyright
johnAlexander 0:c523920bcc09 10 notice, this list of conditions and the following disclaimer in the
johnAlexander 0:c523920bcc09 11 documentation and/or other materials provided with the distribution.
johnAlexander 0:c523920bcc09 12 * Neither the name of STMicroelectronics nor the
johnAlexander 0:c523920bcc09 13 names of its contributors may be used to endorse or promote products
johnAlexander 0:c523920bcc09 14 derived from this software without specific prior written permission.
johnAlexander 0:c523920bcc09 15
johnAlexander 0:c523920bcc09 16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
johnAlexander 0:c523920bcc09 17 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
johnAlexander 0:c523920bcc09 18 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
johnAlexander 0:c523920bcc09 19 NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
johnAlexander 0:c523920bcc09 20 IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
johnAlexander 0:c523920bcc09 21 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
johnAlexander 0:c523920bcc09 22 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
johnAlexander 0:c523920bcc09 23 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
johnAlexander 0:c523920bcc09 24 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
johnAlexander 0:c523920bcc09 25 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
johnAlexander 0:c523920bcc09 26 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
johnAlexander 0:c523920bcc09 27 *****************************************************************************/
johnAlexander 0:c523920bcc09 28
johnAlexander 0:c523920bcc09 29 #ifndef __VL53L0X_CLASS_H
johnAlexander 0:c523920bcc09 30 #define __VL53L0X_CLASS_H
johnAlexander 0:c523920bcc09 31
johnAlexander 0:c523920bcc09 32
johnAlexander 0:c523920bcc09 33 #ifdef _MSC_VER
johnAlexander 0:c523920bcc09 34 # ifdef VL53L0X_API_EXPORTS
johnAlexander 0:c523920bcc09 35 # define VL53L0X_API __declspec(dllexport)
johnAlexander 0:c523920bcc09 36 # else
johnAlexander 0:c523920bcc09 37 # define VL53L0X_API
johnAlexander 0:c523920bcc09 38 # endif
johnAlexander 0:c523920bcc09 39 #else
johnAlexander 0:c523920bcc09 40 # define VL53L0X_API
johnAlexander 0:c523920bcc09 41 #endif
johnAlexander 0:c523920bcc09 42
johnAlexander 0:c523920bcc09 43
johnAlexander 0:c523920bcc09 44 /* Includes ------------------------------------------------------------------*/
johnAlexander 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 0:c523920bcc09 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 2:58b5e9097aa3 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 0:c523920bcc09 354 }
johnAlexander 0:c523920bcc09 355
johnAlexander 0:c523920bcc09 356 /**
johnAlexander 0:c523920bcc09 357 * @brief PowerOff the sensor
johnAlexander 0:c523920bcc09 358 * @return void
johnAlexander 0:c523920bcc09 359 */
johnAlexander 0:c523920bcc09 360 /* turns off the sensor */
johnAlexander 0:c523920bcc09 361 void VL53L0X_Off(void)
johnAlexander 0:c523920bcc09 362 {
johnAlexander 0:c523920bcc09 363 if (gpio0)
johnAlexander 0:c523920bcc09 364 *gpio0 = 0;
johnAlexander 0:c523920bcc09 365 else if (expgpio0)
johnAlexander 0:c523920bcc09 366 *expgpio0 = 0;
johnAlexander 0:c523920bcc09 367 }
johnAlexander 0:c523920bcc09 368
johnAlexander 0:c523920bcc09 369 /**
johnAlexander 0:c523920bcc09 370 * @brief Initialize the sensor with default values
johnAlexander 0:c523920bcc09 371 * @return 0 on Success
johnAlexander 2:58b5e9097aa3 372 */
johnAlexander 0:c523920bcc09 373 int InitSensor(uint8_t NewAddr);
johnAlexander 0:c523920bcc09 374
johnAlexander 0:c523920bcc09 375
johnAlexander 0:c523920bcc09 376 /**
johnAlexander 0:c523920bcc09 377 * @brief Start the measure indicated by operating mode
johnAlexander 0:c523920bcc09 378 * @param[in] operating_mode specifies requested measure
johnAlexander 0:c523920bcc09 379 * @param[in] fptr specifies call back function must be !NULL in case of interrupt measure
johnAlexander 0:c523920bcc09 380 * @return 0 on Success
johnAlexander 0:c523920bcc09 381 */
johnAlexander 0:c523920bcc09 382 int StartMeasurement(OperatingMode operating_mode, void (*fptr)(void));
johnAlexander 0:c523920bcc09 383
johnAlexander 0:c523920bcc09 384 /**
johnAlexander 0:c523920bcc09 385 * @brief Get results for the measure indicated by operating mode
johnAlexander 0:c523920bcc09 386 * @param[in] operating_mode specifies requested measure results
johnAlexander 0:c523920bcc09 387 * @param[out] Data pointer to the MeasureData_t structure to read data in to
johnAlexander 0:c523920bcc09 388 * @return 0 on Success
johnAlexander 0:c523920bcc09 389 */
johnAlexander 0:c523920bcc09 390 int GetMeasurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 391
johnAlexander 0:c523920bcc09 392 /**
johnAlexander 0:c523920bcc09 393 * @brief Stop the currently running measure indicate by operating_mode
johnAlexander 0:c523920bcc09 394 * @param[in] operating_mode specifies requested measure to stop
johnAlexander 0:c523920bcc09 395 * @return 0 on Success
johnAlexander 0:c523920bcc09 396 */
johnAlexander 0:c523920bcc09 397 int StopMeasurement(OperatingMode operating_mode);
johnAlexander 0:c523920bcc09 398
johnAlexander 0:c523920bcc09 399 /**
johnAlexander 0:c523920bcc09 400 * @brief Interrupt handling func to be called by user after an INT is occourred
johnAlexander 0:c523920bcc09 401 * @param[in] opeating_mode indicating the in progress measure
johnAlexander 0:c523920bcc09 402 * @param[out] Data pointer to the MeasureData_t structure to read data in to
johnAlexander 0:c523920bcc09 403 * @return 0 on Success
johnAlexander 0:c523920bcc09 404 */
johnAlexander 0:c523920bcc09 405 int HandleIRQ(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 406
johnAlexander 0:c523920bcc09 407 /**
johnAlexander 0:c523920bcc09 408 * @brief Enable interrupt measure IRQ
johnAlexander 0:c523920bcc09 409 * @return 0 on Success
johnAlexander 0:c523920bcc09 410 */
johnAlexander 0:c523920bcc09 411 void EnableInterruptMeasureDetectionIRQ(void)
johnAlexander 0:c523920bcc09 412 {
johnAlexander 0:c523920bcc09 413 if (gpio1Int != NULL) gpio1Int->enable_irq();
johnAlexander 0:c523920bcc09 414 }
johnAlexander 0:c523920bcc09 415
johnAlexander 0:c523920bcc09 416 /**
johnAlexander 0:c523920bcc09 417 * @brief Disable interrupt measure IRQ
johnAlexander 0:c523920bcc09 418 * @return 0 on Success
johnAlexander 0:c523920bcc09 419 */
johnAlexander 0:c523920bcc09 420 void DisableInterruptMeasureDetectionIRQ(void)
johnAlexander 0:c523920bcc09 421 {
johnAlexander 0:c523920bcc09 422 if (gpio1Int != NULL) gpio1Int->disable_irq();
johnAlexander 0:c523920bcc09 423 }
johnAlexander 0:c523920bcc09 424 /*** End High level API ***/
johnAlexander 0:c523920bcc09 425
johnAlexander 0:c523920bcc09 426 /**
johnAlexander 0:c523920bcc09 427 * @brief Attach a function to call when an interrupt is detected, i.e. measurement is ready
johnAlexander 0:c523920bcc09 428 * @param[in] fptr pointer to call back function to be called whenever an interrupt occours
johnAlexander 0:c523920bcc09 429 * @return 0 on Success
johnAlexander 0:c523920bcc09 430 */
johnAlexander 0:c523920bcc09 431 void AttachInterruptMeasureDetectionIRQ(void (*fptr)(void))
johnAlexander 0:c523920bcc09 432 {
johnAlexander 0:c523920bcc09 433 if (gpio1Int != NULL) gpio1Int->rise(fptr);
johnAlexander 0:c523920bcc09 434 }
johnAlexander 0:c523920bcc09 435
johnAlexander 0:c523920bcc09 436 /**
johnAlexander 0:c523920bcc09 437 * @brief Check the sensor presence
johnAlexander 0:c523920bcc09 438 * @return 1 when device is present
johnAlexander 0:c523920bcc09 439 */
johnAlexander 0:c523920bcc09 440 unsigned Present()
johnAlexander 0:c523920bcc09 441 {
johnAlexander 0:c523920bcc09 442 // return Device->Present;
johnAlexander 0:c523920bcc09 443 return 1;
johnAlexander 0:c523920bcc09 444 }
johnAlexander 0:c523920bcc09 445
johnAlexander 0:c523920bcc09 446 /** Wrapper functions */
johnAlexander 0:c523920bcc09 447 /** @defgroup api_init Init functions
johnAlexander 0:c523920bcc09 448 * @brief API init functions
johnAlexander 0:c523920bcc09 449 * @ingroup api_hl
johnAlexander 0:c523920bcc09 450 * @{
johnAlexander 0:c523920bcc09 451 */
johnAlexander 0:c523920bcc09 452 /**
johnAlexander 0:c523920bcc09 453 * @brief Wait for device booted after chip enable (hardware standby)
johnAlexander 0:c523920bcc09 454 * @par Function Description
johnAlexander 0:c523920bcc09 455 * After Chip enable Application you can also simply wait at least 1ms to ensure device is ready
johnAlexander 0:c523920bcc09 456 * @warning After device chip enable (gpio0) de-asserted user must wait gpio1 to get asserted (hardware standby).
johnAlexander 0:c523920bcc09 457 * or wait at least 400usec prior to do any low level access or api call .
johnAlexander 0:c523920bcc09 458 *
johnAlexander 0:c523920bcc09 459 * This function implements polling for standby but you must ensure 400usec from chip enable passed\n
johnAlexander 0:c523920bcc09 460 * @warning if device get prepared @a VL53L0X_Prepare() re-using these function can hold indefinitely\n
johnAlexander 0:c523920bcc09 461 *
johnAlexander 0:c523920bcc09 462 * @param void
johnAlexander 0:c523920bcc09 463 * @return 0 on success
johnAlexander 0:c523920bcc09 464 */
johnAlexander 0:c523920bcc09 465 int WaitDeviceBooted()
johnAlexander 0:c523920bcc09 466 {
johnAlexander 0:c523920bcc09 467 return VL53L0X_WaitDeviceBooted(Device);
johnAlexander 0:c523920bcc09 468 // return 1;
johnAlexander 0:c523920bcc09 469 }
johnAlexander 0:c523920bcc09 470
johnAlexander 0:c523920bcc09 471 /**
johnAlexander 0:c523920bcc09 472 *
johnAlexander 0:c523920bcc09 473 * @brief One time device initialization
johnAlexander 0:c523920bcc09 474 *
johnAlexander 0:c523920bcc09 475 * To be called once and only once after device is brought out of reset (Chip enable) and booted see @a VL6180x_WaitDeviceBooted()
johnAlexander 0:c523920bcc09 476 *
johnAlexander 0:c523920bcc09 477 * @par Function Description
johnAlexander 0:c523920bcc09 478 * When not used after a fresh device "power up" or reset, it may return @a #CALIBRATION_WARNING
johnAlexander 0:c523920bcc09 479 * meaning wrong calibration data may have been fetched from device that can result in ranging offset error\n
johnAlexander 0:c523920bcc09 480 * If application cannot execute device reset or need to run VL6180x_InitData multiple time
johnAlexander 0:c523920bcc09 481 * then it must ensure proper offset calibration saving and restore on its own
johnAlexander 0:c523920bcc09 482 * by using @a VL6180x_GetOffsetCalibrationData() on first power up and then @a VL6180x_SetOffsetCalibrationData() all all subsequent init
johnAlexander 0:c523920bcc09 483 *
johnAlexander 0:c523920bcc09 484 * @param void
johnAlexander 0:c523920bcc09 485 * @return 0 on success, @a #CALIBRATION_WARNING if failed
johnAlexander 0:c523920bcc09 486 */
johnAlexander 2:58b5e9097aa3 487 // virtual int Init()
johnAlexander 2:58b5e9097aa3 488 virtual int Init(void * NewAddr)
johnAlexander 0:c523920bcc09 489 {
johnAlexander 2:58b5e9097aa3 490 // return VL53L0X_DataInit(&MyDevice);
johnAlexander 2:58b5e9097aa3 491 return VL53L0X_DataInit(Device);
johnAlexander 2:58b5e9097aa3 492 /*
johnAlexander 2:58b5e9097aa3 493 int status;
johnAlexander 2:58b5e9097aa3 494
johnAlexander 2:58b5e9097aa3 495 VL6180x_Off();
johnAlexander 2:58b5e9097aa3 496 VL6180x_On();
johnAlexander 2:58b5e9097aa3 497
johnAlexander 2:58b5e9097aa3 498 status=VL6180x_WaitDeviceBooted(Device);
johnAlexander 2:58b5e9097aa3 499 if(status) {
johnAlexander 2:58b5e9097aa3 500 VL6180x_ErrLog("WaitDeviceBooted fail\n\r");
johnAlexander 2:58b5e9097aa3 501 }
johnAlexander 2:58b5e9097aa3 502 status=IsPresent();
johnAlexander 2:58b5e9097aa3 503 if(!status)
johnAlexander 2:58b5e9097aa3 504 {
johnAlexander 2:58b5e9097aa3 505 Device->Present=1;
johnAlexander 2:58b5e9097aa3 506 VL6180x_InitData(Device);
johnAlexander 2:58b5e9097aa3 507 if(status)
johnAlexander 2:58b5e9097aa3 508 {
johnAlexander 2:58b5e9097aa3 509 printf("Failed to init VL6180X sensor!\n\r");
johnAlexander 2:58b5e9097aa3 510 return status;
johnAlexander 2:58b5e9097aa3 511 }
johnAlexander 2:58b5e9097aa3 512 status=Prepare();
johnAlexander 2:58b5e9097aa3 513 if(status)
johnAlexander 2:58b5e9097aa3 514 {
johnAlexander 2:58b5e9097aa3 515 printf("Failed to prepare VL6180X!\n\r");
johnAlexander 2:58b5e9097aa3 516 return status;
johnAlexander 2:58b5e9097aa3 517 }
johnAlexander 2:58b5e9097aa3 518 if(*(uint8_t*)NewAddr!=DEFAULT_DEVICE_ADDRESS)
johnAlexander 2:58b5e9097aa3 519 {
johnAlexander 2:58b5e9097aa3 520 status=SetI2CAddress(*(uint8_t*)NewAddr);
johnAlexander 2:58b5e9097aa3 521 if(status)
johnAlexander 2:58b5e9097aa3 522 {
johnAlexander 2:58b5e9097aa3 523 printf("Failed to change I2C address!\n\r");
johnAlexander 2:58b5e9097aa3 524 return status;
johnAlexander 2:58b5e9097aa3 525 }
johnAlexander 2:58b5e9097aa3 526 }
johnAlexander 2:58b5e9097aa3 527 Device->Ready=1;
johnAlexander 2:58b5e9097aa3 528 }
johnAlexander 2:58b5e9097aa3 529 return status;
johnAlexander 2:58b5e9097aa3 530 */
johnAlexander 0:c523920bcc09 531 }
johnAlexander 0:c523920bcc09 532
johnAlexander 0:c523920bcc09 533 /**
johnAlexander 0:c523920bcc09 534 * @brief Configure GPIO1 function and set polarity.
johnAlexander 0:c523920bcc09 535 * @par Function Description
johnAlexander 0:c523920bcc09 536 * To be used prior to arm single shot measure or start continuous mode.
johnAlexander 0:c523920bcc09 537 *
johnAlexander 0:c523920bcc09 538 * The function uses @a VL6180x_SetupGPIOx() for setting gpio 1.
johnAlexander 0:c523920bcc09 539 * @warning changing polarity can generate a spurious interrupt on pins.
johnAlexander 0:c523920bcc09 540 * It sets an interrupt flags condition that must be cleared to avoid polling hangs. \n
johnAlexander 0:c523920bcc09 541 * It is safe to run VL6180x_ClearAllInterrupt() just after.
johnAlexander 0:c523920bcc09 542 *
johnAlexander 0:c523920bcc09 543 * @param IntFunction The interrupt functionality to use one of :\n
johnAlexander 0:c523920bcc09 544 * @a #GPIOx_SELECT_OFF \n
johnAlexander 0:c523920bcc09 545 * @a #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT
johnAlexander 0:c523920bcc09 546 * @param ActiveHigh The interrupt line polarity see ::IntrPol_e
johnAlexander 0:c523920bcc09 547 * use @a #INTR_POL_LOW (falling edge) or @a #INTR_POL_HIGH (rising edge)
johnAlexander 0:c523920bcc09 548 * @return 0 on success
johnAlexander 0:c523920bcc09 549 */
johnAlexander 0:c523920bcc09 550 int SetupGPIO1(uint8_t InitFunction, int ActiveHigh)
johnAlexander 0:c523920bcc09 551 {
johnAlexander 0:c523920bcc09 552 // return VL6180x_SetupGPIO1(Device, InitFunction, ActiveHigh);
johnAlexander 0:c523920bcc09 553 return 1;
johnAlexander 0:c523920bcc09 554 }
johnAlexander 0:c523920bcc09 555
johnAlexander 0:c523920bcc09 556 /**
johnAlexander 0:c523920bcc09 557 * @brief Prepare device for operation
johnAlexander 0:c523920bcc09 558 * @par Function Description
johnAlexander 0:c523920bcc09 559 * Does static initialization and reprogram common default settings \n
johnAlexander 0:c523920bcc09 560 * Device is prepared for new measure, ready single shot ranging or ALS typical polling operation\n
johnAlexander 0:c523920bcc09 561 * After prepare user can : \n
johnAlexander 0:c523920bcc09 562 * @li Call other API function to set other settings\n
johnAlexander 0:c523920bcc09 563 * @li Configure the interrupt pins, etc... \n
johnAlexander 0:c523920bcc09 564 * @li Then start ranging or ALS operations in single shot or continuous mode
johnAlexander 0:c523920bcc09 565 *
johnAlexander 0:c523920bcc09 566 * @param void
johnAlexander 0:c523920bcc09 567 * @return 0 on success
johnAlexander 0:c523920bcc09 568 */
johnAlexander 0:c523920bcc09 569 int Prepare()
johnAlexander 0:c523920bcc09 570 {
johnAlexander 0:c523920bcc09 571 // return VL6180x_Prepare(Device);
johnAlexander 0:c523920bcc09 572 // taken from rangingTest() in vl53l0x_SingleRanging_Example.c
johnAlexander 0:c523920bcc09 573 VL53L0X_Error Status = VL53L0X_ERROR_NONE;
johnAlexander 0:c523920bcc09 574 uint32_t refSpadCount;
johnAlexander 0:c523920bcc09 575 uint8_t isApertureSpads;
johnAlexander 0:c523920bcc09 576 uint8_t VhvSettings;
johnAlexander 0:c523920bcc09 577 uint8_t PhaseCal;
johnAlexander 0:c523920bcc09 578
johnAlexander 0:c523920bcc09 579 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 580 {
johnAlexander 0:c523920bcc09 581 printf ("Call of VL53L0X_StaticInit\n");
johnAlexander 0:c523920bcc09 582 Status = VL53L0X_StaticInit(Device); // Device Initialization
johnAlexander 0:c523920bcc09 583 }
johnAlexander 0:c523920bcc09 584
johnAlexander 0:c523920bcc09 585 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 586 {
johnAlexander 0:c523920bcc09 587 printf ("Call of VL53L0X_PerformRefCalibration\n");
johnAlexander 0:c523920bcc09 588 Status = VL53L0X_PerformRefCalibration(Device,
johnAlexander 0:c523920bcc09 589 &VhvSettings, &PhaseCal); // Device Initialization
johnAlexander 0:c523920bcc09 590 }
johnAlexander 0:c523920bcc09 591
johnAlexander 0:c523920bcc09 592 if(Status == VL53L0X_ERROR_NONE)
johnAlexander 0:c523920bcc09 593 {
johnAlexander 0:c523920bcc09 594 printf ("Call of VL53L0X_PerformRefSpadManagement\n");
johnAlexander 0:c523920bcc09 595 Status = VL53L0X_PerformRefSpadManagement(Device,
johnAlexander 0:c523920bcc09 596 &refSpadCount, &isApertureSpads); // Device Initialization
johnAlexander 0:c523920bcc09 597 // printf ("refSpadCount = %d, isApertureSpads = %d\n", refSpadCount, isApertureSpads);
johnAlexander 0:c523920bcc09 598 }
johnAlexander 0:c523920bcc09 599
johnAlexander 0:c523920bcc09 600 return Status;
johnAlexander 0:c523920bcc09 601 }
johnAlexander 0:c523920bcc09 602
johnAlexander 0:c523920bcc09 603 /**
johnAlexander 0:c523920bcc09 604 * @brief Start continuous ranging mode
johnAlexander 0:c523920bcc09 605 *
johnAlexander 0:c523920bcc09 606 * @details End user should ensure device is in idle state and not already running
johnAlexander 0:c523920bcc09 607 * @return 0 on success
johnAlexander 0:c523920bcc09 608 */
johnAlexander 0:c523920bcc09 609 int RangeStartContinuousMode()
johnAlexander 0:c523920bcc09 610 {
johnAlexander 0:c523920bcc09 611 // return VL6180x_RangeStartContinuousMode(Device);
johnAlexander 0:c523920bcc09 612 return 1;
johnAlexander 0:c523920bcc09 613 }
johnAlexander 0:c523920bcc09 614
johnAlexander 0:c523920bcc09 615 /**
johnAlexander 0:c523920bcc09 616 * @brief Start single shot ranging measure
johnAlexander 0:c523920bcc09 617 *
johnAlexander 0:c523920bcc09 618 * @details End user should ensure device is in idle state and not already running
johnAlexander 0:c523920bcc09 619 * @return 0 on success
johnAlexander 0:c523920bcc09 620 */
johnAlexander 0:c523920bcc09 621 int RangeStartSingleShot()
johnAlexander 0:c523920bcc09 622 {
johnAlexander 0:c523920bcc09 623 // return VL6180x_RangeStartSingleShot(Device);
johnAlexander 0:c523920bcc09 624 return 1;
johnAlexander 0:c523920bcc09 625 }
johnAlexander 0:c523920bcc09 626
johnAlexander 0:c523920bcc09 627 /**
johnAlexander 0:c523920bcc09 628 * @brief Set maximum convergence time
johnAlexander 0:c523920bcc09 629 *
johnAlexander 0:c523920bcc09 630 * @par Function Description
johnAlexander 0:c523920bcc09 631 * Setting a low convergence time can impact maximal detectable distance.
johnAlexander 0:c523920bcc09 632 * Refer to VL6180x Datasheet Table 7 : Typical range convergence time.
johnAlexander 0:c523920bcc09 633 * A typical value for up to x3 scaling is 50 ms
johnAlexander 0:c523920bcc09 634 *
johnAlexander 0:c523920bcc09 635 * @param MaxConTime_msec
johnAlexander 0:c523920bcc09 636 * @return 0 on success. <0 on error. >0 for calibration warning status
johnAlexander 0:c523920bcc09 637 */
johnAlexander 0:c523920bcc09 638 int RangeSetMaxConvergenceTime(uint8_t MaxConTime_msec)
johnAlexander 0:c523920bcc09 639 {
johnAlexander 0:c523920bcc09 640 // return VL6180x_RangeSetMaxConvergenceTime(Device, MaxConTime_msec);
johnAlexander 0:c523920bcc09 641 return 1;
johnAlexander 0:c523920bcc09 642 }
johnAlexander 0:c523920bcc09 643
johnAlexander 0:c523920bcc09 644 /**
johnAlexander 0:c523920bcc09 645 * @brief Single shot Range measurement in polling mode.
johnAlexander 0:c523920bcc09 646 *
johnAlexander 0:c523920bcc09 647 * @par Function Description
johnAlexander 0:c523920bcc09 648 * Kick off a new single shot range then wait for ready to retrieve it by polling interrupt status \n
johnAlexander 0:c523920bcc09 649 * 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 650 * This function reference VL6180x_PollDelay(dev) porting macro/call on each polling loop,
johnAlexander 0:c523920bcc09 651 * but PollDelay(dev) may never be called if measure in ready on first poll loop \n
johnAlexander 0:c523920bcc09 652 * Should not be use in continuous mode operation as it will stop it and cause stop/start misbehaviour \n
johnAlexander 0:c523920bcc09 653 * \n This function clears Range Interrupt status , but not error one. For that uses @a VL6180x_ClearErrorInterrupt() \n
johnAlexander 0:c523920bcc09 654 * This range error is not related VL6180x_RangeData_t::errorStatus that refer measure status \n
johnAlexander 0:c523920bcc09 655 *
johnAlexander 0:c523920bcc09 656 * @param pRangeData Will be populated with the result ranging data @a VL6180x_RangeData_t
johnAlexander 0:c523920bcc09 657 * @return 0 on success , @a #RANGE_ERROR if device reports an error case in it status (not cleared) use
johnAlexander 0:c523920bcc09 658 *
johnAlexander 0:c523920bcc09 659 * \sa ::VL6180x_RangeData_t
johnAlexander 0:c523920bcc09 660 */
johnAlexander 0:c523920bcc09 661 int RangePollMeasurement(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 662 {
johnAlexander 0:c523920bcc09 663 // return VL6180x_RangePollMeasurement(Device, pRangeData);
johnAlexander 0:c523920bcc09 664 return 1;
johnAlexander 0:c523920bcc09 665 }
johnAlexander 0:c523920bcc09 666
johnAlexander 0:c523920bcc09 667 /**
johnAlexander 0:c523920bcc09 668 * @brief Check for measure readiness and get it if ready
johnAlexander 0:c523920bcc09 669 *
johnAlexander 0:c523920bcc09 670 * @par Function Description
johnAlexander 0:c523920bcc09 671 * Using this function is an alternative to @a VL6180x_RangePollMeasurement() to avoid polling operation. This is suitable for applications
johnAlexander 0:c523920bcc09 672 * 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 673 * operation is triggered by a call to @a VL6180x_RangeStartSingleShot(). Then, host CPU regularly calls @a VL6180x_RangeGetMeasurementIfReady() to
johnAlexander 0:c523920bcc09 674 * 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 675 *
johnAlexander 0:c523920bcc09 676 * @warning
johnAlexander 0:c523920bcc09 677 * This function does not re-start a new measurement : this is up to the host CPU to do it.\n
johnAlexander 0:c523920bcc09 678 * This function clears Range Interrupt for measure ready , but not error interrupts. For that, uses @a VL6180x_ClearErrorInterrupt() \n
johnAlexander 0:c523920bcc09 679 *
johnAlexander 0:c523920bcc09 680 * @param pRangeData Will be populated with the result ranging data if available
johnAlexander 0:c523920bcc09 681 * @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 682 */
johnAlexander 0:c523920bcc09 683 int RangeGetMeasurementIfReady(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 684 {
johnAlexander 0:c523920bcc09 685 // return VL6180x_RangeGetMeasurementIfReady(Device, pRangeData);
johnAlexander 0:c523920bcc09 686 return 1;
johnAlexander 0:c523920bcc09 687 }
johnAlexander 0:c523920bcc09 688
johnAlexander 0:c523920bcc09 689 /**
johnAlexander 0:c523920bcc09 690 * @brief Retrieve range measurements set from device
johnAlexander 0:c523920bcc09 691 *
johnAlexander 0:c523920bcc09 692 * @par Function Description
johnAlexander 0:c523920bcc09 693 * The measurement is made of range_mm status and error code @a VL6180x_RangeData_t \n
johnAlexander 0:c523920bcc09 694 * Based on configuration selected extra measures are included.
johnAlexander 0:c523920bcc09 695 *
johnAlexander 0:c523920bcc09 696 * @warning should not be used in continuous if wrap around filter is active \n
johnAlexander 0:c523920bcc09 697 * Does not perform any wait nor check for result availability or validity.
johnAlexander 0:c523920bcc09 698 *\sa VL6180x_RangeGetResult for "range only" measurement
johnAlexander 0:c523920bcc09 699 *
johnAlexander 0:c523920bcc09 700 * @param pRangeData Pointer to the data structure to fill up
johnAlexander 0:c523920bcc09 701 * @return 0 on success
johnAlexander 0:c523920bcc09 702 */
johnAlexander 0:c523920bcc09 703 int RangeGetMeasurement(VL53L0X_RangingMeasurementData_t *pRangeData)
johnAlexander 0:c523920bcc09 704 {
johnAlexander 0:c523920bcc09 705 // return VL6180x_RangeGetMeasurement(Device, pRangeData);
johnAlexander 0:c523920bcc09 706 return 1;
johnAlexander 0:c523920bcc09 707 }
johnAlexander 0:c523920bcc09 708
johnAlexander 0:c523920bcc09 709 /**
johnAlexander 0:c523920bcc09 710 * @brief Get ranging result and only that
johnAlexander 0:c523920bcc09 711 *
johnAlexander 0:c523920bcc09 712 * @par Function Description
johnAlexander 0:c523920bcc09 713 * Unlike @a VL6180x_RangeGetMeasurement() this function only retrieves the range in millimeter \n
johnAlexander 0:c523920bcc09 714 * It does any required up-scale translation\n
johnAlexander 0:c523920bcc09 715 * It can be called after success status polling or in interrupt mode \n
johnAlexander 0:c523920bcc09 716 * @warning these function is not doing wrap around filtering \n
johnAlexander 0:c523920bcc09 717 * This function doesn't perform any data ready check!
johnAlexander 0:c523920bcc09 718 *
johnAlexander 0:c523920bcc09 719 * @param pRange_mm Pointer to range distance
johnAlexander 0:c523920bcc09 720 * @return 0 on success
johnAlexander 0:c523920bcc09 721 */
johnAlexander 2:58b5e9097aa3 722 virtual int GetDistance(uint32_t *piData)
johnAlexander 0:c523920bcc09 723 {
johnAlexander 0:c523920bcc09 724 // return VL6180x_RangeGetResult(Device, piData);
johnAlexander 2:58b5e9097aa3 725 int status=0;
johnAlexander 2:58b5e9097aa3 726 VL53L0X_RangingMeasurementData_t pRangingMeasurementData;
johnAlexander 2:58b5e9097aa3 727
johnAlexander 2:58b5e9097aa3 728 status=StartMeasurement(range_single_shot_polling, NULL);
johnAlexander 2:58b5e9097aa3 729 if (!status) {
johnAlexander 2:58b5e9097aa3 730 status=GetMeasurement(range_single_shot_polling, &pRangingMeasurementData);
johnAlexander 2:58b5e9097aa3 731 }
johnAlexander 2:58b5e9097aa3 732 StopMeasurement(range_single_shot_polling);
johnAlexander 2:58b5e9097aa3 733 *piData = pRangingMeasurementData.RangeMilliMeter;
johnAlexander 2:58b5e9097aa3 734 return status;
johnAlexander 0:c523920bcc09 735 }
johnAlexander 0:c523920bcc09 736
johnAlexander 0:c523920bcc09 737 /**
johnAlexander 0:c523920bcc09 738 * @brief Configure ranging interrupt reported to application
johnAlexander 0:c523920bcc09 739 *
johnAlexander 0:c523920bcc09 740 * @param ConfigGpioInt Select ranging report\n select one (and only one) of:\n
johnAlexander 0:c523920bcc09 741 * @a #CONFIG_GPIO_INTERRUPT_DISABLED \n
johnAlexander 0:c523920bcc09 742 * @a #CONFIG_GPIO_INTERRUPT_LEVEL_LOW \n
johnAlexander 0:c523920bcc09 743 * @a #CONFIG_GPIO_INTERRUPT_LEVEL_HIGH \n
johnAlexander 0:c523920bcc09 744 * @a #CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW \n
johnAlexander 0:c523920bcc09 745 * @a #CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY
johnAlexander 0:c523920bcc09 746 * @return 0 on success
johnAlexander 0:c523920bcc09 747 */
johnAlexander 0:c523920bcc09 748 int RangeConfigInterrupt(uint8_t ConfigGpioInt)
johnAlexander 0:c523920bcc09 749 {
johnAlexander 0:c523920bcc09 750 // return VL6180x_RangeConfigInterrupt(Device, ConfigGpioInt);
johnAlexander 0:c523920bcc09 751 return 1;
johnAlexander 0:c523920bcc09 752 }
johnAlexander 0:c523920bcc09 753
johnAlexander 0:c523920bcc09 754 /**
johnAlexander 0:c523920bcc09 755 * @brief Return ranging error interrupt status
johnAlexander 0:c523920bcc09 756 *
johnAlexander 0:c523920bcc09 757 * @par Function Description
johnAlexander 0:c523920bcc09 758 * Appropriate Interrupt report must have been selected first by @a VL6180x_RangeConfigInterrupt() or @a VL6180x_Prepare() \n
johnAlexander 0:c523920bcc09 759 *
johnAlexander 0:c523920bcc09 760 * Can be used in polling loop to wait for a given ranging event or in interrupt to read the trigger \n
johnAlexander 0:c523920bcc09 761 * Events triggers are : \n
johnAlexander 0:c523920bcc09 762 * @a #RES_INT_STAT_GPIO_LOW_LEVEL_THRESHOLD \n
johnAlexander 0:c523920bcc09 763 * @a #RES_INT_STAT_GPIO_HIGH_LEVEL_THRESHOLD \n
johnAlexander 0:c523920bcc09 764 * @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 765 * @a #RES_INT_STAT_GPIO_NEW_SAMPLE_READY \n
johnAlexander 0:c523920bcc09 766 *
johnAlexander 0:c523920bcc09 767 * @sa IntrStatus_t
johnAlexander 0:c523920bcc09 768 * @param pIntStatus Pointer to status variable to update
johnAlexander 0:c523920bcc09 769 * @return 0 on success
johnAlexander 0:c523920bcc09 770 */
johnAlexander 0:c523920bcc09 771 int RangeGetInterruptStatus(uint8_t *pIntStatus)
johnAlexander 0:c523920bcc09 772 {
johnAlexander 0:c523920bcc09 773 // return VL6180x_RangeGetInterruptStatus(Device, pIntStatus);
johnAlexander 0:c523920bcc09 774 return 1;
johnAlexander 0:c523920bcc09 775 }
johnAlexander 0:c523920bcc09 776
johnAlexander 0:c523920bcc09 777 /**
johnAlexander 0:c523920bcc09 778 * @brief Low level ranging and ALS register static settings (you should call @a VL6180x_Prepare() function instead)
johnAlexander 0:c523920bcc09 779 *
johnAlexander 0:c523920bcc09 780 * @return 0 on success
johnAlexander 0:c523920bcc09 781 */
johnAlexander 0:c523920bcc09 782 int StaticInit()
johnAlexander 0:c523920bcc09 783 {
johnAlexander 0:c523920bcc09 784 // return VL6180x_StaticInit(Device);
johnAlexander 0:c523920bcc09 785 return 1;
johnAlexander 0:c523920bcc09 786 }
johnAlexander 0:c523920bcc09 787
johnAlexander 0:c523920bcc09 788 /**
johnAlexander 0:c523920bcc09 789 * @brief Wait for device to be ready (before a new ranging command can be issued by application)
johnAlexander 0:c523920bcc09 790 * @param MaxLoop Max Number of i2c polling loop see @a #msec_2_i2cloop
johnAlexander 0:c523920bcc09 791 * @return 0 on success. <0 when fail \n
johnAlexander 0:c523920bcc09 792 * @ref VL6180x_ErrCode_t::TIME_OUT for time out \n
johnAlexander 0:c523920bcc09 793 * @ref VL6180x_ErrCode_t::INVALID_PARAMS if MaxLop<1
johnAlexander 0:c523920bcc09 794 */
johnAlexander 0:c523920bcc09 795 int RangeWaitDeviceReady(int MaxLoop )
johnAlexander 0:c523920bcc09 796 {
johnAlexander 0:c523920bcc09 797 // return VL6180x_RangeWaitDeviceReady(Device, MaxLoop);
johnAlexander 0:c523920bcc09 798 return 1;
johnAlexander 0:c523920bcc09 799 }
johnAlexander 0:c523920bcc09 800
johnAlexander 0:c523920bcc09 801 /**
johnAlexander 0:c523920bcc09 802 * @brief Program Inter measurement period (used only in continuous mode)
johnAlexander 0:c523920bcc09 803 *
johnAlexander 0:c523920bcc09 804 * @par Function Description
johnAlexander 0:c523920bcc09 805 * When trying to set too long time, it returns #INVALID_PARAMS
johnAlexander 0:c523920bcc09 806 *
johnAlexander 0:c523920bcc09 807 * @param InterMeasTime_msec Requires inter-measurement time in msec
johnAlexander 0:c523920bcc09 808 * @return 0 on success
johnAlexander 0:c523920bcc09 809 */
johnAlexander 0:c523920bcc09 810 int RangeSetInterMeasPeriod(uint32_t InterMeasTime_msec)
johnAlexander 0:c523920bcc09 811 {
johnAlexander 0:c523920bcc09 812 // return VL6180x_RangeSetInterMeasPeriod(Device, InterMeasTime_msec);
johnAlexander 0:c523920bcc09 813 return 1;
johnAlexander 0:c523920bcc09 814 }
johnAlexander 0:c523920bcc09 815
johnAlexander 0:c523920bcc09 816 /**
johnAlexander 0:c523920bcc09 817 * @brief Set device ranging scaling factor
johnAlexander 0:c523920bcc09 818 *
johnAlexander 0:c523920bcc09 819 * @par Function Description
johnAlexander 0:c523920bcc09 820 * 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 821 * Changing the scaling factor when device is not in f/w standby state (free running) is not safe.
johnAlexander 0:c523920bcc09 822 * It can be source of spurious interrupt, wrongly scaled range etc ...
johnAlexander 0:c523920bcc09 823 * @warning __This function doesns't update high/low threshold and other programmed settings linked to scaling factor__.
johnAlexander 0:c523920bcc09 824 * To ensure proper operation, threshold and scaling changes should be done following this procedure: \n
johnAlexander 0:c523920bcc09 825 * @li Set Group hold : @a VL6180x_SetGroupParamHold() \n
johnAlexander 0:c523920bcc09 826 * @li Get Threshold @a VL6180x_RangeGetThresholds() \n
johnAlexander 0:c523920bcc09 827 * @li Change scaling : @a VL6180x_UpscaleSetScaling() \n
johnAlexander 0:c523920bcc09 828 * @li Set Threshold : @a VL6180x_RangeSetThresholds() \n
johnAlexander 0:c523920bcc09 829 * @li Unset Group Hold : @a VL6180x_SetGroupParamHold()
johnAlexander 0:c523920bcc09 830 *
johnAlexander 0:c523920bcc09 831 * @param scaling Scaling factor to apply (1,2 or 3)
johnAlexander 0:c523920bcc09 832 * @return 0 on success when up-scale support is not configured it fail for any
johnAlexander 0:c523920bcc09 833 * scaling than the one statically configured.
johnAlexander 0:c523920bcc09 834 */
johnAlexander 0:c523920bcc09 835 int UpscaleSetScaling(uint8_t scaling)
johnAlexander 0:c523920bcc09 836 {
johnAlexander 0:c523920bcc09 837 // return VL6180x_UpscaleSetScaling(Device, scaling);
johnAlexander 0:c523920bcc09 838 return 1;
johnAlexander 0:c523920bcc09 839 }
johnAlexander 0:c523920bcc09 840
johnAlexander 0:c523920bcc09 841 /**
johnAlexander 0:c523920bcc09 842 * @brief Get current ranging scaling factor
johnAlexander 0:c523920bcc09 843 *
johnAlexander 0:c523920bcc09 844 * @return The current scaling factor
johnAlexander 0:c523920bcc09 845 */
johnAlexander 0:c523920bcc09 846 int UpscaleGetScaling()
johnAlexander 0:c523920bcc09 847 {
johnAlexander 0:c523920bcc09 848 // return VL6180x_UpscaleGetScaling(Device);
johnAlexander 0:c523920bcc09 849 return 1;
johnAlexander 0:c523920bcc09 850 }
johnAlexander 0:c523920bcc09 851
johnAlexander 0:c523920bcc09 852 /**
johnAlexander 0:c523920bcc09 853 * @brief Get the maximal distance for actual scaling
johnAlexander 0:c523920bcc09 854 * @par Function Description
johnAlexander 0:c523920bcc09 855 * Do not use prior to @a VL6180x_Prepare() or at least @a VL6180x_InitData()
johnAlexander 0:c523920bcc09 856 *
johnAlexander 0:c523920bcc09 857 * Any range value more than the value returned by this function is to be considered as "no target detected"
johnAlexander 0:c523920bcc09 858 * or "no target in detectable range" \n
johnAlexander 0:c523920bcc09 859 * @warning The maximal distance depends on the scaling
johnAlexander 0:c523920bcc09 860 *
johnAlexander 0:c523920bcc09 861 * @return The maximal range limit for actual mode and scaling
johnAlexander 0:c523920bcc09 862 */
johnAlexander 0:c523920bcc09 863 uint16_t GetUpperLimit()
johnAlexander 0:c523920bcc09 864 {
johnAlexander 0:c523920bcc09 865 // return VL6180x_GetUpperLimit(Device);
johnAlexander 0:c523920bcc09 866 return 1;
johnAlexander 0:c523920bcc09 867 }
johnAlexander 0:c523920bcc09 868
johnAlexander 0:c523920bcc09 869 /**
johnAlexander 0:c523920bcc09 870 * @brief Apply low and high ranging thresholds that are considered only in continuous mode
johnAlexander 0:c523920bcc09 871 *
johnAlexander 0:c523920bcc09 872 * @par Function Description
johnAlexander 0:c523920bcc09 873 * This function programs low and high ranging thresholds that are considered in continuous mode :
johnAlexander 0:c523920bcc09 874 * interrupt will be raised only when an object is detected at a distance inside this [low:high] range.
johnAlexander 0:c523920bcc09 875 * The function takes care of applying current scaling factor if any.\n
johnAlexander 0:c523920bcc09 876 * To be safe, in continuous operation, thresholds must be changed under "group parameter hold" cover.
johnAlexander 0:c523920bcc09 877 * Group hold can be activated/deactivated directly in the function or externally (then set 0)
johnAlexander 0:c523920bcc09 878 * using /a VL6180x_SetGroupParamHold() function.
johnAlexander 0:c523920bcc09 879 *
johnAlexander 0:c523920bcc09 880 * @param low Low threshold in mm
johnAlexander 0:c523920bcc09 881 * @param high High threshold in mm
johnAlexander 0:c523920bcc09 882 * @param SafeHold Use of group parameters hold to surround threshold programming.
johnAlexander 0:c523920bcc09 883 * @return 0 On success
johnAlexander 0:c523920bcc09 884 */
johnAlexander 0:c523920bcc09 885 int RangeSetThresholds(uint16_t low, uint16_t high, int SafeHold)
johnAlexander 0:c523920bcc09 886 {
johnAlexander 0:c523920bcc09 887 // return VL6180x_RangeSetThresholds(Device, low, high, SafeHold);
johnAlexander 0:c523920bcc09 888 return 1;
johnAlexander 0:c523920bcc09 889 }
johnAlexander 0:c523920bcc09 890
johnAlexander 0:c523920bcc09 891 /**
johnAlexander 0:c523920bcc09 892 * @brief Get scaled high and low threshold from device
johnAlexander 0:c523920bcc09 893 *
johnAlexander 0:c523920bcc09 894 * @par Function Description
johnAlexander 0:c523920bcc09 895 * Due to scaling factor, the returned value may be different from what has been programmed first (precision lost).
johnAlexander 0:c523920bcc09 896 * For instance VL6180x_RangeSetThresholds(dev,11,22) with scale 3
johnAlexander 0:c523920bcc09 897 * will read back 9 ((11/3)x3) and 21 ((22/3)x3).
johnAlexander 0:c523920bcc09 898 *
johnAlexander 0:c523920bcc09 899 * @param low scaled low Threshold ptr can be NULL if not needed
johnAlexander 0:c523920bcc09 900 * @param high scaled High Threshold ptr can be NULL if not needed
johnAlexander 0:c523920bcc09 901 * @return 0 on success, return value is undefined if both low and high are NULL
johnAlexander 0:c523920bcc09 902 * @warning return value is undefined if both low and high are NULL
johnAlexander 0:c523920bcc09 903 */
johnAlexander 0:c523920bcc09 904 int RangeGetThresholds(uint16_t *low, uint16_t *high)
johnAlexander 0:c523920bcc09 905 {
johnAlexander 0:c523920bcc09 906 // return VL6180x_RangeGetThresholds(Device, low, high);
johnAlexander 0:c523920bcc09 907 return 1;
johnAlexander 0:c523920bcc09 908 }
johnAlexander 0:c523920bcc09 909
johnAlexander 0:c523920bcc09 910 /**
johnAlexander 0:c523920bcc09 911 * @brief Set ranging raw thresholds (scaling not considered so not recommended to use it)
johnAlexander 0:c523920bcc09 912 *
johnAlexander 0:c523920bcc09 913 * @param low raw low threshold set to raw register
johnAlexander 0:c523920bcc09 914 * @param high raw high threshold set to raw register
johnAlexander 0:c523920bcc09 915 * @return 0 on success
johnAlexander 0:c523920bcc09 916 */
johnAlexander 0:c523920bcc09 917 int RangeSetRawThresholds(uint8_t low, uint8_t high)
johnAlexander 0:c523920bcc09 918 {
johnAlexander 0:c523920bcc09 919 // return VL6180x_RangeSetRawThresholds(Device, low, high);
johnAlexander 0:c523920bcc09 920 return 1;
johnAlexander 0:c523920bcc09 921 }
johnAlexander 0:c523920bcc09 922
johnAlexander 0:c523920bcc09 923 /**
johnAlexander 0:c523920bcc09 924 * @brief Set Early Convergence Estimate ratio
johnAlexander 0:c523920bcc09 925 * @par Function Description
johnAlexander 0:c523920bcc09 926 * For more information on ECE check datasheet
johnAlexander 0:c523920bcc09 927 * @warning May return a calibration warning in some use cases
johnAlexander 0:c523920bcc09 928 *
johnAlexander 0:c523920bcc09 929 * @param FactorM ECE factor M in M/D
johnAlexander 0:c523920bcc09 930 * @param FactorD ECE factor D in M/D
johnAlexander 0:c523920bcc09 931 * @return 0 on success. <0 on error. >0 on warning
johnAlexander 0:c523920bcc09 932 */
johnAlexander 0:c523920bcc09 933 int RangeSetEceFactor(uint16_t FactorM, uint16_t FactorD)
johnAlexander 0:c523920bcc09 934 {
johnAlexander 0:c523920bcc09 935 // return VL6180x_RangeSetEceFactor(Device, FactorM, FactorD);
johnAlexander 0:c523920bcc09 936 return 1;
johnAlexander 0:c523920bcc09 937 }
johnAlexander 0:c523920bcc09 938
johnAlexander 0:c523920bcc09 939 /**
johnAlexander 0:c523920bcc09 940 * @brief Set Early Convergence Estimate state (See #SYSRANGE_RANGE_CHECK_ENABLES register)
johnAlexander 0:c523920bcc09 941 * @param enable State to be set 0=disabled, otherwise enabled
johnAlexander 0:c523920bcc09 942 * @return 0 on success
johnAlexander 0:c523920bcc09 943 */
johnAlexander 0:c523920bcc09 944 int RangeSetEceState(int enable)
johnAlexander 0:c523920bcc09 945 {
johnAlexander 0:c523920bcc09 946 // return VL6180x_RangeSetEceState(Device, enable);
johnAlexander 0:c523920bcc09 947 return 1;
johnAlexander 0:c523920bcc09 948 }
johnAlexander 0:c523920bcc09 949
johnAlexander 0:c523920bcc09 950 /**
johnAlexander 0:c523920bcc09 951 * @brief Set activation state of the wrap around filter
johnAlexander 0:c523920bcc09 952 * @param state New activation state (0=off, otherwise on)
johnAlexander 0:c523920bcc09 953 * @return 0 on success
johnAlexander 0:c523920bcc09 954 */
johnAlexander 0:c523920bcc09 955 int FilterSetState(int state)
johnAlexander 0:c523920bcc09 956 {
johnAlexander 0:c523920bcc09 957 // return VL6180x_FilterSetState(Device, state);
johnAlexander 0:c523920bcc09 958 return 1;
johnAlexander 0:c523920bcc09 959 }
johnAlexander 0:c523920bcc09 960
johnAlexander 0:c523920bcc09 961 /**
johnAlexander 0:c523920bcc09 962 * Get activation state of the wrap around filter
johnAlexander 0:c523920bcc09 963 * @return Filter enabled or not, when filter is not supported it always returns 0S
johnAlexander 0:c523920bcc09 964 */
johnAlexander 0:c523920bcc09 965 int FilterGetState()
johnAlexander 0:c523920bcc09 966 {
johnAlexander 0:c523920bcc09 967 // return VL6180x_FilterGetState(Device);
johnAlexander 0:c523920bcc09 968 return 1;
johnAlexander 0:c523920bcc09 969 }
johnAlexander 0:c523920bcc09 970
johnAlexander 0:c523920bcc09 971 /**
johnAlexander 0:c523920bcc09 972 * @brief Set activation state of DMax computation
johnAlexander 0:c523920bcc09 973 * @param state New activation state (0=off, otherwise on)
johnAlexander 0:c523920bcc09 974 * @return 0 on success
johnAlexander 0:c523920bcc09 975 */
johnAlexander 0:c523920bcc09 976 int DMaxSetState(int state)
johnAlexander 0:c523920bcc09 977 {
johnAlexander 0:c523920bcc09 978 // return VL6180x_DMaxSetState(Device, state);
johnAlexander 0:c523920bcc09 979 return 1;
johnAlexander 0:c523920bcc09 980 }
johnAlexander 0:c523920bcc09 981
johnAlexander 0:c523920bcc09 982 /**
johnAlexander 0:c523920bcc09 983 * Get activation state of DMax computation
johnAlexander 0:c523920bcc09 984 * @return Filter enabled or not, when filter is not supported it always returns 0S
johnAlexander 0:c523920bcc09 985 */
johnAlexander 0:c523920bcc09 986 int DMaxGetState()
johnAlexander 0:c523920bcc09 987 {
johnAlexander 0:c523920bcc09 988 // return VL6180x_DMaxGetState(Device);
johnAlexander 0:c523920bcc09 989 return 1;
johnAlexander 0:c523920bcc09 990 }
johnAlexander 0:c523920bcc09 991
johnAlexander 0:c523920bcc09 992 /**
johnAlexander 0:c523920bcc09 993 * @brief Set ranging mode and start/stop measure (use high level functions instead : @a VL6180x_RangeStartSingleShot() or @a VL6180x_RangeStartContinuousMode())
johnAlexander 0:c523920bcc09 994 *
johnAlexander 0:c523920bcc09 995 * @par Function Description
johnAlexander 0:c523920bcc09 996 * When used outside scope of known polling single shot stopped state, \n
johnAlexander 0:c523920bcc09 997 * user must ensure the device state is "idle" before to issue a new command.
johnAlexander 0:c523920bcc09 998 *
johnAlexander 0:c523920bcc09 999 * @param mode A combination of working mode (#MODE_SINGLESHOT or #MODE_CONTINUOUS) and start/stop condition (#MODE_START_STOP) \n
johnAlexander 0:c523920bcc09 1000 * @return 0 on success
johnAlexander 0:c523920bcc09 1001 */
johnAlexander 0:c523920bcc09 1002 int RangeSetSystemMode(uint8_t mode)
johnAlexander 0:c523920bcc09 1003 {
johnAlexander 0:c523920bcc09 1004 // return VL6180x_RangeSetSystemMode(Device, mode);
johnAlexander 0:c523920bcc09 1005 return 1;
johnAlexander 0:c523920bcc09 1006 }
johnAlexander 0:c523920bcc09 1007
johnAlexander 0:c523920bcc09 1008 /** @} */
johnAlexander 0:c523920bcc09 1009
johnAlexander 0:c523920bcc09 1010 /** @defgroup api_ll_range_calibration Ranging calibration functions
johnAlexander 0:c523920bcc09 1011 * @brief Ranging calibration functions
johnAlexander 0:c523920bcc09 1012 * @ingroup api_ll
johnAlexander 0:c523920bcc09 1013 * @{
johnAlexander 0:c523920bcc09 1014 */
johnAlexander 0:c523920bcc09 1015 /**
johnAlexander 0:c523920bcc09 1016 * @brief Get part to part calibration offset
johnAlexander 0:c523920bcc09 1017 *
johnAlexander 0:c523920bcc09 1018 * @par Function Description
johnAlexander 0:c523920bcc09 1019 * Should only be used after a successful call to @a VL6180x_InitData to backup device nvm value
johnAlexander 0:c523920bcc09 1020 *
johnAlexander 0:c523920bcc09 1021 * @return part to part calibration offset from device
johnAlexander 0:c523920bcc09 1022 */
johnAlexander 0:c523920bcc09 1023 int8_t GetOffsetCalibrationData()
johnAlexander 0:c523920bcc09 1024 {
johnAlexander 0:c523920bcc09 1025 // return VL6180x_GetOffsetCalibrationData(Device);
johnAlexander 0:c523920bcc09 1026 return 1;
johnAlexander 0:c523920bcc09 1027 }
johnAlexander 0:c523920bcc09 1028
johnAlexander 0:c523920bcc09 1029 /**
johnAlexander 0:c523920bcc09 1030 * Set or over-write part to part calibration offset
johnAlexander 0:c523920bcc09 1031 * \sa VL6180x_InitData(), VL6180x_GetOffsetCalibrationData()
johnAlexander 0:c523920bcc09 1032 * @param offset Offset
johnAlexander 0:c523920bcc09 1033 */
johnAlexander 0:c523920bcc09 1034 void SetOffsetCalibrationData(int8_t offset)
johnAlexander 0:c523920bcc09 1035 {
johnAlexander 0:c523920bcc09 1036 // return VL6180x_SetOffsetCalibrationData(Device, offset);
johnAlexander 0:c523920bcc09 1037 return;
johnAlexander 0:c523920bcc09 1038 }
johnAlexander 0:c523920bcc09 1039
johnAlexander 0:c523920bcc09 1040 /**
johnAlexander 0:c523920bcc09 1041 * @brief Set Cross talk compensation rate
johnAlexander 0:c523920bcc09 1042 *
johnAlexander 0:c523920bcc09 1043 * @par Function Description
johnAlexander 0:c523920bcc09 1044 * It programs register @a #SYSRANGE_CROSSTALK_COMPENSATION_RATE
johnAlexander 0:c523920bcc09 1045 *
johnAlexander 0:c523920bcc09 1046 * @param Rate Compensation rate (9.7 fix point) see datasheet for details
johnAlexander 0:c523920bcc09 1047 * @return 0 on success
johnAlexander 0:c523920bcc09 1048 */
johnAlexander 0:c523920bcc09 1049 int SetXTalkCompensationRate(uint16_t Rate)
johnAlexander 0:c523920bcc09 1050 {
johnAlexander 0:c523920bcc09 1051 // return VL6180x_SetXTalkCompensationRate(Device, Rate);
johnAlexander 0:c523920bcc09 1052 return 1;
johnAlexander 0:c523920bcc09 1053 }
johnAlexander 0:c523920bcc09 1054 /** @} */
johnAlexander 0:c523920bcc09 1055
johnAlexander 0:c523920bcc09 1056 /**
johnAlexander 0:c523920bcc09 1057 * @brief Set new device i2c address
johnAlexander 0:c523920bcc09 1058 *
johnAlexander 0:c523920bcc09 1059 * After completion the device will answer to the new address programmed.
johnAlexander 0:c523920bcc09 1060 *
johnAlexander 0:c523920bcc09 1061 * @sa AN4478: Using multiple VL6180X's in a single design
johnAlexander 0:c523920bcc09 1062 * @param NewAddr The new i2c address (7bit)
johnAlexander 0:c523920bcc09 1063 * @return 0 on success
johnAlexander 0:c523920bcc09 1064 */
johnAlexander 0:c523920bcc09 1065 int SetDeviceAddress(int NewAddr)
johnAlexander 0:c523920bcc09 1066 {
johnAlexander 0:c523920bcc09 1067 int status;
johnAlexander 0:c523920bcc09 1068
johnAlexander 0:c523920bcc09 1069 status=VL53L0X_SetDeviceAddress(Device, NewAddr);
johnAlexander 0:c523920bcc09 1070 if(!status)
johnAlexander 0:c523920bcc09 1071 Device->I2cDevAddr=NewAddr;
johnAlexander 0:c523920bcc09 1072 return status;
johnAlexander 0:c523920bcc09 1073
johnAlexander 0:c523920bcc09 1074 // return 1;
johnAlexander 0:c523920bcc09 1075 }
johnAlexander 0:c523920bcc09 1076
johnAlexander 0:c523920bcc09 1077 /**
johnAlexander 0:c523920bcc09 1078 * @brief Fully configure gpio 0/1 pin : polarity and functionality
johnAlexander 0:c523920bcc09 1079 *
johnAlexander 0:c523920bcc09 1080 * @param pin gpio pin 0 or 1
johnAlexander 0:c523920bcc09 1081 * @param IntFunction Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
johnAlexander 0:c523920bcc09 1082 * @param ActiveHigh Set active high polarity, or active low see @a ::IntrPol_e
johnAlexander 0:c523920bcc09 1083 * @return 0 on success
johnAlexander 0:c523920bcc09 1084 */
johnAlexander 0:c523920bcc09 1085 int SetupGPIOx(int pin, uint8_t IntFunction, int ActiveHigh)
johnAlexander 0:c523920bcc09 1086 {
johnAlexander 0:c523920bcc09 1087 // return VL6180x_SetupGPIOx(Device, pin, IntFunction, ActiveHigh);
johnAlexander 0:c523920bcc09 1088 return 1;
johnAlexander 0:c523920bcc09 1089 }
johnAlexander 0:c523920bcc09 1090
johnAlexander 0:c523920bcc09 1091 /**
johnAlexander 0:c523920bcc09 1092 * @brief Set interrupt pin polarity for the given GPIO
johnAlexander 0:c523920bcc09 1093 *
johnAlexander 0:c523920bcc09 1094 * @param pin Pin 0 or 1
johnAlexander 0:c523920bcc09 1095 * @param active_high select active high or low polarity using @ref IntrPol_e
johnAlexander 0:c523920bcc09 1096 * @return 0 on success
johnAlexander 0:c523920bcc09 1097 */
johnAlexander 0:c523920bcc09 1098 int SetGPIOxPolarity(int pin, int active_high)
johnAlexander 0:c523920bcc09 1099 {
johnAlexander 0:c523920bcc09 1100 // return VL6180x_SetGPIOxPolarity(Device, pin, active_high);
johnAlexander 0:c523920bcc09 1101 return 1;
johnAlexander 0:c523920bcc09 1102 }
johnAlexander 0:c523920bcc09 1103
johnAlexander 0:c523920bcc09 1104 /**
johnAlexander 0:c523920bcc09 1105 * Select interrupt functionality for the given GPIO
johnAlexander 0:c523920bcc09 1106 *
johnAlexander 0:c523920bcc09 1107 * @par Function Description
johnAlexander 0:c523920bcc09 1108 * Functionality refer to @a SYSTEM_MODE_GPIO0
johnAlexander 0:c523920bcc09 1109 *
johnAlexander 0:c523920bcc09 1110 * @param pin Pin to configure 0 or 1 (gpio0 or gpio1)\nNote that gpio0 is chip enable at power up !
johnAlexander 0:c523920bcc09 1111 * @param functionality Pin functionality : either #GPIOx_SELECT_OFF or #GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT (refer to #SYSTEM_MODE_GPIO1 register definition)
johnAlexander 0:c523920bcc09 1112 * @return 0 on success
johnAlexander 0:c523920bcc09 1113 */
johnAlexander 0:c523920bcc09 1114 int SetGPIOxFunctionality(int pin, uint8_t functionality)
johnAlexander 0:c523920bcc09 1115 {
johnAlexander 0:c523920bcc09 1116 // return VL6180x_SetGPIOxFunctionality(Device, pin, functionality);
johnAlexander 0:c523920bcc09 1117 return 1;
johnAlexander 0:c523920bcc09 1118 }
johnAlexander 0:c523920bcc09 1119
johnAlexander 0:c523920bcc09 1120 /**
johnAlexander 0:c523920bcc09 1121 * #brief Disable and turn to Hi-Z gpio output pin
johnAlexander 0:c523920bcc09 1122 *
johnAlexander 0:c523920bcc09 1123 * @param pin The pin number to disable 0 or 1
johnAlexander 0:c523920bcc09 1124 * @return 0 on success
johnAlexander 0:c523920bcc09 1125 */
johnAlexander 0:c523920bcc09 1126 int DisableGPIOxOut(int pin)
johnAlexander 0:c523920bcc09 1127 {
johnAlexander 0:c523920bcc09 1128 // return VL6180x_DisableGPIOxOut(Device, pin);
johnAlexander 0:c523920bcc09 1129 return 1;
johnAlexander 0:c523920bcc09 1130 }
johnAlexander 0:c523920bcc09 1131
johnAlexander 0:c523920bcc09 1132 /** @} */
johnAlexander 0:c523920bcc09 1133
johnAlexander 0:c523920bcc09 1134 /** @defgroup api_ll_intr Interrupts management functions
johnAlexander 0:c523920bcc09 1135 * @brief Interrupts management functions
johnAlexander 0:c523920bcc09 1136 * @ingroup api_ll
johnAlexander 0:c523920bcc09 1137 * @{
johnAlexander 0:c523920bcc09 1138 */
johnAlexander 0:c523920bcc09 1139
johnAlexander 0:c523920bcc09 1140 /**
johnAlexander 0:c523920bcc09 1141 * @brief Get all interrupts cause
johnAlexander 0:c523920bcc09 1142 *
johnAlexander 0:c523920bcc09 1143 * @param status Ptr to interrupt status. You can use @a IntrStatus_t::val
johnAlexander 0:c523920bcc09 1144 * @return 0 on success
johnAlexander 0:c523920bcc09 1145 */
johnAlexander 0:c523920bcc09 1146 int GetInterruptStatus(uint8_t *status)
johnAlexander 0:c523920bcc09 1147 {
johnAlexander 0:c523920bcc09 1148 // return VL6180x_GetInterruptStatus(Device, status);
johnAlexander 0:c523920bcc09 1149 return 1;
johnAlexander 0:c523920bcc09 1150 }
johnAlexander 0:c523920bcc09 1151
johnAlexander 0:c523920bcc09 1152 /**
johnAlexander 0:c523920bcc09 1153 * @brief Clear given system interrupt condition
johnAlexander 0:c523920bcc09 1154 *
johnAlexander 0:c523920bcc09 1155 * @par Function Description
johnAlexander 0:c523920bcc09 1156 * Clear given interrupt cause by writing into register #SYSTEM_INTERRUPT_CLEAR register.
johnAlexander 0:c523920bcc09 1157 * @param dev The device
johnAlexander 0:c523920bcc09 1158 * @param IntClear Which interrupt source to clear. Use any combinations of #INTERRUPT_CLEAR_RANGING , #INTERRUPT_CLEAR_ALS , #INTERRUPT_CLEAR_ERROR.
johnAlexander 0:c523920bcc09 1159 * @return 0 On success
johnAlexander 0:c523920bcc09 1160 */
johnAlexander 0:c523920bcc09 1161 int ClearInterrupt(uint8_t IntClear)
johnAlexander 0:c523920bcc09 1162 {
johnAlexander 0:c523920bcc09 1163 // return VL6180x_ClearInterrupt(Device, IntClear );
johnAlexander 0:c523920bcc09 1164 return 1;
johnAlexander 0:c523920bcc09 1165 }
johnAlexander 0:c523920bcc09 1166
johnAlexander 0:c523920bcc09 1167 /**
johnAlexander 0:c523920bcc09 1168 * @brief Clear error interrupt
johnAlexander 0:c523920bcc09 1169 *
johnAlexander 0:c523920bcc09 1170 * @param dev The device
johnAlexander 0:c523920bcc09 1171 * @return 0 On success
johnAlexander 0:c523920bcc09 1172 */
johnAlexander 0:c523920bcc09 1173 #define VL6180x_ClearErrorInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR)
johnAlexander 0:c523920bcc09 1174
johnAlexander 0:c523920bcc09 1175 /**
johnAlexander 0:c523920bcc09 1176 * @brief Clear All interrupt causes (als+range+error)
johnAlexander 0:c523920bcc09 1177 *
johnAlexander 0:c523920bcc09 1178 * @param dev The device
johnAlexander 0:c523920bcc09 1179 * @return 0 On success
johnAlexander 0:c523920bcc09 1180 */
johnAlexander 0:c523920bcc09 1181 #define VL6180x_ClearAllInterrupt(dev) VL6180x_ClearInterrupt(dev, INTERRUPT_CLEAR_ERROR|INTERRUPT_CLEAR_RANGING|INTERRUPT_CLEAR_ALS)
johnAlexander 0:c523920bcc09 1182
johnAlexander 0:c523920bcc09 1183
johnAlexander 0:c523920bcc09 1184 private:
johnAlexander 0:c523920bcc09 1185 /* api.h functions */
johnAlexander 0:c523920bcc09 1186 VL53L0X_Error VL53L0X_DataInit(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1187 VL53L0X_Error VL53L0X_GetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev, int32_t *pOffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1188 VL53L0X_Error VL53L0X_SetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1189 int32_t OffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1190 VL53L0X_Error VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1191 VL53L0X_DeviceParameters_t *pDeviceParameters);
johnAlexander 0:c523920bcc09 1192 VL53L0X_Error VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1193 VL53L0X_DeviceModes *pDeviceMode);
johnAlexander 0:c523920bcc09 1194 VL53L0X_Error VL53L0X_GetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1195 uint32_t *pInterMeasurementPeriodMilliSeconds);
johnAlexander 0:c523920bcc09 1196 VL53L0X_Error VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1197 FixPoint1616_t *pXTalkCompensationRateMegaCps);
johnAlexander 0:c523920bcc09 1198 VL53L0X_Error VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1199 FixPoint1616_t *pLimitCheckValue);
johnAlexander 0:c523920bcc09 1200 VL53L0X_Error VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1201 uint8_t *pLimitCheckEnable);
johnAlexander 0:c523920bcc09 1202 VL53L0X_Error VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1203 uint8_t *pWrapAroundCheckEnable);
johnAlexander 0:c523920bcc09 1204 VL53L0X_Error VL53L0X_GetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1205 uint32_t *pMeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1206 VL53L0X_Error VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1207 VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps);
johnAlexander 0:c523920bcc09 1208 VL53L0X_Error sequence_step_enabled(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1209 VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceConfig,
johnAlexander 0:c523920bcc09 1210 uint8_t *pSequenceStepEnabled);
johnAlexander 0:c523920bcc09 1211 VL53L0X_Error VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1212 VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1213 VL53L0X_Error VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1214 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1215 VL53L0X_Error VL53L0X_StaticInit(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1216 VL53L0X_Error VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1217 uint8_t *pMeasurementDataReady);
johnAlexander 0:c523920bcc09 1218 VL53L0X_Error VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1219 uint32_t *pInterruptMaskStatus);
johnAlexander 0:c523920bcc09 1220 VL53L0X_Error VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask);
johnAlexander 0:c523920bcc09 1221 VL53L0X_Error VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1222 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
johnAlexander 0:c523920bcc09 1223 VL53L0X_Error VL53L0X_SetDeviceMode(VL53L0X_DEV Dev, VL53L0X_DeviceModes DeviceMode);
johnAlexander 0:c523920bcc09 1224 VL53L0X_Error VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1225 VL53L0X_Error VL53L0X_StartMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1226 VL53L0X_Error VL53L0X_CheckAndLoadInterruptSettings(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1227 uint8_t StartNotStopFlag);
johnAlexander 0:c523920bcc09 1228 VL53L0X_Error VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1229 VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
johnAlexander 0:c523920bcc09 1230 FixPoint1616_t *pThresholdHigh);
johnAlexander 0:c523920bcc09 1231 VL53L0X_Error VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1232 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData);
johnAlexander 0:c523920bcc09 1233 VL53L0X_Error VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1234 uint8_t *pXTalkCompensationEnable);
johnAlexander 0:c523920bcc09 1235 VL53L0X_Error VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1236 VL53L0X_Error VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
johnAlexander 0:c523920bcc09 1237 uint8_t *pPhaseCal);
johnAlexander 0:c523920bcc09 1238 VL53L0X_Error VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1239 uint32_t *refSpadCount, uint8_t *isApertureSpads);
johnAlexander 0:c523920bcc09 1240 VL53L0X_Error VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev, uint8_t DeviceAddress);
johnAlexander 0:c523920bcc09 1241 VL53L0X_Error VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
johnAlexander 0:c523920bcc09 1242 VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
johnAlexander 0:c523920bcc09 1243 VL53L0X_InterruptPolarity Polarity);
johnAlexander 0:c523920bcc09 1244 VL53L0X_Error VL53L0X_GetFractionEnable(VL53L0X_DEV Dev, uint8_t *pEnabled);
johnAlexander 0:c523920bcc09 1245 VL53L0X_Error VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1246 VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled);
johnAlexander 0:c523920bcc09 1247 VL53L0X_Error VL53L0X_SetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1248 uint32_t MeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1249 VL53L0X_Error VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1250 uint8_t LimitCheckEnable);
johnAlexander 0:c523920bcc09 1251 VL53L0X_Error VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
johnAlexander 0:c523920bcc09 1252 FixPoint1616_t LimitCheckValue);
johnAlexander 0:c523920bcc09 1253 VL53L0X_Error VL53L0X_StopMeasurement(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1254 VL53L0X_Error VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1255 uint32_t *pStopStatus);
johnAlexander 0:c523920bcc09 1256 VL53L0X_Error VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1257 VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriod);
johnAlexander 0:c523920bcc09 1258
johnAlexander 0:c523920bcc09 1259 /* api_core.h functions */
johnAlexander 0:c523920bcc09 1260 VL53L0X_Error VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option);
johnAlexander 0:c523920bcc09 1261 VL53L0X_Error VL53L0X_device_read_strobe(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1262 VL53L0X_Error VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1263 uint32_t *pMeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1264 VL53L0X_Error VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1265 VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1266 uint8_t VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg);
johnAlexander 0:c523920bcc09 1267 uint32_t VL53L0X_decode_timeout(uint16_t encoded_timeout);
johnAlexander 0:c523920bcc09 1268 uint32_t VL53L0X_calc_timeout_us(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1269 uint16_t timeout_period_mclks,
johnAlexander 0:c523920bcc09 1270 uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1271 uint32_t VL53L0X_calc_macro_period_ps(VL53L0X_DEV Dev, uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1272 VL53L0X_Error VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1273 VL53L0X_Error VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1274 uint8_t *pTuningSettingBuffer);
johnAlexander 0:c523920bcc09 1275 VL53L0X_Error VL53L0X_get_pal_range_status(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1276 uint8_t DeviceRangeStatus,
johnAlexander 0:c523920bcc09 1277 FixPoint1616_t SignalRate,
johnAlexander 0:c523920bcc09 1278 uint16_t EffectiveSpadRtnCount,
johnAlexander 0:c523920bcc09 1279 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1280 uint8_t *pPalRangeStatus);
johnAlexander 0:c523920bcc09 1281 VL53L0X_Error VL53L0X_calc_sigma_estimate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1282 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1283 FixPoint1616_t *pSigmaEstimate,
johnAlexander 0:c523920bcc09 1284 uint32_t *pDmax_mm);
johnAlexander 0:c523920bcc09 1285 VL53L0X_Error VL53L0X_get_total_signal_rate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1286 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1287 FixPoint1616_t *ptotal_signal_rate_mcps);
johnAlexander 0:c523920bcc09 1288 VL53L0X_Error VL53L0X_get_total_xtalk_rate(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1289 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
johnAlexander 0:c523920bcc09 1290 FixPoint1616_t *ptotal_xtalk_rate_mcps);
johnAlexander 0:c523920bcc09 1291 uint32_t VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1292 uint32_t timeout_period_us,
johnAlexander 0:c523920bcc09 1293 uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1294 uint32_t VL53L0X_isqrt(uint32_t num);
johnAlexander 0:c523920bcc09 1295 VL53L0X_Error VL53L0X_calc_dmax(
johnAlexander 0:c523920bcc09 1296 VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1297 FixPoint1616_t totalSignalRate_mcps,
johnAlexander 0:c523920bcc09 1298 FixPoint1616_t totalCorrSignalRate_mcps,
johnAlexander 0:c523920bcc09 1299 FixPoint1616_t pwMult,
johnAlexander 0:c523920bcc09 1300 uint32_t sigmaEstimateP1,
johnAlexander 0:c523920bcc09 1301 FixPoint1616_t sigmaEstimateP2,
johnAlexander 0:c523920bcc09 1302 uint32_t peakVcselDuration_us,
johnAlexander 0:c523920bcc09 1303 uint32_t *pdmax_mm);
johnAlexander 0:c523920bcc09 1304 VL53L0X_Error VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1305 uint32_t MeasurementTimingBudgetMicroSeconds);
johnAlexander 0:c523920bcc09 1306 VL53L0X_Error get_sequence_step_timeout(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1307 VL53L0X_SequenceStepId SequenceStepId,
johnAlexander 0:c523920bcc09 1308 uint32_t *pTimeOutMicroSecs);
johnAlexander 0:c523920bcc09 1309 VL53L0X_Error set_sequence_step_timeout(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1310 VL53L0X_SequenceStepId SequenceStepId,
johnAlexander 0:c523920bcc09 1311 uint32_t TimeOutMicroSecs);
johnAlexander 0:c523920bcc09 1312 uint16_t VL53L0X_encode_timeout(uint32_t timeout_macro_clks);
johnAlexander 0:c523920bcc09 1313 VL53L0X_Error VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1314 VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK);
johnAlexander 0:c523920bcc09 1315 uint8_t VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks);
johnAlexander 0:c523920bcc09 1316
johnAlexander 0:c523920bcc09 1317 /* api_calibration.h functions */
johnAlexander 0:c523920bcc09 1318 VL53L0X_Error VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1319 VL53L0X_Error VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1320 int32_t *pOffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1321 VL53L0X_Error VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1322 int32_t OffsetCalibrationDataMicroMeter);
johnAlexander 0:c523920bcc09 1323 VL53L0X_Error VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1324 uint32_t *refSpadCount,
johnAlexander 0:c523920bcc09 1325 uint8_t *isApertureSpads);
johnAlexander 0:c523920bcc09 1326 VL53L0X_Error VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1327 uint8_t *pVhvSettings, uint8_t *pPhaseCal, uint8_t get_data_enable);
johnAlexander 0:c523920bcc09 1328 VL53L0X_Error VL53L0X_perform_vhv_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1329 uint8_t *pVhvSettings, const uint8_t get_data_enable,
johnAlexander 0:c523920bcc09 1330 const uint8_t restore_config);
johnAlexander 0:c523920bcc09 1331 VL53L0X_Error VL53L0X_perform_single_ref_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1332 uint8_t vhv_init_byte);
johnAlexander 0:c523920bcc09 1333 VL53L0X_Error VL53L0X_ref_calibration_io(VL53L0X_DEV Dev, uint8_t read_not_write,
johnAlexander 0:c523920bcc09 1334 uint8_t VhvSettings, uint8_t PhaseCal,
johnAlexander 0:c523920bcc09 1335 uint8_t *pVhvSettings, uint8_t *pPhaseCal,
johnAlexander 0:c523920bcc09 1336 const uint8_t vhv_enable, const uint8_t phase_enable);
johnAlexander 0:c523920bcc09 1337 VL53L0X_Error VL53L0X_perform_phase_calibration(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1338 uint8_t *pPhaseCal, const uint8_t get_data_enable,
johnAlexander 0:c523920bcc09 1339 const uint8_t restore_config);
johnAlexander 0:c523920bcc09 1340 VL53L0X_Error enable_ref_spads(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1341 uint8_t apertureSpads,
johnAlexander 0:c523920bcc09 1342 uint8_t goodSpadArray[],
johnAlexander 0:c523920bcc09 1343 uint8_t spadArray[],
johnAlexander 0:c523920bcc09 1344 uint32_t size,
johnAlexander 0:c523920bcc09 1345 uint32_t start,
johnAlexander 0:c523920bcc09 1346 uint32_t offset,
johnAlexander 0:c523920bcc09 1347 uint32_t spadCount,
johnAlexander 0:c523920bcc09 1348 uint32_t *lastSpad);
johnAlexander 0:c523920bcc09 1349 void get_next_good_spad(uint8_t goodSpadArray[], uint32_t size,
johnAlexander 0:c523920bcc09 1350 uint32_t curr, int32_t *next);
johnAlexander 0:c523920bcc09 1351 uint8_t is_aperture(uint32_t spadIndex);
johnAlexander 0:c523920bcc09 1352 VL53L0X_Error enable_spad_bit(uint8_t spadArray[], uint32_t size,
johnAlexander 0:c523920bcc09 1353 uint32_t spadIndex);
johnAlexander 0:c523920bcc09 1354 VL53L0X_Error set_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray);
johnAlexander 0:c523920bcc09 1355 VL53L0X_Error get_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray);
johnAlexander 0:c523920bcc09 1356 VL53L0X_Error perform_ref_signal_measurement(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1357 uint16_t *refSignalRate);
johnAlexander 0:c523920bcc09 1358 VL53L0X_Error VL53L0X_set_reference_spads(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1359 uint32_t count, uint8_t isApertureSpads);
johnAlexander 0:c523920bcc09 1360
johnAlexander 0:c523920bcc09 1361 /* api_strings.h functions */
johnAlexander 0:c523920bcc09 1362 VL53L0X_Error VL53L0X_get_device_info(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1363 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1364 VL53L0X_Error VL53L0X_check_part_used(VL53L0X_DEV Dev,
johnAlexander 0:c523920bcc09 1365 uint8_t *Revision,
johnAlexander 0:c523920bcc09 1366 VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
johnAlexander 0:c523920bcc09 1367
johnAlexander 0:c523920bcc09 1368 /* Read function of the ID device */
johnAlexander 2:58b5e9097aa3 1369 // virtual int ReadID();
johnAlexander 2:58b5e9097aa3 1370 virtual int ReadID(uint8_t *id);
johnAlexander 0:c523920bcc09 1371
johnAlexander 0:c523920bcc09 1372 VL53L0X_Error WaitMeasurementDataReady(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1373 VL53L0X_Error WaitStopCompleted(VL53L0X_DEV Dev);
johnAlexander 0:c523920bcc09 1374
johnAlexander 0:c523920bcc09 1375 /* Write and read functions from I2C */
johnAlexander 0:c523920bcc09 1376
johnAlexander 0:c523920bcc09 1377 VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV dev, uint8_t index, uint8_t data);
johnAlexander 0:c523920bcc09 1378 VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV dev, uint8_t index, uint16_t data);
johnAlexander 0:c523920bcc09 1379 VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV dev, uint8_t index, uint32_t data);
johnAlexander 0:c523920bcc09 1380 VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV dev, uint8_t index, uint8_t *data);
johnAlexander 0:c523920bcc09 1381 VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV dev, uint8_t index, uint16_t *data);
johnAlexander 0:c523920bcc09 1382 VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV dev, uint8_t index, uint32_t *data);
johnAlexander 0:c523920bcc09 1383 VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV dev, uint8_t index, uint8_t AndData, uint8_t OrData);
johnAlexander 0:c523920bcc09 1384
johnAlexander 0:c523920bcc09 1385 VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
johnAlexander 0:c523920bcc09 1386 VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
johnAlexander 0:c523920bcc09 1387
johnAlexander 0:c523920bcc09 1388 VL53L0X_Error VL53L0X_I2CWrite(uint8_t dev, uint8_t index, uint8_t *data, uint16_t number_of_bytes);
johnAlexander 0:c523920bcc09 1389 VL53L0X_Error VL53L0X_I2CRead(uint8_t dev, uint8_t index, uint8_t *data, uint16_t number_of_bytes);
johnAlexander 0:c523920bcc09 1390
johnAlexander 0:c523920bcc09 1391 VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev); /* usually best implemented as a real function */
johnAlexander 0:c523920bcc09 1392
johnAlexander 0:c523920bcc09 1393 int IsPresent()
johnAlexander 0:c523920bcc09 1394 {
johnAlexander 0:c523920bcc09 1395 int status;
johnAlexander 2:58b5e9097aa3 1396 uint8_t id;
johnAlexander 0:c523920bcc09 1397
johnAlexander 2:58b5e9097aa3 1398 status=ReadID(&id);
johnAlexander 0:c523920bcc09 1399 if(status)
johnAlexander 0:c523920bcc09 1400 VL53L0X_ErrLog("Failed to read ID device. Device not present!\n\r");
johnAlexander 0:c523920bcc09 1401 return status;
johnAlexander 0:c523920bcc09 1402 }
johnAlexander 0:c523920bcc09 1403 int StopRangeMeasurement(OperatingMode operating_mode);
johnAlexander 0:c523920bcc09 1404 int GetRangeMeas(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data);
johnAlexander 0:c523920bcc09 1405 int RangeSetLowThreshold(uint16_t threshold);
johnAlexander 0:c523920bcc09 1406 int RangeSetHighThreshold(uint16_t threshold);
johnAlexander 0:c523920bcc09 1407 int GetRangeError(VL53L0X_RangingMeasurementData_t *Data, VL53L0X_RangingMeasurementData_t RangeData);
johnAlexander 0:c523920bcc09 1408 int RangeMeasPollSingleShot();
johnAlexander 0:c523920bcc09 1409 int RangeMeasPollContinuousMode();
johnAlexander 0:c523920bcc09 1410 int RangeMeasIntContinuousMode(void (*fptr)(void));
johnAlexander 0:c523920bcc09 1411
johnAlexander 0:c523920bcc09 1412
johnAlexander 0:c523920bcc09 1413 VL53L0X_DeviceInfo_t DeviceInfo;
johnAlexander 0:c523920bcc09 1414
johnAlexander 0:c523920bcc09 1415 /* IO Device */
johnAlexander 0:c523920bcc09 1416 DevI2C &dev_i2c;
johnAlexander 0:c523920bcc09 1417 /* GPIO expander */
johnAlexander 0:c523920bcc09 1418 // STMPE1600 &io_expander;
johnAlexander 0:c523920bcc09 1419 // ExpGpioPinName xshutdown;
johnAlexander 0:c523920bcc09 1420 /* Digital out pin */
johnAlexander 0:c523920bcc09 1421 DigitalOut *gpio0;
johnAlexander 0:c523920bcc09 1422 /* GPIO expander */
johnAlexander 0:c523920bcc09 1423 STMPE1600DigiOut *expgpio0;
johnAlexander 0:c523920bcc09 1424 /* Measure detection IRQ */
johnAlexander 0:c523920bcc09 1425 InterruptIn *gpio1Int;
johnAlexander 0:c523920bcc09 1426 /* Device data */
johnAlexander 0:c523920bcc09 1427 VL53L0X_Dev_t MyDevice;
johnAlexander 0:c523920bcc09 1428 VL53L0X_DEV Device;
johnAlexander 0:c523920bcc09 1429 };
johnAlexander 0:c523920bcc09 1430
johnAlexander 0:c523920bcc09 1431
johnAlexander 0:c523920bcc09 1432 #endif /* _VL53L0X_CLASS_H_ */
johnAlexander 0:c523920bcc09 1433
johnAlexander 0:c523920bcc09 1434