Jerry Szczurak / X_NUCLEO_53L0A1

Changes to the library related to interrupt mode.

Dependencies:   ST_INTERFACES X_NUCLEO_COMMON

Dependents:   Display_53L0A1_IntSatelites Display_53L0A1_InterruptMode

Fork of X_NUCLEO_53L0A1 by ST

Components/VL53L0X/vl53l0x_class.h@12:820afb1af4ef, 2017-06-14 (annotated)

Committer:
JerrySzczurak
Date:
Wed Jun 14 14:10:45 2017 +0000
Revision:
12:820afb1af4ef
Parent:
11:c955adfbb19b 
Library change to work in interrupt continuous ranging mode

Who changed what in which revision?

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