/* * Copyright (c) 2017, STMicroelectronics - All Rights Reserved * * This file is part of VL53L1 Core and is dual licensed, * either 'STMicroelectronics * Proprietary license' * or 'BSD 3-clause "New" or "Revised" License' , at your option. * ******************************************************************************** * * 'STMicroelectronics Proprietary license' * ******************************************************************************** * * License terms: STMicroelectronics Proprietary in accordance with licensing * terms at www.st.com/sla0081 * * STMicroelectronics confidential * Reproduction and Communication of this document is strictly prohibited unless * specifically authorized in writing by STMicroelectronics. * * ******************************************************************************** * * Alternatively, VL53L1 Core may be distributed under the terms of * 'BSD 3-clause "New" or "Revised" License', in which case the following * provisions apply instead of the ones mentioned above : * ******************************************************************************** * * License terms: BSD 3-clause "New" or "Revised" License. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * 3. Neither the name of the copyright holder nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * ******************************************************************************** * */ #include "vl53l1_api.h" #include "vl53l1_api_strings.h" #include "vl53l1_register_settings.h" #include "vl53l1_register_funcs.h" #include "vl53l1_core.h" #include "vl53l1_api_calibration.h" #include "vl53l1_wait.h" #include "vl53l1_preset_setup.h" #include "vl53l1_api_debug.h" #include "vl53l1_api_core.h" /* Check for minimum user zone requested by Xtalk calibration */ /* no need for VL53L1_MAX_USER_ZONES check, set 5 to pass the test */ #define ZONE_CHECK 5 #if ZONE_CHECK < 5 #error Must define at least 5 zones in MAX_USER_ZONES constant #endif #ifdef VL53L1_NOCALIB #define OFFSET_CALIB_EMPTY #endif #ifndef VL53L1_NOCALIB #define OFFSET_CALIB #endif #define LOG_FUNCTION_START(fmt, ...) \ _LOG_FUNCTION_START(VL53L1_TRACE_MODULE_API, fmt, ##__VA_ARGS__) #define LOG_FUNCTION_END(status, ...) \ _LOG_FUNCTION_END(VL53L1_TRACE_MODULE_API, status, ##__VA_ARGS__) #define LOG_FUNCTION_END_FMT(status, fmt, ...) \ _LOG_FUNCTION_END_FMT(VL53L1_TRACE_MODULE_API, status, \ fmt, ##__VA_ARGS__) #ifdef VL53L1_LOG_ENABLE #define trace_print(level, ...) trace_print_module_function(\ VL53L1_TRACE_MODULE_API, level, VL53L1_TRACE_FUNCTION_NONE, \ ##__VA_ARGS__) #endif #ifndef MIN #define MIN(v1, v2) ((v1) < (v2) ? (v1) : (v2)) #endif #ifndef MAX #define MAX(v1, v2) ((v1) < (v2) ? (v2) : (v1)) #endif #define DMAX_REFLECTANCE_IDX 2 /* Use Dmax index 2 because it's the 50% reflectance case by default */ /* Following LOWPOWER_AUTO figures have been measured observing vcsel * emissions on an actual device */ #define LOWPOWER_AUTO_VHV_LOOP_DURATION_US 245 #define LOWPOWER_AUTO_OVERHEAD_BEFORE_A_RANGING 1448 #define LOWPOWER_AUTO_OVERHEAD_BETWEEN_A_B_RANGING 2100 #define FDA_MAX_TIMING_BUDGET_US 550000 /* Maximum timing budget allowed codex #456189*/ /* local static utilities functions */ /* Bare Driver Tuning parameter table indexed with VL53L1_Tuning_t */ static int32_t BDTable[VL53L1_TUNING_MAX_TUNABLE_KEY] = { TUNING_VERSION, TUNING_PROXY_MIN, TUNING_SINGLE_TARGET_XTALK_TARGET_DISTANCE_MM, TUNING_SINGLE_TARGET_XTALK_SAMPLE_NUMBER, TUNING_MIN_AMBIENT_DMAX_VALID, TUNING_MAX_SIMPLE_OFFSET_CALIBRATION_SAMPLE_NUMBER, TUNING_XTALK_FULL_ROI_TARGET_DISTANCE_MM, TUNING_SIMPLE_OFFSET_CALIBRATION_REPEAT }; #define VL53L1_NVM_POWER_UP_DELAY_US 50 #define VL53L1_NVM_READ_TRIGGER_DELAY_US 5 static VL53L1_Error VL53L1_nvm_enable( VL53L1_DEV Dev, uint16_t nvm_ctrl_pulse_width, int32_t nvm_power_up_delay_us) { /* * Sequence below enables NVM for reading * * - Enable power force * - Disable firmware * - Power up NVM * - Wait for 50us while the NVM powers up * - Configure for reading and set the pulse width (16-bit) */ VL53L1_Error status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); /* Disable Firmware */ if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ status = VL53L1_disable_firmware(Dev); /* Enable Power Force */ if (status == VL53L1_ERROR_NONE) status = VL53L1_enable_powerforce(Dev); /* Wait the required time for the regulators, bandgap, * oscillator to wake up and settle */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WaitUs( Dev, VL53L1_ENABLE_POWERFORCE_SETTLING_TIME_US); /* Power up NVM */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__PDN, 0x01); /* Enable NVM Clock */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__CLK_CTRL1, 0x05); /* Wait the required time for NVM to power up*/ if (status == VL53L1_ERROR_NONE) status = VL53L1_WaitUs( Dev, nvm_power_up_delay_us); /* Select read mode and set control pulse width */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__MODE, 0x01); if (status == VL53L1_ERROR_NONE) status = VL53L1_WrWord( Dev, VL53L1_RANGING_CORE__NVM_CTRL__PULSE_WIDTH_MSB, nvm_ctrl_pulse_width); LOG_FUNCTION_END(status); return status; } static VL53L1_Error VL53L1_nvm_read( VL53L1_DEV Dev, uint8_t start_address, uint8_t count, uint8_t *pdata) { /* * Sequence per 32-bit NVM read access: * * - Set up the 5-bit (0-127) NVM Address * - Trigger the read of the NVM data by toggling NVM_CTRL__READN * - Read the NVM data - 4 bytes wide read/write interface * - Increment data byte pointer by 4 ready for the next loop */ VL53L1_Error status = VL53L1_ERROR_NONE; uint8_t nvm_addr = 0; LOG_FUNCTION_START(""); for (nvm_addr = start_address; nvm_addr < (start_address+count) ; nvm_addr++) { /* Step 1 : set address */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__ADDR, nvm_addr); /* Step 2 : trigger reading of data */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__READN, 0x00); /* Step 3 : wait the required time */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WaitUs( Dev, VL53L1_NVM_READ_TRIGGER_DELAY_US); if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__READN, 0x01); /* Step 3 : read 4-byte wide data register */ if (status == VL53L1_ERROR_NONE) status = VL53L1_ReadMulti( Dev, VL53L1_RANGING_CORE__NVM_CTRL__DATAOUT_MMM, pdata, 4); /* Step 4 : increment byte buffer pointer */ pdata = pdata + 4; } LOG_FUNCTION_END(status); return status; } static VL53L1_Error VL53L1_nvm_disable( VL53L1_DEV Dev) { /* * Power down NVM (OTP) to extend lifetime */ VL53L1_Error status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__READN, 0x01); /* Power down NVM */ if (status == VL53L1_ERROR_NONE) status = VL53L1_WrByte( Dev, VL53L1_RANGING_CORE__NVM_CTRL__PDN, 0x00); /* Keep power force enabled */ if (status == VL53L1_ERROR_NONE) status = VL53L1_disable_powerforce(Dev); /* (Re)Enable Firmware */ if (status == VL53L1_ERROR_NONE) status = VL53L1_enable_firmware(Dev); LOG_FUNCTION_END(status); return status; } static VL53L1_Error VL53L1_read_nvm_raw_data( VL53L1_DEV Dev, uint8_t start_address, uint8_t count, uint8_t *pnvm_raw_data) { /* * Reads ALL 512 bytes of NVM data */ VL53L1_Error status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); /* * Enable NVM and set control pulse width */ if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ status = VL53L1_nvm_enable( Dev, 0x0004, VL53L1_NVM_POWER_UP_DELAY_US); /* * Read the raw NVM data * - currently all of 128 * 4 bytes = 512 bytes are read */ if (status == VL53L1_ERROR_NONE) status = VL53L1_nvm_read( Dev, start_address, count, pnvm_raw_data); /* * Disable NVM */ if (status == VL53L1_ERROR_NONE) status = VL53L1_nvm_disable(Dev); LOG_FUNCTION_END(status); return status; } static VL53L1_Error SingleTargetXTalkCalibration(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint32_t sum_ranging = 0; uint32_t sum_spads = 0; FixPoint1616_t sum_signalRate = 0; FixPoint1616_t total_count = 0; uint8_t xtalk_meas = 0; uint8_t xtalk_measmax = BDTable[VL53L1_TUNING_SINGLE_TARGET_XTALK_SAMPLE_NUMBER]; VL53L1_RangingMeasurementData_t RMData; FixPoint1616_t xTalkStoredMeanSignalRate; FixPoint1616_t xTalkStoredMeanRange; FixPoint1616_t xTalkStoredMeanRtnSpads; uint32_t xTalkStoredMeanRtnSpadsAsInt; uint32_t xTalkCalDistanceAsInt; FixPoint1616_t XTalkCompensationRateMegaCps; uint32_t signalXTalkTotalPerSpad; VL53L1_PresetModes PresetMode; VL53L1_CalibrationData_t CalibrationData; VL53L1_CustomerNvmManaged_t *pC; LOG_FUNCTION_START(""); /* check if the following are selected * VL53L1_PRESETMODE_AUTONOMOUS, * VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS * VL53L1_PRESETMODE_LITE_RANGING */ PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); if ((PresetMode != VL53L1_PRESETMODE_AUTONOMOUS) && (PresetMode != VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS) && (PresetMode != VL53L1_PRESETMODE_LITE_RANGING)) { Status = VL53L1_ERROR_MODE_NOT_SUPPORTED; goto ENDFUNC; } /* disable crosstalk calibration */ Status = VL53L1_disable_xtalk_compensation(Dev); CHECK_ERROR_GO_ENDFUNC; Status = VL53L1_StartMeasurement(Dev); CHECK_ERROR_GO_ENDFUNC; sum_ranging = 0; sum_spads = 0; sum_signalRate = 0; total_count = 0; for (xtalk_meas = 0; xtalk_meas < xtalk_measmax; xtalk_meas++) { VL53L1_WaitMeasurementDataReady(Dev); VL53L1_GetRangingMeasurementData(Dev, &RMData); VL53L1_ClearInterruptAndStartMeasurement(Dev); if (RMData.RangeStatus == VL53L1_RANGESTATUS_RANGE_VALID) { sum_ranging += RMData.RangeMilliMeter; sum_signalRate += RMData.SignalRateRtnMegaCps; sum_spads += RMData.EffectiveSpadRtnCount / 256; total_count++; } } Status = VL53L1_StopMeasurement(Dev); if (total_count > 0) { /* FixPoint1616_t / uint16_t = FixPoint1616_t */ xTalkStoredMeanSignalRate = sum_signalRate / total_count; xTalkStoredMeanRange = (FixPoint1616_t)(sum_ranging << 16); xTalkStoredMeanRange /= total_count; xTalkStoredMeanRtnSpads = (FixPoint1616_t)(sum_spads << 16); xTalkStoredMeanRtnSpads /= total_count; /* Round Mean Spads to Whole Number. * Typically the calculated mean SPAD count is a whole number * or very close to a whole * number, therefore any truncation will not result in a * significant loss in accuracy. * Also, for a grey target at a typical distance of around * 400mm, around 220 SPADs will * be enabled, therefore, any truncation will result in a loss * of accuracy of less than * 0.5%. */ xTalkStoredMeanRtnSpadsAsInt = (xTalkStoredMeanRtnSpads + 0x8000) >> 16; /* Round Cal Distance to Whole Number. * Note that the cal distance is in mm, therefore no resolution * is lost. */ xTalkCalDistanceAsInt = ((uint32_t)BDTable[ VL53L1_TUNING_SINGLE_TARGET_XTALK_TARGET_DISTANCE_MM]); if (xTalkStoredMeanRtnSpadsAsInt == 0 || xTalkCalDistanceAsInt == 0 || xTalkStoredMeanRange >= (xTalkCalDistanceAsInt << 16)) { XTalkCompensationRateMegaCps = 0; } else { /* Apply division by mean spad count early in the * calculation to keep the numbers small. * This ensures we can maintain a 32bit calculation. * Fixed1616 / int := Fixed1616 */ signalXTalkTotalPerSpad = (xTalkStoredMeanSignalRate) / xTalkStoredMeanRtnSpadsAsInt; /* Complete the calculation for total Signal XTalk per * SPAD * Fixed1616 * (Fixed1616 - Fixed1616/int) := * (2^16 * Fixed1616) */ signalXTalkTotalPerSpad *= (((uint32_t)1 << 16) - (xTalkStoredMeanRange / xTalkCalDistanceAsInt)); /* Round from 2^16 * Fixed1616, to Fixed1616. */ XTalkCompensationRateMegaCps = (signalXTalkTotalPerSpad + 0x8000) >> 16; } Status = VL53L1_GetCalibrationData(Dev, &CalibrationData); CHECK_ERROR_GO_ENDFUNC; pC = &CalibrationData.customer; pC->algo__crosstalk_compensation_plane_offset_kcps = (uint32_t)(1000 * ((XTalkCompensationRateMegaCps + ((uint32_t)1<<6)) >> (16-9))); Status = VL53L1_SetCalibrationData(Dev, &CalibrationData); CHECK_ERROR_GO_ENDFUNC; Status = VL53L1_enable_xtalk_compensation(Dev); } else /* return error because no valid data found */ Status = VL53L1_ERROR_XTALK_EXTRACTION_NO_SAMPLE_FAIL; ENDFUNC: LOG_FUNCTION_END(Status); return Status; } /* Check Rectangle in user's coordinate system: * 15 TL(x,y) o-----* * ^ | | * | *-----o BR(x,y) * 0------------------------- >15 * check Rectangle definition conforms to the (0,15,15) coordinate system * with a minimum of 4x4 size */ static VL53L1_Error CheckValidRectRoi(VL53L1_UserRoi_t ROI) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); /* Negative check are not necessary because value is unsigned */ if ((ROI.TopLeftX > 15) || (ROI.TopLeftY > 15) || (ROI.BotRightX > 15) || (ROI.BotRightY > 15)) Status = VL53L1_ERROR_INVALID_PARAMS; if ((ROI.TopLeftX > ROI.BotRightX) || (ROI.TopLeftY < ROI.BotRightY)) Status = VL53L1_ERROR_INVALID_PARAMS; LOG_FUNCTION_END(Status); return Status; } static VL53L1_GPIO_Interrupt_Mode ConvertModeToLLD(VL53L1_Error *pStatus, VL53L1_ThresholdMode CrossMode) { VL53L1_GPIO_Interrupt_Mode Mode; switch (CrossMode) { case VL53L1_THRESHOLD_CROSSED_LOW: Mode = VL53L1_GPIOINTMODE_LEVEL_LOW; break; case VL53L1_THRESHOLD_CROSSED_HIGH: Mode = VL53L1_GPIOINTMODE_LEVEL_HIGH; break; case VL53L1_THRESHOLD_OUT_OF_WINDOW: Mode = VL53L1_GPIOINTMODE_OUT_OF_WINDOW; break; case VL53L1_THRESHOLD_IN_WINDOW: Mode = VL53L1_GPIOINTMODE_IN_WINDOW; break; default: /* define Mode to avoid warning but actual value doesn't mind */ Mode = VL53L1_GPIOINTMODE_LEVEL_HIGH; *pStatus = VL53L1_ERROR_INVALID_PARAMS; } return Mode; } static VL53L1_ThresholdMode ConvertModeFromLLD(VL53L1_Error *pStatus, VL53L1_GPIO_Interrupt_Mode CrossMode) { VL53L1_ThresholdMode Mode; switch (CrossMode) { case VL53L1_GPIOINTMODE_LEVEL_LOW: Mode = VL53L1_THRESHOLD_CROSSED_LOW; break; case VL53L1_GPIOINTMODE_LEVEL_HIGH: Mode = VL53L1_THRESHOLD_CROSSED_HIGH; break; case VL53L1_GPIOINTMODE_OUT_OF_WINDOW: Mode = VL53L1_THRESHOLD_OUT_OF_WINDOW; break; case VL53L1_GPIOINTMODE_IN_WINDOW: Mode = VL53L1_THRESHOLD_IN_WINDOW; break; default: /* define Mode to avoid warning but actual value doesn't mind */ Mode = VL53L1_THRESHOLD_CROSSED_HIGH; *pStatus = VL53L1_ERROR_UNDEFINED; } return Mode; } /* Group PAL General Functions */ VL53L1_Error VL53L1_GetVersion(VL53L1_Version_t *pVersion) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); pVersion->major = VL53L1_IMPLEMENTATION_VER_MAJOR; pVersion->minor = VL53L1_IMPLEMENTATION_VER_MINOR; pVersion->build = VL53L1_IMPLEMENTATION_VER_SUB; pVersion->revision = VL53L1_IMPLEMENTATION_VER_REVISION; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetProductRevision(VL53L1_DEV Dev, uint8_t *pProductRevisionMajor, uint8_t *pProductRevisionMinor) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t revision_id; VL53L1_LLDriverData_t *pLLData; LOG_FUNCTION_START(""); pLLData = VL53L1DevStructGetLLDriverHandle(Dev); revision_id = pLLData->nvm_copy_data.identification__revision_id; *pProductRevisionMajor = 1; *pProductRevisionMinor = (revision_id & 0xF0) >> 4; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetDeviceInfo(VL53L1_DEV Dev, VL53L1_DeviceInfo_t *pVL53L1_DeviceInfo) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t revision_id; VL53L1_LLDriverData_t *pLLData; LOG_FUNCTION_START(""); pLLData = VL53L1DevStructGetLLDriverHandle(Dev); strncpy(pVL53L1_DeviceInfo->ProductId, "", VL53L1_DEVINFO_STRLEN-1); pVL53L1_DeviceInfo->ProductType = pLLData->nvm_copy_data.identification__module_type; revision_id = pLLData->nvm_copy_data.identification__revision_id; pVL53L1_DeviceInfo->ProductRevisionMajor = 1; pVL53L1_DeviceInfo->ProductRevisionMinor = (revision_id & 0xF0) >> 4; #ifndef VL53L1_USE_EMPTY_STRING if (pVL53L1_DeviceInfo->ProductRevisionMinor == 0) strncpy(pVL53L1_DeviceInfo->Name, VL53L1_STRING_DEVICE_INFO_NAME0, VL53L1_DEVINFO_STRLEN-1); else strncpy(pVL53L1_DeviceInfo->Name, VL53L1_STRING_DEVICE_INFO_NAME1, VL53L1_DEVINFO_STRLEN-1); strncpy(pVL53L1_DeviceInfo->Type, VL53L1_STRING_DEVICE_INFO_TYPE, VL53L1_DEVINFO_STRLEN-1); #else pVL53L1_DeviceInfo->Name[0] = 0; pVL53L1_DeviceInfo->Type[0] = 0; #endif LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetRangeStatusString(uint8_t RangeStatus, char *pRangeStatusString) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_range_status_string(RangeStatus, pRangeStatusString); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetPalErrorString(VL53L1_Error PalErrorCode, char *pPalErrorString) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_pal_error_string(PalErrorCode, pPalErrorString); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetPalStateString(VL53L1_State PalStateCode, char *pPalStateString) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_pal_state_string(PalStateCode, pPalStateString); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetPalState(VL53L1_DEV Dev, VL53L1_State *pPalState) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); *pPalState = VL53L1DevDataGet(Dev, PalState); LOG_FUNCTION_END(Status); return Status; } /* End Group PAL General Functions */ /* Group PAL Init Functions */ VL53L1_Error VL53L1_SetDeviceAddress(VL53L1_DEV Dev, uint8_t DeviceAddress) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_WrByte(Dev, VL53L1_I2C_SLAVE__DEVICE_ADDRESS, DeviceAddress / 2); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_DataInit(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t i; LOG_FUNCTION_START(""); /* 2V8 power mode selection codex 447463 */ #ifdef USE_I2C_2V8 Status = VL53L1_RdByte(Dev, VL53L1_PAD_I2C_HV__EXTSUP_CONFIG, &i); if (Status == VL53L1_ERROR_NONE) { i = (i & 0xfe) | 0x01; Status = VL53L1_WrByte(Dev, VL53L1_PAD_I2C_HV__EXTSUP_CONFIG, i); } #endif if (Status == VL53L1_ERROR_NONE) Status = VL53L1_data_init(Dev, 1); if (Status == VL53L1_ERROR_NONE) { VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_WAIT_STATICINIT); VL53L1DevDataSet(Dev, CurrentParameters.PresetMode, VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS); } /* Enable all check */ for (i = 0; i < VL53L1_CHECKENABLE_NUMBER_OF_CHECKS; i++) { if (Status == VL53L1_ERROR_NONE) Status |= VL53L1_SetLimitCheckEnable(Dev, i, 1); else break; } /* Limit default values */ if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_SetLimitCheckValue(Dev, VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE, (FixPoint1616_t)(18 * 65536)); } if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_SetLimitCheckValue(Dev, VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, (FixPoint1616_t)(25 * 65536 / 100)); /* 0.25 * 65536 */ } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_StaticInit(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t measurement_mode; LOG_FUNCTION_START(""); VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_IDLE); measurement_mode = VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK; VL53L1DevDataSet(Dev, LLData.measurement_mode, measurement_mode); VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode, VL53L1_DISTANCEMODE_LONG); VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode, VL53L1_DISTANCEMODE_LONG); VL53L1DevDataSet(Dev, CurrentParameters.DistanceMode, VL53L1_DISTANCEMODE_LONG); /* ticket 472728 fix */ Status = VL53L1_SetPresetMode(Dev, VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS); /* end of ticket 472728 fix */ LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_WaitDeviceBooted(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_poll_for_boot_completion(Dev, VL53L1_BOOT_COMPLETION_POLLING_TIMEOUT_MS); LOG_FUNCTION_END(Status); return Status; } /* End Group PAL Init Functions */ /* Group PAL Parameters Functions */ static VL53L1_Error ComputeDevicePresetMode( VL53L1_PresetModes PresetMode, VL53L1_DistanceModes DistanceMode, VL53L1_DevicePresetModes *pDevicePresetMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t DistIdx; VL53L1_DevicePresetModes LightModes[3] = { VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_SHORT_RANGE, VL53L1_DEVICEPRESETMODE_STANDARD_RANGING, VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_LONG_RANGE}; VL53L1_DevicePresetModes TimedModes[3] = { VL53L1_DEVICEPRESETMODE_TIMED_RANGING_SHORT_RANGE, VL53L1_DEVICEPRESETMODE_TIMED_RANGING, VL53L1_DEVICEPRESETMODE_TIMED_RANGING_LONG_RANGE}; VL53L1_DevicePresetModes LowPowerTimedModes[3] = { VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_SHORT_RANGE, VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_MEDIUM_RANGE, VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_LONG_RANGE}; *pDevicePresetMode = VL53L1_DEVICEPRESETMODE_STANDARD_RANGING; switch (DistanceMode) { case VL53L1_DISTANCEMODE_SHORT: DistIdx = 0; break; case VL53L1_DISTANCEMODE_MEDIUM: DistIdx = 1; break; default: DistIdx = 2; } switch (PresetMode) { case VL53L1_PRESETMODE_LITE_RANGING: *pDevicePresetMode = LightModes[DistIdx]; break; case VL53L1_PRESETMODE_AUTONOMOUS: *pDevicePresetMode = TimedModes[DistIdx]; break; case VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS: *pDevicePresetMode = LowPowerTimedModes[DistIdx]; break; default: /* Unsupported mode */ Status = VL53L1_ERROR_MODE_NOT_SUPPORTED; } return Status; } static VL53L1_Error SetPresetMode(VL53L1_DEV Dev, VL53L1_PresetModes PresetMode, VL53L1_DistanceModes DistanceMode, uint32_t inter_measurement_period_ms) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_DevicePresetModes device_preset_mode; uint8_t measurement_mode; uint16_t dss_config__target_total_rate_mcps; uint32_t phasecal_config_timeout_us; uint32_t mm_config_timeout_us; uint32_t lld_range_config_timeout_us; LOG_FUNCTION_START("%d", (int)PresetMode); if ((PresetMode == VL53L1_PRESETMODE_AUTONOMOUS) || (PresetMode == VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS)) measurement_mode = VL53L1_DEVICEMEASUREMENTMODE_TIMED; else measurement_mode = VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK; Status = ComputeDevicePresetMode(PresetMode, DistanceMode, &device_preset_mode); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_preset_mode_timing_cfg(Dev, device_preset_mode, &dss_config__target_total_rate_mcps, &phasecal_config_timeout_us, &mm_config_timeout_us, &lld_range_config_timeout_us); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_set_preset_mode( Dev, device_preset_mode, dss_config__target_total_rate_mcps, phasecal_config_timeout_us, mm_config_timeout_us, lld_range_config_timeout_us, inter_measurement_period_ms); if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, LLData.measurement_mode, measurement_mode); if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, CurrentParameters.PresetMode, PresetMode); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetPresetMode(VL53L1_DEV Dev, VL53L1_PresetModes PresetMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_DistanceModes DistanceMode = VL53L1_DISTANCEMODE_LONG; LOG_FUNCTION_START("%d", (int)PresetMode); Status = SetPresetMode(Dev, PresetMode, DistanceMode, 1000); if (Status == VL53L1_ERROR_NONE) { VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode, DistanceMode); VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode, DistanceMode); if ((PresetMode == VL53L1_PRESETMODE_LITE_RANGING) || (PresetMode == VL53L1_PRESETMODE_AUTONOMOUS) || (PresetMode == VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS)) Status = VL53L1_SetMeasurementTimingBudgetMicroSeconds( Dev, 41000); else /* Set default timing budget to 30Hz (33.33 ms)*/ Status = VL53L1_SetMeasurementTimingBudgetMicroSeconds( Dev, 33333); } if (Status == VL53L1_ERROR_NONE) { /* Set default intermeasurement period to 1000 ms */ Status = VL53L1_SetInterMeasurementPeriodMilliSeconds(Dev, 1000); } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetPresetMode(VL53L1_DEV Dev, VL53L1_PresetModes *pPresetMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); *pPresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetDistanceMode(VL53L1_DEV Dev, VL53L1_DistanceModes DistanceMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_PresetModes PresetMode; VL53L1_DistanceModes InternalDistanceMode; uint32_t inter_measurement_period_ms; uint32_t TimingBudget; uint32_t MmTimeoutUs; uint32_t PhaseCalTimeoutUs; VL53L1_user_zone_t user_zone; LOG_FUNCTION_START("%d", (int)DistanceMode); PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); /* when the distance mode is valid: * Manual Mode: all modes * AUTO AUTO_LITE : LITE_RANGING, RANGING */ if ((DistanceMode != VL53L1_DISTANCEMODE_SHORT) && (DistanceMode != VL53L1_DISTANCEMODE_MEDIUM) && (DistanceMode != VL53L1_DISTANCEMODE_LONG)) return VL53L1_ERROR_INVALID_PARAMS; /* The internal distance mode is limited to Short, Medium or * long only */ if (Status == VL53L1_ERROR_NONE) { if ((DistanceMode == VL53L1_DISTANCEMODE_SHORT) || (DistanceMode == VL53L1_DISTANCEMODE_MEDIUM)) InternalDistanceMode = DistanceMode; else /* (DistanceMode == VL53L1_DISTANCEMODE_LONG) */ InternalDistanceMode = VL53L1_DISTANCEMODE_LONG; } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_user_zone(Dev, &user_zone); inter_measurement_period_ms = VL53L1DevDataGet(Dev, LLData.inter_measurement_period_ms); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_timeouts_us(Dev, &PhaseCalTimeoutUs, &MmTimeoutUs, &TimingBudget); if (Status == VL53L1_ERROR_NONE) Status = SetPresetMode(Dev, PresetMode, InternalDistanceMode, inter_measurement_period_ms); if (Status == VL53L1_ERROR_NONE) { VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode, InternalDistanceMode); VL53L1DevDataSet(Dev, CurrentParameters.NewDistanceMode, InternalDistanceMode); VL53L1DevDataSet(Dev, CurrentParameters.DistanceMode, DistanceMode); } if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_set_timeouts_us(Dev, PhaseCalTimeoutUs, MmTimeoutUs, TimingBudget); if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, LLData.range_config_timeout_us, TimingBudget); } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_set_user_zone(Dev, &user_zone); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetDistanceMode(VL53L1_DEV Dev, VL53L1_DistanceModes *pDistanceMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); *pDistanceMode = VL53L1DevDataGet(Dev, CurrentParameters.DistanceMode); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetMeasurementTimingBudgetMicroSeconds(VL53L1_DEV Dev, uint32_t MeasurementTimingBudgetMicroSeconds) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t Mm1Enabled; uint8_t Mm2Enabled; uint32_t TimingGuard; uint32_t divisor; uint32_t TimingBudget; uint32_t MmTimeoutUs; VL53L1_PresetModes PresetMode; uint32_t PhaseCalTimeoutUs; uint32_t vhv; int32_t vhv_loops; uint32_t FDAMaxTimingBudgetUs = FDA_MAX_TIMING_BUDGET_US; LOG_FUNCTION_START(""); /* Timing budget is limited to 10 seconds */ if (MeasurementTimingBudgetMicroSeconds > 10000000) Status = VL53L1_ERROR_INVALID_PARAMS; if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_GetSequenceStepEnable(Dev, VL53L1_SEQUENCESTEP_MM1, &Mm1Enabled); } if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_GetSequenceStepEnable(Dev, VL53L1_SEQUENCESTEP_MM2, &Mm2Enabled); } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_timeouts_us(Dev, &PhaseCalTimeoutUs, &MmTimeoutUs, &TimingBudget); if (Status == VL53L1_ERROR_NONE) { PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); TimingGuard = 0; divisor = 1; switch (PresetMode) { case VL53L1_PRESETMODE_LITE_RANGING: if ((Mm1Enabled == 1) || (Mm2Enabled == 1)) TimingGuard = 5000; else TimingGuard = 1000; break; case VL53L1_PRESETMODE_AUTONOMOUS: FDAMaxTimingBudgetUs *= 2; if ((Mm1Enabled == 1) || (Mm2Enabled == 1)) TimingGuard = 26600; else TimingGuard = 21600; divisor = 2; break; case VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS: FDAMaxTimingBudgetUs *= 2; vhv = LOWPOWER_AUTO_VHV_LOOP_DURATION_US; VL53L1_get_tuning_parm(Dev, VL53L1_TUNINGPARM_LOWPOWERAUTO_VHV_LOOP_BOUND, &vhv_loops); if (vhv_loops > 0) { vhv += vhv_loops * LOWPOWER_AUTO_VHV_LOOP_DURATION_US; } TimingGuard = LOWPOWER_AUTO_OVERHEAD_BEFORE_A_RANGING + LOWPOWER_AUTO_OVERHEAD_BETWEEN_A_B_RANGING + vhv; divisor = 2; break; default: /* Unsupported mode */ Status = VL53L1_ERROR_MODE_NOT_SUPPORTED; } if (MeasurementTimingBudgetMicroSeconds <= TimingGuard) Status = VL53L1_ERROR_INVALID_PARAMS; else { TimingBudget = (MeasurementTimingBudgetMicroSeconds - TimingGuard); } if (Status == VL53L1_ERROR_NONE) { if (TimingBudget > FDAMaxTimingBudgetUs) Status = VL53L1_ERROR_INVALID_PARAMS; else { TimingBudget /= divisor; Status = VL53L1_set_timeouts_us( Dev, PhaseCalTimeoutUs, MmTimeoutUs, TimingBudget); } if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, LLData.range_config_timeout_us, TimingBudget); } } if (Status == VL53L1_ERROR_NONE) { VL53L1DevDataSet(Dev, CurrentParameters.MeasurementTimingBudgetMicroSeconds, MeasurementTimingBudgetMicroSeconds); } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetMeasurementTimingBudgetMicroSeconds(VL53L1_DEV Dev, uint32_t *pMeasurementTimingBudgetMicroSeconds) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t Mm1Enabled = 0; uint8_t Mm2Enabled = 0; uint32_t MmTimeoutUs = 0; uint32_t RangeTimeoutUs = 0; uint32_t MeasTimingBdg = 0; uint32_t PhaseCalTimeoutUs = 0; VL53L1_PresetModes PresetMode; uint32_t TimingGuard; uint32_t vhv; int32_t vhv_loops; LOG_FUNCTION_START(""); *pMeasurementTimingBudgetMicroSeconds = 0; if (Status == VL53L1_ERROR_NONE) Status = VL53L1_GetSequenceStepEnable(Dev, VL53L1_SEQUENCESTEP_MM1, &Mm1Enabled); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_GetSequenceStepEnable(Dev, VL53L1_SEQUENCESTEP_MM2, &Mm2Enabled); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_timeouts_us(Dev, &PhaseCalTimeoutUs, &MmTimeoutUs, &RangeTimeoutUs); if (Status == VL53L1_ERROR_NONE) { PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); switch (PresetMode) { case VL53L1_PRESETMODE_LITE_RANGING: if ((Mm1Enabled == 1) || (Mm2Enabled == 1)) MeasTimingBdg = RangeTimeoutUs + 5000; else MeasTimingBdg = RangeTimeoutUs + 1000; break; case VL53L1_PRESETMODE_AUTONOMOUS: if ((Mm1Enabled == 1) || (Mm2Enabled == 1)) MeasTimingBdg = 2 * RangeTimeoutUs + 26600; else MeasTimingBdg = 2 * RangeTimeoutUs + 21600; break; case VL53L1_PRESETMODE_LOWPOWER_AUTONOMOUS: vhv = LOWPOWER_AUTO_VHV_LOOP_DURATION_US; VL53L1_get_tuning_parm(Dev, VL53L1_TUNINGPARM_LOWPOWERAUTO_VHV_LOOP_BOUND, &vhv_loops); if (vhv_loops > 0) { vhv += vhv_loops * LOWPOWER_AUTO_VHV_LOOP_DURATION_US; } TimingGuard = LOWPOWER_AUTO_OVERHEAD_BEFORE_A_RANGING + LOWPOWER_AUTO_OVERHEAD_BETWEEN_A_B_RANGING + vhv; MeasTimingBdg = 2 * RangeTimeoutUs + TimingGuard; break; default: /* Unsupported mode */ Status = VL53L1_ERROR_MODE_NOT_SUPPORTED; } } if (Status == VL53L1_ERROR_NONE) *pMeasurementTimingBudgetMicroSeconds = MeasTimingBdg; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetInterMeasurementPeriodMilliSeconds(VL53L1_DEV Dev, uint32_t InterMeasurementPeriodMilliSeconds) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint32_t adjustedIMP; LOG_FUNCTION_START(""); /* Fix for Ticket 468205 actual measurement period shorter than set */ adjustedIMP = InterMeasurementPeriodMilliSeconds; adjustedIMP += (adjustedIMP * 64) / 1000; /* End of fix for Ticket 468205 */ Status = VL53L1_set_inter_measurement_period_ms(Dev, adjustedIMP); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetInterMeasurementPeriodMilliSeconds(VL53L1_DEV Dev, uint32_t *pInterMeasurementPeriodMilliSeconds) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint32_t adjustedIMP; LOG_FUNCTION_START(""); Status = VL53L1_get_inter_measurement_period_ms(Dev, &adjustedIMP); /* Fix for Ticket 468205 actual measurement period shorter than set */ adjustedIMP -= (adjustedIMP * 64) / 1000; *pInterMeasurementPeriodMilliSeconds = adjustedIMP; /* End of fix for Ticket 468205 */ LOG_FUNCTION_END(Status); return Status; } /* End Group PAL Parameters Functions */ /* Group Limit check Functions */ VL53L1_Error VL53L1_GetNumberOfLimitCheck(uint16_t *pNumberOfLimitCheck) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); *pNumberOfLimitCheck = VL53L1_CHECKENABLE_NUMBER_OF_CHECKS; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetLimitCheckInfo(uint16_t LimitCheckId, char *pLimitCheckString) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_limit_check_info(LimitCheckId, pLimitCheckString); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetLimitCheckStatus(VL53L1_DEV Dev, uint16_t LimitCheckId, uint8_t *pLimitCheckStatus) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t Temp8; LOG_FUNCTION_START(""); if (LimitCheckId >= VL53L1_CHECKENABLE_NUMBER_OF_CHECKS) { Status = VL53L1_ERROR_INVALID_PARAMS; } else { VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksStatus, LimitCheckId, Temp8); *pLimitCheckStatus = Temp8; } LOG_FUNCTION_END(Status); return Status; } static VL53L1_Error SetLimitValue(VL53L1_DEV Dev, uint16_t LimitCheckId, FixPoint1616_t value) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint16_t tmpuint16; /* temporary variable */ LOG_FUNCTION_START(""); switch (LimitCheckId) { case VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE: tmpuint16 = VL53L1_FIXPOINT1616TOFIXPOINT142(value); VL53L1_set_lite_sigma_threshold(Dev, tmpuint16); break; case VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE: tmpuint16 = VL53L1_FIXPOINT1616TOFIXPOINT97(value); VL53L1_set_lite_min_count_rate(Dev, tmpuint16); break; default: Status = VL53L1_ERROR_INVALID_PARAMS; } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetLimitCheckEnable(VL53L1_DEV Dev, uint16_t LimitCheckId, uint8_t LimitCheckEnable) { VL53L1_Error Status = VL53L1_ERROR_NONE; FixPoint1616_t TempFix1616 = 0; LOG_FUNCTION_START(""); if (LimitCheckId >= VL53L1_CHECKENABLE_NUMBER_OF_CHECKS) { Status = VL53L1_ERROR_INVALID_PARAMS; } else { /* TempFix1616 contains either 0 or the limit value */ if (LimitCheckEnable == 0) TempFix1616 = 0; else VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue, LimitCheckId, TempFix1616); Status = SetLimitValue(Dev, LimitCheckId, TempFix1616); } if (Status == VL53L1_ERROR_NONE) VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId, ((LimitCheckEnable == 0) ? 0 : 1)); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetLimitCheckEnable(VL53L1_DEV Dev, uint16_t LimitCheckId, uint8_t *pLimitCheckEnable) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t Temp8; LOG_FUNCTION_START(""); if (LimitCheckId >= VL53L1_CHECKENABLE_NUMBER_OF_CHECKS) { Status = VL53L1_ERROR_INVALID_PARAMS; *pLimitCheckEnable = 0; } else { VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId, Temp8); *pLimitCheckEnable = Temp8; } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetLimitCheckValue(VL53L1_DEV Dev, uint16_t LimitCheckId, FixPoint1616_t LimitCheckValue) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t LimitChecksEnable; LOG_FUNCTION_START(""); if (LimitCheckId >= VL53L1_CHECKENABLE_NUMBER_OF_CHECKS) { Status = VL53L1_ERROR_INVALID_PARAMS; } else { VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId, LimitChecksEnable); if (LimitChecksEnable == 0) { /* disabled write only internal value */ VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue, LimitCheckId, LimitCheckValue); } else { Status = SetLimitValue(Dev, LimitCheckId, LimitCheckValue); if (Status == VL53L1_ERROR_NONE) { VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue, LimitCheckId, LimitCheckValue); } } } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetLimitCheckValue(VL53L1_DEV Dev, uint16_t LimitCheckId, FixPoint1616_t *pLimitCheckValue) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint16_t MinCountRate; FixPoint1616_t TempFix1616; uint16_t SigmaThresh; LOG_FUNCTION_START(""); switch (LimitCheckId) { case VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE: Status = VL53L1_get_lite_sigma_threshold(Dev, &SigmaThresh); TempFix1616 = VL53L1_FIXPOINT142TOFIXPOINT1616(SigmaThresh); break; case VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE: Status = VL53L1_get_lite_min_count_rate(Dev, &MinCountRate); TempFix1616 = VL53L1_FIXPOINT97TOFIXPOINT1616(MinCountRate); break; default: Status = VL53L1_ERROR_INVALID_PARAMS; } if (Status == VL53L1_ERROR_NONE) { if (TempFix1616 == 0) { /* disabled: return value from memory */ VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue, LimitCheckId, TempFix1616); *pLimitCheckValue = TempFix1616; VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId, 0); } else { *pLimitCheckValue = TempFix1616; VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue, LimitCheckId, TempFix1616); VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId, 1); } } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetLimitCheckCurrent(VL53L1_DEV Dev, uint16_t LimitCheckId, FixPoint1616_t *pLimitCheckCurrent) { VL53L1_Error Status = VL53L1_ERROR_NONE; FixPoint1616_t TempFix1616 = 0; LOG_FUNCTION_START(""); if (LimitCheckId >= VL53L1_CHECKENABLE_NUMBER_OF_CHECKS) { Status = VL53L1_ERROR_INVALID_PARAMS; } else { VL53L1_GETARRAYPARAMETERFIELD(Dev, LimitChecksCurrent, LimitCheckId, TempFix1616); *pLimitCheckCurrent = TempFix1616; } LOG_FUNCTION_END(Status); return Status; } /* End Group Limit check Functions */ /* Group ROI Functions */ VL53L1_Error VL53L1_SetUserROI(VL53L1_DEV Dev, VL53L1_UserRoi_t *pRoi) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_user_zone_t user_zone; Status = CheckValidRectRoi(*pRoi); if (Status != VL53L1_ERROR_NONE) return VL53L1_ERROR_INVALID_PARAMS; user_zone.x_centre = (pRoi->BotRightX + pRoi->TopLeftX + 1) / 2; user_zone.y_centre = (pRoi->TopLeftY + pRoi->BotRightY + 1) / 2; user_zone.width = (pRoi->BotRightX - pRoi->TopLeftX); user_zone.height = (pRoi->TopLeftY - pRoi->BotRightY); if ((user_zone.width < 3) || (user_zone.height < 3)) Status = VL53L1_ERROR_INVALID_PARAMS; else Status = VL53L1_set_user_zone(Dev, &user_zone); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetUserROI(VL53L1_DEV Dev, VL53L1_UserRoi_t *pRoi) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_user_zone_t user_zone; Status = VL53L1_get_user_zone(Dev, &user_zone); pRoi->TopLeftX = (2 * user_zone.x_centre - user_zone.width) >> 1; pRoi->TopLeftY = (2 * user_zone.y_centre + user_zone.height) >> 1; pRoi->BotRightX = (2 * user_zone.x_centre + user_zone.width) >> 1; pRoi->BotRightY = (2 * user_zone.y_centre - user_zone.height) >> 1; LOG_FUNCTION_END(Status); return Status; } /* End Group ROI Functions */ /* Group Sequence Step Functions */ VL53L1_Error VL53L1_GetNumberOfSequenceSteps(VL53L1_DEV Dev, uint8_t *pNumberOfSequenceSteps) { VL53L1_Error Status = VL53L1_ERROR_NONE; SUPPRESS_UNUSED_WARNING(Dev); LOG_FUNCTION_START(""); *pNumberOfSequenceSteps = VL53L1_SEQUENCESTEP_NUMBER_OF_ITEMS; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetSequenceStepsInfo(VL53L1_SequenceStepId SequenceStepId, char *pSequenceStepsString) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_sequence_steps_info( SequenceStepId, pSequenceStepsString); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetSequenceStepEnable(VL53L1_DEV Dev, VL53L1_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint32_t MeasurementTimingBudgetMicroSeconds; LOG_FUNCTION_START(""); /* the VL53L1_SequenceStepId correspond to the LLD * VL53L1_DeviceSequenceConfig */ Status = VL53L1_set_sequence_config_bit(Dev, (VL53L1_DeviceSequenceConfig)SequenceStepId, SequenceStepEnabled); /* Apply New Setting */ if (Status == VL53L1_ERROR_NONE) { /* Recalculate timing budget */ MeasurementTimingBudgetMicroSeconds = VL53L1DevDataGet(Dev, CurrentParameters.MeasurementTimingBudgetMicroSeconds); VL53L1_SetMeasurementTimingBudgetMicroSeconds(Dev, MeasurementTimingBudgetMicroSeconds); } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetSequenceStepEnable(VL53L1_DEV Dev, VL53L1_SequenceStepId SequenceStepId, uint8_t *pSequenceStepEnabled) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_get_sequence_config_bit(Dev, (VL53L1_DeviceSequenceConfig)SequenceStepId, pSequenceStepEnabled); LOG_FUNCTION_END(Status); return Status; } /* End Group Sequence Step Functions Functions */ /* Group PAL Measurement Functions */ VL53L1_Error VL53L1_StartMeasurement(VL53L1_DEV Dev) { #define TIMED_MODE_TIMING_GUARD_MILLISECONDS 4 VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t DeviceMeasurementMode; VL53L1_State CurrPalState; VL53L1_Error lStatus; uint32_t MTBus, IMPms; LOG_FUNCTION_START(""); CurrPalState = VL53L1DevDataGet(Dev, PalState); switch (CurrPalState) { case VL53L1_STATE_IDLE: Status = VL53L1_ERROR_NONE; break; case VL53L1_STATE_POWERDOWN: case VL53L1_STATE_WAIT_STATICINIT: case VL53L1_STATE_STANDBY: case VL53L1_STATE_RUNNING: case VL53L1_STATE_RESET: case VL53L1_STATE_UNKNOWN: case VL53L1_STATE_ERROR: Status = VL53L1_ERROR_INVALID_COMMAND; break; default: Status = VL53L1_ERROR_UNDEFINED; } DeviceMeasurementMode = VL53L1DevDataGet(Dev, LLData.measurement_mode); /* Check timing configuration between timing budget and * inter measurement period */ if ((Status == VL53L1_ERROR_NONE) && (DeviceMeasurementMode == VL53L1_DEVICEMEASUREMENTMODE_TIMED)) { lStatus = VL53L1_GetMeasurementTimingBudgetMicroSeconds(Dev, &MTBus); /* convert timing budget in ms */ MTBus /= 1000; lStatus = VL53L1_GetInterMeasurementPeriodMilliSeconds(Dev, &IMPms); /* trick to get rid of compiler "set but not used" warning */ SUPPRESS_UNUSED_WARNING(lStatus); if (IMPms < MTBus + TIMED_MODE_TIMING_GUARD_MILLISECONDS) Status = VL53L1_ERROR_INVALID_PARAMS; } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_init_and_start_range( Dev, DeviceMeasurementMode, VL53L1_DEVICECONFIGLEVEL_FULL); /* Set PAL State to Running */ if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_RUNNING); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_StopMeasurement(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_stop_range(Dev); /* Set PAL State to Idle */ if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, PalState, VL53L1_STATE_IDLE); LOG_FUNCTION_END(Status); return Status; } static VL53L1_Error ChangePresetMode(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_PresetModes PresetMode; VL53L1_DistanceModes NewDistanceMode; VL53L1_user_zone_t user_zone; uint32_t TimingBudget; uint32_t MmTimeoutUs; uint32_t PhaseCalTimeoutUs; uint8_t DeviceMeasurementMode; uint32_t inter_measurement_period_ms; LOG_FUNCTION_START(""); Status = VL53L1_get_user_zone(Dev, &user_zone); /* Initialize variables fix ticket EwokP #475395 */ PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); NewDistanceMode = VL53L1DevDataGet(Dev, CurrentParameters.NewDistanceMode); /* End of Initialize variables fix ticket EwokP #475395 */ if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_timeouts_us(Dev, &PhaseCalTimeoutUs, &MmTimeoutUs, &TimingBudget); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_stop_range(Dev); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_WaitUs(Dev, 500); if (Status == VL53L1_ERROR_NONE) { inter_measurement_period_ms = VL53L1DevDataGet(Dev, LLData.inter_measurement_period_ms); Status = SetPresetMode(Dev, PresetMode, NewDistanceMode, inter_measurement_period_ms); } if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_set_timeouts_us(Dev, PhaseCalTimeoutUs, MmTimeoutUs, TimingBudget); if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, LLData.range_config_timeout_us, TimingBudget); } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_set_user_zone(Dev, &user_zone); if (Status == VL53L1_ERROR_NONE) { DeviceMeasurementMode = VL53L1DevDataGet(Dev, LLData.measurement_mode); Status = VL53L1_init_and_start_range( Dev, DeviceMeasurementMode, VL53L1_DEVICECONFIGLEVEL_FULL); } if (Status == VL53L1_ERROR_NONE) VL53L1DevDataSet(Dev, CurrentParameters.InternalDistanceMode, NewDistanceMode); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_ClearInterruptAndStartMeasurement(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t DeviceMeasurementMode; VL53L1_DistanceModes InternalDistanceMode; VL53L1_DistanceModes NewDistanceMode; LOG_FUNCTION_START(""); DeviceMeasurementMode = VL53L1DevDataGet(Dev, LLData.measurement_mode); InternalDistanceMode = VL53L1DevDataGet(Dev, CurrentParameters.InternalDistanceMode); NewDistanceMode = VL53L1DevDataGet(Dev, CurrentParameters.NewDistanceMode); if (NewDistanceMode != InternalDistanceMode) Status = ChangePresetMode(Dev); else Status = VL53L1_clear_interrupt_and_enable_next_range( Dev, DeviceMeasurementMode); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetMeasurementDataReady(VL53L1_DEV Dev, uint8_t *pMeasurementDataReady) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); Status = VL53L1_is_new_data_ready(Dev, pMeasurementDataReady); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_WaitMeasurementDataReady(VL53L1_DEV Dev) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); /* Note that the timeout is given by: * VL53L1_RANGE_COMPLETION_POLLING_TIMEOUT_MS defined in def.h */ Status = VL53L1_poll_for_range_completion(Dev, VL53L1_RANGE_COMPLETION_POLLING_TIMEOUT_MS); LOG_FUNCTION_END(Status); return Status; } static uint8_t ComputeRQL(uint8_t active_results, uint8_t FilteredRangeStatus, VL53L1_range_data_t *presults_data) { int16_t SRL = 300; uint16_t SRAS = 30; FixPoint1616_t RAS; FixPoint1616_t SRQL; FixPoint1616_t GI = 7713587; /* 117.7 * 65536 */ FixPoint1616_t GGm = 3198157; /* 48.8 * 65536 */ FixPoint1616_t LRAP = 6554; /* 0.1 * 65536 */ FixPoint1616_t partial; uint8_t finalvalue; uint8_t returnvalue; if (active_results == 0) returnvalue = 0; else if (FilteredRangeStatus == VL53L1_DEVICEERROR_PHASECONSISTENCY) returnvalue = 50; else { if (presults_data->median_range_mm < SRL) RAS = SRAS * 65536; else RAS = LRAP * presults_data->median_range_mm; /* Fix1616 + (fix1616 * uint16_t / fix1616) * 65536 = fix1616 */ if (RAS != 0) { partial = (GGm * presults_data->sigma_mm); partial = partial + (RAS >> 1); partial = partial / RAS; partial = partial * 65536; if (partial <= GI) SRQL = GI - partial; else SRQL = 50 * 65536; } else SRQL = 100 * 65536; finalvalue = (uint8_t)(SRQL >> 16); returnvalue = MAX(50, MIN(100, finalvalue)); } return returnvalue; } static uint8_t ConvertStatusLite(uint8_t FilteredRangeStatus) { uint8_t RangeStatus; switch (FilteredRangeStatus) { case VL53L1_DEVICEERROR_GPHSTREAMCOUNT0READY: RangeStatus = VL53L1_RANGESTATUS_SYNCRONISATION_INT; break; case VL53L1_DEVICEERROR_RANGECOMPLETE_NO_WRAP_CHECK: RangeStatus = VL53L1_RANGESTATUS_RANGE_VALID_NO_WRAP_CHECK_FAIL; break; case VL53L1_DEVICEERROR_RANGEPHASECHECK: RangeStatus = VL53L1_RANGESTATUS_OUTOFBOUNDS_FAIL; break; case VL53L1_DEVICEERROR_MSRCNOTARGET: RangeStatus = VL53L1_RANGESTATUS_SIGNAL_FAIL; break; case VL53L1_DEVICEERROR_SIGMATHRESHOLDCHECK: RangeStatus = VL53L1_RANGESTATUS_SIGMA_FAIL; break; case VL53L1_DEVICEERROR_PHASECONSISTENCY: RangeStatus = VL53L1_RANGESTATUS_WRAP_TARGET_FAIL; break; case VL53L1_DEVICEERROR_RANGEIGNORETHRESHOLD: RangeStatus = VL53L1_RANGESTATUS_XTALK_SIGNAL_FAIL; break; case VL53L1_DEVICEERROR_MINCLIP: RangeStatus = VL53L1_RANGESTATUS_RANGE_VALID_MIN_RANGE_CLIPPED; break; case VL53L1_DEVICEERROR_RANGECOMPLETE: RangeStatus = VL53L1_RANGESTATUS_RANGE_VALID; break; default: RangeStatus = VL53L1_RANGESTATUS_NONE; } return RangeStatus; } static VL53L1_Error SetSimpleData(VL53L1_DEV Dev, uint8_t active_results, uint8_t device_status, VL53L1_range_data_t *presults_data, VL53L1_RangingMeasurementData_t *pRangeData) { VL53L1_Error Status = VL53L1_ERROR_NONE; uint8_t FilteredRangeStatus; uint8_t SigmaLimitflag; uint8_t SignalLimitflag; uint8_t Temp8Enable; uint8_t Temp8; FixPoint1616_t AmbientRate; FixPoint1616_t SignalRate; FixPoint1616_t TempFix1616; FixPoint1616_t LimitCheckValue; int16_t Range; pRangeData->TimeStamp = presults_data->time_stamp; FilteredRangeStatus = presults_data->range_status & 0x1F; pRangeData->RangeQualityLevel = ComputeRQL(active_results, FilteredRangeStatus, presults_data); SignalRate = VL53L1_FIXPOINT97TOFIXPOINT1616( presults_data->peak_signal_count_rate_mcps); pRangeData->SignalRateRtnMegaCps = SignalRate; AmbientRate = VL53L1_FIXPOINT97TOFIXPOINT1616( presults_data->ambient_count_rate_mcps); pRangeData->AmbientRateRtnMegaCps = AmbientRate; pRangeData->EffectiveSpadRtnCount = presults_data->actual_effective_spads; TempFix1616 = VL53L1_FIXPOINT97TOFIXPOINT1616( presults_data->sigma_mm); pRangeData->SigmaMilliMeter = TempFix1616; pRangeData->RangeMilliMeter = presults_data->median_range_mm; pRangeData->RangeFractionalPart = 0; /* Treat device error status first */ switch (device_status) { case VL53L1_DEVICEERROR_MULTCLIPFAIL: case VL53L1_DEVICEERROR_VCSELWATCHDOGTESTFAILURE: case VL53L1_DEVICEERROR_VCSELCONTINUITYTESTFAILURE: case VL53L1_DEVICEERROR_NOVHVVALUEFOUND: pRangeData->RangeStatus = VL53L1_RANGESTATUS_HARDWARE_FAIL; break; case VL53L1_DEVICEERROR_USERROICLIP: pRangeData->RangeStatus = VL53L1_RANGESTATUS_MIN_RANGE_FAIL; break; default: pRangeData->RangeStatus = VL53L1_RANGESTATUS_RANGE_VALID; } /* Now deal with range status according to the ranging preset */ if (pRangeData->RangeStatus == VL53L1_RANGESTATUS_RANGE_VALID) { pRangeData->RangeStatus = ConvertStatusLite(FilteredRangeStatus); } /* Update current Limit Check */ TempFix1616 = VL53L1_FIXPOINT97TOFIXPOINT1616( presults_data->sigma_mm); VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksCurrent, VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE, TempFix1616); TempFix1616 = VL53L1_FIXPOINT97TOFIXPOINT1616( presults_data->peak_signal_count_rate_mcps); VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksCurrent, VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, TempFix1616); /* Update Limit Check Status */ /* Sigma */ VL53L1_GetLimitCheckValue(Dev, VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE, &LimitCheckValue); SigmaLimitflag = (FilteredRangeStatus == VL53L1_DEVICEERROR_SIGMATHRESHOLDCHECK) ? 1 : 0; VL53L1_GetLimitCheckEnable(Dev, VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE, &Temp8Enable); Temp8 = ((Temp8Enable == 1) && (SigmaLimitflag == 1)) ? 1 : 0; VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus, VL53L1_CHECKENABLE_SIGMA_FINAL_RANGE, Temp8); /* Signal Rate */ VL53L1_GetLimitCheckValue(Dev, VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, &LimitCheckValue); SignalLimitflag = (FilteredRangeStatus == VL53L1_DEVICEERROR_MSRCNOTARGET) ? 1 : 0; VL53L1_GetLimitCheckEnable(Dev, VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, &Temp8Enable); Temp8 = ((Temp8Enable == 1) && (SignalLimitflag == 1)) ? 1 : 0; VL53L1_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus, VL53L1_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, Temp8); Range = pRangeData->RangeMilliMeter; if ((pRangeData->RangeStatus == VL53L1_RANGESTATUS_RANGE_VALID) && (Range < 0)) { if (Range < BDTable[VL53L1_TUNING_PROXY_MIN]) pRangeData->RangeStatus = VL53L1_RANGESTATUS_RANGE_INVALID; else pRangeData->RangeMilliMeter = 0; } return Status; } VL53L1_Error VL53L1_GetRangingMeasurementData(VL53L1_DEV Dev, VL53L1_RangingMeasurementData_t *pRangingMeasurementData) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_range_results_t results; VL53L1_range_results_t *presults = &results; VL53L1_range_data_t *presults_data; LOG_FUNCTION_START(""); /* Clear Ranging Data */ memset(pRangingMeasurementData, 0xFF, sizeof(VL53L1_RangingMeasurementData_t)); /* Get Ranging Data */ Status = VL53L1_get_device_results( Dev, VL53L1_DEVICERESULTSLEVEL_FULL, presults); if (Status == VL53L1_ERROR_NONE) { pRangingMeasurementData->StreamCount = presults->stream_count; /* in case of lite ranging or autonomous the following function * returns index = 0 */ presults_data = &(presults->data[0]); Status = SetSimpleData(Dev, 1, presults->device_status, presults_data, pRangingMeasurementData); } LOG_FUNCTION_END(Status); return Status; } /* End Group PAL Measurement Functions */ /* Group Calibration functions */ VL53L1_Error VL53L1_SetTuningParameter(VL53L1_DEV Dev, uint16_t TuningParameterId, int32_t TuningParameterValue) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); if (TuningParameterId >= 32768) Status = VL53L1_set_tuning_parm(Dev, TuningParameterId, TuningParameterValue); else { if (TuningParameterId < VL53L1_TUNING_MAX_TUNABLE_KEY) BDTable[TuningParameterId] = TuningParameterValue; else Status = VL53L1_ERROR_INVALID_PARAMS; } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetTuningParameter(VL53L1_DEV Dev, uint16_t TuningParameterId, int32_t *pTuningParameterValue) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); if (TuningParameterId >= 32768) Status = VL53L1_get_tuning_parm(Dev, TuningParameterId, pTuningParameterValue); else { if (TuningParameterId < VL53L1_TUNING_MAX_TUNABLE_KEY) *pTuningParameterValue = BDTable[TuningParameterId]; else Status = VL53L1_ERROR_INVALID_PARAMS; } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_PerformRefSpadManagement(VL53L1_DEV Dev) { #ifdef VL53L1_NOCALIB VL53L1_Error Status = VL53L1_ERROR_NOT_SUPPORTED; SUPPRESS_UNUSED_WARNING(Dev); LOG_FUNCTION_START(""); #else VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_Error RawStatus; uint8_t dcrbuffer[24]; uint8_t *comms_buffer; uint8_t numloc[2] = {5,3}; VL53L1_LLDriverData_t *pdev; VL53L1_customer_nvm_managed_t *pc; VL53L1_PresetModes PresetMode; LOG_FUNCTION_START(""); pdev = VL53L1DevStructGetLLDriverHandle(Dev); pc = &pdev->customer; if (Status == VL53L1_ERROR_NONE) { PresetMode = VL53L1DevDataGet(Dev, CurrentParameters.PresetMode); Status = VL53L1_run_ref_spad_char(Dev, &RawStatus); /* We discovered RefSpad mngt badly breaks some preset mode * The WA is to apply again the current one */ if (Status == VL53L1_ERROR_NONE) Status = VL53L1_SetPresetMode(Dev, PresetMode); } if (Status == VL53L1_WARNING_REF_SPAD_CHAR_RATE_TOO_HIGH) { /* Fix ticket #466282 RefSpad management error/warning -29 * force usage of location 3 and 5 refspads in registers */ Status = VL53L1_read_nvm_raw_data(Dev, (uint8_t)(0xA0 >> 2), (uint8_t)(24 >> 2), dcrbuffer); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_WriteMulti( Dev, VL53L1_REF_SPAD_MAN__NUM_REQUESTED_REF_SPADS, numloc, 2); if (Status == VL53L1_ERROR_NONE) { pc->ref_spad_man__num_requested_ref_spads = numloc[0]; pc->ref_spad_man__ref_location = numloc[1]; } if (Status == VL53L1_ERROR_NONE) comms_buffer = &dcrbuffer[16]; /* * update & copy reference SPAD enables to customer nvm managed */ if (Status == VL53L1_ERROR_NONE) Status = VL53L1_WriteMulti(Dev, VL53L1_GLOBAL_CONFIG__SPAD_ENABLES_REF_0, comms_buffer, 6); if (Status == VL53L1_ERROR_NONE) { pc->global_config__spad_enables_ref_0 = comms_buffer[0]; pc->global_config__spad_enables_ref_1 = comms_buffer[1]; pc->global_config__spad_enables_ref_2 = comms_buffer[2]; pc->global_config__spad_enables_ref_3 = comms_buffer[3]; pc->global_config__spad_enables_ref_4 = comms_buffer[4]; pc->global_config__spad_enables_ref_5 = comms_buffer[5]; } /* End of fix ticket #466282 */ } #endif LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetXTalkCompensationEnable(VL53L1_DEV Dev, uint8_t XTalkCompensationEnable) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); if (XTalkCompensationEnable == 0) Status = VL53L1_disable_xtalk_compensation(Dev); else Status = VL53L1_enable_xtalk_compensation(Dev); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetXTalkCompensationEnable(VL53L1_DEV Dev, uint8_t *pXTalkCompensationEnable) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); VL53L1_get_xtalk_compensation_enable( Dev, pXTalkCompensationEnable); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_PerformSingleTargetXTalkCalibration(VL53L1_DEV Dev, int32_t CalDistanceMilliMeter) { VL53L1_Error Status = VL53L1_ERROR_NONE; LOG_FUNCTION_START(""); if (CalDistanceMilliMeter > 0) { BDTable[VL53L1_TUNING_SINGLE_TARGET_XTALK_TARGET_DISTANCE_MM] = CalDistanceMilliMeter; Status = SingleTargetXTalkCalibration(Dev); } else Status = VL53L1_ERROR_INVALID_PARAMS; LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetOffsetCalibrationMode(VL53L1_DEV Dev, VL53L1_OffsetCalibrationModes OffsetCalibrationMode) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_OffsetCalibrationMode offset_cal_mode; LOG_FUNCTION_START(""); if (OffsetCalibrationMode == VL53L1_OFFSETCALIBRATIONMODE_STANDARD) { offset_cal_mode = VL53L1_DEVICEPRESETMODE_STANDARD_RANGING; } else if (OffsetCalibrationMode == VL53L1_OFFSETCALIBRATIONMODE_PRERANGE_ONLY) { offset_cal_mode = VL53L1_OFFSETCALIBRATIONMODE__MM1_MM2__STANDARD_PRE_RANGE_ONLY; } else { Status = VL53L1_ERROR_INVALID_PARAMS; } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_set_offset_calibration_mode(Dev, offset_cal_mode); LOG_FUNCTION_END(Status); return Status; } #ifdef OFFSET_CALIB VL53L1_Error VL53L1_PerformOffsetCalibration(VL53L1_DEV Dev, int32_t CalDistanceMilliMeter) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_Error UnfilteredStatus; VL53L1_OffsetCalibrationMode offset_cal_mode; LOG_FUNCTION_START(""); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_get_offset_calibration_mode(Dev, &offset_cal_mode); if (Status != VL53L1_ERROR_NONE) { LOG_FUNCTION_END(Status); return Status; } if ((offset_cal_mode == VL53L1_OFFSETCALIBRATIONMODE__MM1_MM2__STANDARD) || (offset_cal_mode == VL53L1_OFFSETCALIBRATIONMODE__MM1_MM2__STANDARD_PRE_RANGE_ONLY )) { if (Status == VL53L1_ERROR_NONE) Status = VL53L1_run_offset_calibration( Dev, (int16_t)CalDistanceMilliMeter, &UnfilteredStatus); } else { Status = VL53L1_ERROR_INVALID_PARAMS; } LOG_FUNCTION_END(Status); return Status; } #endif #ifdef OFFSET_CALIB_EMPTY VL53L1_Error VL53L1_PerformOffsetCalibration(VL53L1_DEV Dev, int32_t CalDistanceMilliMeter) { VL53L1_Error Status = VL53L1_ERROR_NOT_SUPPORTED; SUPPRESS_UNUSED_WARNING(Dev); SUPPRESS_UNUSED_WARNING(CalDistanceMilliMeter); return Status; } #endif VL53L1_Error VL53L1_PerformOffsetSimpleCalibration(VL53L1_DEV Dev, int32_t CalDistanceMilliMeter) { VL53L1_Error Status = VL53L1_ERROR_NONE; int32_t sum_ranging; uint8_t offset_meas; int16_t Max, UnderMax, OverMax, Repeat; int32_t total_count, inloopcount; int32_t IncRounding; int16_t meanDistance_mm; int16_t offset; VL53L1_RangingMeasurementData_t RangingMeasurementData; VL53L1_LLDriverData_t *pdev; uint8_t goodmeas; LOG_FUNCTION_START(""); pdev = VL53L1DevStructGetLLDriverHandle(Dev); /* Disable any offsets */ pdev->customer.algo__part_to_part_range_offset_mm = 0; pdev->customer.mm_config__inner_offset_mm = 0; pdev->customer.mm_config__outer_offset_mm = 0; Repeat=BDTable[VL53L1_TUNING_SIMPLE_OFFSET_CALIBRATION_REPEAT]; Max=BDTable[VL53L1_TUNING_MAX_SIMPLE_OFFSET_CALIBRATION_SAMPLE_NUMBER]; UnderMax = 1 + (Max / 2); OverMax = Max + (Max / 2); sum_ranging = 0; total_count = 0; while ((Repeat > 0) && (Status == VL53L1_ERROR_NONE)) { Status = VL53L1_StartMeasurement(Dev); /* Very first ranging completion interrupt must be ignored */ if (Status == VL53L1_ERROR_NONE) Status = VL53L1_WaitMeasurementDataReady(Dev); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_GetRangingMeasurementData(Dev, &RangingMeasurementData); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_ClearInterruptAndStartMeasurement(Dev); /* offset calibration main loop */ inloopcount = 0; offset_meas = 0; while ((Status == VL53L1_ERROR_NONE) && (inloopcount < Max) && (offset_meas < OverMax)) { Status = VL53L1_WaitMeasurementDataReady(Dev); if (Status == VL53L1_ERROR_NONE) Status = VL53L1_GetRangingMeasurementData(Dev, &RangingMeasurementData); goodmeas = (RangingMeasurementData.RangeStatus == VL53L1_RANGESTATUS_RANGE_VALID); if ((Status == VL53L1_ERROR_NONE) && goodmeas) { sum_ranging = sum_ranging + RangingMeasurementData.RangeMilliMeter; inloopcount++; } if (Status == VL53L1_ERROR_NONE) { Status = VL53L1_ClearInterruptAndStartMeasurement( Dev); } offset_meas++; } total_count += inloopcount; /* no enough valid values found */ if (inloopcount < UnderMax) { Status = VL53L1_ERROR_OFFSET_CAL_NO_SAMPLE_FAIL; } VL53L1_StopMeasurement(Dev); Repeat--; } /* check overflow (unlikely if target is near to the device) */ if ((sum_ranging < 0) || (sum_ranging > ((int32_t) total_count * 0xffff))) { Status = VL53L1_WARNING_OFFSET_CAL_SIGMA_TOO_HIGH; } if ((Status == VL53L1_ERROR_NONE) && (total_count > 0)) { IncRounding = total_count / 2; meanDistance_mm = (int16_t)((sum_ranging + IncRounding) / total_count); offset = (int16_t)CalDistanceMilliMeter - meanDistance_mm; pdev->customer.algo__part_to_part_range_offset_mm = 0; pdev->customer.mm_config__inner_offset_mm = offset; pdev->customer.mm_config__outer_offset_mm = offset; Status = VL53L1_set_customer_nvm_managed(Dev, &(pdev->customer)); } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_SetCalibrationData(VL53L1_DEV Dev, VL53L1_CalibrationData_t *pCalibrationData) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_CustomerNvmManaged_t *pC; VL53L1_calibration_data_t cal_data; uint32_t x; LOG_FUNCTION_START(""); cal_data.struct_version = pCalibrationData->struct_version - VL53L1_ADDITIONAL_CALIBRATION_DATA_STRUCT_VERSION; /* memcpy(DEST, SRC, N) */ memcpy( &(cal_data.add_off_cal_data), &(pCalibrationData->add_off_cal_data), sizeof(VL53L1_additional_offset_cal_data_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(cal_data.optical_centre), &(pCalibrationData->optical_centre), sizeof(VL53L1_optical_centre_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(cal_data.gain_cal), &(pCalibrationData->gain_cal), sizeof(VL53L1_gain_calibration_data_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(cal_data.cal_peak_rate_map), &(pCalibrationData->cal_peak_rate_map), sizeof(VL53L1_cal_peak_rate_map_t)); pC = &pCalibrationData->customer; x = pC->algo__crosstalk_compensation_plane_offset_kcps; cal_data.customer.algo__crosstalk_compensation_plane_offset_kcps = (uint16_t)(x&0x0000FFFF); cal_data.customer.global_config__spad_enables_ref_0 = pC->global_config__spad_enables_ref_0; cal_data.customer.global_config__spad_enables_ref_1 = pC->global_config__spad_enables_ref_1; cal_data.customer.global_config__spad_enables_ref_2 = pC->global_config__spad_enables_ref_2; cal_data.customer.global_config__spad_enables_ref_3 = pC->global_config__spad_enables_ref_3; cal_data.customer.global_config__spad_enables_ref_4 = pC->global_config__spad_enables_ref_4; cal_data.customer.global_config__spad_enables_ref_5 = pC->global_config__spad_enables_ref_5; cal_data.customer.global_config__ref_en_start_select = pC->global_config__ref_en_start_select; cal_data.customer.ref_spad_man__num_requested_ref_spads = pC->ref_spad_man__num_requested_ref_spads; cal_data.customer.ref_spad_man__ref_location = pC->ref_spad_man__ref_location; cal_data.customer.algo__crosstalk_compensation_x_plane_gradient_kcps = pC->algo__crosstalk_compensation_x_plane_gradient_kcps; cal_data.customer.algo__crosstalk_compensation_y_plane_gradient_kcps = pC->algo__crosstalk_compensation_y_plane_gradient_kcps; cal_data.customer.ref_spad_char__total_rate_target_mcps = pC->ref_spad_char__total_rate_target_mcps; cal_data.customer.algo__part_to_part_range_offset_mm = pC->algo__part_to_part_range_offset_mm; cal_data.customer.mm_config__inner_offset_mm = pC->mm_config__inner_offset_mm; cal_data.customer.mm_config__outer_offset_mm = pC->mm_config__outer_offset_mm; Status = VL53L1_set_part_to_part_data(Dev, &cal_data); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetCalibrationData(VL53L1_DEV Dev, VL53L1_CalibrationData_t *pCalibrationData) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_calibration_data_t cal_data; VL53L1_CustomerNvmManaged_t *pC; VL53L1_customer_nvm_managed_t *pC2; LOG_FUNCTION_START(""); /* struct_version is filled inside get part to part function */ Status = VL53L1_get_part_to_part_data(Dev, &cal_data); pCalibrationData->struct_version = cal_data.struct_version + VL53L1_ADDITIONAL_CALIBRATION_DATA_STRUCT_VERSION; /* memcpy(DEST, SRC, N) */ memcpy( &(pCalibrationData->add_off_cal_data), &(cal_data.add_off_cal_data), sizeof(VL53L1_additional_offset_cal_data_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(pCalibrationData->optical_centre), &(cal_data.optical_centre), sizeof(VL53L1_optical_centre_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(pCalibrationData->gain_cal), &(cal_data.gain_cal), sizeof(VL53L1_gain_calibration_data_t)); /* memcpy (DEST, SRC, N) */ memcpy( &(pCalibrationData->cal_peak_rate_map), &(cal_data.cal_peak_rate_map), sizeof(VL53L1_cal_peak_rate_map_t)); pC = &pCalibrationData->customer; pC2 = &cal_data.customer; pC->global_config__spad_enables_ref_0 = pC2->global_config__spad_enables_ref_0; pC->global_config__spad_enables_ref_1 = pC2->global_config__spad_enables_ref_1; pC->global_config__spad_enables_ref_2 = pC2->global_config__spad_enables_ref_2; pC->global_config__spad_enables_ref_3 = pC2->global_config__spad_enables_ref_3; pC->global_config__spad_enables_ref_4 = pC2->global_config__spad_enables_ref_4; pC->global_config__spad_enables_ref_5 = pC2->global_config__spad_enables_ref_5; pC->global_config__ref_en_start_select = pC2->global_config__ref_en_start_select; pC->ref_spad_man__num_requested_ref_spads = pC2->ref_spad_man__num_requested_ref_spads; pC->ref_spad_man__ref_location = pC2->ref_spad_man__ref_location; pC->algo__crosstalk_compensation_x_plane_gradient_kcps = pC2->algo__crosstalk_compensation_x_plane_gradient_kcps; pC->algo__crosstalk_compensation_y_plane_gradient_kcps = pC2->algo__crosstalk_compensation_y_plane_gradient_kcps; pC->ref_spad_char__total_rate_target_mcps = pC2->ref_spad_char__total_rate_target_mcps; pC->algo__part_to_part_range_offset_mm = pC2->algo__part_to_part_range_offset_mm; pC->mm_config__inner_offset_mm = pC2->mm_config__inner_offset_mm; pC->mm_config__outer_offset_mm = pC2->mm_config__outer_offset_mm; pC->algo__crosstalk_compensation_plane_offset_kcps = (uint32_t)( pC2->algo__crosstalk_compensation_plane_offset_kcps); LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetOpticalCenter(VL53L1_DEV Dev, FixPoint1616_t *pOpticalCenterX, FixPoint1616_t *pOpticalCenterY) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_calibration_data_t CalibrationData; LOG_FUNCTION_START(""); *pOpticalCenterX = 0; *pOpticalCenterY = 0; Status = VL53L1_get_part_to_part_data(Dev, &CalibrationData); if (Status == VL53L1_ERROR_NONE) { *pOpticalCenterX = VL53L1_FIXPOINT44TOFIXPOINT1616( CalibrationData.optical_centre.x_centre); *pOpticalCenterY = VL53L1_FIXPOINT44TOFIXPOINT1616( CalibrationData.optical_centre.y_centre); } LOG_FUNCTION_END(Status); return Status; } /* END Group Calibration functions */ /* Group PAL detection triggered events Functions */ VL53L1_Error VL53L1_SetThresholdConfig(VL53L1_DEV Dev, VL53L1_DetectionConfig_t *pConfig) { #define BADTHRESBOUNDS(T) \ (((T.CrossMode == VL53L1_THRESHOLD_OUT_OF_WINDOW) || \ (T.CrossMode == VL53L1_THRESHOLD_IN_WINDOW)) && (T.Low > T.High)) VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_GPIO_interrupt_config_t Cfg; uint16_t g; FixPoint1616_t gain, high1616, low1616; VL53L1_LLDriverData_t *pdev; LOG_FUNCTION_START(""); pdev = VL53L1DevStructGetLLDriverHandle(Dev); Status = VL53L1_get_GPIO_interrupt_config(Dev, &Cfg); if (Status == VL53L1_ERROR_NONE) { if (pConfig->DetectionMode == VL53L1_DETECTION_NORMAL_RUN) { Cfg.intr_new_measure_ready = 1; Status = VL53L1_set_GPIO_interrupt_config_struct(Dev, Cfg); } else { if (BADTHRESBOUNDS(pConfig->Distance)) Status = VL53L1_ERROR_INVALID_PARAMS; if ((Status == VL53L1_ERROR_NONE) && (BADTHRESBOUNDS(pConfig->Rate))) Status = VL53L1_ERROR_INVALID_PARAMS; if (Status == VL53L1_ERROR_NONE) { Cfg.intr_new_measure_ready = 0; Cfg.intr_no_target = pConfig->IntrNoTarget; /* fix ticket 466238 * Apply invert distance gain to thresholds */ g = pdev->gain_cal.standard_ranging_gain_factor; /* gain is ufix 5.11, convert to 16.16 */ gain = (FixPoint1616_t) ((uint32_t)g << 5); high1616 = (FixPoint1616_t) ((uint32_t) pConfig->Distance.High << 16); low1616 = (FixPoint1616_t) ((uint32_t) pConfig->Distance.Low << 16); /* +32768 to round the results*/ high1616 = (high1616 + 32768) / gain; low1616 = (low1616 + 32768) / gain; Cfg.threshold_distance_high = (uint16_t) (high1616 & 0xFFFF); Cfg.threshold_distance_low = (uint16_t) (low1616 & 0xFFFF); /* end fix ticket 466238 */ Cfg.threshold_rate_high = VL53L1_FIXPOINT1616TOFIXPOINT97( pConfig->Rate.High); Cfg.threshold_rate_low = VL53L1_FIXPOINT1616TOFIXPOINT97( pConfig->Rate.Low); Cfg.intr_mode_distance = ConvertModeToLLD( &Status, pConfig->Distance.CrossMode); if (Status == VL53L1_ERROR_NONE) Cfg.intr_mode_rate = ConvertModeToLLD( &Status, pConfig->Rate.CrossMode); } /* Refine thresholds combination now */ if (Status == VL53L1_ERROR_NONE) { Cfg.intr_combined_mode = 1; switch (pConfig->DetectionMode) { case VL53L1_DETECTION_DISTANCE_ONLY: Cfg.threshold_rate_high = 0; Cfg.threshold_rate_low = 0; break; case VL53L1_DETECTION_RATE_ONLY: Cfg.threshold_distance_high = 0; Cfg.threshold_distance_low = 0; break; case VL53L1_DETECTION_DISTANCE_OR_RATE: /* Nothing to do all is already * in place */ break; case VL53L1_DETECTION_DISTANCE_AND_RATE: Cfg.intr_combined_mode = 0; break; default: Status = VL53L1_ERROR_INVALID_PARAMS; } } if (Status == VL53L1_ERROR_NONE) Status = VL53L1_set_GPIO_interrupt_config_struct(Dev, Cfg); } } LOG_FUNCTION_END(Status); return Status; } VL53L1_Error VL53L1_GetThresholdConfig(VL53L1_DEV Dev, VL53L1_DetectionConfig_t *pConfig) { VL53L1_Error Status = VL53L1_ERROR_NONE; VL53L1_GPIO_interrupt_config_t Cfg; LOG_FUNCTION_START(""); Status = VL53L1_get_GPIO_interrupt_config(Dev, &Cfg); if (Status != VL53L1_ERROR_NONE) { LOG_FUNCTION_END(Status); return Status; } pConfig->IntrNoTarget = Cfg.intr_no_target; pConfig->Distance.High = Cfg.threshold_distance_high; pConfig->Distance.Low = Cfg.threshold_distance_low; pConfig->Rate.High = VL53L1_FIXPOINT97TOFIXPOINT1616( Cfg.threshold_rate_high); pConfig->Rate.Low = VL53L1_FIXPOINT97TOFIXPOINT1616(Cfg.threshold_rate_low); pConfig->Distance.CrossMode = ConvertModeFromLLD(&Status, Cfg.intr_mode_distance); if (Status == VL53L1_ERROR_NONE) pConfig->Rate.CrossMode = ConvertModeFromLLD(&Status, Cfg.intr_mode_rate); if (Cfg.intr_new_measure_ready == 1) { pConfig->DetectionMode = VL53L1_DETECTION_NORMAL_RUN; } else { /* Refine thresholds combination now */ if (Status == VL53L1_ERROR_NONE) { if (Cfg.intr_combined_mode == 0) pConfig->DetectionMode = VL53L1_DETECTION_DISTANCE_AND_RATE; else { if ((Cfg.threshold_distance_high == 0) && (Cfg.threshold_distance_low == 0)) pConfig->DetectionMode = VL53L1_DETECTION_RATE_ONLY; else if ((Cfg.threshold_rate_high == 0) && (Cfg.threshold_rate_low == 0)) pConfig->DetectionMode = VL53L1_DETECTION_DISTANCE_ONLY; else pConfig->DetectionMode = VL53L1_DETECTION_DISTANCE_OR_RATE; } } } LOG_FUNCTION_END(Status); return Status; } /* End Group PAL IRQ Triggered events Functions */