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