From 9221493eaa5079a6f9acab4e2d6ccd00f3da7cdb Mon Sep 17 00:00:00 2001
From: YunHorn Technology <dp.s@yunhorn.com>
Date: Mon, 9 Sep 2024 12:19:31 +0800
Subject: [PATCH] --- driver included
---
Components/vl53l1x_uld/VL53L1X_api.c | 850 +++++++++++++++++++
Components/vl53l1x_uld/VL53L1X_api.h | 393 +++++++++
Components/vl53l1x_uld/VL53L1X_calibration.c | 136 +++
Components/vl53l1x_uld/VL53L1X_calibration.h | 93 ++
STM32CubeIDE/Release/STS_P2_VL53L1.bin | Bin 0 -> 83172 bytes
5 files changed, 1472 insertions(+)
create mode 100644 Components/vl53l1x_uld/VL53L1X_api.c
create mode 100644 Components/vl53l1x_uld/VL53L1X_api.h
create mode 100644 Components/vl53l1x_uld/VL53L1X_calibration.c
create mode 100644 Components/vl53l1x_uld/VL53L1X_calibration.h
create mode 100644 STM32CubeIDE/Release/STS_P2_VL53L1.bin
diff --git a/Components/vl53l1x_uld/VL53L1X_api.c b/Components/vl53l1x_uld/VL53L1X_api.c
new file mode 100644
index 0000000..49e8ed3
--- /dev/null
+++ b/Components/vl53l1x_uld/VL53L1X_api.c
@@ -0,0 +1,850 @@
+/*
+ Copyright (c) 2017, STMicroelectronics - All Rights Reserved
+
+ This file : part of VL53L1 Core and : 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 : 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.
+*******************************************************************************
+*/
+
+/**
+ * @file vl53l1x_api.c
+ * @brief Functions implementation
+ */
+
+#include "VL53L1X_api.h"
+#include <string.h>
+
+#if 0
+uint8_t VL51L1X_NVM_CONFIGURATION[] = {
+0x00, /* 0x00 : not user-modifiable */
+0x29, /* 0x01 : 7 bits I2C address (default=0x29), use SetI2CAddress(). Warning: after changing the register value to a new I2C address, the device will only answer to the new address */
+0x00, /* 0x02 : not user-modifiable */
+0x00, /* 0x03 : not user-modifiable */
+0x00, /* 0x04 : not user-modifiable */
+0x00, /* 0x05 : not user-modifiable */
+0x00, /* 0x06 : not user-modifiable */
+0x00, /* 0x07 : not user-modifiable */
+0x00, /* 0x08 : not user-modifiable */
+0x50, /* 0x09 : not user-modifiable */
+0x00, /* 0x0A : not user-modifiable */
+0x00, /* 0x0B : not user-modifiable */
+0x00, /* 0x0C : not user-modifiable */
+0x00, /* 0x0D : not user-modifiable */
+0x0a, /* 0x0E : not user-modifiable */
+0x00, /* 0x0F : not user-modifiable */
+0x00, /* 0x10 : not user-modifiable */
+0x00, /* 0x11 : not user-modifiable */
+0x00, /* 0x12 : not user-modifiable */
+0x00, /* 0x13 : not user-modifiable */
+0x00, /* 0x14 : not user-modifiable */
+0x00, /* 0x15 : not user-modifiable */
+0x00, /* 0x16 : Xtalk calibration value MSB (7.9 format in kcps), use SetXtalk() */
+0x00, /* 0x17 : Xtalk calibration value LSB */
+0x00, /* 0x18 : not user-modifiable */
+0x00, /* 0x19 : not user-modifiable */
+0x00, /* 0x1a : not user-modifiable */
+0x00, /* 0x1b : not user-modifiable */
+0x00, /* 0x1e : Part to Part offset x4 MSB (in mm), use SetOffset() */
+0x50, /* 0x1f : Part to Part offset x4 LSB */
+0x00, /* 0x20 : not user-modifiable */
+0x00, /* 0x21 : not user-modifiable */
+0x00, /* 0x22 : not user-modifiable */
+0x00, /* 0x23 : not user-modifiable */
+}
+#endif
+
+const uint8_t VL51L1X_DEFAULT_CONFIGURATION[] = {
+0x00, /* 0x2d : set bit 2 and 5 to 1 for fast plus mode (1MHz I2C), else don't touch */
+0x00, /* 0x2e : bit 0 if I2C pulled up at 1.8V, else set bit 0 to 1 (pull up at AVDD) */
+0x00, /* 0x2f : bit 0 if GPIO pulled up at 1.8V, else set bit 0 to 1 (pull up at AVDD) */
+0x01, /* 0x30 : set bit 4 to 0 for active high interrupt and 1 for active low (bits 3:0 must be 0x1), use SetInterruptPolarity() */
+0x02, /* 0x31 : bit 1 = interrupt depending on the polarity, use CheckForDataReady() */
+0x00, /* 0x32 : not user-modifiable */
+0x02, /* 0x33 : not user-modifiable */
+0x08, /* 0x34 : not user-modifiable */
+0x00, /* 0x35 : not user-modifiable */
+0x08, /* 0x36 : not user-modifiable */
+0x10, /* 0x37 : not user-modifiable */
+0x01, /* 0x38 : not user-modifiable */
+0x01, /* 0x39 : not user-modifiable */
+0x00, /* 0x3a : not user-modifiable */
+0x00, /* 0x3b : not user-modifiable */
+0x00, /* 0x3c : not user-modifiable */
+0x00, /* 0x3d : not user-modifiable */
+0xff, /* 0x3e : not user-modifiable */
+0x00, /* 0x3f : not user-modifiable */
+0x0F, /* 0x40 : not user-modifiable */
+0x00, /* 0x41 : not user-modifiable */
+0x00, /* 0x42 : not user-modifiable */
+0x00, /* 0x43 : not user-modifiable */
+0x00, /* 0x44 : not user-modifiable */
+0x00, /* 0x45 : not user-modifiable */
+0x20, /* 0x46 : interrupt configuration 0->level low detection, 1-> level high, 2-> Out of window, 3->In window, 0x20-> New sample ready , TBC */
+0x0b, /* 0x47 : not user-modifiable */
+0x00, /* 0x48 : not user-modifiable */
+0x00, /* 0x49 : not user-modifiable */
+0x02, /* 0x4a : not user-modifiable */
+0x0a, /* 0x4b : not user-modifiable */
+0x21, /* 0x4c : not user-modifiable */
+0x00, /* 0x4d : not user-modifiable */
+0x00, /* 0x4e : not user-modifiable */
+0x05, /* 0x4f : not user-modifiable */
+0x00, /* 0x50 : not user-modifiable */
+0x00, /* 0x51 : not user-modifiable */
+0x00, /* 0x52 : not user-modifiable */
+0x00, /* 0x53 : not user-modifiable */
+0xc8, /* 0x54 : not user-modifiable */
+0x00, /* 0x55 : not user-modifiable */
+0x00, /* 0x56 : not user-modifiable */
+0x38, /* 0x57 : not user-modifiable */
+0xff, /* 0x58 : not user-modifiable */
+0x01, /* 0x59 : not user-modifiable */
+0x00, /* 0x5a : not user-modifiable */
+0x08, /* 0x5b : not user-modifiable */
+0x00, /* 0x5c : not user-modifiable */
+0x00, /* 0x5d : not user-modifiable */
+0x01, /* 0x5e : not user-modifiable */
+0xcc, /* 0x5f : not user-modifiable */
+0x0f, /* 0x60 : not user-modifiable */
+0x01, /* 0x61 : not user-modifiable */
+0xf1, /* 0x62 : not user-modifiable */
+0x0d, /* 0x63 : not user-modifiable */
+0x01, /* 0x64 : Sigma threshold MSB (mm in 14.2 format for MSB+LSB), use SetSigmaThreshold(), default value 90 mm */
+0x68, /* 0x65 : Sigma threshold LSB */
+0x00, /* 0x66 : Min count Rate MSB (MCPS in 9.7 format for MSB+LSB), use SetSignalThreshold() */
+0x80, /* 0x67 : Min count Rate LSB */
+0x08, /* 0x68 : not user-modifiable */
+0xb8, /* 0x69 : not user-modifiable */
+0x00, /* 0x6a : not user-modifiable */
+0x00, /* 0x6b : not user-modifiable */
+0x00, /* 0x6c : Intermeasurement period MSB, 32 bits register, use SetIntermeasurementInMs() */
+0x00, /* 0x6d : Intermeasurement period */
+0x0f, /* 0x6e : Intermeasurement period */
+0x89, /* 0x6f : Intermeasurement period LSB */
+0x00, /* 0x70 : not user-modifiable */
+0x00, /* 0x71 : not user-modifiable */
+0x00, /* 0x72 : distance threshold high MSB (in mm, MSB+LSB), use SetD:tanceThreshold() */
+0x00, /* 0x73 : distance threshold high LSB */
+0x00, /* 0x74 : distance threshold low MSB ( in mm, MSB+LSB), use SetD:tanceThreshold() */
+0x00, /* 0x75 : distance threshold low LSB */
+0x00, /* 0x76 : not user-modifiable */
+0x01, /* 0x77 : not user-modifiable */
+0x0f, /* 0x78 : not user-modifiable */
+0x0d, /* 0x79 : not user-modifiable */
+0x0e, /* 0x7a : not user-modifiable */
+0x0e, /* 0x7b : not user-modifiable */
+0x00, /* 0x7c : not user-modifiable */
+0x00, /* 0x7d : not user-modifiable */
+0x02, /* 0x7e : not user-modifiable */
+0xc7, /* 0x7f : ROI center, use SetROI() */
+0xff, /* 0x80 : XY ROI (X=Width, Y=Height), use SetROI() */
+0x9B, /* 0x81 : not user-modifiable */
+0x00, /* 0x82 : not user-modifiable */
+0x00, /* 0x83 : not user-modifiable */
+0x00, /* 0x84 : not user-modifiable */
+0x01, /* 0x85 : not user-modifiable */
+0x00, /* 0x86 : clear interrupt, use ClearInterrupt() */
+0x00 /* 0x87 : start ranging, use StartRanging() or StopRanging(), If you want an automatic start after VL53L1X_init() call, put 0x40 in location 0x87 */
+};
+
+static const uint8_t status_rtn[24] = { 255, 255, 255, 5, 2, 4, 1, 7, 3, 0,
+ 255, 255, 9, 13, 255, 255, 255, 255, 10, 6,
+ 255, 255, 11, 12
+};
+
+VL53L1X_ERROR VL53L1X_GetSWVersion(VL53L1X_Version_t *pVersion)
+{
+ VL53L1X_ERROR Status = 0;
+
+ pVersion->major = VL53L1X_IMPLEMENTATION_VER_MAJOR;
+ pVersion->minor = VL53L1X_IMPLEMENTATION_VER_MINOR;
+ pVersion->build = VL53L1X_IMPLEMENTATION_VER_SUB;
+ pVersion->revision = VL53L1X_IMPLEMENTATION_VER_REVISION;
+ return Status;
+}
+
+VL53L1X_ERROR VL53L1X_SetI2CAddress(uint16_t dev, uint8_t new_address)
+{
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrByte(dev, VL53L1_I2C_SLAVE__DEVICE_ADDRESS, new_address >> 1);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SensorInit(uint16_t dev)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t Addr = 0x00, tmp;
+
+ for (Addr = 0x2D; Addr <= 0x87; Addr++){
+ status = VL53L1_WrByte(dev, Addr, VL51L1X_DEFAULT_CONFIGURATION[Addr - 0x2D]);
+ }
+ status = VL53L1X_StartRanging(dev);
+ tmp = 0;
+ while(tmp==0){
+ status = VL53L1X_CheckForDataReady(dev, &tmp);
+ }
+ status = VL53L1X_ClearInterrupt(dev);
+ status = VL53L1X_StopRanging(dev);
+ status = VL53L1_WrByte(dev, VL53L1_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND, 0x09); /* two bounds VHV */
+ status = VL53L1_WrByte(dev, 0x0B, 0); /* start VHV from the previous temperature */
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_ClearInterrupt(uint16_t dev)
+{
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrByte(dev, SYSTEM__INTERRUPT_CLEAR, 0x01);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetInterruptPolarity(uint16_t dev, uint8_t NewPolarity)
+{
+ uint8_t Temp;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_RdByte(dev, GPIO_HV_MUX__CTRL, &Temp);
+ Temp = Temp & 0xEF;
+ status = VL53L1_WrByte(dev, GPIO_HV_MUX__CTRL, Temp | (!(NewPolarity & 1)) << 4);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetInterruptPolarity(uint16_t dev, uint8_t *pInterruptPolarity)
+{
+ uint8_t Temp;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_RdByte(dev, GPIO_HV_MUX__CTRL, &Temp);
+ Temp = Temp & 0x10;
+ *pInterruptPolarity = !(Temp>>4);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_StartRanging(uint16_t dev)
+{
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrByte(dev, SYSTEM__MODE_START, 0x40); /* Enable VL53L1X */
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_StopRanging(uint16_t dev)
+{
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrByte(dev, SYSTEM__MODE_START, 0x00); /* Disable VL53L1X */
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_CheckForDataReady(uint16_t dev, uint8_t *isDataReady)
+{
+ uint8_t Temp;
+ uint8_t IntPol;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1X_GetInterruptPolarity(dev, &IntPol);
+ status = VL53L1_RdByte(dev, GPIO__TIO_HV_STATUS, &Temp);
+ /* Read in the register to check if a new value is available */
+ if (status == 0){
+ if ((Temp & 1) == IntPol)
+ *isDataReady = 1;
+ else
+ *isDataReady = 0;
+ }
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetTimingBudgetInMs(uint16_t dev, uint16_t TimingBudgetInMs)
+{
+ uint16_t DM;
+ VL53L1X_ERROR status=0;
+
+ status = VL53L1X_GetDistanceMode(dev, &DM);
+ if (DM == 0)
+ return 1;
+ else if (DM == 1) { /* Short DistanceMode */
+ switch (TimingBudgetInMs) {
+ case 15: /* only available in short distance mode */
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x01D);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x0027);
+ break;
+ case 20:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x0051);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x006E);
+ break;
+ case 33:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x00D6);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x006E);
+ break;
+ case 50:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x1AE);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x01E8);
+ break;
+ case 100:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x02E1);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x0388);
+ break;
+ case 200:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x03E1);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x0496);
+ break;
+ case 500:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x0591);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x05C1);
+ break;
+ default:
+ status = 1;
+ break;
+ }
+ } else {
+ switch (TimingBudgetInMs) {
+ case 20:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x001E);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x0022);
+ break;
+ case 33:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x0060);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x006E);
+ break;
+ case 50:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x00AD);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x00C6);
+ break;
+ case 100:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x01CC);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x01EA);
+ break;
+ case 200:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x02D9);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x02F8);
+ break;
+ case 500:
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI,
+ 0x048F);
+ VL53L1_WrWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_B_HI,
+ 0x04A4);
+ break;
+ default:
+ status = 1;
+ break;
+ }
+ }
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetTimingBudgetInMs(uint16_t dev, uint16_t *pTimingBudget)
+{
+ uint16_t Temp;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_RdWord(dev, RANGE_CONFIG__TIMEOUT_MACROP_A_HI, &Temp);
+ switch (Temp) {
+ case 0x001D :
+ *pTimingBudget = 15;
+ break;
+ case 0x0051 :
+ case 0x001E :
+ *pTimingBudget = 20;
+ break;
+ case 0x00D6 :
+ case 0x0060 :
+ *pTimingBudget = 33;
+ break;
+ case 0x1AE :
+ case 0x00AD :
+ *pTimingBudget = 50;
+ break;
+ case 0x02E1 :
+ case 0x01CC :
+ *pTimingBudget = 100;
+ break;
+ case 0x03E1 :
+ case 0x02D9 :
+ *pTimingBudget = 200;
+ break;
+ case 0x0591 :
+ case 0x048F :
+ *pTimingBudget = 500;
+ break;
+ default:
+ status = 1;
+ *pTimingBudget = 0;
+ }
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetDistanceMode(uint16_t dev, uint16_t DM)
+{
+ uint16_t TB;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1X_GetTimingBudgetInMs(dev, &TB);
+ if (status != 0)
+ return 1;
+ switch (DM) {
+ case 1:
+ status = VL53L1_WrByte(dev, PHASECAL_CONFIG__TIMEOUT_MACROP, 0x14);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VCSEL_PERIOD_A, 0x07);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VCSEL_PERIOD_B, 0x05);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VALID_PHASE_HIGH, 0x38);
+ status = VL53L1_WrWord(dev, SD_CONFIG__WOI_SD0, 0x0705);
+ status = VL53L1_WrWord(dev, SD_CONFIG__INITIAL_PHASE_SD0, 0x0606);
+ break;
+ case 2:
+ status = VL53L1_WrByte(dev, PHASECAL_CONFIG__TIMEOUT_MACROP, 0x0A);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VCSEL_PERIOD_A, 0x0F);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VCSEL_PERIOD_B, 0x0D);
+ status = VL53L1_WrByte(dev, RANGE_CONFIG__VALID_PHASE_HIGH, 0xB8);
+ status = VL53L1_WrWord(dev, SD_CONFIG__WOI_SD0, 0x0F0D);
+ status = VL53L1_WrWord(dev, SD_CONFIG__INITIAL_PHASE_SD0, 0x0E0E);
+ break;
+ default:
+ status = 1;
+ break;
+ }
+
+ if (status == 0)
+ status = VL53L1X_SetTimingBudgetInMs(dev, TB);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetDistanceMode(uint16_t dev, uint16_t *DM)
+{
+ uint8_t TempDM, status=0;
+
+ status = VL53L1_RdByte(dev,PHASECAL_CONFIG__TIMEOUT_MACROP, &TempDM);
+ if (TempDM == 0x14)
+ *DM=1;
+ if(TempDM == 0x0A)
+ *DM=2;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetInterMeasurementInMs(uint16_t dev, uint16_t InterMeasMs)
+{
+ uint16_t ClockPLL;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_RdWord(dev, VL53L1_RESULT__OSC_CALIBRATE_VAL, &ClockPLL);
+ ClockPLL = ClockPLL&0x3FF;
+ VL53L1_WrDWord(dev, VL53L1_SYSTEM__INTERMEASUREMENT_PERIOD,
+ (uint32_t)(ClockPLL * InterMeasMs * 1.075));
+ return status;
+
+}
+
+VL53L1X_ERROR VL53L1X_GetInterMeasurementInMs(uint16_t dev, uint16_t *pIM)
+{
+ uint16_t ClockPLL;
+ VL53L1X_ERROR status = 0;
+ uint32_t tmp;
+
+ status = VL53L1_RdDWord(dev,VL53L1_SYSTEM__INTERMEASUREMENT_PERIOD, &tmp);
+ *pIM = (uint16_t)tmp;
+ status = VL53L1_RdWord(dev, VL53L1_RESULT__OSC_CALIBRATE_VAL, &ClockPLL);
+ ClockPLL = ClockPLL&0x3FF;
+ *pIM= (uint16_t)(*pIM/(ClockPLL*1.065));
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_BootState(uint16_t dev, uint8_t *state)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t tmp = 0;
+
+ status = VL53L1_RdByte(dev,VL53L1_FIRMWARE__SYSTEM_STATUS, &tmp);
+ *state = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSensorId(uint16_t dev, uint16_t *sensorId)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp = 0;
+
+ status = VL53L1_RdWord(dev, VL53L1_IDENTIFICATION__MODEL_ID, &tmp);
+ *sensorId = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetDistance(uint16_t dev, uint16_t *distance)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = (VL53L1_RdWord(dev,
+ VL53L1_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0, &tmp));
+ *distance = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSignalPerSpad(uint16_t dev, uint16_t *signalRate)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t SpNb=1, signal;
+
+ status = VL53L1_RdWord(dev,
+ VL53L1_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0, &signal);
+ status = VL53L1_RdWord(dev,
+ VL53L1_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0, &SpNb);
+ *signalRate = (uint16_t) (2000.0*signal/SpNb);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetAmbientPerSpad(uint16_t dev, uint16_t *ambPerSp)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t AmbientRate, SpNb = 1;
+
+ status = VL53L1_RdWord(dev, RESULT__AMBIENT_COUNT_RATE_MCPS_SD, &AmbientRate);
+ status = VL53L1_RdWord(dev, VL53L1_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0, &SpNb);
+ *ambPerSp=(uint16_t) (2000.0 * AmbientRate / SpNb);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSignalRate(uint16_t dev, uint16_t *signal)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,
+ VL53L1_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0, &tmp);
+ *signal = tmp*8;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSpadNb(uint16_t dev, uint16_t *spNb)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,
+ VL53L1_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0, &tmp);
+ *spNb = tmp >> 8;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetAmbientRate(uint16_t dev, uint16_t *ambRate)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev, RESULT__AMBIENT_COUNT_RATE_MCPS_SD, &tmp);
+ *ambRate = tmp*8;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetRangeStatus(uint16_t dev, uint8_t *rangeStatus)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t RgSt;
+
+ *rangeStatus = 255;
+ status = VL53L1_RdByte(dev, VL53L1_RESULT__RANGE_STATUS, &RgSt);
+ RgSt = RgSt & 0x1F;
+ if (RgSt < 24)
+ *rangeStatus = status_rtn[RgSt];
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetResult(uint16_t dev, VL53L1X_Result_t *pResult)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t Temp[17];
+ uint8_t RgSt = 255;
+
+ status = VL53L1_ReadMulti(dev, VL53L1_RESULT__RANGE_STATUS, Temp, 17);
+ RgSt = Temp[0] & 0x1F;
+ if (RgSt < 24)
+ RgSt = status_rtn[RgSt];
+ pResult->Status = RgSt;
+ pResult->Ambient = (Temp[7] << 8 | Temp[8]) * 8;
+ pResult->NumSPADs = Temp[3];
+ pResult->SigPerSPAD = (Temp[15] << 8 | Temp[16]) * 8;
+ pResult->Distance = Temp[13] << 8 | Temp[14];
+
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetOffset(uint16_t dev, int16_t OffsetValue)
+{
+ VL53L1X_ERROR status = 0;
+ int16_t Temp;
+
+ Temp = (OffsetValue*4);
+ VL53L1_WrWord(dev, ALGO__PART_TO_PART_RANGE_OFFSET_MM,
+ (uint16_t)Temp);
+ VL53L1_WrWord(dev, MM_CONFIG__INNER_OFFSET_MM, 0x0);
+ VL53L1_WrWord(dev, MM_CONFIG__OUTER_OFFSET_MM, 0x0);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetOffset(uint16_t dev, int16_t *offset)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t Temp;
+
+ status = VL53L1_RdWord(dev,ALGO__PART_TO_PART_RANGE_OFFSET_MM, &Temp);
+ Temp = Temp<<3;
+ Temp = Temp>>5;
+ *offset = (int16_t)(Temp);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetXtalk(uint16_t dev, uint16_t XtalkValue)
+{
+/* XTalkValue in count per second to avoid float type */
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrWord(dev,
+ ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS,
+ 0x0000);
+ status = VL53L1_WrWord(dev, ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS,
+ 0x0000);
+ status = VL53L1_WrWord(dev, ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS,
+ (XtalkValue<<9)/1000); /* * << 9 (7.9 format) and /1000 to convert cps to kpcs */
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetXtalk(uint16_t dev, uint16_t *xtalk )
+{
+ VL53L1X_ERROR status = 0;
+ uint32_t tmp;
+
+ status = VL53L1_RdDWord(dev,ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS, &tmp);
+ *xtalk = (uint16_t)(tmp*1000)>>9; /* * 1000 to convert kcps to cps and >> 9 (7.9 format) */
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetDistanceThreshold(uint16_t dev, uint16_t ThreshLow,
+ uint16_t ThreshHigh, uint8_t Window,
+ uint8_t IntOnNoTarget)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t Temp = 0;
+
+ status = VL53L1_RdByte(dev, SYSTEM__INTERRUPT_CONFIG_GPIO, &Temp);
+ Temp = Temp & 0x47;
+ if (IntOnNoTarget == 0) {
+ status = VL53L1_WrByte(dev, SYSTEM__INTERRUPT_CONFIG_GPIO,
+ (Temp | (Window & 0x07)));
+ } else {
+ status = VL53L1_WrByte(dev, SYSTEM__INTERRUPT_CONFIG_GPIO,
+ ((Temp | (Window & 0x07)) | 0x40));
+ }
+ status = VL53L1_WrWord(dev, SYSTEM__THRESH_HIGH, ThreshHigh);
+ status = VL53L1_WrWord(dev, SYSTEM__THRESH_LOW, ThreshLow);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdWindow(uint16_t dev, uint16_t *window)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t tmp;
+ status = VL53L1_RdByte(dev,SYSTEM__INTERRUPT_CONFIG_GPIO, &tmp);
+ *window = (uint16_t)(tmp & 0x7);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdLow(uint16_t dev, uint16_t *low)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,SYSTEM__THRESH_LOW, &tmp);
+ *low = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdHigh(uint16_t dev, uint16_t *high)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,SYSTEM__THRESH_HIGH, &tmp);
+ *high = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetROICenter(uint16_t dev, uint8_t ROICenter)
+{
+ VL53L1X_ERROR status = 0;
+ status = VL53L1_WrByte(dev, ROI_CONFIG__USER_ROI_CENTRE_SPAD, ROICenter);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetROICenter(uint16_t dev, uint8_t *ROICenter)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t tmp;
+ status = VL53L1_RdByte(dev, ROI_CONFIG__USER_ROI_CENTRE_SPAD, &tmp);
+ *ROICenter = tmp;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetROI(uint16_t dev, uint16_t X, uint16_t Y)
+{
+ uint8_t OpticalCenter;
+ VL53L1X_ERROR status = 0;
+
+ status =VL53L1_RdByte(dev, VL53L1_ROI_CONFIG__MODE_ROI_CENTRE_SPAD, &OpticalCenter);
+ if (X > 16)
+ X = 16;
+ if (Y > 16)
+ Y = 16;
+ if (X > 10 || Y > 10){
+ OpticalCenter = 199;
+ }
+ status = VL53L1_WrByte(dev, ROI_CONFIG__USER_ROI_CENTRE_SPAD, OpticalCenter);
+ status = VL53L1_WrByte(dev, ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE,
+ (Y - 1) << 4 | (X - 1));
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetROI_XY(uint16_t dev, uint16_t *ROI_X, uint16_t *ROI_Y)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t tmp;
+
+ status = VL53L1_RdByte(dev,ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE, &tmp);
+ *ROI_X = ((uint16_t)tmp & 0x0F) + 1;
+ *ROI_Y = (((uint16_t)tmp & 0xF0) >> 4) + 1;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetSignalThreshold(uint16_t dev, uint16_t Signal)
+{
+ VL53L1X_ERROR status = 0;
+
+ VL53L1_WrWord(dev,RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS,Signal>>3);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSignalThreshold(uint16_t dev, uint16_t *signal)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,
+ RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS, &tmp);
+ *signal = tmp <<3;
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_SetSigmaThreshold(uint16_t dev, uint16_t Sigma)
+{
+ VL53L1X_ERROR status = 0;
+
+ if(Sigma>(0xFFFF>>2)){
+ return 1;
+ }
+ /* 16 bits register 14.2 format */
+ status = VL53L1_WrWord(dev,RANGE_CONFIG__SIGMA_THRESH,Sigma<<2);
+ return status;
+}
+
+VL53L1X_ERROR VL53L1X_GetSigmaThreshold(uint16_t dev, uint16_t *sigma)
+{
+ VL53L1X_ERROR status = 0;
+ uint16_t tmp;
+
+ status = VL53L1_RdWord(dev,RANGE_CONFIG__SIGMA_THRESH, &tmp);
+ *sigma = tmp >> 2;
+ return status;
+
+}
+
+VL53L1X_ERROR VL53L1X_StartTemperatureUpdate(uint16_t dev)
+{
+ VL53L1X_ERROR status = 0;
+ uint8_t tmp=0;
+
+ status = VL53L1_WrByte(dev,VL53L1_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND,0x81); /* full VHV */
+ status = VL53L1_WrByte(dev,0x0B,0x92);
+ status = VL53L1X_StartRanging(dev);
+ while(tmp==0){
+ status = VL53L1X_CheckForDataReady(dev, &tmp);
+ }
+ tmp = 0;
+ status = VL53L1X_ClearInterrupt(dev);
+ status = VL53L1X_StopRanging(dev);
+ status = VL53L1_WrByte(dev, VL53L1_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND, 0x09); /* two bounds VHV */
+ status = VL53L1_WrByte(dev, 0x0B, 0); /* start VHV from the previous temperature */
+ return status;
+}
diff --git a/Components/vl53l1x_uld/VL53L1X_api.h b/Components/vl53l1x_uld/VL53L1X_api.h
new file mode 100644
index 0000000..0f6e0a6
--- /dev/null
+++ b/Components/vl53l1x_uld/VL53L1X_api.h
@@ -0,0 +1,393 @@
+/*
+* Copyright (c) 2017, STMicroelectronics - All Rights Reserved
+*
+* This file : part of VL53L1 Core and : 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 : 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.
+*
+*
+********************************************************************************
+*
+*/
+
+/**
+ * @file vl53l1x_api.h
+ * @brief Functions definition
+ */
+
+#ifndef _API_H_
+#define _API_H_
+
+#include "vl53l1_platform.h"
+
+#define VL53L1X_IMPLEMENTATION_VER_MAJOR 3
+#define VL53L1X_IMPLEMENTATION_VER_MINOR 2
+#define VL53L1X_IMPLEMENTATION_VER_SUB 0
+#define VL53L1X_IMPLEMENTATION_VER_REVISION 0000
+
+typedef int8_t VL53L1X_ERROR;
+
+#define SOFT_RESET 0x0000
+#define VL53L1_I2C_SLAVE__DEVICE_ADDRESS 0x0001
+#define VL53L1_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND 0x0008
+#define ALGO__CROSSTALK_COMPENSATION_PLANE_OFFSET_KCPS 0x0016
+#define ALGO__CROSSTALK_COMPENSATION_X_PLANE_GRADIENT_KCPS 0x0018
+#define ALGO__CROSSTALK_COMPENSATION_Y_PLANE_GRADIENT_KCPS 0x001A
+#define ALGO__PART_TO_PART_RANGE_OFFSET_MM 0x001E
+#define MM_CONFIG__INNER_OFFSET_MM 0x0020
+#define MM_CONFIG__OUTER_OFFSET_MM 0x0022
+#define GPIO_HV_MUX__CTRL 0x0030
+#define GPIO__TIO_HV_STATUS 0x0031
+#define SYSTEM__INTERRUPT_CONFIG_GPIO 0x0046
+#define PHASECAL_CONFIG__TIMEOUT_MACROP 0x004B
+#define RANGE_CONFIG__TIMEOUT_MACROP_A_HI 0x005E
+#define RANGE_CONFIG__VCSEL_PERIOD_A 0x0060
+#define RANGE_CONFIG__VCSEL_PERIOD_B 0x0063
+#define RANGE_CONFIG__TIMEOUT_MACROP_B_HI 0x0061
+#define RANGE_CONFIG__TIMEOUT_MACROP_B_LO 0x0062
+#define RANGE_CONFIG__SIGMA_THRESH 0x0064
+#define RANGE_CONFIG__MIN_COUNT_RATE_RTN_LIMIT_MCPS 0x0066
+#define RANGE_CONFIG__VALID_PHASE_HIGH 0x0069
+#define VL53L1_SYSTEM__INTERMEASUREMENT_PERIOD 0x006C
+#define SYSTEM__THRESH_HIGH 0x0072
+#define SYSTEM__THRESH_LOW 0x0074
+#define SD_CONFIG__WOI_SD0 0x0078
+#define SD_CONFIG__INITIAL_PHASE_SD0 0x007A
+#define ROI_CONFIG__USER_ROI_CENTRE_SPAD 0x007F
+#define ROI_CONFIG__USER_ROI_REQUESTED_GLOBAL_XY_SIZE 0x0080
+#define SYSTEM__SEQUENCE_CONFIG 0x0081
+#define VL53L1_SYSTEM__GROUPED_PARAMETER_HOLD 0x0082
+#define SYSTEM__INTERRUPT_CLEAR 0x0086
+#define SYSTEM__MODE_START 0x0087
+#define VL53L1_RESULT__RANGE_STATUS 0x0089
+#define VL53L1_RESULT__DSS_ACTUAL_EFFECTIVE_SPADS_SD0 0x008C
+#define RESULT__AMBIENT_COUNT_RATE_MCPS_SD 0x0090
+#define VL53L1_RESULT__FINAL_CROSSTALK_CORRECTED_RANGE_MM_SD0 0x0096
+#define VL53L1_RESULT__PEAK_SIGNAL_COUNT_RATE_CROSSTALK_CORRECTED_MCPS_SD0 0x0098
+#define VL53L1_RESULT__OSC_CALIBRATE_VAL 0x00DE
+#define VL53L1_FIRMWARE__SYSTEM_STATUS 0x00E5
+#define VL53L1_IDENTIFICATION__MODEL_ID 0x010F
+#define VL53L1_ROI_CONFIG__MODE_ROI_CENTRE_SPAD 0x013E
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/**
+ * @brief defines SW Version
+ */
+typedef struct {
+ uint8_t major; /*!< major number */
+ uint8_t minor; /*!< minor number */
+ uint8_t build; /*!< build number */
+ uint32_t revision; /*!< revision number */
+} VL53L1X_Version_t;
+
+/**
+ * @brief defines packed reading results type
+ */
+typedef struct {
+ uint8_t Status; /*!< ResultStatus */
+ uint16_t Distance; /*!< ResultDistance */
+ uint16_t Ambient; /*!< ResultAmbient */
+ uint16_t SigPerSPAD;/*!< ResultSignalPerSPAD */
+ uint16_t NumSPADs; /*!< ResultNumSPADs */
+} VL53L1X_Result_t;
+
+/**
+ * @brief This function returns the SW driver version
+ */
+VL53L1X_ERROR VL53L1X_GetSWVersion(VL53L1X_Version_t *pVersion);
+
+/**
+ * @brief This function sets the sensor I2C address used in case multiple devices application, default address 0x52
+ */
+VL53L1X_ERROR VL53L1X_SetI2CAddress(uint16_t, uint8_t new_address);
+
+/**
+ * @brief This function loads the 135 bytes default values to initialize the sensor.
+ * @param dev Device address
+ * @return 0:success, != 0:failed
+ */
+VL53L1X_ERROR VL53L1X_SensorInit(uint16_t dev);
+
+/**
+ * @brief This function clears the interrupt, to be called after a ranging data reading
+ * to arm the interrupt for the next data ready event.
+ */
+VL53L1X_ERROR VL53L1X_ClearInterrupt(uint16_t dev);
+
+/**
+ * @brief This function programs the interrupt polarity\n
+ * 1=active high (default), 0=active low
+ */
+VL53L1X_ERROR VL53L1X_SetInterruptPolarity(uint16_t dev, uint8_t IntPol);
+
+/**
+ * @brief This function returns the current interrupt polarity\n
+ * 1=active high (default), 0=active low
+ */
+VL53L1X_ERROR VL53L1X_GetInterruptPolarity(uint16_t dev, uint8_t *pIntPol);
+
+/**
+ * @brief This function starts the ranging distance operation\n
+ * The ranging operation is continuous. The clear interrupt has to be done after each get data to allow the interrupt to raise when the next data is ready\n
+ * 1=active high (default), 0=active low, use SetInterruptPolarity() to change the interrupt polarity if required.
+ */
+VL53L1X_ERROR VL53L1X_StartRanging(uint16_t dev);
+
+/**
+ * @brief This function stops the ranging.
+ */
+VL53L1X_ERROR VL53L1X_StopRanging(uint16_t dev);
+
+/**
+ * @brief This function checks if the new ranging data is available by polling the dedicated register.
+ * @param : isDataReady==0 -> not ready; isDataReady==1 -> ready
+ */
+VL53L1X_ERROR VL53L1X_CheckForDataReady(uint16_t dev, uint8_t *isDataReady);
+
+/**
+ * @brief This function programs the timing budget in ms.
+ * Predefined values = 15, 20, 33, 50, 100(default), 200, 500.
+ */
+VL53L1X_ERROR VL53L1X_SetTimingBudgetInMs(uint16_t dev, uint16_t TimingBudgetInMs);
+
+/**
+ * @brief This function returns the current timing budget in ms.
+ */
+VL53L1X_ERROR VL53L1X_GetTimingBudgetInMs(uint16_t dev, uint16_t *pTimingBudgetInMs);
+
+/**
+ * @brief This function programs the distance mode (1=short, 2=long(default)).
+ * Short mode max distance is limited to 1.3 m but better ambient immunity.\n
+ * Long mode can range up to 4 m in the dark with 200 ms timing budget.
+ */
+VL53L1X_ERROR VL53L1X_SetDistanceMode(uint16_t dev, uint16_t DistanceMode);
+
+/**
+ * @brief This function returns the current distance mode (1=short, 2=long).
+ */
+VL53L1X_ERROR VL53L1X_GetDistanceMode(uint16_t dev, uint16_t *pDistanceMode);
+
+/**
+ * @brief This function programs the Intermeasurement period in ms\n
+ * Intermeasurement period must be >/= timing budget. This condition is not checked by the API,
+ * the customer has the duty to check the condition. Default = 100 ms
+ */
+VL53L1X_ERROR VL53L1X_SetInterMeasurementInMs(uint16_t dev,
+ uint16_t InterMeasurementInMs);
+
+/**
+ * @brief This function returns the Intermeasurement period in ms.
+ */
+VL53L1X_ERROR VL53L1X_GetInterMeasurementInMs(uint16_t dev, uint16_t * pIM);
+
+/**
+ * @brief This function returns the boot state of the device (1:booted, 0:not booted)
+ */
+VL53L1X_ERROR VL53L1X_BootState(uint16_t dev, uint8_t *state);
+
+/**
+ * @brief This function returns the sensor id, sensor Id must be 0xEEAC
+ */
+VL53L1X_ERROR VL53L1X_GetSensorId(uint16_t dev, uint16_t *id);
+
+/**
+ * @brief This function returns the distance measured by the sensor in mm
+ */
+VL53L1X_ERROR VL53L1X_GetDistance(uint16_t dev, uint16_t *distance);
+
+/**
+ * @brief This function returns the returned signal per SPAD in kcps/SPAD.
+ * With kcps stands for Kilo Count Per Second
+ */
+VL53L1X_ERROR VL53L1X_GetSignalPerSpad(uint16_t dev, uint16_t *signalPerSp);
+
+/**
+ * @brief This function returns the ambient per SPAD in kcps/SPAD
+ */
+VL53L1X_ERROR VL53L1X_GetAmbientPerSpad(uint16_t dev, uint16_t *amb);
+
+/**
+ * @brief This function returns the returned signal in kcps.
+ */
+VL53L1X_ERROR VL53L1X_GetSignalRate(uint16_t dev, uint16_t *signalRate);
+
+/**
+ * @brief This function returns the current number of enabled SPADs
+ */
+VL53L1X_ERROR VL53L1X_GetSpadNb(uint16_t dev, uint16_t *spNb);
+
+/**
+ * @brief This function returns the ambient rate in kcps
+ */
+VL53L1X_ERROR VL53L1X_GetAmbientRate(uint16_t dev, uint16_t *ambRate);
+
+/**
+ * @brief This function returns the ranging status error \n
+ * (0:no error, 1:sigma failed, 2:signal failed, ..., 7:wrap-around)
+ */
+VL53L1X_ERROR VL53L1X_GetRangeStatus(uint16_t dev, uint8_t *rangeStatus);
+
+/**
+ * @brief This function returns measurements and the range status in a single read access
+ */
+VL53L1X_ERROR VL53L1X_GetResult(uint16_t dev, VL53L1X_Result_t *pResult);
+
+/**
+ * @brief This function programs the offset correction in mm
+ * @param OffsetValue:the offset correction value to program in mm
+ */
+VL53L1X_ERROR VL53L1X_SetOffset(uint16_t dev, int16_t OffsetValue);
+
+/**
+ * @brief This function returns the programmed offset correction value in mm
+ */
+VL53L1X_ERROR VL53L1X_GetOffset(uint16_t dev, int16_t *Offset);
+
+/**
+ * @brief This function programs the xtalk correction value in cps (Count Per Second).\n
+ * This is the number of photons reflected back from the cover glass in cps.
+ */
+VL53L1X_ERROR VL53L1X_SetXtalk(uint16_t dev, uint16_t XtalkValue);
+
+/**
+ * @brief This function returns the current programmed xtalk correction value in cps
+ */
+VL53L1X_ERROR VL53L1X_GetXtalk(uint16_t dev, uint16_t *Xtalk);
+
+/**
+ * @brief This function programs the threshold detection mode\n
+ * Example:\n
+ * VL53L1X_SetDistanceThreshold(dev,100,300,0,1): Below 100 \n
+ * VL53L1X_SetDistanceThreshold(dev,100,300,1,1): Above 300 \n
+ * VL53L1X_SetDistanceThreshold(dev,100,300,2,1): Out of window \n
+ * VL53L1X_SetDistanceThreshold(dev,100,300,3,1): In window \n
+ * @param dev : device address
+ * @param ThreshLow(in mm) : the threshold under which one the device raises an interrupt if Window = 0
+ * @param ThreshHigh(in mm) : the threshold above which one the device raises an interrupt if Window = 1
+ * @param Window detection mode : 0=below, 1=above, 2=out, 3=in
+ * @param IntOnNoTarget = 1 (No longer used - just use 1)
+ */
+VL53L1X_ERROR VL53L1X_SetDistanceThreshold(uint16_t dev, uint16_t ThreshLow,
+ uint16_t ThreshHigh, uint8_t Window,
+ uint8_t IntOnNoTarget);
+
+/**
+ * @brief This function returns the window detection mode (0=below; 1=above; 2=out; 3=in)
+ */
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdWindow(uint16_t dev, uint16_t *window);
+
+/**
+ * @brief This function returns the low threshold in mm
+ */
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdLow(uint16_t dev, uint16_t *low);
+
+/**
+ * @brief This function returns the high threshold in mm
+ */
+VL53L1X_ERROR VL53L1X_GetDistanceThresholdHigh(uint16_t dev, uint16_t *high);
+
+/**
+ * @brief This function programs the ROI (Region of Interest)\n
+ * The ROI position is centered, only the ROI size can be reprogrammed.\n
+ * The smallest acceptable ROI size = 4\n
+ * @param X:ROI Width; Y=ROI Height
+ */
+VL53L1X_ERROR VL53L1X_SetROI(uint16_t dev, uint16_t X, uint16_t Y);
+
+/**
+ *@brief This function returns width X and height Y
+ */
+VL53L1X_ERROR VL53L1X_GetROI_XY(uint16_t dev, uint16_t *ROI_X, uint16_t *ROI_Y);
+
+/**
+ *@brief This function programs the new user ROI center, please to be aware that there is no check in this function.
+ *if the ROI center vs ROI size is out of border the ranging function return error #13
+ */
+VL53L1X_ERROR VL53L1X_SetROICenter(uint16_t dev, uint8_t ROICenter);
+
+/**
+ *@brief This function returns the current user ROI center
+ */
+VL53L1X_ERROR VL53L1X_GetROICenter(uint16_t dev, uint8_t *ROICenter);
+
+/**
+ * @brief This function programs a new signal threshold in kcps (default=1024 kcps\n
+ */
+VL53L1X_ERROR VL53L1X_SetSignalThreshold(uint16_t dev, uint16_t signal);
+
+/**
+ * @brief This function returns the current signal threshold in kcps
+ */
+VL53L1X_ERROR VL53L1X_GetSignalThreshold(uint16_t dev, uint16_t *signal);
+
+/**
+ * @brief This function programs a new sigma threshold in mm (default=15 mm)
+ */
+VL53L1X_ERROR VL53L1X_SetSigmaThreshold(uint16_t dev, uint16_t sigma);
+
+/**
+ * @brief This function returns the current sigma threshold in mm
+ */
+VL53L1X_ERROR VL53L1X_GetSigmaThreshold(uint16_t dev, uint16_t *signal);
+
+/**
+ * @brief This function performs the temperature calibration.
+ * It is recommended to call this function any time the temperature might have changed by more than 8 deg C
+ * without sensor ranging activity for an extended period.
+ */
+VL53L1X_ERROR VL53L1X_StartTemperatureUpdate(uint16_t dev);
+
+#endif
diff --git a/Components/vl53l1x_uld/VL53L1X_calibration.c b/Components/vl53l1x_uld/VL53L1X_calibration.c
new file mode 100644
index 0000000..05a7d43
--- /dev/null
+++ b/Components/vl53l1x_uld/VL53L1X_calibration.c
@@ -0,0 +1,136 @@
+/*
+* Copyright (c) 2017, STMicroelectronics - All Rights Reserved
+*
+* This file : part of VL53L1 Core and : 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 : 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.
+*
+*
+********************************************************************************
+*
+*/
+/**
+ * @file vl53l1x_calibration.c
+ * @brief Calibration functions implementation
+ */
+#include "VL53L1X_api.h"
+#include "VL53L1X_calibration.h"
+
+#define ALGO__PART_TO_PART_RANGE_OFFSET_MM 0x001E
+#define MM_CONFIG__INNER_OFFSET_MM 0x0020
+#define MM_CONFIG__OUTER_OFFSET_MM 0x0022
+
+int8_t VL53L1X_CalibrateOffset(uint16_t dev, uint16_t TargetDistInMm, int16_t *offset)
+{
+ uint8_t i, tmp;
+ int16_t AverageDistance = 0;
+ uint16_t distance;
+ VL53L1X_ERROR status = 0;
+
+ status = VL53L1_WrWord(dev, ALGO__PART_TO_PART_RANGE_OFFSET_MM, 0x0);
+ status = VL53L1_WrWord(dev, MM_CONFIG__INNER_OFFSET_MM, 0x0);
+ status = VL53L1_WrWord(dev, MM_CONFIG__OUTER_OFFSET_MM, 0x0);
+ status = VL53L1X_StartRanging(dev); /* Enable VL53L1X sensor */
+ for (i = 0; i < 50; i++) {
+ tmp = 0;
+ while (tmp == 0){
+ status = VL53L1X_CheckForDataReady(dev, &tmp);
+ }
+ status = VL53L1X_GetDistance(dev, &distance);
+ status = VL53L1X_ClearInterrupt(dev);
+ AverageDistance = AverageDistance + distance;
+ }
+ status = VL53L1X_StopRanging(dev);
+ AverageDistance = AverageDistance / 50;
+ *offset = TargetDistInMm - AverageDistance;
+ status = VL53L1_WrWord(dev, ALGO__PART_TO_PART_RANGE_OFFSET_MM, *offset*4);
+ return status;
+}
+
+int8_t VL53L1X_CalibrateXtalk(uint16_t dev, uint16_t TargetDistInMm, uint16_t *xtalk)
+{
+ uint8_t i, tmp;
+ float AverageSignalRate = 0;
+ float AverageDistance = 0;
+ float AverageSpadNb = 0;
+ uint16_t distance = 0, spadNum;
+ uint16_t sr;
+ VL53L1X_ERROR status = 0;
+ uint32_t calXtalk;
+
+ status = VL53L1_WrWord(dev, 0x0016,0);
+ status = VL53L1X_StartRanging(dev);
+ for (i = 0; i < 50; i++) {
+ tmp = 0;
+ while (tmp == 0){
+ status = VL53L1X_CheckForDataReady(dev, &tmp);
+ }
+ status= VL53L1X_GetSignalRate(dev, &sr);
+ status= VL53L1X_GetDistance(dev, &distance);
+ status = VL53L1X_ClearInterrupt(dev);
+ AverageDistance = AverageDistance + distance;
+ status = VL53L1X_GetSpadNb(dev, &spadNum);
+ AverageSpadNb = AverageSpadNb + spadNum;
+ AverageSignalRate =
+ AverageSignalRate + sr;
+ }
+ status = VL53L1X_StopRanging(dev);
+ AverageDistance = AverageDistance / 50;
+ AverageSpadNb = AverageSpadNb / 50;
+ AverageSignalRate = AverageSignalRate / 50;
+ /* Calculate Xtalk value */
+ calXtalk = (uint16_t)(512*(AverageSignalRate*(1-(AverageDistance/TargetDistInMm)))/AverageSpadNb);
+ *xtalk = (uint16_t)(calXtalk*1000)>>9;
+ status = VL53L1_WrWord(dev, 0x0016, calXtalk);
+ return status;
+}
diff --git a/Components/vl53l1x_uld/VL53L1X_calibration.h b/Components/vl53l1x_uld/VL53L1X_calibration.h
new file mode 100644
index 0000000..c057722
--- /dev/null
+++ b/Components/vl53l1x_uld/VL53L1X_calibration.h
@@ -0,0 +1,93 @@
+/*
+* Copyright (c) 2017, STMicroelectronics - All Rights Reserved
+*
+* This file : part of VL53L1 Core and : 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 : 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.
+*
+*
+********************************************************************************
+*
+*/
+/**
+ * @file vl53l1x_calibration.h
+ * @brief Calibration Functions definition
+ */
+
+#ifndef _CALIBRATION_H_
+#define _CALIBRATION_H_
+
+/**
+ * @brief This function performs the offset calibration.\n
+ * The function returns the offset value found and programs the offset compensation into the device.
+ * @param TargetDistInMm target distance in mm, ST recommended 100 mm
+ * Target reflectance = grey17%
+ * @return 0:success, !=0: failed
+ * @return offset pointer contains the offset found in mm
+ */
+int8_t VL53L1X_CalibrateOffset(uint16_t dev, uint16_t TargetDistInMm, int16_t *offset);
+
+/**
+ * @brief This function performs the xtalk calibration.\n
+ * The function returns the xtalk value found and programs the xtalk compensation to the device
+ * @param TargetDistInMm target distance in mm\n
+ * The target distance : the distance where the sensor start to "under range"\n
+ * due to the influence of the photons reflected back from the cover glass becoming strong\n
+ * It's also called inflection point\n
+ * Target reflectance = grey 17%
+ * @return 0: success, !=0: failed
+ * @return xtalk pointer contains the xtalk value found in cps (number of photons in count per second)
+ */
+int8_t VL53L1X_CalibrateXtalk(uint16_t dev, uint16_t TargetDistInMm, uint16_t *xtalk);
+
+#endif
diff --git a/STM32CubeIDE/Release/STS_P2_VL53L1.bin b/STM32CubeIDE/Release/STS_P2_VL53L1.bin
new file mode 100644
index 0000000000000000000000000000000000000000..437e566f60bff6df2d5599346176875fdc6f5a78
GIT binary patch
literal 83172
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
Y0Hh1lngy*<0<Dh%@sZa%f%xPC02N&+I{*Lx
literal 0
HcmV?d00001