vl53l0x_api.cpp

00001 /*******************************************************************************
00002  Copyright � 2016, STMicroelectronics International N.V.
00003  All rights reserved.
00004 
00005  Redistribution and use in source and binary forms, with or without
00006  modification, are permitted provided that the following conditions are met:
00007  * Redistributions of source code must retain the above copyright
00008  notice, this list of conditions and the following disclaimer.
00009  * Redistributions in binary form must reproduce the above copyright
00010  notice, this list of conditions and the following disclaimer in the
00011  documentation and/or other materials provided with the distribution.
00012  * Neither the name of STMicroelectronics nor the
00013  names of its contributors may be used to endorse or promote products
00014  derived from this software without specific prior written permission.
00015 
00016  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
00017  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
00018  WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
00019  NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
00020  IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
00021  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
00022  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00023  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
00024  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00025  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00026  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00027  ******************************************************************************/
00028 
00029 #include "vl53l0x_api.h"
00030 #include "vl53l0x_tuning.h"
00031 #include "vl53l0x_interrupt_threshold_settings.h"
00032 #include "vl53l0x_api_core.h"
00033 #include "vl53l0x_api_calibration.h"
00034 #include "vl53l0x_api_strings.h"
00035 
00036 #ifndef __KERNEL__
00037 #include <stdlib.h>
00038 #endif
00039 
00040 
00041 /* Group PAL General Functions */
00042 
00043 VL53L0X_Error VL53L0X_GetVersion(VL53L0X_Version_t *pVersion)
00044 {
00045     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00046 
00047     pVersion->major  = VL53L0X_IMPLEMENTATION_VER_MAJOR;
00048     pVersion->minor  = VL53L0X_IMPLEMENTATION_VER_MINOR;
00049     pVersion->build  = VL53L0X_IMPLEMENTATION_VER_SUB;
00050 
00051     pVersion->revision  = VL53L0X_IMPLEMENTATION_VER_REVISION;
00052 
00053     return Status;
00054 }
00055 
00056 VL53L0X_Error VL53L0X_GetPalSpecVersion(VL53L0X_Version_t *pPalSpecVersion)
00057 {
00058     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00059 
00060 
00061     pPalSpecVersion->major  = VL53L0X_SPECIFICATION_VER_MAJOR;
00062     pPalSpecVersion->minor  = VL53L0X_SPECIFICATION_VER_MINOR;
00063     pPalSpecVersion->build  = VL53L0X_SPECIFICATION_VER_SUB;
00064 
00065     pPalSpecVersion->revision  = VL53L0X_SPECIFICATION_VER_REVISION;
00066 
00067     return Status;
00068 }
00069 
00070 VL53L0X_Error VL53L0X_GetProductRevision(VL53L0X_DEV Dev,
00071     uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor)
00072 {
00073     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00074     uint8_t revision_id;
00075 
00076 
00077     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_REVISION_ID,
00078         &revision_id);
00079     *pProductRevisionMajor = 1;
00080     *pProductRevisionMinor = (revision_id & 0xF0) >> 4;
00081 
00082     return Status;
00083 
00084 }
00085 
00086 VL53L0X_Error VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
00087     VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
00088 {
00089     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00090 
00091     Status = VL53L0X_get_device_info(Dev, pVL53L0X_DeviceInfo);
00092 
00093     return Status;
00094 }
00095 
00096 VL53L0X_Error VL53L0X_GetDeviceErrorStatus(VL53L0X_DEV Dev,
00097     VL53L0X_DeviceError *pDeviceErrorStatus)
00098 {
00099     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00100     uint8_t RangeStatus;
00101 
00102 
00103     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
00104         &RangeStatus);
00105 
00106     *pDeviceErrorStatus = (VL53L0X_DeviceError)((RangeStatus & 0x78) >> 3);
00107 
00108     return Status;
00109 }
00110 
00111 
00112 VL53L0X_Error VL53L0X_GetDeviceErrorString(VL53L0X_DeviceError ErrorCode,
00113     char *pDeviceErrorString)
00114 {
00115     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00116 
00117 
00118     Status = VL53L0X_get_device_error_string(ErrorCode, pDeviceErrorString);
00119 
00120     return Status;
00121 }
00122 
00123 VL53L0X_Error VL53L0X_GetRangeStatusString(uint8_t RangeStatus,
00124     char *pRangeStatusString)
00125 {
00126     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00127 
00128     Status = VL53L0X_get_range_status_string(RangeStatus,
00129         pRangeStatusString);
00130 
00131     return Status;
00132 }
00133 
00134 VL53L0X_Error VL53L0X_GetPalErrorString(VL53L0X_Error PalErrorCode,
00135     char *pPalErrorString)
00136 {
00137     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00138 
00139     Status = VL53L0X_get_pal_error_string(PalErrorCode, pPalErrorString);
00140 
00141     return Status;
00142 }
00143 
00144 VL53L0X_Error VL53L0X_GetPalStateString(VL53L0X_State PalStateCode,
00145     char *pPalStateString)
00146 {
00147     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00148 
00149     Status = VL53L0X_get_pal_state_string(PalStateCode, pPalStateString);
00150 
00151     return Status;
00152 }
00153 
00154 VL53L0X_Error VL53L0X_GetPalState(VL53L0X_DEV Dev, VL53L0X_State *pPalState)
00155 {
00156     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00157 
00158     *pPalState = PALDevDataGet(Dev, PalState);
00159 
00160     return Status;
00161 }
00162 
00163 VL53L0X_Error VL53L0X_SetPowerMode(VL53L0X_DEV Dev, VL53L0X_PowerModes PowerMode)
00164 {
00165     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00166 
00167     /* Only level1 of Power mode exists */
00168     if ((PowerMode != VL53L0X_POWERMODE_STANDBY_LEVEL1)
00169         && (PowerMode != VL53L0X_POWERMODE_IDLE_LEVEL1)) {
00170         Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
00171     } else if (PowerMode == VL53L0X_POWERMODE_STANDBY_LEVEL1) {
00172         /* set the standby level1 of power mode */
00173         Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
00174         if (Status == VL53L0X_ERROR_NONE) {
00175             /* Set PAL State to standby */
00176             PALDevDataSet(Dev, PalState, VL53L0X_STATE_STANDBY);
00177             PALDevDataSet(Dev, PowerMode,
00178                 VL53L0X_POWERMODE_STANDBY_LEVEL1);
00179         }
00180 
00181     } else {
00182         /* VL53L0X_POWERMODE_IDLE_LEVEL1 */
00183         Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
00184         if (Status == VL53L0X_ERROR_NONE)
00185             Status = VL53L0X_StaticInit(Dev);
00186 
00187         if (Status == VL53L0X_ERROR_NONE)
00188             PALDevDataSet(Dev, PowerMode,
00189                 VL53L0X_POWERMODE_IDLE_LEVEL1);
00190 
00191     }
00192 
00193     return Status;
00194 }
00195 
00196 VL53L0X_Error VL53L0X_GetPowerMode(VL53L0X_DEV Dev, VL53L0X_PowerModes *pPowerMode)
00197 {
00198     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00199     uint8_t Byte;
00200 
00201     /* Only level1 of Power mode exists */
00202     Status = VL53L0X_RdByte(Dev, 0x80, &Byte);
00203 
00204     if (Status == VL53L0X_ERROR_NONE) {
00205         if (Byte == 1) {
00206             PALDevDataSet(Dev, PowerMode,
00207                 VL53L0X_POWERMODE_IDLE_LEVEL1);
00208         } else {
00209             PALDevDataSet(Dev, PowerMode,
00210                 VL53L0X_POWERMODE_STANDBY_LEVEL1);
00211         }
00212     }
00213 
00214     return Status;
00215 }
00216 
00217 VL53L0X_Error VL53L0X_SetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
00218     int32_t OffsetCalibrationDataMicroMeter)
00219 {
00220     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00221 
00222     Status = VL53L0X_set_offset_calibration_data_micro_meter(Dev,
00223         OffsetCalibrationDataMicroMeter);
00224 
00225     return Status;
00226 }
00227 
00228 VL53L0X_Error VL53L0X_GetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
00229     int32_t *pOffsetCalibrationDataMicroMeter)
00230 {
00231     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00232 
00233     Status = VL53L0X_get_offset_calibration_data_micro_meter(Dev,
00234         pOffsetCalibrationDataMicroMeter);
00235 
00236     return Status;
00237 }
00238 
00239 VL53L0X_Error VL53L0X_SetLinearityCorrectiveGain(VL53L0X_DEV Dev,
00240     int16_t LinearityCorrectiveGain)
00241 {
00242     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00243 
00244     if ((LinearityCorrectiveGain < 0) || (LinearityCorrectiveGain > 1000))
00245         Status = VL53L0X_ERROR_INVALID_PARAMS;
00246     else {
00247         PALDevDataSet(Dev, LinearityCorrectiveGain,
00248             LinearityCorrectiveGain);
00249 
00250         if (LinearityCorrectiveGain != 1000) {
00251             /* Disable FW Xtalk */
00252             Status = VL53L0X_WrWord(Dev,
00253             VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, 0);
00254         }
00255     }
00256 
00257     return Status;
00258 }
00259 
00260 VL53L0X_Error VL53L0X_GetLinearityCorrectiveGain(VL53L0X_DEV Dev,
00261     uint16_t *pLinearityCorrectiveGain)
00262 {
00263     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00264 
00265     *pLinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
00266 
00267     return Status;
00268 }
00269 
00270 VL53L0X_Error VL53L0X_SetGroupParamHold(VL53L0X_DEV Dev, uint8_t GroupParamHold)
00271 {
00272     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
00273 
00274     /* not implemented on VL53L0X */
00275 
00276     return Status;
00277 }
00278 
00279 VL53L0X_Error VL53L0X_GetUpperLimitMilliMeter(VL53L0X_DEV Dev,
00280     uint16_t *pUpperLimitMilliMeter)
00281 {
00282     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
00283 
00284     /* not implemented on VL53L0X */
00285 
00286     return Status;
00287 }
00288 
00289 VL53L0X_Error VL53L0X_GetTotalSignalRate(VL53L0X_DEV Dev,
00290     FixPoint1616_t *pTotalSignalRate)
00291 {
00292     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00293     VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
00294 
00295 
00296     LastRangeDataBuffer = PALDevDataGet(Dev, LastRangeMeasure);
00297 
00298     Status = VL53L0X_get_total_signal_rate(
00299         Dev, &LastRangeDataBuffer, pTotalSignalRate);
00300 
00301     return Status;
00302 }
00303 
00304 /* End Group PAL General Functions */
00305 
00306 /* Group PAL Init Functions */
00307 VL53L0X_Error VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev, uint8_t DeviceAddress)
00308 {
00309     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00310 
00311     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
00312         DeviceAddress / 2);
00313 
00314     return Status;
00315 }
00316 
00317 VL53L0X_Error VL53L0X_DataInit(VL53L0X_DEV Dev)
00318 {
00319     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00320     VL53L0X_DeviceParameters_t CurrentParameters;
00321     int i;
00322     uint8_t StopVariable;
00323 
00324 
00325     /* by default the I2C is running at 1V8 if you want to change it you
00326      * need to include this define at compilation level. */
00327 #ifdef USE_I2C_2V8
00328     Status = VL53L0X_UpdateByte(Dev,
00329         VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
00330         0xFE,
00331         0x01);
00332 #endif
00333 
00334     /* Set I2C standard mode */
00335     if (Status == VL53L0X_ERROR_NONE)
00336         Status = VL53L0X_WrByte(Dev, 0x88, 0x00);
00337 
00338     VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone, 0);
00339 
00340 #ifdef USE_IQC_STATION
00341     if (Status == VL53L0X_ERROR_NONE)
00342         Status = VL53L0X_apply_offset_adjustment(Dev);
00343 #endif
00344 
00345     /* Default value is 1000 for Linearity Corrective Gain */
00346     PALDevDataSet(Dev, LinearityCorrectiveGain, 1000);
00347 
00348     /* Dmax default Parameter */
00349     PALDevDataSet(Dev, DmaxCalRangeMilliMeter, 400);
00350     PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
00351         (FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
00352 
00353     /* Set Default static parameters
00354      *set first temporary values 9.44MHz * 65536 = 618660 */
00355     VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz, 618660);
00356 
00357     /* Set Default XTalkCompensationRateMegaCps to 0  */
00358     VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps, 0);
00359 
00360     /* Get default parameters */
00361     Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
00362     if (Status == VL53L0X_ERROR_NONE) {
00363         /* initialize PAL values */
00364         CurrentParameters.DeviceMode  = VL53L0X_DEVICEMODE_SINGLE_RANGING;
00365         CurrentParameters.HistogramMode  = VL53L0X_HISTOGRAMMODE_DISABLED;
00366         PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
00367     }
00368 
00369     /* Sigma estimator variable */
00370     PALDevDataSet(Dev, SigmaEstRefArray, 100);
00371     PALDevDataSet(Dev, SigmaEstEffPulseWidth, 900);
00372     PALDevDataSet(Dev, SigmaEstEffAmbWidth, 500);
00373     PALDevDataSet(Dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
00374 
00375     /* Use internal default settings */
00376     PALDevDataSet(Dev, UseInternalTuningSettings, 1);
00377 
00378     Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
00379     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
00380     Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
00381     Status |= VL53L0X_RdByte(Dev, 0x91, &StopVariable);
00382     PALDevDataSet(Dev, StopVariable, StopVariable);
00383     Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
00384     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
00385     Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
00386 
00387     /* Enable all check */
00388     for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
00389         if (Status == VL53L0X_ERROR_NONE)
00390             Status |= VL53L0X_SetLimitCheckEnable(Dev, i, 1);
00391         else
00392             break;
00393 
00394     }
00395 
00396     /* Disable the following checks */
00397     if (Status == VL53L0X_ERROR_NONE)
00398         Status = VL53L0X_SetLimitCheckEnable(Dev,
00399             VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
00400 
00401     if (Status == VL53L0X_ERROR_NONE)
00402         Status = VL53L0X_SetLimitCheckEnable(Dev,
00403             VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
00404 
00405     if (Status == VL53L0X_ERROR_NONE)
00406         Status = VL53L0X_SetLimitCheckEnable(Dev,
00407             VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
00408 
00409     if (Status == VL53L0X_ERROR_NONE)
00410         Status = VL53L0X_SetLimitCheckEnable(Dev,
00411             VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
00412 
00413     /* Limit default values */
00414     if (Status == VL53L0X_ERROR_NONE) {
00415         Status = VL53L0X_SetLimitCheckValue(Dev,
00416             VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
00417                 (FixPoint1616_t)(18 * 65536));
00418     }
00419     if (Status == VL53L0X_ERROR_NONE) {
00420         Status = VL53L0X_SetLimitCheckValue(Dev,
00421             VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
00422                 (FixPoint1616_t)(25 * 65536 / 100));
00423                 /* 0.25 * 65536 */
00424     }
00425 
00426     if (Status == VL53L0X_ERROR_NONE) {
00427         Status = VL53L0X_SetLimitCheckValue(Dev,
00428             VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
00429                 (FixPoint1616_t)(35 * 65536));
00430     }
00431 
00432     if (Status == VL53L0X_ERROR_NONE) {
00433         Status = VL53L0X_SetLimitCheckValue(Dev,
00434             VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
00435                 (FixPoint1616_t)(0 * 65536));
00436     }
00437 
00438     if (Status == VL53L0X_ERROR_NONE) {
00439 
00440         PALDevDataSet(Dev, SequenceConfig, 0xFF);
00441         Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
00442             0xFF);
00443 
00444         /* Set PAL state to tell that we are waiting for call to
00445          * VL53L0X_StaticInit */
00446         PALDevDataSet(Dev, PalState, VL53L0X_STATE_WAIT_STATICINIT);
00447     }
00448 
00449     if (Status == VL53L0X_ERROR_NONE)
00450         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 0);
00451 
00452 
00453     return Status;
00454 }
00455 
00456 VL53L0X_Error VL53L0X_SetTuningSettingBuffer(VL53L0X_DEV Dev,
00457     uint8_t *pTuningSettingBuffer, uint8_t UseInternalTuningSettings)
00458 {
00459     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00460 
00461 
00462     if (UseInternalTuningSettings == 1) {
00463         /* Force use internal settings */
00464         PALDevDataSet(Dev, UseInternalTuningSettings, 1);
00465     } else {
00466 
00467         /* check that the first byte is not 0 */
00468         if (*pTuningSettingBuffer != 0) {
00469             PALDevDataSet(Dev, pTuningSettingsPointer,
00470                 pTuningSettingBuffer);
00471             PALDevDataSet(Dev, UseInternalTuningSettings, 0);
00472 
00473         } else {
00474             Status = VL53L0X_ERROR_INVALID_PARAMS;
00475         }
00476     }
00477 
00478     return Status;
00479 }
00480 
00481 VL53L0X_Error VL53L0X_GetTuningSettingBuffer(VL53L0X_DEV Dev,
00482     uint8_t **ppTuningSettingBuffer, uint8_t *pUseInternalTuningSettings)
00483 {
00484     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00485 
00486 
00487     *ppTuningSettingBuffer = PALDevDataGet(Dev, pTuningSettingsPointer);
00488     *pUseInternalTuningSettings = PALDevDataGet(Dev,
00489         UseInternalTuningSettings);
00490 
00491     return Status;
00492 }
00493 
00494 VL53L0X_Error VL53L0X_StaticInit(VL53L0X_DEV Dev)
00495 {
00496     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00497     VL53L0X_DeviceParameters_t CurrentParameters = {0};
00498     uint8_t *pTuningSettingBuffer;
00499     uint16_t tempword = 0;
00500     uint8_t tempbyte = 0;
00501     uint8_t UseInternalTuningSettings = 0;
00502     uint32_t count = 0;
00503     uint8_t isApertureSpads = 0;
00504     uint32_t refSpadCount = 0;
00505     uint8_t ApertureSpads = 0;
00506     uint8_t vcselPulsePeriodPCLK;
00507     uint32_t seqTimeoutMicroSecs;
00508   
00509     Status = VL53L0X_get_info_from_device(Dev, 1);
00510 
00511 
00512     /* set the ref spad from NVM */
00513     count           = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ReferenceSpadCount);
00514   ApertureSpads =           VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ReferenceSpadType);
00515 
00516 
00517     /* NVM value invalid */
00518     if ((ApertureSpads > 1) || ((ApertureSpads == 1) && (count > 32)) || ((ApertureSpads == 0) && (count > 12)))
00519   {
00520         Status = VL53L0X_perform_ref_spad_management(Dev, &refSpadCount, &isApertureSpads);
00521   }
00522   else
00523   {
00524         Status = VL53L0X_set_reference_spads(Dev, count, ApertureSpads);
00525   }
00526 
00527     /* Initialize tuning settings buffer to prevent compiler warning. */
00528     pTuningSettingBuffer = DefaultTuningSettings;
00529 
00530     if (Status == VL53L0X_ERROR_NONE)
00531   {
00532         UseInternalTuningSettings = PALDevDataGet(Dev, UseInternalTuningSettings);
00533 
00534         if (UseInternalTuningSettings == 0)
00535     {
00536             pTuningSettingBuffer = PALDevDataGet(Dev,   pTuningSettingsPointer);
00537     }
00538         else
00539     {
00540       pTuningSettingBuffer = DefaultTuningSettings;
00541     }
00542     }
00543 
00544     if (Status == VL53L0X_ERROR_NONE)
00545   {
00546         Status = VL53L0X_load_tuning_settings(Dev, pTuningSettingBuffer);
00547   }
00548 
00549     /* Set interrupt config to new sample ready */
00550     if (Status == VL53L0X_ERROR_NONE) {
00551         Status = VL53L0X_SetGpioConfig(Dev, 0, 0,   VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY, VL53L0X_INTERRUPTPOLARITY_LOW);
00552     }
00553 
00554     if (Status == VL53L0X_ERROR_NONE) {
00555         Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
00556         Status |= VL53L0X_RdWord(Dev, 0x84, &tempword);
00557         Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
00558     }
00559 
00560     if (Status == VL53L0X_ERROR_NONE) {
00561         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz, VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
00562     }
00563 
00564     /* After static init, some device parameters may be changed,
00565      * so update them */
00566     if (Status == VL53L0X_ERROR_NONE)
00567   {
00568         Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
00569   }
00570 
00571     if (Status == VL53L0X_ERROR_NONE)
00572   {
00573         Status = VL53L0X_GetFractionEnable(Dev, &tempbyte);
00574 
00575         if (Status == VL53L0X_ERROR_NONE)
00576       {
00577       PALDevDataSet(Dev, RangeFractionalEnable, tempbyte);
00578     }
00579     }
00580 
00581     if (Status == VL53L0X_ERROR_NONE)
00582   {
00583         PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
00584   }
00585 
00586     /* read the sequence config and save it */
00587     if (Status == VL53L0X_ERROR_NONE)
00588   {
00589         Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
00590 
00591         if (Status == VL53L0X_ERROR_NONE)
00592     {
00593             PALDevDataSet(Dev, SequenceConfig, tempbyte);
00594     }
00595     }
00596 
00597     /* Disable MSRC and TCC by default */
00598     if (Status == VL53L0X_ERROR_NONE)
00599   {
00600         Status = VL53L0X_SetSequenceStepEnable(Dev, VL53L0X_SEQUENCESTEP_TCC, 0);
00601   }
00602 
00603 
00604     if (Status == VL53L0X_ERROR_NONE)
00605   {
00606         Status = VL53L0X_SetSequenceStepEnable(Dev, VL53L0X_SEQUENCESTEP_MSRC, 0);
00607   }
00608 
00609 
00610     /* Set PAL State to standby */
00611     if (Status == VL53L0X_ERROR_NONE)
00612   {
00613         PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
00614   }
00615 
00616 
00617     /* Store pre-range vcsel period */
00618     if (Status == VL53L0X_ERROR_NONE)
00619   {
00620         Status = VL53L0X_GetVcselPulsePeriod(Dev, VL53L0X_VCSEL_PERIOD_PRE_RANGE, &vcselPulsePeriodPCLK);
00621     }
00622 
00623     if (Status == VL53L0X_ERROR_NONE)
00624   {
00625     VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, PreRangeVcselPulsePeriod, vcselPulsePeriodPCLK);
00626     }
00627 
00628     /* Store final-range vcsel period */
00629     if (Status == VL53L0X_ERROR_NONE)
00630   {
00631         Status = VL53L0X_GetVcselPulsePeriod(Dev, VL53L0X_VCSEL_PERIOD_FINAL_RANGE, &vcselPulsePeriodPCLK);
00632   }
00633 
00634     if (Status == VL53L0X_ERROR_NONE)
00635   {
00636         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, FinalRangeVcselPulsePeriod, vcselPulsePeriodPCLK);
00637     }
00638 
00639     /* Store pre-range timeout */
00640     if (Status == VL53L0X_ERROR_NONE)
00641   {
00642         Status = get_sequence_step_timeout(Dev, VL53L0X_SEQUENCESTEP_PRE_RANGE, &seqTimeoutMicroSecs);
00643     }
00644 
00645     if (Status == VL53L0X_ERROR_NONE) {
00646         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, PreRangeTimeoutMicroSecs,   seqTimeoutMicroSecs);
00647     }
00648 
00649     /* Store final-range timeout */
00650     if (Status == VL53L0X_ERROR_NONE)
00651   {
00652         Status = get_sequence_step_timeout(Dev, VL53L0X_SEQUENCESTEP_FINAL_RANGE, &seqTimeoutMicroSecs);
00653   }
00654 
00655     if (Status == VL53L0X_ERROR_NONE) {
00656         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, FinalRangeTimeoutMicroSecs, seqTimeoutMicroSecs);
00657     }
00658 
00659     return Status;
00660 }
00661 
00662 VL53L0X_Error VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev)
00663 {
00664     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
00665 
00666     /* not implemented on VL53L0X */
00667 
00668     return Status;
00669 }
00670 
00671 VL53L0X_Error VL53L0X_ResetDevice(VL53L0X_DEV Dev)
00672 {
00673     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00674     uint8_t Byte;
00675 
00676     /* Set reset bit */
00677     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
00678         0x00);
00679 
00680     /* Wait for some time */
00681     if (Status == VL53L0X_ERROR_NONE) {
00682         do {
00683             Status = VL53L0X_RdByte(Dev,
00684             VL53L0X_REG_IDENTIFICATION_MODEL_ID, &Byte);
00685         } while (Byte != 0x00);
00686     }
00687 
00688     VL53L0X_PollingDelay(Dev);
00689 
00690     /* Release reset */
00691     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
00692         0x01);
00693 
00694     /* Wait until correct boot-up of the device */
00695     if (Status == VL53L0X_ERROR_NONE) {
00696         do {
00697             Status = VL53L0X_RdByte(Dev,
00698             VL53L0X_REG_IDENTIFICATION_MODEL_ID, &Byte);
00699         } while (Byte == 0x00);
00700     }
00701 
00702     VL53L0X_PollingDelay(Dev);
00703 
00704     /* Set PAL State to VL53L0X_STATE_POWERDOWN */
00705     if (Status == VL53L0X_ERROR_NONE)
00706         PALDevDataSet(Dev, PalState, VL53L0X_STATE_POWERDOWN);
00707 
00708 
00709     return Status;
00710 }
00711 /* End Group PAL Init Functions */
00712 
00713 /* Group PAL Parameters Functions */
00714 VL53L0X_Error VL53L0X_SetDeviceParameters(VL53L0X_DEV Dev,
00715     const VL53L0X_DeviceParameters_t *pDeviceParameters)
00716 {
00717     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00718     int i;
00719     Status = VL53L0X_SetDeviceMode(Dev, pDeviceParameters->DeviceMode );
00720 
00721     if (Status == VL53L0X_ERROR_NONE)
00722         Status = VL53L0X_SetInterMeasurementPeriodMilliSeconds(Dev,
00723             pDeviceParameters->InterMeasurementPeriodMilliSeconds );
00724 
00725 
00726     if (Status == VL53L0X_ERROR_NONE)
00727         Status = VL53L0X_SetXTalkCompensationRateMegaCps(Dev,
00728             pDeviceParameters->XTalkCompensationRateMegaCps );
00729 
00730 
00731     if (Status == VL53L0X_ERROR_NONE)
00732         Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev,
00733             pDeviceParameters->RangeOffsetMicroMeters );
00734 
00735 
00736     for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
00737         if (Status == VL53L0X_ERROR_NONE)
00738             Status |= VL53L0X_SetLimitCheckEnable(Dev, i,
00739                 pDeviceParameters->LimitChecksEnable [i]);
00740         else
00741             break;
00742 
00743         if (Status == VL53L0X_ERROR_NONE)
00744             Status |= VL53L0X_SetLimitCheckValue(Dev, i,
00745                 pDeviceParameters->LimitChecksValue [i]);
00746         else
00747             break;
00748 
00749     }
00750 
00751     if (Status == VL53L0X_ERROR_NONE)
00752         Status = VL53L0X_SetWrapAroundCheckEnable(Dev,
00753             pDeviceParameters->WrapAroundCheckEnable );
00754 
00755     if (Status == VL53L0X_ERROR_NONE)
00756         Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
00757             pDeviceParameters->MeasurementTimingBudgetMicroSeconds );
00758 
00759 
00760     return Status;
00761 }
00762 
00763 VL53L0X_Error VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
00764     VL53L0X_DeviceParameters_t *pDeviceParameters)
00765 {
00766     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00767     int i;
00768 
00769 
00770     Status = VL53L0X_GetDeviceMode(Dev, &(pDeviceParameters->DeviceMode ));
00771 
00772     if (Status == VL53L0X_ERROR_NONE)
00773         Status = VL53L0X_GetInterMeasurementPeriodMilliSeconds(Dev,
00774         &(pDeviceParameters->InterMeasurementPeriodMilliSeconds ));
00775 
00776 
00777     if (Status == VL53L0X_ERROR_NONE)
00778         pDeviceParameters->XTalkCompensationEnable  = 0;
00779 
00780     if (Status == VL53L0X_ERROR_NONE)
00781         Status = VL53L0X_GetXTalkCompensationRateMegaCps(Dev,
00782             &(pDeviceParameters->XTalkCompensationRateMegaCps ));
00783 
00784 
00785     if (Status == VL53L0X_ERROR_NONE)
00786         Status = VL53L0X_GetOffsetCalibrationDataMicroMeter(Dev,
00787             &(pDeviceParameters->RangeOffsetMicroMeters ));
00788 
00789 
00790     if (Status == VL53L0X_ERROR_NONE) {
00791         for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
00792             /* get first the values, then the enables.
00793              * VL53L0X_GetLimitCheckValue will modify the enable
00794              * flags
00795              */
00796             if (Status == VL53L0X_ERROR_NONE) {
00797                 Status |= VL53L0X_GetLimitCheckValue(Dev, i,
00798                 &(pDeviceParameters->LimitChecksValue [i]));
00799             } else {
00800                 break;
00801             }
00802             if (Status == VL53L0X_ERROR_NONE) {
00803                 Status |= VL53L0X_GetLimitCheckEnable(Dev, i,
00804                 &(pDeviceParameters->LimitChecksEnable [i]));
00805             } else {
00806                 break;
00807             }
00808         }
00809     }
00810 
00811     if (Status == VL53L0X_ERROR_NONE) {
00812         Status = VL53L0X_GetWrapAroundCheckEnable(Dev,
00813             &(pDeviceParameters->WrapAroundCheckEnable ));
00814     }
00815 
00816     /* Need to be done at the end as it uses VCSELPulsePeriod */
00817     if (Status == VL53L0X_ERROR_NONE) {
00818         Status = VL53L0X_GetMeasurementTimingBudgetMicroSeconds(Dev,
00819         &(pDeviceParameters->MeasurementTimingBudgetMicroSeconds ));
00820     }
00821 
00822     return Status;
00823 }
00824 
00825 VL53L0X_Error VL53L0X_SetDeviceMode(VL53L0X_DEV Dev, VL53L0X_DeviceModes DeviceMode)
00826 {
00827     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00828 
00829 
00830     switch (DeviceMode) {
00831     case VL53L0X_DEVICEMODE_SINGLE_RANGING:
00832     case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
00833     case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
00834     case VL53L0X_DEVICEMODE_GPIO_DRIVE:
00835     case VL53L0X_DEVICEMODE_GPIO_OSC:
00836         /* Supported modes */
00837         VL53L0X_SETPARAMETERFIELD(Dev, DeviceMode, DeviceMode);
00838         break;
00839     default:
00840         /* Unsupported mode */
00841         Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
00842     }
00843 
00844     return Status;
00845 }
00846 
00847 VL53L0X_Error VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
00848     VL53L0X_DeviceModes *pDeviceMode)
00849 {
00850     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00851 
00852     VL53L0X_GETPARAMETERFIELD(Dev, DeviceMode, *pDeviceMode);
00853 
00854     return Status;
00855 }
00856 
00857 VL53L0X_Error VL53L0X_SetRangeFractionEnable(VL53L0X_DEV Dev,   uint8_t Enable)
00858 {
00859     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00860 
00861 
00862     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, Enable);
00863 
00864     if (Status == VL53L0X_ERROR_NONE)
00865         PALDevDataSet(Dev, RangeFractionalEnable, Enable);
00866 
00867     return Status;
00868 }
00869 
00870 VL53L0X_Error VL53L0X_GetFractionEnable(VL53L0X_DEV Dev, uint8_t *pEnabled)
00871 {
00872     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00873 
00874     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, pEnabled);
00875 
00876     if (Status == VL53L0X_ERROR_NONE)
00877         *pEnabled = (*pEnabled & 1);
00878 
00879     return Status;
00880 }
00881 
00882 VL53L0X_Error VL53L0X_SetHistogramMode(VL53L0X_DEV Dev,
00883     VL53L0X_HistogramModes HistogramMode)
00884 {
00885     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
00886 
00887     /* not implemented on VL53L0X */
00888 
00889     return Status;
00890 }
00891 
00892 VL53L0X_Error VL53L0X_GetHistogramMode(VL53L0X_DEV Dev,
00893     VL53L0X_HistogramModes *pHistogramMode)
00894 {
00895     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
00896 
00897     /* not implemented on VL53L0X */
00898 
00899     return Status;
00900 }
00901 
00902 VL53L0X_Error VL53L0X_SetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
00903     uint32_t MeasurementTimingBudgetMicroSeconds)
00904 {
00905     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00906 
00907     Status = VL53L0X_set_measurement_timing_budget_micro_seconds(Dev,
00908         MeasurementTimingBudgetMicroSeconds);
00909 
00910 
00911     return Status;
00912 }
00913 
00914 VL53L0X_Error VL53L0X_GetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
00915     uint32_t *pMeasurementTimingBudgetMicroSeconds)
00916 {
00917     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00918 
00919     Status = VL53L0X_get_measurement_timing_budget_micro_seconds(Dev,
00920         pMeasurementTimingBudgetMicroSeconds);
00921 
00922     return Status;
00923 }
00924 
00925 VL53L0X_Error VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
00926     VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK)
00927 {
00928     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00929 
00930     Status = VL53L0X_set_vcsel_pulse_period(Dev, VcselPeriodType,
00931         VCSELPulsePeriodPCLK);
00932 
00933     return Status;
00934 }
00935 
00936 VL53L0X_Error VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
00937     VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
00938 {
00939     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00940 
00941     Status = VL53L0X_get_vcsel_pulse_period(Dev, VcselPeriodType,
00942         pVCSELPulsePeriodPCLK);
00943 
00944     return Status;
00945 }
00946 
00947 VL53L0X_Error VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
00948     VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled)
00949 {
00950     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
00951     uint8_t SequenceConfig = 0;
00952     uint8_t SequenceConfigNew = 0;
00953     uint32_t MeasurementTimingBudgetMicroSeconds;
00954 
00955     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
00956         &SequenceConfig);
00957 
00958     SequenceConfigNew = SequenceConfig;
00959 
00960     if (Status == VL53L0X_ERROR_NONE) {
00961         if (SequenceStepEnabled == 1) {
00962 
00963             /* Enable requested sequence step
00964              */
00965             switch (SequenceStepId) {
00966             case VL53L0X_SEQUENCESTEP_TCC:
00967                 SequenceConfigNew |= 0x10;
00968                 break;
00969             case VL53L0X_SEQUENCESTEP_DSS:
00970                 SequenceConfigNew |= 0x28;
00971                 break;
00972             case VL53L0X_SEQUENCESTEP_MSRC:
00973                 SequenceConfigNew |= 0x04;
00974                 break;
00975             case VL53L0X_SEQUENCESTEP_PRE_RANGE:
00976                 SequenceConfigNew |= 0x40;
00977                 break;
00978             case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
00979                 SequenceConfigNew |= 0x80;
00980                 break;
00981             default:
00982                 Status = VL53L0X_ERROR_INVALID_PARAMS;
00983             }
00984         } else {
00985             /* Disable requested sequence step
00986              */
00987             switch (SequenceStepId) {
00988             case VL53L0X_SEQUENCESTEP_TCC:
00989                 SequenceConfigNew &= 0xef;
00990                 break;
00991             case VL53L0X_SEQUENCESTEP_DSS:
00992                 SequenceConfigNew &= 0xd7;
00993                 break;
00994             case VL53L0X_SEQUENCESTEP_MSRC:
00995                 SequenceConfigNew &= 0xfb;
00996                 break;
00997             case VL53L0X_SEQUENCESTEP_PRE_RANGE:
00998                 SequenceConfigNew &= 0xbf;
00999                 break;
01000             case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
01001                 SequenceConfigNew &= 0x7f;
01002                 break;
01003             default:
01004                 Status = VL53L0X_ERROR_INVALID_PARAMS;
01005             }
01006         }
01007     }
01008 
01009     if (SequenceConfigNew != SequenceConfig) {
01010         /* Apply New Setting */
01011         if (Status == VL53L0X_ERROR_NONE) {
01012             Status = VL53L0X_WrByte(Dev,
01013             VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, SequenceConfigNew);
01014         }
01015         if (Status == VL53L0X_ERROR_NONE)
01016             PALDevDataSet(Dev, SequenceConfig, SequenceConfigNew);
01017 
01018 
01019         /* Recalculate timing budget */
01020         if (Status == VL53L0X_ERROR_NONE) {
01021             VL53L0X_GETPARAMETERFIELD(Dev,
01022                 MeasurementTimingBudgetMicroSeconds,
01023                 MeasurementTimingBudgetMicroSeconds);
01024 
01025             VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
01026                 MeasurementTimingBudgetMicroSeconds);
01027         }
01028     }
01029 
01030 
01031     return Status;
01032 }
01033 
01034 VL53L0X_Error sequence_step_enabled(VL53L0X_DEV Dev,
01035     VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceConfig,
01036     uint8_t *pSequenceStepEnabled)
01037 {
01038     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01039     *pSequenceStepEnabled = 0;
01040 
01041     switch (SequenceStepId) {
01042     case VL53L0X_SEQUENCESTEP_TCC:
01043         *pSequenceStepEnabled = (SequenceConfig & 0x10) >> 4;
01044         break;
01045     case VL53L0X_SEQUENCESTEP_DSS:
01046         *pSequenceStepEnabled = (SequenceConfig & 0x08) >> 3;
01047         break;
01048     case VL53L0X_SEQUENCESTEP_MSRC:
01049         *pSequenceStepEnabled = (SequenceConfig & 0x04) >> 2;
01050         break;
01051     case VL53L0X_SEQUENCESTEP_PRE_RANGE:
01052         *pSequenceStepEnabled = (SequenceConfig & 0x40) >> 6;
01053         break;
01054     case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
01055         *pSequenceStepEnabled = (SequenceConfig & 0x80) >> 7;
01056         break;
01057     default:
01058         Status = VL53L0X_ERROR_INVALID_PARAMS;
01059     }
01060 
01061     return Status;
01062 }
01063 
01064 VL53L0X_Error VL53L0X_GetSequenceStepEnable(VL53L0X_DEV Dev,
01065     VL53L0X_SequenceStepId SequenceStepId, uint8_t *pSequenceStepEnabled)
01066 {
01067     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01068     uint8_t SequenceConfig = 0;
01069 
01070     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
01071         &SequenceConfig);
01072 
01073     if (Status == VL53L0X_ERROR_NONE) {
01074         Status = sequence_step_enabled(Dev, SequenceStepId,
01075             SequenceConfig, pSequenceStepEnabled);
01076     }
01077 
01078     return Status;
01079 }
01080 
01081 VL53L0X_Error VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
01082     VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps)
01083 {
01084     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01085     uint8_t SequenceConfig = 0;
01086 
01087     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
01088         &SequenceConfig);
01089 
01090     if (Status == VL53L0X_ERROR_NONE) {
01091         Status = sequence_step_enabled(Dev,
01092         VL53L0X_SEQUENCESTEP_TCC, SequenceConfig,
01093             &pSchedulerSequenceSteps->TccOn);
01094     }
01095     if (Status == VL53L0X_ERROR_NONE) {
01096         Status = sequence_step_enabled(Dev,
01097         VL53L0X_SEQUENCESTEP_DSS, SequenceConfig,
01098             &pSchedulerSequenceSteps->DssOn);
01099     }
01100     if (Status == VL53L0X_ERROR_NONE) {
01101         Status = sequence_step_enabled(Dev,
01102         VL53L0X_SEQUENCESTEP_MSRC, SequenceConfig,
01103             &pSchedulerSequenceSteps->MsrcOn);
01104     }
01105     if (Status == VL53L0X_ERROR_NONE) {
01106         Status = sequence_step_enabled(Dev,
01107         VL53L0X_SEQUENCESTEP_PRE_RANGE, SequenceConfig,
01108             &pSchedulerSequenceSteps->PreRangeOn);
01109     }
01110     if (Status == VL53L0X_ERROR_NONE) {
01111         Status = sequence_step_enabled(Dev,
01112         VL53L0X_SEQUENCESTEP_FINAL_RANGE, SequenceConfig,
01113             &pSchedulerSequenceSteps->FinalRangeOn);
01114     }
01115 
01116     return Status;
01117 }
01118 
01119 VL53L0X_Error VL53L0X_GetNumberOfSequenceSteps(VL53L0X_DEV Dev,
01120     uint8_t *pNumberOfSequenceSteps)
01121 {
01122     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01123 
01124     *pNumberOfSequenceSteps = VL53L0X_SEQUENCESTEP_NUMBER_OF_CHECKS;
01125 
01126     return Status;
01127 }
01128 
01129 VL53L0X_Error VL53L0X_GetSequenceStepsInfo(VL53L0X_SequenceStepId SequenceStepId,
01130     char *pSequenceStepsString)
01131 {
01132     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01133 
01134     Status = VL53L0X_get_sequence_steps_info(
01135             SequenceStepId,
01136             pSequenceStepsString);
01137 
01138 
01139     return Status;
01140 }
01141 
01142 VL53L0X_Error VL53L0X_SetSequenceStepTimeout(VL53L0X_DEV Dev,
01143     VL53L0X_SequenceStepId SequenceStepId, FixPoint1616_t TimeOutMilliSecs)
01144 {
01145     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01146     VL53L0X_Error Status1 = VL53L0X_ERROR_NONE;
01147     uint32_t TimeoutMicroSeconds = ((TimeOutMilliSecs * 1000) + 0x8000)
01148         >> 16;
01149     uint32_t MeasurementTimingBudgetMicroSeconds;
01150     FixPoint1616_t OldTimeOutMicroSeconds;
01151 
01152 
01153     /* Read back the current value in case we need to revert back to this.
01154      */
01155     Status = get_sequence_step_timeout(Dev, SequenceStepId,
01156         &OldTimeOutMicroSeconds);
01157 
01158     if (Status == VL53L0X_ERROR_NONE) {
01159         Status = set_sequence_step_timeout(Dev, SequenceStepId,
01160             TimeoutMicroSeconds);
01161     }
01162 
01163     if (Status == VL53L0X_ERROR_NONE) {
01164         VL53L0X_GETPARAMETERFIELD(Dev,
01165             MeasurementTimingBudgetMicroSeconds,
01166             MeasurementTimingBudgetMicroSeconds);
01167 
01168         /* At this point we don't know if the requested value is valid,
01169          therefore proceed to update the entire timing budget and
01170          if this fails, revert back to the previous value.
01171          */
01172         Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
01173             MeasurementTimingBudgetMicroSeconds);
01174 
01175         if (Status != VL53L0X_ERROR_NONE) {
01176             Status1 = set_sequence_step_timeout(Dev, SequenceStepId,
01177                 OldTimeOutMicroSeconds);
01178 
01179             if (Status1 == VL53L0X_ERROR_NONE) {
01180                 Status1 =
01181                 VL53L0X_SetMeasurementTimingBudgetMicroSeconds(
01182                     Dev,
01183                     MeasurementTimingBudgetMicroSeconds);
01184             }
01185 
01186             Status = Status1;
01187         }
01188     }
01189 
01190 
01191     return Status;
01192 }
01193 
01194 VL53L0X_Error VL53L0X_GetSequenceStepTimeout(VL53L0X_DEV Dev,
01195     VL53L0X_SequenceStepId SequenceStepId, FixPoint1616_t *pTimeOutMilliSecs)
01196 {
01197     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01198     uint32_t TimeoutMicroSeconds;
01199 
01200     Status = get_sequence_step_timeout(Dev, SequenceStepId,
01201         &TimeoutMicroSeconds);
01202     if (Status == VL53L0X_ERROR_NONE) {
01203         TimeoutMicroSeconds <<= 8;
01204         *pTimeOutMilliSecs = (TimeoutMicroSeconds + 500)/1000;
01205         *pTimeOutMilliSecs <<= 8;
01206     }
01207 
01208     return Status;
01209 }
01210 
01211 VL53L0X_Error VL53L0X_SetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
01212     uint32_t InterMeasurementPeriodMilliSeconds)
01213 {
01214     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01215     uint16_t osc_calibrate_val;
01216     uint32_t IMPeriodMilliSeconds;
01217 
01218 
01219     Status = VL53L0X_RdWord(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
01220         &osc_calibrate_val);
01221 
01222     if (Status == VL53L0X_ERROR_NONE) {
01223         if (osc_calibrate_val != 0) {
01224             IMPeriodMilliSeconds =
01225                 InterMeasurementPeriodMilliSeconds
01226                     * osc_calibrate_val;
01227         } else {
01228             IMPeriodMilliSeconds =
01229                 InterMeasurementPeriodMilliSeconds;
01230         }
01231         Status = VL53L0X_WrDWord(Dev,
01232         VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
01233             IMPeriodMilliSeconds);
01234     }
01235 
01236     if (Status == VL53L0X_ERROR_NONE) {
01237         VL53L0X_SETPARAMETERFIELD(Dev,
01238             InterMeasurementPeriodMilliSeconds,
01239             InterMeasurementPeriodMilliSeconds);
01240     }
01241 
01242     return Status;
01243 }
01244 
01245 VL53L0X_Error VL53L0X_GetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
01246     uint32_t *pInterMeasurementPeriodMilliSeconds)
01247 {
01248     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01249     uint16_t osc_calibrate_val;
01250     uint32_t IMPeriodMilliSeconds;
01251 
01252 
01253     Status = VL53L0X_RdWord(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
01254         &osc_calibrate_val);
01255 
01256     if (Status == VL53L0X_ERROR_NONE) {
01257         Status = VL53L0X_RdDWord(Dev,
01258         VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
01259             &IMPeriodMilliSeconds);
01260     }
01261 
01262     if (Status == VL53L0X_ERROR_NONE) {
01263         if (osc_calibrate_val != 0) {
01264             *pInterMeasurementPeriodMilliSeconds =
01265                 IMPeriodMilliSeconds / osc_calibrate_val;
01266         }
01267         VL53L0X_SETPARAMETERFIELD(Dev,
01268             InterMeasurementPeriodMilliSeconds,
01269             *pInterMeasurementPeriodMilliSeconds);
01270     }
01271 
01272     return Status;
01273 }
01274 
01275 VL53L0X_Error VL53L0X_SetXTalkCompensationEnable(VL53L0X_DEV Dev,
01276     uint8_t XTalkCompensationEnable)
01277 {
01278     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01279     FixPoint1616_t TempFix1616;
01280     uint16_t LinearityCorrectiveGain;
01281 
01282 
01283     LinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
01284 
01285     if ((XTalkCompensationEnable == 0)
01286         || (LinearityCorrectiveGain != 1000)) {
01287         TempFix1616 = 0;
01288     } else {
01289         VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
01290             TempFix1616);
01291     }
01292 
01293     /* the following register has a format 3.13 */
01294     Status = VL53L0X_WrWord(Dev,
01295     VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS,
01296         VL53L0X_FIXPOINT1616TOFIXPOINT313(TempFix1616));
01297 
01298     if (Status == VL53L0X_ERROR_NONE) {
01299         if (XTalkCompensationEnable == 0) {
01300             VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
01301                 0);
01302         } else {
01303             VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
01304                 1);
01305         }
01306     }
01307 
01308     return Status;
01309 }
01310 
01311 VL53L0X_Error VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
01312     uint8_t *pXTalkCompensationEnable)
01313 {
01314     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01315     uint8_t Temp8;
01316 
01317     VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable, Temp8);
01318     *pXTalkCompensationEnable = Temp8;
01319 
01320     return Status;
01321 }
01322 
01323 VL53L0X_Error VL53L0X_SetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
01324     FixPoint1616_t XTalkCompensationRateMegaCps)
01325 {
01326     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01327     uint8_t Temp8;
01328     uint16_t LinearityCorrectiveGain;
01329     uint16_t data;
01330 
01331     VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable, Temp8);
01332     LinearityCorrectiveGain = PALDevDataGet(Dev, LinearityCorrectiveGain);
01333 
01334     if (Temp8 == 0) { /* disabled write only internal value */
01335         VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
01336             XTalkCompensationRateMegaCps);
01337     } else {
01338         /* the following register has a format 3.13 */
01339         if (LinearityCorrectiveGain == 1000) {
01340             data = VL53L0X_FIXPOINT1616TOFIXPOINT313(
01341                 XTalkCompensationRateMegaCps);
01342         } else {
01343             data = 0;
01344         }
01345 
01346         Status = VL53L0X_WrWord(Dev,
01347         VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, data);
01348 
01349         if (Status == VL53L0X_ERROR_NONE) {
01350             VL53L0X_SETPARAMETERFIELD(Dev,
01351                 XTalkCompensationRateMegaCps,
01352                 XTalkCompensationRateMegaCps);
01353         }
01354     }
01355 
01356     return Status;
01357 }
01358 
01359 VL53L0X_Error VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
01360     FixPoint1616_t *pXTalkCompensationRateMegaCps)
01361 {
01362     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01363     uint16_t Value;
01364     FixPoint1616_t TempFix1616;
01365 
01366 
01367     Status = VL53L0X_RdWord(Dev,
01368     VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&Value);
01369     if (Status == VL53L0X_ERROR_NONE) {
01370         if (Value == 0) {
01371             /* the Xtalk is disabled return value from memory */
01372             VL53L0X_GETPARAMETERFIELD(Dev,
01373                 XTalkCompensationRateMegaCps, TempFix1616);
01374             *pXTalkCompensationRateMegaCps = TempFix1616;
01375             VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
01376                 0);
01377         } else {
01378             TempFix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(Value);
01379             *pXTalkCompensationRateMegaCps = TempFix1616;
01380             VL53L0X_SETPARAMETERFIELD(Dev,
01381                 XTalkCompensationRateMegaCps, TempFix1616);
01382             VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
01383                 1);
01384         }
01385     }
01386 
01387     return Status;
01388 }
01389 
01390 VL53L0X_Error VL53L0X_SetRefCalibration(VL53L0X_DEV Dev, uint8_t VhvSettings,
01391     uint8_t PhaseCal)
01392 {
01393     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01394 
01395     Status = VL53L0X_set_ref_calibration(Dev, VhvSettings, PhaseCal);
01396 
01397     return Status;
01398 }
01399 
01400 VL53L0X_Error VL53L0X_GetRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
01401     uint8_t *pPhaseCal)
01402 {
01403     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01404 
01405     Status = VL53L0X_get_ref_calibration(Dev, pVhvSettings, pPhaseCal);
01406 
01407     return Status;
01408 }
01409 
01410 /*
01411  * CHECK LIMIT FUNCTIONS
01412  */
01413 
01414 VL53L0X_Error VL53L0X_GetNumberOfLimitCheck(uint16_t *pNumberOfLimitCheck)
01415 {
01416     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01417 
01418     *pNumberOfLimitCheck = VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS;
01419 
01420     return Status;
01421 }
01422 
01423 VL53L0X_Error VL53L0X_GetLimitCheckInfo(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01424     char *pLimitCheckString)
01425 {
01426     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01427 
01428 
01429     Status = VL53L0X_get_limit_check_info(Dev, LimitCheckId,
01430         pLimitCheckString);
01431 
01432     return Status;
01433 }
01434 
01435 VL53L0X_Error VL53L0X_GetLimitCheckStatus(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01436     uint8_t *pLimitCheckStatus)
01437 {
01438     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01439     uint8_t Temp8;
01440 
01441 
01442     if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
01443         Status = VL53L0X_ERROR_INVALID_PARAMS;
01444     } else {
01445 
01446         VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
01447             LimitCheckId, Temp8);
01448 
01449         *pLimitCheckStatus = Temp8;
01450 
01451     }
01452 
01453     return Status;
01454 }
01455 
01456 VL53L0X_Error VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01457     uint8_t LimitCheckEnable)
01458 {
01459     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01460     FixPoint1616_t TempFix1616 = 0;
01461     uint8_t LimitCheckEnableInt = 0;
01462     uint8_t LimitCheckDisable = 0;
01463     uint8_t Temp8;
01464 
01465 
01466     if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
01467         Status = VL53L0X_ERROR_INVALID_PARAMS;
01468     } else {
01469         if (LimitCheckEnable == 0) {
01470             TempFix1616 = 0;
01471             LimitCheckEnableInt = 0;
01472             LimitCheckDisable = 1;
01473 
01474         } else {
01475             VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01476                 LimitCheckId, TempFix1616);
01477             LimitCheckDisable = 0;
01478             /* this to be sure to have either 0 or 1 */
01479             LimitCheckEnableInt = 1;
01480         }
01481 
01482         switch (LimitCheckId) {
01483 
01484         case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
01485             /* internal computation: */
01486             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01487                 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
01488                 LimitCheckEnableInt);
01489 
01490             break;
01491 
01492         case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
01493 
01494             Status = VL53L0X_WrWord(Dev,
01495             VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
01496                 VL53L0X_FIXPOINT1616TOFIXPOINT97(TempFix1616));
01497 
01498             break;
01499 
01500         case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
01501 
01502             /* internal computation: */
01503             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01504                 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
01505                 LimitCheckEnableInt);
01506 
01507             break;
01508 
01509         case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
01510 
01511             /* internal computation: */
01512             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01513                 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
01514                 LimitCheckEnableInt);
01515 
01516             break;
01517 
01518         case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
01519 
01520             Temp8 = (uint8_t)(LimitCheckDisable << 1);
01521             Status = VL53L0X_UpdateByte(Dev,
01522                 VL53L0X_REG_MSRC_CONFIG_CONTROL,
01523                 0xFE, Temp8);
01524 
01525             break;
01526 
01527         case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
01528 
01529             Temp8 = (uint8_t)(LimitCheckDisable << 4);
01530             Status = VL53L0X_UpdateByte(Dev,
01531                 VL53L0X_REG_MSRC_CONFIG_CONTROL,
01532                 0xEF, Temp8);
01533 
01534             break;
01535 
01536 
01537         default:
01538             Status = VL53L0X_ERROR_INVALID_PARAMS;
01539 
01540         }
01541 
01542     }
01543 
01544     if (Status == VL53L0X_ERROR_NONE) {
01545         if (LimitCheckEnable == 0) {
01546             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01547                 LimitCheckId, 0);
01548         } else {
01549             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01550                 LimitCheckId, 1);
01551         }
01552     }
01553 
01554     return Status;
01555 }
01556 
01557 VL53L0X_Error VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01558     uint8_t *pLimitCheckEnable)
01559 {
01560     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01561     uint8_t Temp8;
01562 
01563 
01564     if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
01565         Status = VL53L0X_ERROR_INVALID_PARAMS;
01566         *pLimitCheckEnable = 0;
01567     } else {
01568         VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
01569             LimitCheckId, Temp8);
01570         *pLimitCheckEnable = Temp8;
01571     }
01572 
01573     return Status;
01574 }
01575 
01576 VL53L0X_Error VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01577     FixPoint1616_t LimitCheckValue)
01578 {
01579     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01580     uint8_t Temp8;
01581 
01582 
01583     VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId,
01584         Temp8);
01585 
01586     if (Temp8 == 0) { /* disabled write only internal value */
01587         VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01588             LimitCheckId, LimitCheckValue);
01589     } else {
01590 
01591         switch (LimitCheckId) {
01592 
01593         case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
01594             /* internal computation: */
01595             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01596                 VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
01597                 LimitCheckValue);
01598             break;
01599 
01600         case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
01601 
01602             Status = VL53L0X_WrWord(Dev,
01603             VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
01604                 VL53L0X_FIXPOINT1616TOFIXPOINT97(
01605                     LimitCheckValue));
01606 
01607             break;
01608 
01609         case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
01610 
01611             /* internal computation: */
01612             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01613                 VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
01614                 LimitCheckValue);
01615 
01616             break;
01617 
01618         case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
01619 
01620             /* internal computation: */
01621             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01622                 VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
01623                 LimitCheckValue);
01624 
01625             break;
01626 
01627         case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
01628         case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
01629 
01630             Status = VL53L0X_WrWord(Dev,
01631                 VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
01632                 VL53L0X_FIXPOINT1616TOFIXPOINT97(
01633                     LimitCheckValue));
01634 
01635             break;
01636 
01637         default:
01638             Status = VL53L0X_ERROR_INVALID_PARAMS;
01639 
01640         }
01641 
01642         if (Status == VL53L0X_ERROR_NONE) {
01643             VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01644                 LimitCheckId, LimitCheckValue);
01645         }
01646     }
01647 
01648     return Status;
01649 }
01650 
01651 VL53L0X_Error VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01652     FixPoint1616_t *pLimitCheckValue)
01653 {
01654     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01655     uint8_t EnableZeroValue = 0;
01656     uint16_t Temp16;
01657     FixPoint1616_t TempFix1616;
01658 
01659 
01660     switch (LimitCheckId) {
01661 
01662     case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
01663         /* internal computation: */
01664         VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01665             VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, TempFix1616);
01666         EnableZeroValue = 0;
01667         break;
01668 
01669     case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
01670         Status = VL53L0X_RdWord(Dev,
01671         VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
01672             &Temp16);
01673         if (Status == VL53L0X_ERROR_NONE)
01674             TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
01675 
01676 
01677         EnableZeroValue = 1;
01678         break;
01679 
01680     case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
01681         /* internal computation: */
01682         VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01683             VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, TempFix1616);
01684         EnableZeroValue = 0;
01685         break;
01686 
01687     case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
01688         /* internal computation: */
01689         VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
01690             VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, TempFix1616);
01691         EnableZeroValue = 0;
01692         break;
01693 
01694     case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
01695     case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
01696         Status = VL53L0X_RdWord(Dev,
01697             VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
01698             &Temp16);
01699         if (Status == VL53L0X_ERROR_NONE)
01700             TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
01701 
01702 
01703         EnableZeroValue = 0;
01704         break;
01705 
01706     default:
01707         Status = VL53L0X_ERROR_INVALID_PARAMS;
01708 
01709     }
01710 
01711     if (Status == VL53L0X_ERROR_NONE) {
01712 
01713         if (EnableZeroValue == 1) {
01714 
01715             if (TempFix1616 == 0) {
01716                 /* disabled: return value from memory */
01717                 VL53L0X_GETARRAYPARAMETERFIELD(Dev,
01718                     LimitChecksValue, LimitCheckId,
01719                     TempFix1616);
01720                 *pLimitCheckValue = TempFix1616;
01721                 VL53L0X_SETARRAYPARAMETERFIELD(Dev,
01722                     LimitChecksEnable, LimitCheckId, 0);
01723             } else {
01724                 *pLimitCheckValue = TempFix1616;
01725                 VL53L0X_SETARRAYPARAMETERFIELD(Dev,
01726                     LimitChecksValue, LimitCheckId,
01727                     TempFix1616);
01728                 VL53L0X_SETARRAYPARAMETERFIELD(Dev,
01729                     LimitChecksEnable, LimitCheckId, 1);
01730             }
01731         } else {
01732             *pLimitCheckValue = TempFix1616;
01733         }
01734     }
01735 
01736     return Status;
01737 
01738 }
01739 
01740 VL53L0X_Error VL53L0X_GetLimitCheckCurrent(VL53L0X_DEV Dev, uint16_t LimitCheckId,
01741     FixPoint1616_t *pLimitCheckCurrent)
01742 {
01743     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01744     VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
01745 
01746 
01747     if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
01748         Status = VL53L0X_ERROR_INVALID_PARAMS;
01749     } else {
01750         switch (LimitCheckId) {
01751         case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
01752             /* Need to run a ranging to have the latest values */
01753             *pLimitCheckCurrent = PALDevDataGet(Dev, SigmaEstimate);
01754 
01755             break;
01756 
01757         case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
01758             /* Need to run a ranging to have the latest values */
01759             LastRangeDataBuffer = PALDevDataGet(Dev,
01760                 LastRangeMeasure);
01761             *pLimitCheckCurrent =
01762                 LastRangeDataBuffer.SignalRateRtnMegaCps;
01763 
01764             break;
01765 
01766         case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
01767             /* Need to run a ranging to have the latest values */
01768             *pLimitCheckCurrent = PALDevDataGet(Dev,
01769                 LastSignalRefMcps);
01770 
01771             break;
01772 
01773         case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
01774             /* Need to run a ranging to have the latest values */
01775             LastRangeDataBuffer = PALDevDataGet(Dev,
01776                 LastRangeMeasure);
01777             *pLimitCheckCurrent =
01778                 LastRangeDataBuffer.SignalRateRtnMegaCps;
01779 
01780             break;
01781 
01782         case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
01783             /* Need to run a ranging to have the latest values */
01784             LastRangeDataBuffer = PALDevDataGet(Dev,
01785                 LastRangeMeasure);
01786             *pLimitCheckCurrent =
01787                 LastRangeDataBuffer.SignalRateRtnMegaCps;
01788 
01789             break;
01790 
01791         case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
01792             /* Need to run a ranging to have the latest values */
01793             LastRangeDataBuffer = PALDevDataGet(Dev,
01794                 LastRangeMeasure);
01795             *pLimitCheckCurrent =
01796                 LastRangeDataBuffer.SignalRateRtnMegaCps;
01797 
01798             break;
01799 
01800         default:
01801             Status = VL53L0X_ERROR_INVALID_PARAMS;
01802         }
01803     }
01804 
01805     return Status;
01806 
01807 }
01808 
01809 /*
01810  * WRAPAROUND Check
01811  */
01812 VL53L0X_Error VL53L0X_SetWrapAroundCheckEnable(VL53L0X_DEV Dev,
01813     uint8_t WrapAroundCheckEnable)
01814 {
01815     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01816     uint8_t Byte;
01817     uint8_t WrapAroundCheckEnableInt;
01818 
01819 
01820     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &Byte);
01821     if (WrapAroundCheckEnable == 0) {
01822         /* Disable wraparound */
01823         Byte = Byte & 0x7F;
01824         WrapAroundCheckEnableInt = 0;
01825     } else {
01826         /*Enable wraparound */
01827         Byte = Byte | 0x80;
01828         WrapAroundCheckEnableInt = 1;
01829     }
01830 
01831     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, Byte);
01832 
01833     if (Status == VL53L0X_ERROR_NONE) {
01834         PALDevDataSet(Dev, SequenceConfig, Byte);
01835         VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
01836             WrapAroundCheckEnableInt);
01837     }
01838 
01839     return Status;
01840 }
01841 
01842 VL53L0X_Error VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
01843     uint8_t *pWrapAroundCheckEnable)
01844 {
01845     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01846     uint8_t data;
01847 
01848 
01849     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
01850     if (Status == VL53L0X_ERROR_NONE) {
01851         PALDevDataSet(Dev, SequenceConfig, data);
01852         if (data & (0x01 << 7))
01853             *pWrapAroundCheckEnable = 0x01;
01854         else
01855             *pWrapAroundCheckEnable = 0x00;
01856     }
01857     if (Status == VL53L0X_ERROR_NONE) {
01858         VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
01859             *pWrapAroundCheckEnable);
01860     }
01861 
01862     return Status;
01863 }
01864 
01865 VL53L0X_Error VL53L0X_SetDmaxCalParameters(VL53L0X_DEV Dev,
01866     uint16_t RangeMilliMeter, FixPoint1616_t SignalRateRtnMegaCps)
01867 {
01868     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01869     FixPoint1616_t SignalRateRtnMegaCpsTemp = 0;
01870 
01871 
01872     /* Check if one of input parameter is zero, in that case the
01873      * value are get from NVM */
01874     if ((RangeMilliMeter == 0) || (SignalRateRtnMegaCps == 0)) {
01875         /* NVM parameters */
01876         /* Run VL53L0X_get_info_from_device wit option 4 to get
01877          * signal rate at 400 mm if the value have been already
01878          * get this function will return with no access to device */
01879         VL53L0X_get_info_from_device(Dev, 4);
01880 
01881         SignalRateRtnMegaCpsTemp = VL53L0X_GETDEVICESPECIFICPARAMETER(
01882             Dev, SignalRateMeasFixed400mm);
01883 
01884         PALDevDataSet(Dev, DmaxCalRangeMilliMeter, 400);
01885         PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
01886             SignalRateRtnMegaCpsTemp);
01887     } else {
01888         /* User parameters */
01889         PALDevDataSet(Dev, DmaxCalRangeMilliMeter, RangeMilliMeter);
01890         PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
01891             SignalRateRtnMegaCps);
01892     }
01893 
01894     return Status;
01895 }
01896 
01897 VL53L0X_Error VL53L0X_GetDmaxCalParameters(VL53L0X_DEV Dev,
01898     uint16_t *pRangeMilliMeter, FixPoint1616_t *pSignalRateRtnMegaCps)
01899 {
01900     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01901 
01902 
01903     *pRangeMilliMeter = PALDevDataGet(Dev, DmaxCalRangeMilliMeter);
01904     *pSignalRateRtnMegaCps = PALDevDataGet(Dev,
01905         DmaxCalSignalRateRtnMegaCps);
01906 
01907     return Status;
01908 }
01909 
01910 /* End Group PAL Parameters Functions */
01911 
01912 /* Group PAL Measurement Functions */
01913 VL53L0X_Error VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev)
01914 {
01915     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01916     VL53L0X_DeviceModes DeviceMode;
01917 
01918 
01919     /* Get Current DeviceMode */
01920     Status = VL53L0X_GetDeviceMode(Dev, &DeviceMode);
01921 
01922     /* Start immediately to run a single ranging measurement in case of
01923      * single ranging or single histogram */
01924     if (Status == VL53L0X_ERROR_NONE
01925         && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
01926         Status = VL53L0X_StartMeasurement(Dev);
01927 
01928 
01929     if (Status == VL53L0X_ERROR_NONE)
01930         Status = VL53L0X_measurement_poll_for_completion(Dev);
01931 
01932 
01933     /* Change PAL State in case of single ranging or single histogram */
01934     if (Status == VL53L0X_ERROR_NONE
01935         && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
01936         PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
01937 
01938 
01939     return Status;
01940 }
01941 
01942 VL53L0X_Error VL53L0X_PerformSingleHistogramMeasurement(VL53L0X_DEV Dev,
01943     VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData)
01944 {
01945     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
01946 
01947     /* not implemented on VL53L0X */
01948 
01949     return Status;
01950 }
01951 
01952 VL53L0X_Error VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
01953     uint8_t *pPhaseCal)
01954 {
01955     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01956 
01957     Status = VL53L0X_perform_ref_calibration(Dev, pVhvSettings,
01958         pPhaseCal, 1);
01959 
01960     return Status;
01961 }
01962 
01963 VL53L0X_Error VL53L0X_PerformXTalkMeasurement(VL53L0X_DEV Dev,
01964     uint32_t TimeoutMs, FixPoint1616_t *pXtalkPerSpad,
01965     uint8_t *pAmbientTooHigh)
01966 {
01967     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
01968 
01969     /* not implemented on VL53L0X */
01970 
01971     return Status;
01972 }
01973 
01974 VL53L0X_Error VL53L0X_PerformXTalkCalibration(VL53L0X_DEV Dev,
01975     FixPoint1616_t XTalkCalDistance,
01976     FixPoint1616_t *pXTalkCompensationRateMegaCps)
01977 {
01978     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01979 
01980     Status = VL53L0X_perform_xtalk_calibration(Dev, XTalkCalDistance,
01981         pXTalkCompensationRateMegaCps);
01982 
01983     return Status;
01984 }
01985 
01986 VL53L0X_Error VL53L0X_PerformOffsetCalibration(VL53L0X_DEV Dev,
01987     FixPoint1616_t CalDistanceMilliMeter, int32_t *pOffsetMicroMeter)
01988 {
01989     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
01990 
01991     Status = VL53L0X_perform_offset_calibration(Dev, CalDistanceMilliMeter,
01992         pOffsetMicroMeter);
01993 
01994     return Status;
01995 }
01996 
01997 VL53L0X_Error VL53L0X_CheckAndLoadInterruptSettings(VL53L0X_DEV Dev,
01998     uint8_t StartNotStopFlag)
01999 {
02000     uint8_t InterruptConfig;
02001     FixPoint1616_t ThresholdLow;
02002     FixPoint1616_t ThresholdHigh;
02003     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02004 
02005     InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
02006         Pin0GpioFunctionality);
02007 
02008     if ((InterruptConfig ==
02009         VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
02010         (InterruptConfig ==
02011         VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH) ||
02012         (InterruptConfig ==
02013         VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
02014 
02015         Status = VL53L0X_GetInterruptThresholds(Dev,
02016             VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
02017             &ThresholdLow, &ThresholdHigh);
02018 
02019         if (((ThresholdLow > 255*65536) ||
02020             (ThresholdHigh > 255*65536)) &&
02021             (Status == VL53L0X_ERROR_NONE)) {
02022 
02023             if (StartNotStopFlag != 0) {
02024                 Status = VL53L0X_load_tuning_settings(Dev,
02025                     InterruptThresholdSettings);
02026             } else {
02027                 Status |= VL53L0X_WrByte(Dev, 0xFF, 0x04);
02028                 Status |= VL53L0X_WrByte(Dev, 0x70, 0x00);
02029                 Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
02030                 Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
02031             }
02032 
02033         }
02034 
02035 
02036     }
02037 
02038     return Status;
02039 
02040 }
02041 
02042 
02043 VL53L0X_Error VL53L0X_StartMeasurement(VL53L0X_DEV Dev)
02044 {
02045     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02046     VL53L0X_DeviceModes DeviceMode;
02047     uint8_t Byte;
02048     uint8_t StartStopByte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
02049     uint32_t LoopNb;
02050 
02051     /* Get Current DeviceMode */
02052     VL53L0X_GetDeviceMode(Dev, &DeviceMode);
02053 
02054     Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
02055     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02056     Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
02057     Status = VL53L0X_WrByte(Dev, 0x91, PALDevDataGet(Dev, StopVariable));
02058     Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
02059     Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
02060     Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
02061 
02062     switch (DeviceMode) {
02063     case VL53L0X_DEVICEMODE_SINGLE_RANGING:
02064         Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START, 0x01);
02065 
02066         Byte = StartStopByte;
02067         if (Status == VL53L0X_ERROR_NONE) {
02068             /* Wait until start bit has been cleared */
02069             LoopNb = 0;
02070             do {
02071                 if (LoopNb > 0)
02072                     Status = VL53L0X_RdByte(Dev,
02073                     VL53L0X_REG_SYSRANGE_START, &Byte);
02074                 LoopNb = LoopNb + 1;
02075             } while (((Byte & StartStopByte) == StartStopByte)
02076                 && (Status == VL53L0X_ERROR_NONE)
02077                 && (LoopNb < VL53L0X_DEFAULT_MAX_LOOP));
02078 
02079             if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP)
02080                 Status = VL53L0X_ERROR_TIME_OUT;
02081 
02082         }
02083 
02084         break;
02085     case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
02086         /* Back-to-back mode */
02087 
02088         /* Check if need to apply interrupt settings */
02089         if (Status == VL53L0X_ERROR_NONE)
02090             Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
02091 
02092         Status = VL53L0X_WrByte(Dev,
02093         VL53L0X_REG_SYSRANGE_START,
02094         VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
02095         if (Status == VL53L0X_ERROR_NONE) {
02096             /* Set PAL State to Running */
02097             PALDevDataSet(Dev, PalState, VL53L0X_STATE_RUNNING);
02098         }
02099         break;
02100     case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
02101         /* Continuous mode */
02102         /* Check if need to apply interrupt settings */
02103         if (Status == VL53L0X_ERROR_NONE)
02104             Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
02105 
02106         Status = VL53L0X_WrByte(Dev,
02107         VL53L0X_REG_SYSRANGE_START,
02108         VL53L0X_REG_SYSRANGE_MODE_TIMED);
02109 
02110         if (Status == VL53L0X_ERROR_NONE) {
02111             /* Set PAL State to Running */
02112             PALDevDataSet(Dev, PalState, VL53L0X_STATE_RUNNING);
02113         }
02114         break;
02115     default:
02116         /* Selected mode not supported */
02117         Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
02118     }
02119 
02120 
02121     return Status;
02122 }
02123 
02124 VL53L0X_Error VL53L0X_StopMeasurement(VL53L0X_DEV Dev)
02125 {
02126     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02127 
02128     Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START,
02129     VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
02130 
02131     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02132     Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
02133     Status = VL53L0X_WrByte(Dev, 0x91, 0x00);
02134     Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
02135     Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
02136 
02137     if (Status == VL53L0X_ERROR_NONE) {
02138         /* Set PAL State to Idle */
02139         PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
02140     }
02141 
02142     /* Check if need to apply interrupt settings */
02143     if (Status == VL53L0X_ERROR_NONE)
02144         Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 0);
02145 
02146     return Status;
02147 }
02148 
02149 VL53L0X_Error VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
02150     uint8_t *pMeasurementDataReady)
02151 {
02152     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02153     uint8_t SysRangeStatusRegister;
02154     uint8_t InterruptConfig;
02155     uint32_t InterruptMask;
02156 
02157     InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
02158         Pin0GpioFunctionality);
02159 
02160     if (InterruptConfig ==
02161         VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
02162         Status = VL53L0X_GetInterruptMaskStatus(Dev, &InterruptMask);
02163         if (InterruptMask ==
02164         VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY)
02165             *pMeasurementDataReady = 1;
02166         else
02167             *pMeasurementDataReady = 0;
02168     } else {
02169         Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
02170             &SysRangeStatusRegister);
02171         if (Status == VL53L0X_ERROR_NONE) {
02172             if (SysRangeStatusRegister & 0x01)
02173                 *pMeasurementDataReady = 1;
02174             else
02175                 *pMeasurementDataReady = 0;
02176         }
02177     }
02178 
02179     return Status;
02180 }
02181 
02182 VL53L0X_Error VL53L0X_WaitDeviceReadyForNewMeasurement(VL53L0X_DEV Dev,
02183     uint32_t MaxLoop)
02184 {
02185     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
02186 
02187     /* not implemented for VL53L0X */
02188 
02189     return Status;
02190 }
02191 
02192 
02193 VL53L0X_Error VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
02194     VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
02195 {
02196     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02197     uint8_t DeviceRangeStatus;
02198     uint8_t RangeFractionalEnable;
02199     uint8_t PalRangeStatus;
02200     uint8_t XTalkCompensationEnable;
02201     uint16_t AmbientRate;
02202     FixPoint1616_t SignalRate;
02203     uint16_t XTalkCompensationRateMegaCps;
02204     uint16_t EffectiveSpadRtnCount;
02205     uint16_t tmpuint16;
02206     uint16_t XtalkRangeMilliMeter;
02207     uint16_t LinearityCorrectiveGain;
02208     uint8_t localBuffer[12];
02209     VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
02210 
02211 
02212     /*
02213      * use multi read even if some registers are not useful, result will
02214      * be more efficient
02215      * start reading at 0x14 dec20
02216      * end reading at 0x21 dec33 total 14 bytes to read
02217      */
02218     Status = VL53L0X_ReadMulti(Dev, 0x14, localBuffer, 12);
02219 
02220     if (Status == VL53L0X_ERROR_NONE) {
02221 
02222         pRangingMeasurementData->ZoneId = 0; /* Only one zone */
02223         pRangingMeasurementData->TimeStamp = 0; /* Not Implemented */
02224 
02225         tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11], localBuffer[10]);
02226         /* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
02227          *(format 11.2) else no fractional
02228          */
02229 
02230         pRangingMeasurementData->MeasurementTimeUsec = 0;
02231 
02232         SignalRate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
02233             VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
02234         /* peak_signal_count_rate_rtn_mcps */
02235         pRangingMeasurementData->SignalRateRtnMegaCps = SignalRate;
02236 
02237         AmbientRate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
02238         pRangingMeasurementData->AmbientRateRtnMegaCps =
02239             VL53L0X_FIXPOINT97TOFIXPOINT1616(AmbientRate);
02240 
02241         EffectiveSpadRtnCount = VL53L0X_MAKEUINT16(localBuffer[3],
02242             localBuffer[2]);
02243         /* EffectiveSpadRtnCount is 8.8 format */
02244         pRangingMeasurementData->EffectiveSpadRtnCount =
02245             EffectiveSpadRtnCount;
02246 
02247         DeviceRangeStatus = localBuffer[0];
02248 
02249         /* Get Linearity Corrective Gain */
02250         LinearityCorrectiveGain = PALDevDataGet(Dev,
02251             LinearityCorrectiveGain);
02252 
02253         /* Get ranging configuration */
02254         RangeFractionalEnable = PALDevDataGet(Dev,
02255             RangeFractionalEnable);
02256 
02257         if (LinearityCorrectiveGain != 1000) {
02258 
02259             tmpuint16 = (uint16_t)((LinearityCorrectiveGain
02260                 * tmpuint16 + 500) / 1000);
02261 
02262             /* Implement Xtalk */
02263             VL53L0X_GETPARAMETERFIELD(Dev,
02264                 XTalkCompensationRateMegaCps,
02265                 XTalkCompensationRateMegaCps);
02266             VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable,
02267                 XTalkCompensationEnable);
02268 
02269             if (XTalkCompensationEnable) {
02270 
02271                 if ((SignalRate
02272                     - ((XTalkCompensationRateMegaCps
02273                     * EffectiveSpadRtnCount) >> 8))
02274                     <= 0) {
02275                     if (RangeFractionalEnable)
02276                         XtalkRangeMilliMeter = 8888;
02277                     else
02278                         XtalkRangeMilliMeter = 8888
02279                             << 2;
02280                 } else {
02281                     XtalkRangeMilliMeter =
02282                     (tmpuint16 * SignalRate)
02283                         / (SignalRate
02284                         - ((XTalkCompensationRateMegaCps
02285                         * EffectiveSpadRtnCount)
02286                         >> 8));
02287                 }
02288 
02289                 tmpuint16 = XtalkRangeMilliMeter;
02290             }
02291 
02292         }
02293 
02294         if (RangeFractionalEnable) {
02295             pRangingMeasurementData->RangeMilliMeter =
02296                 (uint16_t)((tmpuint16) >> 2);
02297             pRangingMeasurementData->RangeFractionalPart =
02298                 (uint8_t)((tmpuint16 & 0x03) << 6);
02299         } else {
02300             pRangingMeasurementData->RangeMilliMeter = tmpuint16;
02301             pRangingMeasurementData->RangeFractionalPart = 0;
02302         }
02303 
02304         /*
02305          * For a standard definition of RangeStatus, this should
02306          * return 0 in case of good result after a ranging
02307          * The range status depends on the device so call a device
02308          * specific function to obtain the right Status.
02309          */
02310         Status |= VL53L0X_get_pal_range_status(Dev, DeviceRangeStatus,
02311             SignalRate, EffectiveSpadRtnCount,
02312             pRangingMeasurementData, &PalRangeStatus);
02313 
02314         if (Status == VL53L0X_ERROR_NONE)
02315             pRangingMeasurementData->RangeStatus = PalRangeStatus;
02316 
02317     }
02318 
02319     if (Status == VL53L0X_ERROR_NONE) {
02320         /* Copy last read data into Dev buffer */
02321         LastRangeDataBuffer = PALDevDataGet(Dev, LastRangeMeasure);
02322 
02323         LastRangeDataBuffer.RangeMilliMeter =
02324             pRangingMeasurementData->RangeMilliMeter;
02325         LastRangeDataBuffer.RangeFractionalPart =
02326             pRangingMeasurementData->RangeFractionalPart;
02327         LastRangeDataBuffer.RangeDMaxMilliMeter =
02328             pRangingMeasurementData->RangeDMaxMilliMeter;
02329         LastRangeDataBuffer.MeasurementTimeUsec =
02330             pRangingMeasurementData->MeasurementTimeUsec;
02331         LastRangeDataBuffer.SignalRateRtnMegaCps =
02332             pRangingMeasurementData->SignalRateRtnMegaCps;
02333         LastRangeDataBuffer.AmbientRateRtnMegaCps =
02334             pRangingMeasurementData->AmbientRateRtnMegaCps;
02335         LastRangeDataBuffer.EffectiveSpadRtnCount =
02336             pRangingMeasurementData->EffectiveSpadRtnCount;
02337         LastRangeDataBuffer.RangeStatus =
02338             pRangingMeasurementData->RangeStatus;
02339 
02340         PALDevDataSet(Dev, LastRangeMeasure, LastRangeDataBuffer);
02341     }
02342 
02343     return Status;
02344 }
02345 
02346 VL53L0X_Error VL53L0X_GetMeasurementRefSignal(VL53L0X_DEV Dev,
02347     FixPoint1616_t *pMeasurementRefSignal)
02348 {
02349     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02350     uint8_t SignalRefClipLimitCheckEnable = 0;
02351 
02352     Status = VL53L0X_GetLimitCheckEnable(Dev,
02353             VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
02354             &SignalRefClipLimitCheckEnable);
02355     if (SignalRefClipLimitCheckEnable != 0) {
02356         *pMeasurementRefSignal = PALDevDataGet(Dev, LastSignalRefMcps);
02357     } else {
02358         Status = VL53L0X_ERROR_INVALID_COMMAND;
02359     }
02360 
02361     return Status;
02362 }
02363 
02364 VL53L0X_Error VL53L0X_GetHistogramMeasurementData(VL53L0X_DEV Dev,
02365     VL53L0X_HistogramMeasurementData_t *pHistogramMeasurementData)
02366 {
02367     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
02368 
02369     return Status;
02370 }
02371 
02372 VL53L0X_Error VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
02373     VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
02374 {
02375     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02376 
02377 
02378     /* This function will do a complete single ranging
02379      * Here we fix the mode! */
02380     Status = VL53L0X_SetDeviceMode(Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
02381 
02382     if (Status == VL53L0X_ERROR_NONE)
02383         Status = VL53L0X_PerformSingleMeasurement(Dev);
02384 
02385 
02386     if (Status == VL53L0X_ERROR_NONE)
02387         Status = VL53L0X_GetRangingMeasurementData(Dev,
02388             pRangingMeasurementData);
02389 
02390 
02391     if (Status == VL53L0X_ERROR_NONE)
02392         Status = VL53L0X_ClearInterruptMask(Dev, 0);
02393 
02394 
02395     return Status;
02396 }
02397 
02398 VL53L0X_Error VL53L0X_SetNumberOfROIZones(VL53L0X_DEV Dev,
02399     uint8_t NumberOfROIZones)
02400 {
02401     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02402 
02403 
02404     if (NumberOfROIZones != 1)
02405         Status = VL53L0X_ERROR_INVALID_PARAMS;
02406 
02407 
02408     return Status;
02409 }
02410 
02411 VL53L0X_Error VL53L0X_GetNumberOfROIZones(VL53L0X_DEV Dev,
02412     uint8_t *pNumberOfROIZones)
02413 {
02414     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02415 
02416 
02417     *pNumberOfROIZones = 1;
02418 
02419     return Status;
02420 }
02421 
02422 VL53L0X_Error VL53L0X_GetMaxNumberOfROIZones(VL53L0X_DEV Dev,
02423     uint8_t *pMaxNumberOfROIZones)
02424 {
02425     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02426 
02427 
02428     *pMaxNumberOfROIZones = 1;
02429 
02430     return Status;
02431 }
02432 
02433 /* End Group PAL Measurement Functions */
02434 
02435 VL53L0X_Error VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
02436     VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
02437     VL53L0X_InterruptPolarity Polarity)
02438 {
02439     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02440     uint8_t data;
02441 
02442 
02443     if (Pin != 0) {
02444         Status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
02445     } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
02446         if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
02447             data = 0x10;
02448         else
02449             data = 1;
02450 
02451         Status = VL53L0X_WrByte(Dev,
02452         VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
02453 
02454     } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_OSC) {
02455 
02456         Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
02457         Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
02458 
02459         Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
02460         Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
02461         Status |= VL53L0X_WrByte(Dev, 0x85, 0x02);
02462 
02463         Status |= VL53L0X_WrByte(Dev, 0xff, 0x04);
02464         Status |= VL53L0X_WrByte(Dev, 0xcd, 0x00);
02465         Status |= VL53L0X_WrByte(Dev, 0xcc, 0x11);
02466 
02467         Status |= VL53L0X_WrByte(Dev, 0xff, 0x07);
02468         Status |= VL53L0X_WrByte(Dev, 0xbe, 0x00);
02469 
02470         Status |= VL53L0X_WrByte(Dev, 0xff, 0x06);
02471         Status |= VL53L0X_WrByte(Dev, 0xcc, 0x09);
02472 
02473         Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
02474         Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
02475         Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
02476 
02477     } else {
02478 
02479         if (Status == VL53L0X_ERROR_NONE) {
02480             switch (Functionality) {
02481             case VL53L0X_GPIOFUNCTIONALITY_OFF:
02482                 data = 0x00;
02483                 break;
02484             case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
02485                 data = 0x01;
02486                 break;
02487             case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
02488                 data = 0x02;
02489                 break;
02490             case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
02491                 data = 0x03;
02492                 break;
02493             case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
02494                 data = 0x04;
02495                 break;
02496             default:
02497                 Status =
02498                 VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
02499             }
02500         }
02501 
02502         if (Status == VL53L0X_ERROR_NONE)
02503             Status = VL53L0X_WrByte(Dev,
02504             VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
02505 
02506         if (Status == VL53L0X_ERROR_NONE) {
02507             if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
02508                 data = 0;
02509             else
02510                 data = (uint8_t)(1 << 4);
02511 
02512             Status = VL53L0X_UpdateByte(Dev,
02513             VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
02514         }
02515 
02516         if (Status == VL53L0X_ERROR_NONE)
02517             VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
02518                 Pin0GpioFunctionality, Functionality);
02519 
02520         if (Status == VL53L0X_ERROR_NONE)
02521             Status = VL53L0X_ClearInterruptMask(Dev, 0);
02522 
02523     }
02524 
02525     return Status;
02526 }
02527 
02528 VL53L0X_Error VL53L0X_GetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
02529     VL53L0X_DeviceModes *pDeviceMode,
02530     VL53L0X_GpioFunctionality *pFunctionality,
02531     VL53L0X_InterruptPolarity *pPolarity)
02532 {
02533     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02534     VL53L0X_GpioFunctionality GpioFunctionality;
02535     uint8_t data;
02536 
02537 
02538     /* pDeviceMode not managed by Ewok it return the current mode */
02539 
02540     Status = VL53L0X_GetDeviceMode(Dev, pDeviceMode);
02541 
02542     if (Status == VL53L0X_ERROR_NONE) {
02543         if (Pin != 0) {
02544             Status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
02545         } else {
02546             Status = VL53L0X_RdByte(Dev,
02547             VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, &data);
02548         }
02549     }
02550 
02551     if (Status == VL53L0X_ERROR_NONE) {
02552         switch (data & 0x07) {
02553         case 0x00:
02554             GpioFunctionality = VL53L0X_GPIOFUNCTIONALITY_OFF;
02555             break;
02556         case 0x01:
02557             GpioFunctionality =
02558             VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW;
02559             break;
02560         case 0x02:
02561             GpioFunctionality =
02562             VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH;
02563             break;
02564         case 0x03:
02565             GpioFunctionality =
02566             VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT;
02567             break;
02568         case 0x04:
02569             GpioFunctionality =
02570             VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY;
02571             break;
02572         default:
02573             Status = VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
02574         }
02575     }
02576 
02577     if (Status == VL53L0X_ERROR_NONE)
02578         Status = VL53L0X_RdByte(Dev, VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,
02579             &data);
02580 
02581     if (Status == VL53L0X_ERROR_NONE) {
02582         if ((data & (uint8_t)(1 << 4)) == 0)
02583             *pPolarity = VL53L0X_INTERRUPTPOLARITY_LOW;
02584         else
02585             *pPolarity = VL53L0X_INTERRUPTPOLARITY_HIGH;
02586     }
02587 
02588     if (Status == VL53L0X_ERROR_NONE) {
02589         *pFunctionality = GpioFunctionality;
02590         VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, Pin0GpioFunctionality,
02591             GpioFunctionality);
02592     }
02593 
02594     return Status;
02595 }
02596 
02597 VL53L0X_Error VL53L0X_SetInterruptThresholds(VL53L0X_DEV Dev,
02598     VL53L0X_DeviceModes DeviceMode, FixPoint1616_t ThresholdLow,
02599     FixPoint1616_t ThresholdHigh)
02600 {
02601     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02602     uint16_t Threshold16;
02603 
02604     /* no dependency on DeviceMode for Ewok */
02605     /* Need to divide by 2 because the FW will apply a x2 */
02606     Threshold16 = (uint16_t)((ThresholdLow >> 17) & 0x00fff);
02607     Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, Threshold16);
02608 
02609     if (Status == VL53L0X_ERROR_NONE) {
02610         /* Need to divide by 2 because the FW will apply a x2 */
02611         Threshold16 = (uint16_t)((ThresholdHigh >> 17) & 0x00fff);
02612         Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
02613             Threshold16);
02614     }
02615 
02616     return Status;
02617 }
02618 
02619 VL53L0X_Error VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
02620     VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
02621     FixPoint1616_t *pThresholdHigh)
02622 {
02623     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02624     uint16_t Threshold16;
02625 
02626     /* no dependency on DeviceMode for Ewok */
02627 
02628     Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &Threshold16);
02629     /* Need to multiply by 2 because the FW will apply a x2 */
02630     *pThresholdLow = (FixPoint1616_t)((0x00fff & Threshold16) << 17);
02631 
02632     if (Status == VL53L0X_ERROR_NONE) {
02633         Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
02634             &Threshold16);
02635         /* Need to multiply by 2 because the FW will apply a x2 */
02636         *pThresholdHigh =
02637             (FixPoint1616_t)((0x00fff & Threshold16) << 17);
02638     }
02639 
02640     return Status;
02641 }
02642 
02643 VL53L0X_Error VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
02644     uint32_t *pStopStatus)
02645 {
02646     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02647     uint8_t Byte = 0;
02648 
02649     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02650 
02651     if (Status == VL53L0X_ERROR_NONE)
02652         Status = VL53L0X_RdByte(Dev, 0x04, &Byte);
02653 
02654     if (Status == VL53L0X_ERROR_NONE)
02655         Status = VL53L0X_WrByte(Dev, 0xFF, 0x0);
02656 
02657     *pStopStatus = Byte;
02658 
02659     if (Byte == 0) {
02660         Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
02661         Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02662         Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
02663         Status = VL53L0X_WrByte(Dev, 0x91,
02664             PALDevDataGet(Dev, StopVariable));
02665         Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
02666         Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
02667         Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
02668     }
02669 
02670     return Status;
02671 }
02672 
02673 /* Group PAL Interrupt Functions */
02674 VL53L0X_Error VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask)
02675 {
02676     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02677     uint8_t LoopCount;
02678     uint8_t Byte;
02679 
02680     /* clear bit 0 range interrupt, bit 1 error interrupt */
02681     LoopCount = 0;
02682     do {
02683         Status = VL53L0X_WrByte(Dev,
02684             VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
02685         Status |= VL53L0X_WrByte(Dev,
02686             VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
02687         Status |= VL53L0X_RdByte(Dev,
02688             VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
02689         LoopCount++;
02690     } while (((Byte & 0x07) != 0x00)
02691             && (LoopCount < 3)
02692             && (Status == VL53L0X_ERROR_NONE));
02693 
02694 
02695     if (LoopCount >= 3)
02696         Status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
02697 
02698     return Status;
02699 }
02700 
02701 VL53L0X_Error VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
02702     uint32_t *pInterruptMaskStatus)
02703 {
02704     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02705     uint8_t Byte;
02706 
02707     Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
02708     *pInterruptMaskStatus = Byte & 0x07;
02709 
02710     if (Byte & 0x18)
02711         Status = VL53L0X_ERROR_RANGE_ERROR;
02712 
02713     return Status;
02714 }
02715 
02716 VL53L0X_Error VL53L0X_EnableInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask)
02717 {
02718     VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
02719 
02720     /* not implemented for VL53L0X */
02721 
02722     return Status;
02723 }
02724 
02725 /* End Group PAL Interrupt Functions */
02726 
02727 /* Group SPAD functions */
02728 
02729 VL53L0X_Error VL53L0X_SetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
02730     uint16_t SpadAmbientDamperThreshold)
02731 {
02732     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02733 
02734     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02735     Status |= VL53L0X_WrWord(Dev, 0x40, SpadAmbientDamperThreshold);
02736     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
02737 
02738     return Status;
02739 }
02740 
02741 VL53L0X_Error VL53L0X_GetSpadAmbientDamperThreshold(VL53L0X_DEV Dev,
02742     uint16_t *pSpadAmbientDamperThreshold)
02743 {
02744     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02745 
02746     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02747     Status |= VL53L0X_RdWord(Dev, 0x40, pSpadAmbientDamperThreshold);
02748     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
02749 
02750     return Status;
02751 }
02752 
02753 VL53L0X_Error VL53L0X_SetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
02754     uint16_t SpadAmbientDamperFactor)
02755 {
02756     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02757     uint8_t Byte;
02758 
02759     Byte = (uint8_t)(SpadAmbientDamperFactor & 0x00FF);
02760 
02761     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02762     Status |= VL53L0X_WrByte(Dev, 0x42, Byte);
02763     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
02764 
02765     return Status;
02766 }
02767 
02768 VL53L0X_Error VL53L0X_GetSpadAmbientDamperFactor(VL53L0X_DEV Dev,
02769     uint16_t *pSpadAmbientDamperFactor)
02770 {
02771     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02772     uint8_t Byte;
02773 
02774     Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
02775     Status |= VL53L0X_RdByte(Dev, 0x42, &Byte);
02776     Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
02777     *pSpadAmbientDamperFactor = (uint16_t)Byte;
02778 
02779     return Status;
02780 }
02781 
02782 /* END Group SPAD functions */
02783 
02784 /*****************************************************************************
02785  * Internal functions
02786  *****************************************************************************/
02787 
02788 VL53L0X_Error VL53L0X_SetReferenceSpads(VL53L0X_DEV Dev, uint32_t count,
02789     uint8_t isApertureSpads)
02790 {
02791     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02792 
02793     Status = VL53L0X_set_reference_spads(Dev, count, isApertureSpads);
02794 
02795 
02796     return Status;
02797 }
02798 
02799 VL53L0X_Error VL53L0X_GetReferenceSpads(VL53L0X_DEV Dev, uint32_t *pSpadCount,
02800     uint8_t *pIsApertureSpads)
02801 {
02802     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02803 
02804     Status = VL53L0X_get_reference_spads(Dev, pSpadCount, pIsApertureSpads);
02805 
02806 
02807     return Status;
02808 }
02809 
02810 VL53L0X_Error VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
02811     uint32_t *refSpadCount, uint8_t *isApertureSpads)
02812 {
02813     VL53L0X_Error Status = VL53L0X_ERROR_NONE;
02814 
02815     Status = VL53L0X_perform_ref_spad_management(Dev, refSpadCount,
02816         isApertureSpads);
02817 
02818 
02819     return Status;
02820 }