VL53L0X_Condensed2 - Greatly simplified Architecture, Identical Functi…

Users » sepp_nepp » Code » VL53L0X_Condensed2

Greatly simplified Architecture, Identical Functions Removed: Platform Interfaces, STP6001 interface

VL53L0X.cpp@12:81f37e50f8f8, 2019-07-08 (annotated)

Committer:: sepp_nepp
Date:: Mon Jul 08 14:07:22 2019 +0000
Revision:: 12:81f37e50f8f8
Parent:: 11:d8dbe3b87f9f
Child:: 13:253cb4ea3fcc

Added some status messaging routines.

Who changed what in which revision?

User	Revision	Line number	New contents of line
sepp_nepp	6:fb11b746ceb5	1	/**
sepp_nepp	6:fb11b746ceb5	2	******************************************************************************
sepp_nepp	6:fb11b746ceb5	3	* @file VL53L0X_class.cpp
sepp_nepp	6:fb11b746ceb5	4	* @author IMG
sepp_nepp	6:fb11b746ceb5	5	* @version V0.0.1
sepp_nepp	6:fb11b746ceb5	6	* @date 28-June-2016
sepp_nepp	6:fb11b746ceb5	7	* @brief Implementation file for the VL53L0X driver class
sepp_nepp	6:fb11b746ceb5	8	******************************************************************************
sepp_nepp	6:fb11b746ceb5	9	* @attention
sepp_nepp	6:fb11b746ceb5	10	*
sepp_nepp	6:fb11b746ceb5	11	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
sepp_nepp	6:fb11b746ceb5	12	*
sepp_nepp	6:fb11b746ceb5	13	* Redistribution and use in source and binary forms, with or without modification,
sepp_nepp	6:fb11b746ceb5	14	* are permitted provided that the following conditions are met:
sepp_nepp	6:fb11b746ceb5	15	* 1. Redistributions of source code must retain the above copyright notice,
sepp_nepp	6:fb11b746ceb5	16	* this list of conditions and the following disclaimer.
sepp_nepp	6:fb11b746ceb5	17	* 2. Redistributions in binary form must reproduce the above copyright notice,
sepp_nepp	6:fb11b746ceb5	18	* this list of conditions and the following disclaimer in the documentation
sepp_nepp	6:fb11b746ceb5	19	* and/or other materials provided with the distribution.
sepp_nepp	6:fb11b746ceb5	20	* 3. Neither the name of STMicroelectronics nor the names of its contributors
sepp_nepp	6:fb11b746ceb5	21	* may be used to endorse or promote products derived from this software
sepp_nepp	6:fb11b746ceb5	22	* without specific prior written permission.
sepp_nepp	6:fb11b746ceb5	23	*
sepp_nepp	6:fb11b746ceb5	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
sepp_nepp	6:fb11b746ceb5	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
sepp_nepp	6:fb11b746ceb5	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
sepp_nepp	6:fb11b746ceb5	27	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
sepp_nepp	6:fb11b746ceb5	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
sepp_nepp	6:fb11b746ceb5	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
sepp_nepp	6:fb11b746ceb5	30	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
sepp_nepp	6:fb11b746ceb5	31	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
sepp_nepp	6:fb11b746ceb5	32	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
sepp_nepp	6:fb11b746ceb5	33	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
sepp_nepp	6:fb11b746ceb5	34	*
sepp_nepp	6:fb11b746ceb5	35	******************************************************************************
sepp_nepp	6:fb11b746ceb5	36	*/
sepp_nepp	6:fb11b746ceb5	37
sepp_nepp	11:d8dbe3b87f9f	38	/*
sepp_nepp	11:d8dbe3b87f9f	39	Simplifications versus the original library:
sepp_nepp	11:d8dbe3b87f9f	40
sepp_nepp	11:d8dbe3b87f9f	41	Replace:
sepp_nepp	11:d8dbe3b87f9f	42	* "MicroSeconds" or "micro_seconds" by "us" or "_us"
sepp_nepp	11:d8dbe3b87f9f	43	* "MilliSeconds" or "milli_seconds" by "ms" or "_ms"
sepp_nepp	11:d8dbe3b87f9f	44	* "MegaCps" or "MCps" or "_mega_cps" by "MHz" or "_MHz"
sepp_nepp	11:d8dbe3b87f9f	45	* "MicroMeter" by "um" or "_um"
sepp_nepp	11:d8dbe3b87f9f	46	* "FIXEDPNT" by "FP"
sepp_nepp	11:d8dbe3b87f9f	47
sepp_nepp	11:d8dbe3b87f9f	48	Everything related to histogram_mode seems completely not implemented, so all definitions removed.
sepp_nepp	11:d8dbe3b87f9f	49
sepp_nepp	11:d8dbe3b87f9f	50	Everything related to x_talk_compensation seems also not implemented, all removed
sepp_nepp	11:d8dbe3b87f9f	51
sepp_nepp	11:d8dbe3b87f9f	52	Some example regular expressinos used to simplify the code:
sepp_nepp	8:2fd7cb217068	53	b) Search for: \QRead_Byte(\E([A-Za-z_\d]+)[[:punct:]](\s*)\Q&\E([A-Za-z\d_]+)\Q);\E
sepp_nepp	8:2fd7cb217068	54	Replace by: \3 = Read_Byte\(\1\);
sepp_nepp	8:2fd7cb217068	55	to replace: Read_Byte(0x90,&module_id);
sepp_nepp	8:2fd7cb217068	56	by this: module_id = Read_Byte(0x90);
sepp_nepp	8:2fd7cb217068	57
sepp_nepp	8:2fd7cb217068	58	c) Search for: ([A-Za-z_\d]+)\Q(\E\r\n(\s*)
sepp_nepp	8:2fd7cb217068	59	Replace by: \1\(
sepp_nepp	8:2fd7cb217068	60	To join lines where the first line has an open bracket, and the next line starts listing the parameters.
sepp_nepp	8:2fd7cb217068	61	for example: Status = VL53L0X_UpdateByte(V
sepp_nepp	8:2fd7cb217068	62	L53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV, ....
sepp_nepp	8:2fd7cb217068	63	becomes: Status = VL53L0X_UpdateByte(VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV, ....
sepp_nepp	8:2fd7cb217068	64
sepp_nepp	8:2fd7cb217068	65	*/
sepp_nepp	8:2fd7cb217068	66
sepp_nepp	6:fb11b746ceb5	67	/* Includes */
sepp_nepp	6:fb11b746ceb5	68	#include <stdlib.h>
sepp_nepp	6:fb11b746ceb5	69	#include "VL53L0X.h"
sepp_nepp	6:fb11b746ceb5	70
sepp_nepp	12:81f37e50f8f8	71	void Report_Range_Infos(VL53L0X_RangingMeasurementData_t RangeResults)
sepp_nepp	12:81f37e50f8f8	72	{
sepp_nepp	12:81f37e50f8f8	73	printf("\n\r Reporting All Fields of VL53L0X_RangingMeasurementData_t structure \n\r" );
sepp_nepp	12:81f37e50f8f8	74	printf(" .Range_mm = %dmm; Ranged distance. \n\r", RangeResults.Range_mm );
sepp_nepp	12:81f37e50f8f8	75	printf(" .RangeDMax_mm = %dmm; maximum detection distance in current setup and environment conditions \n\r", RangeResults.RangeDMax_mm );
sepp_nepp	12:81f37e50f8f8	76	printf(" .SignalRateRtn_MHz = %3.3fMHz; effectively a measure of target reflectance \n\r", RangeResults.SignalRateRtn_MHz / 65535.01);
sepp_nepp	12:81f37e50f8f8	77	printf(" .AmbientRateRtn_MHz = %3.3fMHz; effectively a measure of the ambient light \n\r", RangeResults.AmbientRateRtn_MHz / 65535.01 );
sepp_nepp	12:81f37e50f8f8	78	printf(" .EffectiveSpadRtnCount = %3.3f; effective SPAD count for the return signal \n\r", RangeResults.EffectiveSpadRtnCount / 256.001 );
sepp_nepp	12:81f37e50f8f8	79	printf(" .RangeFractionalPart = %d; Fractional part of range distance. \n\r", RangeResults.RangeFractionalPart >> 6 );
sepp_nepp	12:81f37e50f8f8	80	printf(" .RangeStatus = %d[u8]; Status for the current measurement, 0 = value is valid \n\r", RangeResults.RangeStatus );
sepp_nepp	12:81f37e50f8f8	81	printf(" .SigmaEstimate = %3.2f; Estimated Sigma - based on ambient & VCSEL rates and signal_total_events \n\r", RangeResults.SigmaEstimate/ 65535.01 );
sepp_nepp	12:81f37e50f8f8	82	};
sepp_nepp	12:81f37e50f8f8	83
sepp_nepp	12:81f37e50f8f8	84	void Report_Deep_Infos(VL53L0X TOF1)
sepp_nepp	12:81f37e50f8f8	85	{
sepp_nepp	12:81f37e50f8f8	86	printf("\n\r Reporting All Top Level Infos of the class \n\r" );
sepp_nepp	12:81f37e50f8f8	87	printf("I2cDevAddr = %d. \n\r", TOF1.I2cDevAddr );
sepp_nepp	12:81f37e50f8f8	88	printf("comms_type = %d. Type of comms: 1=VL53L0X_COMMS_I2C or VL53L0X_COMMS_SPI \n\r", TOF1.comms_type );
sepp_nepp	12:81f37e50f8f8	89	printf("comms_speed = %d. Communication speed [kHz] : typically 400kHz for I2C \n\r", TOF1.comms_speed_khz );
sepp_nepp	12:81f37e50f8f8	90
sepp_nepp	12:81f37e50f8f8	91	printf("\n\r Reporting All Infos of the Device_Info structure: \n\r" );
sepp_nepp	12:81f37e50f8f8	92	printf("Device_Info.ProductType = 0x%2X. VL53L0X = 1, VL53L1 = 2 \n\r", TOF1.Device_Info.ProductType );
sepp_nepp	12:81f37e50f8f8	93	printf("Device_Info.ProductRevision = %d.%d. Revision NR, major.minor \n\r",
sepp_nepp	12:81f37e50f8f8	94	TOF1.Device_Info.ProductRevisionMajor, TOF1.Device_Info.ProductRevisionMinor );
sepp_nepp	12:81f37e50f8f8	95	printf("Device_Info.Name = %s. Name of Device e.g. Left_Distance\n\r", TOF1.Device_Info.Name );
sepp_nepp	12:81f37e50f8f8	96	printf("Device_Info.Type = %s. Type of Device e.g VL53L0X \n\r", TOF1.Device_Info.Type );
sepp_nepp	12:81f37e50f8f8	97	printf("Device_Info.ProductId = %s. Product Identifier String \n\r", TOF1.Device_Info.ProductId );
sepp_nepp	12:81f37e50f8f8	98
sepp_nepp	12:81f37e50f8f8	99	printf("\n\r Reporting All Fields of CurrentParameters \n\r" );
sepp_nepp	12:81f37e50f8f8	100	printf(" .DeviceMode = %d. Defines type of measurement to be done for the next measurement \n\r",
sepp_nepp	12:81f37e50f8f8	101	TOF1.CurrentParameters.DeviceMode );
sepp_nepp	12:81f37e50f8f8	102	printf(" .Measure_Time_Budget_us= %dus. Allowed total time for a single measurement \n\r",
sepp_nepp	12:81f37e50f8f8	103	TOF1.CurrentParameters.MeasurementTimingBudget_us );
sepp_nepp	12:81f37e50f8f8	104	printf(" .Measure_Period_ms = %dms. Time between two consecutive measurements \n\r",
sepp_nepp	12:81f37e50f8f8	105	TOF1.CurrentParameters.InterMeasurementPeriod_ms );
sepp_nepp	12:81f37e50f8f8	106	printf(" .XTalk_Compens_En = %d. Crosstalk compensation enable or not (0, default) \n\r",
sepp_nepp	12:81f37e50f8f8	107	TOF1.CurrentParameters.XTalkCompensationEnable );
sepp_nepp	12:81f37e50f8f8	108	printf(" .XTalk_CompRange_mm = %dmm. CrossTalk compensation range, seems never used \n\r",
sepp_nepp	12:81f37e50f8f8	109	TOF1.CurrentParameters.XTalkCompensationRange_mm );
sepp_nepp	12:81f37e50f8f8	110	printf(" .XTalk_CompRate_MHz = %3.2fMHz. CrossTalk compensation rate . \n\r",
sepp_nepp	12:81f37e50f8f8	111	(float) TOF1.CurrentParameters.XTalkCompensationRate_MHz / 65536);
sepp_nepp	12:81f37e50f8f8	112	printf(" .RangeOffset_um = %d. Range offset adjustment (um) last programmed.\n\r",
sepp_nepp	12:81f37e50f8f8	113	TOF1.CurrentParameters.RangeOffset_um );
sepp_nepp	12:81f37e50f8f8	114	printf(" .LimitChecks ... = SIGMA_FINAL, SIGNAL_RATE_FINAL, SIGNAL_REF_CLIP, IGNORE_THRESHOLD, SIGNAL_RATE_MSRC, SIGNAL_RATE_PRE.\n\r");
sepp_nepp	12:81f37e50f8f8	115	printf(" .LimitChecksEnable[x] = %d %d %d %d %d %d. The Limit Checks enabled or not.\n\r",
sepp_nepp	12:81f37e50f8f8	116	TOF1.CurrentParameters.LimitChecksEnable[0],TOF1.CurrentParameters.LimitChecksEnable[1] ,TOF1.CurrentParameters.LimitChecksEnable[2],
sepp_nepp	12:81f37e50f8f8	117	TOF1.CurrentParameters.LimitChecksEnable[3],TOF1.CurrentParameters.LimitChecksEnable[4] ,TOF1.CurrentParameters.LimitChecksEnable[5] );
sepp_nepp	12:81f37e50f8f8	118	printf(" .LimitChecksStatus[x] = %d %d %d %d %d %d. Status of checks of last measurement.\n\r",
sepp_nepp	12:81f37e50f8f8	119	TOF1.CurrentParameters.LimitChecksStatus[0],TOF1.CurrentParameters.LimitChecksStatus[1] ,TOF1.CurrentParameters.LimitChecksStatus[2],
sepp_nepp	12:81f37e50f8f8	120	TOF1.CurrentParameters.LimitChecksStatus[3],TOF1.CurrentParameters.LimitChecksStatus[4] ,TOF1.CurrentParameters.LimitChecksStatus[5] );
sepp_nepp	12:81f37e50f8f8	121	printf(" .LimitChecksValue[x] = %d %d %d %d %d %d [FP1616]. The Limit Check values \n\r",
sepp_nepp	12:81f37e50f8f8	122	TOF1.CurrentParameters.LimitChecksValue[0],TOF1.CurrentParameters.LimitChecksValue[1] ,TOF1.CurrentParameters.LimitChecksValue[2],
sepp_nepp	12:81f37e50f8f8	123	TOF1.CurrentParameters.LimitChecksValue[3],TOF1.CurrentParameters.LimitChecksValue[4] ,TOF1.CurrentParameters.LimitChecksValue[5] );
sepp_nepp	12:81f37e50f8f8	124	printf(" .WrapAroundCheckEnable = %d. Wrap Around Check enabled or not \n\r",
sepp_nepp	12:81f37e50f8f8	125	TOF1.CurrentParameters.WrapAroundCheckEnable );
sepp_nepp	12:81f37e50f8f8	126
sepp_nepp	12:81f37e50f8f8	127	printf("\n\r Reporting All Fields of VL53L0X_DevData_t Data structure \n\r" );
sepp_nepp	12:81f37e50f8f8	128	printf(" .OscFrequency_MHz = %3.2fMHz; Frequency used \n\r", (float) TOF1.Data.OscFrequency_MHz/65536 );
sepp_nepp	12:81f37e50f8f8	129	printf(" .LastEncodedTimeout = %d[u16]; Last encoded Time out used for timing budget \n\r", TOF1.Data.LastEncodedTimeout );
sepp_nepp	12:81f37e50f8f8	130	printf(" .Pin0GpioFunctionality = %d[u8]; functionality of the GPIO: pin0 \n\r", TOF1.Data.Pin0GpioFunctionality );
sepp_nepp	12:81f37e50f8f8	131	printf(" .FinalRangeTimeout_us = %d[u32]; Execution time of the final ranging \n\r", TOF1.Data.FinalRangeTimeout_us );
sepp_nepp	12:81f37e50f8f8	132	printf(" .FinalRangeVcselPulsePeriod= %d[u8]; Vcsel pulse period (pll clocks) for the final range measurement \n\r", TOF1.Data.FinalRangeVcselPulsePeriod );
sepp_nepp	12:81f37e50f8f8	133	printf(" .PreRangeTimeout_us = %d[u32]; Execution time of the final range \n\r", TOF1.Data.PreRangeTimeout_us );
sepp_nepp	12:81f37e50f8f8	134	printf(" .PreRangeVcselPulsePeriod = %d[u8]; Vcsel pulse period (pll clocks) for the pre-range measurement \n\r", TOF1.Data.PreRangeVcselPulsePeriod );
sepp_nepp	12:81f37e50f8f8	135	printf(" .ReadDataFromDeviceDone = %2d; reads from device has been done (>0) or not. \n\r", TOF1.Data.ReadDataFromDeviceDone );
sepp_nepp	12:81f37e50f8f8	136	printf(" .ModuleId = %X; Module ID \n\r", TOF1.Data.ModuleId );
sepp_nepp	12:81f37e50f8f8	137	printf(" .Revision = %d[u8]; test Revision \n\r", TOF1.Data.Revision );
sepp_nepp	12:81f37e50f8f8	138	printf(" .ProductId = %s[char*]; Product Identifier String \n\r", TOF1.Data.ProductId );
sepp_nepp	12:81f37e50f8f8	139	printf(" .ReferenceSpadCount = %d[u8]; used for ref spad management \n\r", TOF1.Data.ReferenceSpadCount );
sepp_nepp	12:81f37e50f8f8	140	printf(" .ReferenceSpadType = %d[u8]; used for ref spad management \n\r", TOF1.Data.ReferenceSpadType );
sepp_nepp	12:81f37e50f8f8	141	printf(" .RefSpadsInitialised = %d[u8]; reports if ref spads are initialised. \n\r", TOF1.Data.RefSpadsInitialised );
sepp_nepp	12:81f37e50f8f8	142	printf(" .PartUIDUpper = %d[u32]; Unique Part ID Upper \n\r", TOF1.Data.PartUIDUpper );
sepp_nepp	12:81f37e50f8f8	143	printf(" .PartUIDLower = %d[u32]; Unique Part ID Lower \n\r", TOF1.Data.PartUIDLower );
sepp_nepp	12:81f37e50f8f8	144	printf(" .SignalRateMeasFixed400mm = %3.3f; Peak Signal rate at 400 mm \n\r", 1.0 / 65535.0 * TOF1.Data.SignalRateMeasFixed400mm );
sepp_nepp	12:81f37e50f8f8	145	printf(" .RefSpadEnables[x] = %X %X %X %X %X %X[hex8]; Reference Spad Enables \n\r",
sepp_nepp	12:81f37e50f8f8	146	TOF1.Data.RefSpadEnables[0], TOF1.Data.RefSpadEnables[1], TOF1.Data.RefSpadEnables[2],
sepp_nepp	12:81f37e50f8f8	147	TOF1.Data.RefSpadEnables[3], TOF1.Data.RefSpadEnables[4], TOF1.Data.RefSpadEnables[5] );
sepp_nepp	12:81f37e50f8f8	148	printf(" .RefGoodSpadMap[x] = %X %X %X %X %X %X[hex8]; Reference Spad Good Spad Map\n\r",
sepp_nepp	12:81f37e50f8f8	149	TOF1.Data.RefGoodSpadMap[0], TOF1.Data.RefGoodSpadMap[1], TOF1.Data.RefGoodSpadMap[2],
sepp_nepp	12:81f37e50f8f8	150	TOF1.Data.RefGoodSpadMap[3], TOF1.Data.RefGoodSpadMap[4], TOF1.Data.RefGoodSpadMap[5] );
sepp_nepp	12:81f37e50f8f8	151	printf(" .Part2PartOffsetNVM_um = %d[i32]; backed up NVM value \n\r", TOF1.Data.Part2PartOffsetNVM_um );
sepp_nepp	12:81f37e50f8f8	152	printf(" .Part2PartOffsetAdjustNVM_um= %d[i32]; backed up NVM value of additional offset adjustment \n\r", TOF1.Data.Part2PartOffsetAdjustNVM_um );
sepp_nepp	12:81f37e50f8f8	153	printf(" .SequenceConfig = %d[u8]; Internal value for the sequence config \n\r", TOF1.Data.SequenceConfig );
sepp_nepp	12:81f37e50f8f8	154	printf(" .RangeFractionalEnable = %d[u8]; Enable/Disable fractional part of range data \n\r", TOF1.Data.RangeFractionalEnable);
sepp_nepp	12:81f37e50f8f8	155	printf(" .PalState = %d[u8]; Current state of the PAL \n\r", TOF1.Data.PalState );
sepp_nepp	12:81f37e50f8f8	156	printf(" .PowerMode = %d[u8]; Current Power Mode; Stdby1/2, Idle1/2 \n\r", TOF1.Data.PowerMode );
sepp_nepp	12:81f37e50f8f8	157	printf(" .SigmaEstRefArray = %d[u16]; Reference array sigma value in 1/100th of [mm] \n\r", TOF1.Data.SigmaEstRefArray );
sepp_nepp	12:81f37e50f8f8	158	printf(" .SigmaEstEffPulseWidth = %d[u16]; Effective Pulse width for sigma estimate in 1/100th of ns \n\r", TOF1.Data.SigmaEstEffPulseWidth );
sepp_nepp	12:81f37e50f8f8	159	printf(" .SigmaEstEffAmbWidth = %d. Effective Ambient width for sigma estimate in 1/100th of ns \n\r", TOF1.Data.SigmaEstEffAmbWidth );
sepp_nepp	12:81f37e50f8f8	160	printf(" .StopVariable = %d[u8]; StopVariable used during the stop sequence \n\r", TOF1.Data.StopVariable );
sepp_nepp	12:81f37e50f8f8	161	printf(" .targetRefRate = %d. Target Ambient Rate for Ref spad management \n\r", TOF1.Data.targetRefRate );
sepp_nepp	12:81f37e50f8f8	162	printf(" .LastSignalRef_MHz = %3.3fMHz; Latest Signal ref \n\r", TOF1.Data.LastSignalRef_MHz / 65535.01 );
sepp_nepp	12:81f37e50f8f8	163	printf(" .UseInternalTuningSetting = %d[u8]; Indicate if we use Tuning Settings table \n\r", TOF1.Data.UseInternalTuningSettings );
sepp_nepp	12:81f37e50f8f8	164	printf(" .LinearityCorrectiveGain = %d[u8]; Linearity Corrective Gain value in x1000 \n\r", TOF1.Data.LinearityCorrectiveGain );
sepp_nepp	12:81f37e50f8f8	165	printf(" .DmaxCalRange_mm = %dmm; Dmax Calibration Range \n\r", TOF1.Data.DmaxCalRange_mm );
sepp_nepp	12:81f37e50f8f8	166	printf(" .DmaxCalSignalRateRtn_MHz = %3.3fMHz; Dmax Calibration Signal Rate Return \n\r", TOF1.Data.DmaxCalSignalRateRtn_MHz / 65535.01 );
sepp_nepp	12:81f37e50f8f8	167	}
sepp_nepp	12:81f37e50f8f8	168
sepp_nepp	6:fb11b746ceb5	169	int VL53L0X::read_id(uint8_t *id)
sepp_nepp	8:2fd7cb217068	170	{ int status = 0;
sepp_nepp	6:fb11b746ceb5	171	uint16_t rl_id = 0;
sepp_nepp	6:fb11b746ceb5	172
sepp_nepp	7:3a1115c2556b	173	status = VL53L0X_read_word(VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
sepp_nepp	6:fb11b746ceb5	174	if (rl_id == 0xEEAA) {
sepp_nepp	6:fb11b746ceb5	175	return status;
sepp_nepp	6:fb11b746ceb5	176	}
sepp_nepp	6:fb11b746ceb5	177	return -1;
sepp_nepp	6:fb11b746ceb5	178	}
sepp_nepp	6:fb11b746ceb5	179
sepp_nepp	6:fb11b746ceb5	180	int VL53L0X::init_sensor(uint8_t new_addr)
sepp_nepp	6:fb11b746ceb5	181	{ int status;
sepp_nepp	6:fb11b746ceb5	182
sepp_nepp	6:fb11b746ceb5	183	VL53L0X_off();
sepp_nepp	6:fb11b746ceb5	184	VL53L0X_on();
sepp_nepp	6:fb11b746ceb5	185
sepp_nepp	6:fb11b746ceb5	186	// Verify if the device is actually present
sepp_nepp	6:fb11b746ceb5	187	uint8_t id = 0;
sepp_nepp	6:fb11b746ceb5	188	status = read_id(&id);
sepp_nepp	6:fb11b746ceb5	189	if (status != 0) {
sepp_nepp	6:fb11b746ceb5	190	printf("VL53L0X sensor is not present!\n\r");
sepp_nepp	6:fb11b746ceb5	191	return 99; } // device is not present
sepp_nepp	6:fb11b746ceb5	192
sepp_nepp	7:3a1115c2556b	193	status = VL53L0X_data_init();
sepp_nepp	6:fb11b746ceb5	194	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	195	printf("Failed to init VL53L0X sensor!\n\r");
sepp_nepp	6:fb11b746ceb5	196	return status;
sepp_nepp	6:fb11b746ceb5	197	}
sepp_nepp	6:fb11b746ceb5	198
sepp_nepp	6:fb11b746ceb5	199	// deduce silicon version
sepp_nepp	10:cd1758e186a4	200	status = VL53L0X_get_device_info();
sepp_nepp	6:fb11b746ceb5	201
sepp_nepp	6:fb11b746ceb5	202	status = prepare();
sepp_nepp	6:fb11b746ceb5	203	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	204	printf("Failed to prepare VL53L0X!\n\r");
sepp_nepp	6:fb11b746ceb5	205	return status;
sepp_nepp	6:fb11b746ceb5	206	}
sepp_nepp	6:fb11b746ceb5	207
sepp_nepp	6:fb11b746ceb5	208	if (new_addr != VL53L0X_DEFAULT_ADDRESS) {
sepp_nepp	6:fb11b746ceb5	209	status = set_device_address(new_addr);
sepp_nepp	6:fb11b746ceb5	210	if (status) {
sepp_nepp	6:fb11b746ceb5	211	printf("Failed to change I2C address!\n\r");
sepp_nepp	6:fb11b746ceb5	212	return status;
sepp_nepp	6:fb11b746ceb5	213	}
sepp_nepp	6:fb11b746ceb5	214	}
sepp_nepp	6:fb11b746ceb5	215	return status;
sepp_nepp	6:fb11b746ceb5	216	}
sepp_nepp	6:fb11b746ceb5	217
sepp_nepp	7:3a1115c2556b	218	VL53L0X_Error VL53L0X::VL53L0X_data_init(void)
sepp_nepp	8:2fd7cb217068	219	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	220	VL53L0X_DeviceParameters_t CurrentParameters;
sepp_nepp	6:fb11b746ceb5	221	int i;
sepp_nepp	6:fb11b746ceb5	222	uint8_t StopVariable;
sepp_nepp	6:fb11b746ceb5	223
sepp_nepp	6:fb11b746ceb5	224	/* by default the I2C is running at 1V8 if you want to change it you
sepp_nepp	6:fb11b746ceb5	225	* need to include this define at compilation level. */
sepp_nepp	6:fb11b746ceb5	226	#ifdef USE_I2C_2V8
sepp_nepp	11:d8dbe3b87f9f	227	Status = VL53L0X_UpdateByte(VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,0xFE,0x01);
sepp_nepp	6:fb11b746ceb5	228	#endif
sepp_nepp	6:fb11b746ceb5	229
sepp_nepp	6:fb11b746ceb5	230	/* Set I2C standard mode */
sepp_nepp	6:fb11b746ceb5	231	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	232	status = VL53L0X_write_byte( 0x88, 0x00); }
sepp_nepp	6:fb11b746ceb5	233
sepp_nepp	8:2fd7cb217068	234	Data.ReadDataFromDeviceDone = 0;
sepp_nepp	8:2fd7cb217068	235	Data.ReadDataFromDeviceDone = 0;
sepp_nepp	6:fb11b746ceb5	236
sepp_nepp	6:fb11b746ceb5	237	#ifdef USE_IQC_STATION
sepp_nepp	6:fb11b746ceb5	238	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	239	Status = VL53L0X_apply_offset_adjustment();
sepp_nepp	6:fb11b746ceb5	240	}
sepp_nepp	6:fb11b746ceb5	241	#endif
sepp_nepp	6:fb11b746ceb5	242
sepp_nepp	6:fb11b746ceb5	243	/* Default value is 1000 for Linearity Corrective Gain */
sepp_nepp	8:2fd7cb217068	244	Data.LinearityCorrectiveGain = 1000;
sepp_nepp	6:fb11b746ceb5	245
sepp_nepp	6:fb11b746ceb5	246	/* Dmax default Parameter */
sepp_nepp	11:d8dbe3b87f9f	247	Data.DmaxCalRange_mm = 400;
sepp_nepp	11:d8dbe3b87f9f	248	Data.DmaxCalSignalRateRtn_MHz = (FixPoint1616_t)((0x00016B85)); /* 1.42 No Cover Glass*/
sepp_nepp	6:fb11b746ceb5	249
sepp_nepp	6:fb11b746ceb5	250	/* Set Default static parameters
sepp_nepp	11:d8dbe3b87f9f	251	set first temporary values 9.44_MHz 65536 = 618660 */
sepp_nepp	11:d8dbe3b87f9f	252	Data.OscFrequency_MHz = 618660;
sepp_nepp	11:d8dbe3b87f9f	253
sepp_nepp	11:d8dbe3b87f9f	254	/* Set Default XTalkCompensationRate_MHz to 0 */
sepp_nepp	11:d8dbe3b87f9f	255	CurrentParameters.XTalkCompensationRate_MHz = 0;
sepp_nepp	6:fb11b746ceb5	256
sepp_nepp	6:fb11b746ceb5	257	/* Get default parameters */
sepp_nepp	7:3a1115c2556b	258	status = VL53L0X_get_device_parameters( &CurrentParameters);
sepp_nepp	6:fb11b746ceb5	259	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	260	/* initialize PAL values */
sepp_nepp	6:fb11b746ceb5	261	CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
sepp_nepp	10:cd1758e186a4	262	CurrentParameters = CurrentParameters;
sepp_nepp	6:fb11b746ceb5	263	}
sepp_nepp	6:fb11b746ceb5	264
sepp_nepp	6:fb11b746ceb5	265	/* Sigma estimator variable */
sepp_nepp	8:2fd7cb217068	266	Data.SigmaEstRefArray = 100;
sepp_nepp	8:2fd7cb217068	267	Data.SigmaEstEffPulseWidth = 900;
sepp_nepp	8:2fd7cb217068	268	Data.SigmaEstEffAmbWidth = 500;
sepp_nepp	11:d8dbe3b87f9f	269	Data.targetRefRate = 0x0A00; /* 20 MHz in 9:7 format */
sepp_nepp	6:fb11b746ceb5	270
sepp_nepp	6:fb11b746ceb5	271	/* Use internal default settings */
sepp_nepp	8:2fd7cb217068	272	Data.UseInternalTuningSettings = 1;
sepp_nepp	7:3a1115c2556b	273
sepp_nepp	7:3a1115c2556b	274	status \|= VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	7:3a1115c2556b	275	status \|= VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	276	status \|= VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	7:3a1115c2556b	277	status \|= VL53L0X_read_byte( 0x91, &StopVariable);
sepp_nepp	8:2fd7cb217068	278	Data.StopVariable = StopVariable;
sepp_nepp	7:3a1115c2556b	279	status \|= VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	280	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	7:3a1115c2556b	281	status \|= VL53L0X_write_byte( 0x80, 0x00);
sepp_nepp	6:fb11b746ceb5	282
sepp_nepp	6:fb11b746ceb5	283	/* Enable all check */
sepp_nepp	6:fb11b746ceb5	284	for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
sepp_nepp	6:fb11b746ceb5	285	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	286	status \|= VL53L0X_set_limit_check_enable( i, 1);
sepp_nepp	8:2fd7cb217068	287	} else { break; }
sepp_nepp	6:fb11b746ceb5	288	}
sepp_nepp	6:fb11b746ceb5	289
sepp_nepp	6:fb11b746ceb5	290	/* Disable the following checks */
sepp_nepp	6:fb11b746ceb5	291	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	292	status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
sepp_nepp	6:fb11b746ceb5	293
sepp_nepp	6:fb11b746ceb5	294	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	295	status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
sepp_nepp	6:fb11b746ceb5	296
sepp_nepp	6:fb11b746ceb5	297	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	298	status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
sepp_nepp	6:fb11b746ceb5	299
sepp_nepp	6:fb11b746ceb5	300	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	301	status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
sepp_nepp	6:fb11b746ceb5	302
sepp_nepp	6:fb11b746ceb5	303	/* Limit default values */
sepp_nepp	6:fb11b746ceb5	304	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	305	status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	306	(FixPoint1616_t)(18 * 65536));
sepp_nepp	6:fb11b746ceb5	307	}
sepp_nepp	6:fb11b746ceb5	308	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	309	status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
sepp_nepp	12:81f37e50f8f8	310	(FixPoint1616_t)(25 * 65536 / 100)); /* 0.25 * 65536 */
sepp_nepp	6:fb11b746ceb5	311	}
sepp_nepp	6:fb11b746ceb5	312
sepp_nepp	6:fb11b746ceb5	313	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	314	status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
sepp_nepp	6:fb11b746ceb5	315	(FixPoint1616_t)(35 * 65536));
sepp_nepp	6:fb11b746ceb5	316	}
sepp_nepp	6:fb11b746ceb5	317
sepp_nepp	6:fb11b746ceb5	318	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	319	status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
sepp_nepp	6:fb11b746ceb5	320	(FixPoint1616_t)(0 * 65536));
sepp_nepp	6:fb11b746ceb5	321	}
sepp_nepp	6:fb11b746ceb5	322
sepp_nepp	6:fb11b746ceb5	323	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	324	Data.SequenceConfig = 0xFF;
sepp_nepp	7:3a1115c2556b	325	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,0xFF);
sepp_nepp	6:fb11b746ceb5	326
sepp_nepp	6:fb11b746ceb5	327	/* Set PAL state to tell that we are waiting for call to VL53L0X_StaticInit */
sepp_nepp	8:2fd7cb217068	328	Data.PalState = VL53L0X_STATE_WAIT_STATICINIT;
sepp_nepp	6:fb11b746ceb5	329	}
sepp_nepp	6:fb11b746ceb5	330
sepp_nepp	6:fb11b746ceb5	331	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	332	Data.RefSpadsInitialised = 0;
sepp_nepp	6:fb11b746ceb5	333	}
sepp_nepp	6:fb11b746ceb5	334
sepp_nepp	6:fb11b746ceb5	335	return status;
sepp_nepp	6:fb11b746ceb5	336	}
sepp_nepp	6:fb11b746ceb5	337
sepp_nepp	6:fb11b746ceb5	338	int VL53L0X::prepare()
sepp_nepp	8:2fd7cb217068	339	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	340	uint32_t ref_spad_count;
sepp_nepp	6:fb11b746ceb5	341	uint8_t is_aperture_spads;
sepp_nepp	6:fb11b746ceb5	342	uint8_t vhv_settings;
sepp_nepp	6:fb11b746ceb5	343	uint8_t phase_cal;
sepp_nepp	6:fb11b746ceb5	344
sepp_nepp	6:fb11b746ceb5	345	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	346	status = VL53L0X_static_init(); // Device Initialization
sepp_nepp	6:fb11b746ceb5	347	}
sepp_nepp	6:fb11b746ceb5	348
sepp_nepp	6:fb11b746ceb5	349	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	350	status = VL53L0X_perform_ref_calibration(&vhv_settings, &phase_cal); // Device Initialization
sepp_nepp	6:fb11b746ceb5	351	}
sepp_nepp	6:fb11b746ceb5	352
sepp_nepp	6:fb11b746ceb5	353	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	354	status = VL53L0X_perform_ref_spad_management(&ref_spad_count, &is_aperture_spads); // Device Initialization
sepp_nepp	6:fb11b746ceb5	355	}
sepp_nepp	6:fb11b746ceb5	356
sepp_nepp	6:fb11b746ceb5	357	return status;
sepp_nepp	6:fb11b746ceb5	358	}
sepp_nepp	6:fb11b746ceb5	359
sepp_nepp	6:fb11b746ceb5	360	int VL53L0X::start_measurement(OperatingMode operating_mode, void (*fptr)(void),
sepp_nepp	6:fb11b746ceb5	361	VL53L0X_RangingConfig rangingConfig)
sepp_nepp	6:fb11b746ceb5	362	{ int Status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	363	int ClrStatus;
sepp_nepp	6:fb11b746ceb5	364
sepp_nepp	6:fb11b746ceb5	365	uint8_t VhvSettings;
sepp_nepp	6:fb11b746ceb5	366	uint8_t PhaseCal;
sepp_nepp	6:fb11b746ceb5	367	// default settings, for normal range.
sepp_nepp	6:fb11b746ceb5	368	FixPoint1616_t signalLimit = (FixPoint1616_t)(0.25 * 65536);
sepp_nepp	6:fb11b746ceb5	369	FixPoint1616_t sigmaLimit = (FixPoint1616_t)(18 * 65536);
sepp_nepp	6:fb11b746ceb5	370	uint32_t timingBudget = 33000;
sepp_nepp	6:fb11b746ceb5	371	uint8_t preRangeVcselPeriod = 14;
sepp_nepp	6:fb11b746ceb5	372	uint8_t finalRangeVcselPeriod = 10;
sepp_nepp	6:fb11b746ceb5	373
sepp_nepp	6:fb11b746ceb5	374	if (operating_mode == range_continuous_interrupt) {
sepp_nepp	6:fb11b746ceb5	375	if (_gpio1Int == NULL) {
sepp_nepp	6:fb11b746ceb5	376	printf("GPIO1 Error\r\n");
sepp_nepp	6:fb11b746ceb5	377	return 1;
sepp_nepp	6:fb11b746ceb5	378	}
sepp_nepp	6:fb11b746ceb5	379
sepp_nepp	7:3a1115c2556b	380	Status = VL53L0X_stop_measurement(); // it is safer to do this while sensor is stopped
sepp_nepp	6:fb11b746ceb5	381
sepp_nepp	6:fb11b746ceb5	382	// Status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
sepp_nepp	6:fb11b746ceb5	383
sepp_nepp	7:3a1115c2556b	384	Status = VL53L0X_set_gpio_config(0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
sepp_nepp	6:fb11b746ceb5	385	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
sepp_nepp	6:fb11b746ceb5	386	VL53L0X_INTERRUPTPOLARITY_HIGH);
sepp_nepp	6:fb11b746ceb5	387
sepp_nepp	6:fb11b746ceb5	388	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	389	attach_interrupt_measure_detection_irq(fptr);
sepp_nepp	6:fb11b746ceb5	390	enable_interrupt_measure_detection_irq();
sepp_nepp	6:fb11b746ceb5	391	}
sepp_nepp	6:fb11b746ceb5	392
sepp_nepp	6:fb11b746ceb5	393	ClrStatus = clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS \| VL53L0X_REG_RESULT_RANGE_STATUS);
sepp_nepp	6:fb11b746ceb5	394	if (ClrStatus) { Status = 97; } // VL53L0X_ClearErrorInterrupt fail
sepp_nepp	6:fb11b746ceb5	395
sepp_nepp	6:fb11b746ceb5	396	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	397	Status = VL53L0X_set_device_mode(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
sepp_nepp	6:fb11b746ceb5	398	}
sepp_nepp	6:fb11b746ceb5	399
sepp_nepp	6:fb11b746ceb5	400	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	401	Status = VL53L0X_start_measurement();
sepp_nepp	6:fb11b746ceb5	402	}
sepp_nepp	6:fb11b746ceb5	403	}
sepp_nepp	6:fb11b746ceb5	404
sepp_nepp	6:fb11b746ceb5	405	if (operating_mode == range_single_shot_polling) {
sepp_nepp	6:fb11b746ceb5	406	// singelshot, polled ranging
sepp_nepp	6:fb11b746ceb5	407	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	408	// no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
sepp_nepp	7:3a1115c2556b	409	Status = VL53L0X_set_device_mode( VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
sepp_nepp	6:fb11b746ceb5	410	}
sepp_nepp	6:fb11b746ceb5	411
sepp_nepp	6:fb11b746ceb5	412	// Enable/Disable Sigma and Signal check
sepp_nepp	6:fb11b746ceb5	413	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	414	Status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
sepp_nepp	6:fb11b746ceb5	415	}
sepp_nepp	6:fb11b746ceb5	416	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	417	Status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
sepp_nepp	6:fb11b746ceb5	418	}
sepp_nepp	6:fb11b746ceb5	419
sepp_nepp	6:fb11b746ceb5	420	/* Preselected Ranging configurations */
sepp_nepp	6:fb11b746ceb5	421	switch(rangingConfig) {
sepp_nepp	6:fb11b746ceb5	422	case Range_Config_DEFAULT:
sepp_nepp	6:fb11b746ceb5	423	// default settings, for normal range.
sepp_nepp	6:fb11b746ceb5	424	signalLimit = (FixPoint1616_t)(0.25 * 65536);
sepp_nepp	6:fb11b746ceb5	425	sigmaLimit = (FixPoint1616_t)(18 * 65536);
sepp_nepp	6:fb11b746ceb5	426	timingBudget = 33000;
sepp_nepp	6:fb11b746ceb5	427	preRangeVcselPeriod = 14;
sepp_nepp	6:fb11b746ceb5	428	finalRangeVcselPeriod = 10;
sepp_nepp	6:fb11b746ceb5	429	break;
sepp_nepp	6:fb11b746ceb5	430	case Range_Config_LONG_RANGE: // *** from mass market cube expansion v1.1, ranging with satellites.
sepp_nepp	6:fb11b746ceb5	431	signalLimit = (FixPoint1616_t)(0.1 * 65536);
sepp_nepp	6:fb11b746ceb5	432	sigmaLimit = (FixPoint1616_t)(60 * 65536);
sepp_nepp	6:fb11b746ceb5	433	timingBudget = 33000;
sepp_nepp	6:fb11b746ceb5	434	preRangeVcselPeriod = 18;
sepp_nepp	6:fb11b746ceb5	435	finalRangeVcselPeriod = 14;
sepp_nepp	6:fb11b746ceb5	436	break;
sepp_nepp	6:fb11b746ceb5	437	case Range_Config_HIGH_ACCURACY:
sepp_nepp	6:fb11b746ceb5	438	signalLimit = (FixPoint1616_t)(0.25*65536);
sepp_nepp	6:fb11b746ceb5	439	sigmaLimit = (FixPoint1616_t)(18*65536);
sepp_nepp	6:fb11b746ceb5	440	timingBudget = 200000;
sepp_nepp	6:fb11b746ceb5	441	preRangeVcselPeriod = 14;
sepp_nepp	6:fb11b746ceb5	442	finalRangeVcselPeriod = 10;
sepp_nepp	6:fb11b746ceb5	443	break;
sepp_nepp	6:fb11b746ceb5	444	case Range_Config_HIGH_SPEED:
sepp_nepp	6:fb11b746ceb5	445	signalLimit = (FixPoint1616_t)(0.25*65536);
sepp_nepp	6:fb11b746ceb5	446	sigmaLimit = (FixPoint1616_t)(32*65536);
sepp_nepp	6:fb11b746ceb5	447	timingBudget = 20000;
sepp_nepp	6:fb11b746ceb5	448	preRangeVcselPeriod = 14;
sepp_nepp	6:fb11b746ceb5	449	finalRangeVcselPeriod = 10;
sepp_nepp	6:fb11b746ceb5	450	break;
sepp_nepp	6:fb11b746ceb5	451	default:
sepp_nepp	6:fb11b746ceb5	452	Status = 96; // Config Not Supported
sepp_nepp	6:fb11b746ceb5	453	}
sepp_nepp	6:fb11b746ceb5	454
sepp_nepp	6:fb11b746ceb5	455	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	456	Status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);}
sepp_nepp	6:fb11b746ceb5	457
sepp_nepp	6:fb11b746ceb5	458	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	459	Status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);}
sepp_nepp	6:fb11b746ceb5	460
sepp_nepp	6:fb11b746ceb5	461	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	462	Status = VL53L0X_set_measurement_timing_budget_us( timingBudget);}
sepp_nepp	6:fb11b746ceb5	463
sepp_nepp	6:fb11b746ceb5	464	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	465	Status = VL53L0X_set_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);}
sepp_nepp	6:fb11b746ceb5	466
sepp_nepp	6:fb11b746ceb5	467	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	468	Status = VL53L0X_set_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);}
sepp_nepp	6:fb11b746ceb5	469
sepp_nepp	6:fb11b746ceb5	470	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	471	Status = VL53L0X_perform_ref_calibration( &VhvSettings, &PhaseCal);}
sepp_nepp	6:fb11b746ceb5	472
sepp_nepp	6:fb11b746ceb5	473	}
sepp_nepp	6:fb11b746ceb5	474
sepp_nepp	6:fb11b746ceb5	475	if (operating_mode == range_continuous_polling) {
sepp_nepp	6:fb11b746ceb5	476	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	477	//printf("Call of VL53L0X_SetDeviceMode\n");
sepp_nepp	7:3a1115c2556b	478	Status = VL53L0X_set_device_mode( VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
sepp_nepp	6:fb11b746ceb5	479	}
sepp_nepp	6:fb11b746ceb5	480
sepp_nepp	6:fb11b746ceb5	481	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	482	//printf("Call of VL53L0X_StartMeasurement\n");
sepp_nepp	7:3a1115c2556b	483	Status = VL53L0X_start_measurement();
sepp_nepp	6:fb11b746ceb5	484	}
sepp_nepp	6:fb11b746ceb5	485	}
sepp_nepp	6:fb11b746ceb5	486	return Status;
sepp_nepp	6:fb11b746ceb5	487	}
sepp_nepp	6:fb11b746ceb5	488
sepp_nepp	6:fb11b746ceb5	489	int VL53L0X::range_meas_int_continuous_mode(void (*fptr)(void))
sepp_nepp	8:2fd7cb217068	490	{ int status, clr_status;
sepp_nepp	6:fb11b746ceb5	491
sepp_nepp	7:3a1115c2556b	492	status = VL53L0X_stop_measurement(); // it is safer to do this while sensor is stopped
sepp_nepp	6:fb11b746ceb5	493
sepp_nepp	6:fb11b746ceb5	494	// status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
sepp_nepp	6:fb11b746ceb5	495
sepp_nepp	7:3a1115c2556b	496	status = VL53L0X_set_gpio_config( 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
sepp_nepp	6:fb11b746ceb5	497	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
sepp_nepp	6:fb11b746ceb5	498	VL53L0X_INTERRUPTPOLARITY_HIGH);
sepp_nepp	6:fb11b746ceb5	499
sepp_nepp	6:fb11b746ceb5	500	if (!status) {
sepp_nepp	6:fb11b746ceb5	501	attach_interrupt_measure_detection_irq(fptr);
sepp_nepp	6:fb11b746ceb5	502	enable_interrupt_measure_detection_irq();
sepp_nepp	6:fb11b746ceb5	503	}
sepp_nepp	6:fb11b746ceb5	504
sepp_nepp	6:fb11b746ceb5	505	clr_status = clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS \| VL53L0X_REG_RESULT_RANGE_STATUS);
sepp_nepp	6:fb11b746ceb5	506	if (clr_status!=0) { status = 98; } // VL53L0X_ClearErrorInterrupt_fail;
sepp_nepp	6:fb11b746ceb5	507
sepp_nepp	6:fb11b746ceb5	508	if (!status) {
sepp_nepp	6:fb11b746ceb5	509	status = range_start_continuous_mode();
sepp_nepp	6:fb11b746ceb5	510	}
sepp_nepp	6:fb11b746ceb5	511	return status;
sepp_nepp	6:fb11b746ceb5	512	}
sepp_nepp	6:fb11b746ceb5	513
sepp_nepp	7:3a1115c2556b	514	VL53L0X_Error VL53L0X::wait_measurement_data_ready(void)
sepp_nepp	8:2fd7cb217068	515	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	516	uint8_t new_dat_ready = 0;
sepp_nepp	6:fb11b746ceb5	517	uint32_t loop_nb;
sepp_nepp	6:fb11b746ceb5	518
sepp_nepp	6:fb11b746ceb5	519	// Wait until it finished
sepp_nepp	6:fb11b746ceb5	520	// use timeout to avoid deadlock
sepp_nepp	6:fb11b746ceb5	521	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	522	loop_nb = 0;
sepp_nepp	6:fb11b746ceb5	523	do {
sepp_nepp	7:3a1115c2556b	524	status = VL53L0X_get_measurement_data_ready( &new_dat_ready);
sepp_nepp	6:fb11b746ceb5	525	if ((new_dat_ready == 0x01) \|\| status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	526	break;
sepp_nepp	6:fb11b746ceb5	527	}
sepp_nepp	6:fb11b746ceb5	528	loop_nb = loop_nb + 1;
sepp_nepp	7:3a1115c2556b	529	VL53L0X_polling_delay();
sepp_nepp	6:fb11b746ceb5	530	} while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
sepp_nepp	6:fb11b746ceb5	531
sepp_nepp	6:fb11b746ceb5	532	if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
sepp_nepp	6:fb11b746ceb5	533	status = VL53L0X_ERROR_TIME_OUT;
sepp_nepp	6:fb11b746ceb5	534	}
sepp_nepp	6:fb11b746ceb5	535	}
sepp_nepp	6:fb11b746ceb5	536
sepp_nepp	6:fb11b746ceb5	537	return status;
sepp_nepp	6:fb11b746ceb5	538	}
sepp_nepp	6:fb11b746ceb5	539
sepp_nepp	8:2fd7cb217068	540	int VL53L0X::get_distance(uint32_t *p_data)
sepp_nepp	6:fb11b746ceb5	541	{
sepp_nepp	8:2fd7cb217068	542	int status = 0;
sepp_nepp	8:2fd7cb217068	543	VL53L0X_RangingMeasurementData_t p_ranging_measurement_data;
sepp_nepp	8:2fd7cb217068	544
sepp_nepp	8:2fd7cb217068	545	status = start_measurement(range_single_shot_polling, NULL);
sepp_nepp	8:2fd7cb217068	546	if (!status) {
sepp_nepp	8:2fd7cb217068	547	status = get_measurement(range_single_shot_polling, &p_ranging_measurement_data);
sepp_nepp	8:2fd7cb217068	548	}
sepp_nepp	11:d8dbe3b87f9f	549	if (p_ranging_measurement_data.RangeStatus == 0) { // we have a valid range.
sepp_nepp	11:d8dbe3b87f9f	550	*p_data = p_ranging_measurement_data.Range_mm;
sepp_nepp	8:2fd7cb217068	551	} else {
sepp_nepp	8:2fd7cb217068	552	*p_data = 0;
sepp_nepp	8:2fd7cb217068	553	status = VL53L0X_ERROR_RANGE_ERROR;
sepp_nepp	8:2fd7cb217068	554	}
sepp_nepp	8:2fd7cb217068	555	stop_measurement(range_single_shot_polling);
sepp_nepp	8:2fd7cb217068	556	return status;
sepp_nepp	8:2fd7cb217068	557	}
sepp_nepp	8:2fd7cb217068	558
sepp_nepp	8:2fd7cb217068	559	VL53L0X_Error VL53L0X::wait_stop_completed(void)
sepp_nepp	8:2fd7cb217068	560	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	561	uint32_t stop_completed = 0;
sepp_nepp	6:fb11b746ceb5	562	uint32_t loop_nb;
sepp_nepp	6:fb11b746ceb5	563
sepp_nepp	6:fb11b746ceb5	564	// Wait until it finished
sepp_nepp	6:fb11b746ceb5	565	// use timeout to avoid deadlock
sepp_nepp	6:fb11b746ceb5	566	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	567	loop_nb = 0;
sepp_nepp	6:fb11b746ceb5	568	do {
sepp_nepp	7:3a1115c2556b	569	status = VL53L0X_get_stop_completed_status( &stop_completed);
sepp_nepp	6:fb11b746ceb5	570	if ((stop_completed == 0x00) \|\| status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	571	break;
sepp_nepp	6:fb11b746ceb5	572	}
sepp_nepp	6:fb11b746ceb5	573	loop_nb = loop_nb + 1;
sepp_nepp	7:3a1115c2556b	574	VL53L0X_polling_delay();
sepp_nepp	6:fb11b746ceb5	575	} while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
sepp_nepp	6:fb11b746ceb5	576
sepp_nepp	6:fb11b746ceb5	577	if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
sepp_nepp	6:fb11b746ceb5	578	status = VL53L0X_ERROR_TIME_OUT;
sepp_nepp	6:fb11b746ceb5	579	}
sepp_nepp	6:fb11b746ceb5	580	}
sepp_nepp	6:fb11b746ceb5	581
sepp_nepp	6:fb11b746ceb5	582	return status;
sepp_nepp	6:fb11b746ceb5	583	}
sepp_nepp	6:fb11b746ceb5	584
sepp_nepp	6:fb11b746ceb5	585	int VL53L0X::get_measurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *p_data)
sepp_nepp	8:2fd7cb217068	586	{ int Status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	587
sepp_nepp	6:fb11b746ceb5	588	if (operating_mode == range_single_shot_polling) {
sepp_nepp	7:3a1115c2556b	589	Status = VL53L0X_perform_single_ranging_measurement( p_data);
sepp_nepp	6:fb11b746ceb5	590	}
sepp_nepp	6:fb11b746ceb5	591
sepp_nepp	6:fb11b746ceb5	592	if (operating_mode == range_continuous_polling) {
sepp_nepp	6:fb11b746ceb5	593	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	594	Status = VL53L0X_measurement_poll_for_completion();
sepp_nepp	6:fb11b746ceb5	595	}
sepp_nepp	6:fb11b746ceb5	596
sepp_nepp	6:fb11b746ceb5	597	if (Status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	598	Status = VL53L0X_get_ranging_measurement_data( p_data);
sepp_nepp	6:fb11b746ceb5	599
sepp_nepp	6:fb11b746ceb5	600	// Clear the interrupt
sepp_nepp	7:3a1115c2556b	601	VL53L0X_clear_interrupt_mask( VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
sepp_nepp	7:3a1115c2556b	602	VL53L0X_polling_delay();
sepp_nepp	6:fb11b746ceb5	603	}
sepp_nepp	6:fb11b746ceb5	604	}
sepp_nepp	6:fb11b746ceb5	605
sepp_nepp	6:fb11b746ceb5	606	if (operating_mode == range_continuous_interrupt) {
sepp_nepp	7:3a1115c2556b	607	Status = VL53L0X_get_ranging_measurement_data( p_data);
sepp_nepp	7:3a1115c2556b	608	VL53L0X_clear_interrupt_mask( VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR \| VL53L0X_REG_RESULT_INTERRUPT_STATUS);
sepp_nepp	6:fb11b746ceb5	609	}
sepp_nepp	6:fb11b746ceb5	610
sepp_nepp	6:fb11b746ceb5	611	return Status;
sepp_nepp	6:fb11b746ceb5	612	}
sepp_nepp	6:fb11b746ceb5	613
sepp_nepp	6:fb11b746ceb5	614	int VL53L0X::stop_measurement(OperatingMode operating_mode)
sepp_nepp	8:2fd7cb217068	615	{ int status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	616
sepp_nepp	6:fb11b746ceb5	617	// don't need to stop for a singleshot range!
sepp_nepp	6:fb11b746ceb5	618	if (operating_mode == range_single_shot_polling) {
sepp_nepp	6:fb11b746ceb5	619	}
sepp_nepp	6:fb11b746ceb5	620
sepp_nepp	6:fb11b746ceb5	621	if (operating_mode == range_continuous_interrupt \|\| operating_mode == range_continuous_polling) {
sepp_nepp	6:fb11b746ceb5	622	// continuous mode
sepp_nepp	6:fb11b746ceb5	623	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	624	//printf("Call of VL53L0X_StopMeasurement\n");
sepp_nepp	7:3a1115c2556b	625	status = VL53L0X_stop_measurement();
sepp_nepp	6:fb11b746ceb5	626	}
sepp_nepp	6:fb11b746ceb5	627
sepp_nepp	6:fb11b746ceb5	628	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	629	//printf("Wait Stop to be competed\n");
sepp_nepp	7:3a1115c2556b	630	status = wait_stop_completed();
sepp_nepp	6:fb11b746ceb5	631	}
sepp_nepp	6:fb11b746ceb5	632
sepp_nepp	6:fb11b746ceb5	633	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	634	status = VL53L0X_clear_interrupt_mask(VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
sepp_nepp	6:fb11b746ceb5	635	}
sepp_nepp	6:fb11b746ceb5	636
sepp_nepp	6:fb11b746ceb5	637	return status;
sepp_nepp	6:fb11b746ceb5	638	}
sepp_nepp	6:fb11b746ceb5	639
sepp_nepp	6:fb11b746ceb5	640	int VL53L0X::handle_irq(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data)
sepp_nepp	8:2fd7cb217068	641	{ int status;
sepp_nepp	6:fb11b746ceb5	642	status = get_measurement(operating_mode, data);
sepp_nepp	6:fb11b746ceb5	643	enable_interrupt_measure_detection_irq();
sepp_nepp	6:fb11b746ceb5	644	return status;
sepp_nepp	6:fb11b746ceb5	645	}
sepp_nepp	6:fb11b746ceb5	646
sepp_nepp	6:fb11b746ceb5	647	int VL53L0X::range_start_continuous_mode()
sepp_nepp	6:fb11b746ceb5	648	{ int status;
sepp_nepp	7:3a1115c2556b	649	status = VL53L0X_set_device_mode( VL53L0X_DEVICEMODE_CONTINUOUS_RANGING);
sepp_nepp	6:fb11b746ceb5	650
sepp_nepp	6:fb11b746ceb5	651	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	7:3a1115c2556b	652	{ status = VL53L0X_start_measurement(); }
sepp_nepp	6:fb11b746ceb5	653
sepp_nepp	6:fb11b746ceb5	654	return status;
sepp_nepp	6:fb11b746ceb5	655	}
sepp_nepp	6:fb11b746ceb5	656
sepp_nepp	7:3a1115c2556b	657	VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe(void)
sepp_nepp	8:2fd7cb217068	658	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	659	uint8_t strobe;
sepp_nepp	6:fb11b746ceb5	660	uint32_t loop_nb;
sepp_nepp	6:fb11b746ceb5	661
sepp_nepp	7:3a1115c2556b	662	status \|= VL53L0X_write_byte( 0x83, 0x00);
sepp_nepp	6:fb11b746ceb5	663
sepp_nepp	6:fb11b746ceb5	664	/* polling
sepp_nepp	6:fb11b746ceb5	665	* use timeout to avoid deadlock*/
sepp_nepp	6:fb11b746ceb5	666	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	667	loop_nb = 0;
sepp_nepp	6:fb11b746ceb5	668	do {
sepp_nepp	7:3a1115c2556b	669	status = VL53L0X_read_byte( 0x83, &strobe);
sepp_nepp	6:fb11b746ceb5	670	if ((strobe != 0x00) \|\| status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	671	break;
sepp_nepp	6:fb11b746ceb5	672	}
sepp_nepp	6:fb11b746ceb5	673
sepp_nepp	6:fb11b746ceb5	674	loop_nb = loop_nb + 1;
sepp_nepp	6:fb11b746ceb5	675	} while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
sepp_nepp	6:fb11b746ceb5	676
sepp_nepp	6:fb11b746ceb5	677	if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
sepp_nepp	6:fb11b746ceb5	678	status = VL53L0X_ERROR_TIME_OUT;
sepp_nepp	6:fb11b746ceb5	679	}
sepp_nepp	6:fb11b746ceb5	680	}
sepp_nepp	6:fb11b746ceb5	681
sepp_nepp	7:3a1115c2556b	682	status \|= VL53L0X_write_byte( 0x83, 0x01);
sepp_nepp	6:fb11b746ceb5	683
sepp_nepp	6:fb11b746ceb5	684	return status;
sepp_nepp	6:fb11b746ceb5	685	}
sepp_nepp	6:fb11b746ceb5	686
sepp_nepp	7:3a1115c2556b	687	VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device( uint8_t option)
sepp_nepp	8:2fd7cb217068	688	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	689	uint8_t byte;
sepp_nepp	6:fb11b746ceb5	690	uint32_t tmp_dword;
sepp_nepp	6:fb11b746ceb5	691	uint8_t module_id;
sepp_nepp	6:fb11b746ceb5	692	uint8_t revision;
sepp_nepp	6:fb11b746ceb5	693	uint8_t reference_spad_count = 0;
sepp_nepp	6:fb11b746ceb5	694	uint8_t reference_spad_type = 0;
sepp_nepp	6:fb11b746ceb5	695	uint32_t part_uid_upper = 0;
sepp_nepp	6:fb11b746ceb5	696	uint32_t part_uid_lower = 0;
sepp_nepp	6:fb11b746ceb5	697	uint32_t offset_fixed1104_mm = 0;
sepp_nepp	6:fb11b746ceb5	698	int16_t offset_micro_meters = 0;
sepp_nepp	6:fb11b746ceb5	699	uint32_t dist_meas_tgt_fixed1104_mm = 400 << 4;
sepp_nepp	6:fb11b746ceb5	700	uint32_t dist_meas_fixed1104_400_mm = 0;
sepp_nepp	6:fb11b746ceb5	701	uint32_t signal_rate_meas_fixed1104_400_mm = 0;
sepp_nepp	6:fb11b746ceb5	702	char product_id[19];
sepp_nepp	6:fb11b746ceb5	703	char *product_id_tmp;
sepp_nepp	6:fb11b746ceb5	704	uint8_t read_data_from_device_done;
sepp_nepp	6:fb11b746ceb5	705	FixPoint1616_t signal_rate_meas_fixed400_mm_fix = 0;
sepp_nepp	6:fb11b746ceb5	706	uint8_t nvm_ref_good_spad_map[VL53L0X_REF_SPAD_BUFFER_SIZE];
sepp_nepp	6:fb11b746ceb5	707	int i;
sepp_nepp	6:fb11b746ceb5	708
sepp_nepp	8:2fd7cb217068	709	read_data_from_device_done = Data.ReadDataFromDeviceDone;
sepp_nepp	8:2fd7cb217068	710	read_data_from_device_done = Data.ReadDataFromDeviceDone;
sepp_nepp	8:2fd7cb217068	711	read_data_from_device_done = Data.ReadDataFromDeviceDone;
sepp_nepp	6:fb11b746ceb5	712
sepp_nepp	6:fb11b746ceb5	713	/* This access is done only once after that a GetDeviceInfo or
sepp_nepp	6:fb11b746ceb5	714	* datainit is done*/
sepp_nepp	6:fb11b746ceb5	715	if (read_data_from_device_done != 7) {
sepp_nepp	6:fb11b746ceb5	716
sepp_nepp	7:3a1115c2556b	717	status \|= VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	7:3a1115c2556b	718	status \|= VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	719	status \|= VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	7:3a1115c2556b	720	status \|= VL53L0X_write_byte( 0xFF, 0x06);
sepp_nepp	11:d8dbe3b87f9f	721	status \|= VL53L0X_read_byte ( 0x83, &byte);
sepp_nepp	7:3a1115c2556b	722	status \|= VL53L0X_write_byte( 0x83, byte \| 4);
sepp_nepp	7:3a1115c2556b	723	status \|= VL53L0X_write_byte( 0xFF, 0x07);
sepp_nepp	7:3a1115c2556b	724	status \|= VL53L0X_write_byte( 0x81, 0x01);
sepp_nepp	7:3a1115c2556b	725
sepp_nepp	7:3a1115c2556b	726	status \|= VL53L0X_polling_delay();
sepp_nepp	7:3a1115c2556b	727
sepp_nepp	7:3a1115c2556b	728	status \|= VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	6:fb11b746ceb5	729
sepp_nepp	6:fb11b746ceb5	730	if (((option & 1) == 1) &&
sepp_nepp	6:fb11b746ceb5	731	((read_data_from_device_done & 1) == 0)) {
sepp_nepp	7:3a1115c2556b	732	status \|= VL53L0X_write_byte( 0x94, 0x6b);
sepp_nepp	7:3a1115c2556b	733	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	734	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	735
sepp_nepp	6:fb11b746ceb5	736	reference_spad_count = (uint8_t)((tmp_dword >> 8) & 0x07f);
sepp_nepp	6:fb11b746ceb5	737	reference_spad_type = (uint8_t)((tmp_dword >> 15) & 0x01);
sepp_nepp	6:fb11b746ceb5	738
sepp_nepp	7:3a1115c2556b	739	status \|= VL53L0X_write_byte( 0x94, 0x24);
sepp_nepp	7:3a1115c2556b	740	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	741	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	742
sepp_nepp	11:d8dbe3b87f9f	743	nvm_ref_good_spad_map[0] = (uint8_t)((tmp_dword >> 24) & 0xff);
sepp_nepp	11:d8dbe3b87f9f	744	nvm_ref_good_spad_map[1] = (uint8_t)((tmp_dword >> 16) & 0xff);
sepp_nepp	11:d8dbe3b87f9f	745	nvm_ref_good_spad_map[2] = (uint8_t)((tmp_dword >> 8) & 0xff);
sepp_nepp	6:fb11b746ceb5	746	nvm_ref_good_spad_map[3] = (uint8_t)(tmp_dword & 0xff);
sepp_nepp	6:fb11b746ceb5	747
sepp_nepp	7:3a1115c2556b	748	status \|= VL53L0X_write_byte( 0x94, 0x25);
sepp_nepp	7:3a1115c2556b	749	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	750	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	751
sepp_nepp	11:d8dbe3b87f9f	752	nvm_ref_good_spad_map[4] = (uint8_t)((tmp_dword >> 24) & 0xff);
sepp_nepp	11:d8dbe3b87f9f	753	nvm_ref_good_spad_map[5] = (uint8_t)((tmp_dword >> 16) & 0xff);
sepp_nepp	6:fb11b746ceb5	754	}
sepp_nepp	6:fb11b746ceb5	755
sepp_nepp	6:fb11b746ceb5	756	if (((option & 2) == 2) &&
sepp_nepp	6:fb11b746ceb5	757	((read_data_from_device_done & 2) == 0)) {
sepp_nepp	6:fb11b746ceb5	758
sepp_nepp	7:3a1115c2556b	759	status \|= VL53L0X_write_byte( 0x94, 0x02);
sepp_nepp	7:3a1115c2556b	760	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	761	status \|= VL53L0X_read_byte( 0x90, &module_id);
sepp_nepp	7:3a1115c2556b	762
sepp_nepp	7:3a1115c2556b	763	status \|= VL53L0X_write_byte( 0x94, 0x7B);
sepp_nepp	7:3a1115c2556b	764	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	765	status \|= VL53L0X_read_byte( 0x90, &revision);
sepp_nepp	7:3a1115c2556b	766
sepp_nepp	7:3a1115c2556b	767	status \|= VL53L0X_write_byte( 0x94, 0x77);
sepp_nepp	7:3a1115c2556b	768	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	769	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	770
sepp_nepp	6:fb11b746ceb5	771	product_id[0] = (char)((tmp_dword >> 25) & 0x07f);
sepp_nepp	6:fb11b746ceb5	772	product_id[1] = (char)((tmp_dword >> 18) & 0x07f);
sepp_nepp	6:fb11b746ceb5	773	product_id[2] = (char)((tmp_dword >> 11) & 0x07f);
sepp_nepp	6:fb11b746ceb5	774	product_id[3] = (char)((tmp_dword >> 4) & 0x07f);
sepp_nepp	6:fb11b746ceb5	775
sepp_nepp	6:fb11b746ceb5	776	byte = (uint8_t)((tmp_dword & 0x00f) << 3);
sepp_nepp	6:fb11b746ceb5	777
sepp_nepp	7:3a1115c2556b	778	status \|= VL53L0X_write_byte( 0x94, 0x78);
sepp_nepp	7:3a1115c2556b	779	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	780	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	781
sepp_nepp	6:fb11b746ceb5	782	product_id[4] = (char)(byte +
sepp_nepp	6:fb11b746ceb5	783	((tmp_dword >> 29) & 0x07f));
sepp_nepp	6:fb11b746ceb5	784	product_id[5] = (char)((tmp_dword >> 22) & 0x07f);
sepp_nepp	6:fb11b746ceb5	785	product_id[6] = (char)((tmp_dword >> 15) & 0x07f);
sepp_nepp	6:fb11b746ceb5	786	product_id[7] = (char)((tmp_dword >> 8) & 0x07f);
sepp_nepp	6:fb11b746ceb5	787	product_id[8] = (char)((tmp_dword >> 1) & 0x07f);
sepp_nepp	6:fb11b746ceb5	788
sepp_nepp	6:fb11b746ceb5	789	byte = (uint8_t)((tmp_dword & 0x001) << 6);
sepp_nepp	6:fb11b746ceb5	790
sepp_nepp	7:3a1115c2556b	791	status \|= VL53L0X_write_byte( 0x94, 0x79);
sepp_nepp	7:3a1115c2556b	792
sepp_nepp	7:3a1115c2556b	793	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	794
sepp_nepp	7:3a1115c2556b	795	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	796
sepp_nepp	6:fb11b746ceb5	797	product_id[9] = (char)(byte +
sepp_nepp	6:fb11b746ceb5	798	((tmp_dword >> 26) & 0x07f));
sepp_nepp	6:fb11b746ceb5	799	product_id[10] = (char)((tmp_dword >> 19) & 0x07f);
sepp_nepp	6:fb11b746ceb5	800	product_id[11] = (char)((tmp_dword >> 12) & 0x07f);
sepp_nepp	6:fb11b746ceb5	801	product_id[12] = (char)((tmp_dword >> 5) & 0x07f);
sepp_nepp	6:fb11b746ceb5	802
sepp_nepp	6:fb11b746ceb5	803	byte = (uint8_t)((tmp_dword & 0x01f) << 2);
sepp_nepp	6:fb11b746ceb5	804
sepp_nepp	7:3a1115c2556b	805	status \|= VL53L0X_write_byte( 0x94, 0x7A);
sepp_nepp	7:3a1115c2556b	806
sepp_nepp	7:3a1115c2556b	807	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	808
sepp_nepp	7:3a1115c2556b	809	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	810
sepp_nepp	6:fb11b746ceb5	811	product_id[13] = (char)(byte +
sepp_nepp	6:fb11b746ceb5	812	((tmp_dword >> 30) & 0x07f));
sepp_nepp	6:fb11b746ceb5	813	product_id[14] = (char)((tmp_dword >> 23) & 0x07f);
sepp_nepp	6:fb11b746ceb5	814	product_id[15] = (char)((tmp_dword >> 16) & 0x07f);
sepp_nepp	6:fb11b746ceb5	815	product_id[16] = (char)((tmp_dword >> 9) & 0x07f);
sepp_nepp	6:fb11b746ceb5	816	product_id[17] = (char)((tmp_dword >> 2) & 0x07f);
sepp_nepp	6:fb11b746ceb5	817	product_id[18] = '\0';
sepp_nepp	6:fb11b746ceb5	818
sepp_nepp	6:fb11b746ceb5	819	}
sepp_nepp	6:fb11b746ceb5	820
sepp_nepp	6:fb11b746ceb5	821	if (((option & 4) == 4) &&
sepp_nepp	6:fb11b746ceb5	822	((read_data_from_device_done & 4) == 0)) {
sepp_nepp	6:fb11b746ceb5	823
sepp_nepp	7:3a1115c2556b	824	status \|= VL53L0X_write_byte( 0x94, 0x7B);
sepp_nepp	7:3a1115c2556b	825	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	826	status \|= VL53L0X_read_dword( 0x90, &part_uid_upper);
sepp_nepp	7:3a1115c2556b	827
sepp_nepp	7:3a1115c2556b	828	status \|= VL53L0X_write_byte( 0x94, 0x7C);
sepp_nepp	7:3a1115c2556b	829	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	830	status \|= VL53L0X_read_dword( 0x90, &part_uid_lower);
sepp_nepp	7:3a1115c2556b	831
sepp_nepp	7:3a1115c2556b	832	status \|= VL53L0X_write_byte( 0x94, 0x73);
sepp_nepp	7:3a1115c2556b	833	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	834	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	835
sepp_nepp	11:d8dbe3b87f9f	836	signal_rate_meas_fixed1104_400_mm = (tmp_dword & 0x0000000ff) << 8;
sepp_nepp	6:fb11b746ceb5	837
sepp_nepp	7:3a1115c2556b	838	status \|= VL53L0X_write_byte( 0x94, 0x74);
sepp_nepp	7:3a1115c2556b	839	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	840	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	841
sepp_nepp	11:d8dbe3b87f9f	842	signal_rate_meas_fixed1104_400_mm \|= ((tmp_dword & 0xff000000) >> 24);
sepp_nepp	6:fb11b746ceb5	843
sepp_nepp	7:3a1115c2556b	844	status \|= VL53L0X_write_byte( 0x94, 0x75);
sepp_nepp	7:3a1115c2556b	845	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	846	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	847
sepp_nepp	11:d8dbe3b87f9f	848	dist_meas_fixed1104_400_mm = (tmp_dword & 0x0000000ff) << 8;
sepp_nepp	6:fb11b746ceb5	849
sepp_nepp	7:3a1115c2556b	850	status \|= VL53L0X_write_byte( 0x94, 0x76);
sepp_nepp	7:3a1115c2556b	851	status \|= VL53L0X_device_read_strobe();
sepp_nepp	7:3a1115c2556b	852	status \|= VL53L0X_read_dword( 0x90, &tmp_dword);
sepp_nepp	6:fb11b746ceb5	853
sepp_nepp	11:d8dbe3b87f9f	854	dist_meas_fixed1104_400_mm \|= ((tmp_dword & 0xff000000) >> 24);
sepp_nepp	6:fb11b746ceb5	855	}
sepp_nepp	6:fb11b746ceb5	856
sepp_nepp	7:3a1115c2556b	857	status \|= VL53L0X_write_byte( 0x81, 0x00);
sepp_nepp	7:3a1115c2556b	858	status \|= VL53L0X_write_byte( 0xFF, 0x06);
sepp_nepp	7:3a1115c2556b	859	status \|= VL53L0X_read_byte( 0x83, &byte);
sepp_nepp	7:3a1115c2556b	860	status \|= VL53L0X_write_byte( 0x83, byte & 0xfb);
sepp_nepp	7:3a1115c2556b	861	status \|= VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	862	status \|= VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	863
sepp_nepp	7:3a1115c2556b	864	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	7:3a1115c2556b	865	status \|= VL53L0X_write_byte( 0x80, 0x00);
sepp_nepp	6:fb11b746ceb5	866	}
sepp_nepp	6:fb11b746ceb5	867
sepp_nepp	6:fb11b746ceb5	868	if ((status == VL53L0X_ERROR_NONE) &&
sepp_nepp	6:fb11b746ceb5	869	(read_data_from_device_done != 7)) {
sepp_nepp	6:fb11b746ceb5	870	/* Assign to variable if status is ok */
sepp_nepp	6:fb11b746ceb5	871	if (((option & 1) == 1) &&
sepp_nepp	6:fb11b746ceb5	872	((read_data_from_device_done & 1) == 0)) {
sepp_nepp	8:2fd7cb217068	873	Data.ReferenceSpadCount = reference_spad_count;
sepp_nepp	8:2fd7cb217068	874	Data.ReferenceSpadType = reference_spad_type;
sepp_nepp	6:fb11b746ceb5	875
sepp_nepp	6:fb11b746ceb5	876	for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
sepp_nepp	11:d8dbe3b87f9f	877	Data.RefGoodSpadMap[i] =
sepp_nepp	6:fb11b746ceb5	878	nvm_ref_good_spad_map[i];
sepp_nepp	6:fb11b746ceb5	879	}
sepp_nepp	6:fb11b746ceb5	880	}
sepp_nepp	6:fb11b746ceb5	881
sepp_nepp	6:fb11b746ceb5	882	if (((option & 2) == 2) &&
sepp_nepp	6:fb11b746ceb5	883	((read_data_from_device_done & 2) == 0)) {
sepp_nepp	8:2fd7cb217068	884	Data.ModuleId = module_id;
sepp_nepp	8:2fd7cb217068	885	Data.Revision = revision;
sepp_nepp	8:2fd7cb217068	886	product_id_tmp = Data.ProductId;
sepp_nepp	6:fb11b746ceb5	887	VL53L0X_COPYSTRING(product_id_tmp, product_id);
sepp_nepp	6:fb11b746ceb5	888	}
sepp_nepp	6:fb11b746ceb5	889
sepp_nepp	6:fb11b746ceb5	890	if (((option & 4) == 4) &&
sepp_nepp	6:fb11b746ceb5	891	((read_data_from_device_done & 4) == 0)) {
sepp_nepp	8:2fd7cb217068	892	Data.PartUIDUpper = part_uid_upper;
sepp_nepp	8:2fd7cb217068	893	Data.PartUIDLower = part_uid_lower;
sepp_nepp	6:fb11b746ceb5	894	signal_rate_meas_fixed400_mm_fix =
sepp_nepp	11:d8dbe3b87f9f	895	VL53L0X_FP97TOFP1616(signal_rate_meas_fixed1104_400_mm);
sepp_nepp	8:2fd7cb217068	896	Data.SignalRateMeasFixed400mm = signal_rate_meas_fixed400_mm_fix;
sepp_nepp	6:fb11b746ceb5	897
sepp_nepp	6:fb11b746ceb5	898	offset_micro_meters = 0;
sepp_nepp	6:fb11b746ceb5	899	if (dist_meas_fixed1104_400_mm != 0) {
sepp_nepp	6:fb11b746ceb5	900	offset_fixed1104_mm =
sepp_nepp	6:fb11b746ceb5	901	dist_meas_fixed1104_400_mm -
sepp_nepp	6:fb11b746ceb5	902	dist_meas_tgt_fixed1104_mm;
sepp_nepp	6:fb11b746ceb5	903	offset_micro_meters = (offset_fixed1104_mm
sepp_nepp	6:fb11b746ceb5	904	* 1000) >> 4;
sepp_nepp	6:fb11b746ceb5	905	offset_micro_meters *= -1;
sepp_nepp	6:fb11b746ceb5	906	}
sepp_nepp	6:fb11b746ceb5	907
sepp_nepp	11:d8dbe3b87f9f	908	Data.Part2PartOffsetAdjustNVM_um = offset_micro_meters;
sepp_nepp	6:fb11b746ceb5	909	}
sepp_nepp	6:fb11b746ceb5	910	byte = (uint8_t)(read_data_from_device_done \| option);
sepp_nepp	8:2fd7cb217068	911	Data.ReadDataFromDeviceDone = byte;
sepp_nepp	6:fb11b746ceb5	912	}
sepp_nepp	6:fb11b746ceb5	913	return status;
sepp_nepp	6:fb11b746ceb5	914	}
sepp_nepp	6:fb11b746ceb5	915
sepp_nepp	8:2fd7cb217068	916	VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_offset_calibration_data_micro_meter(int32_t *p_offset_calibration_data_micro_meter)
sepp_nepp	8:2fd7cb217068	917	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	918	uint16_t range_offset_register;
sepp_nepp	6:fb11b746ceb5	919	int16_t c_max_offset = 2047;
sepp_nepp	6:fb11b746ceb5	920	int16_t c_offset_range = 4096;
sepp_nepp	6:fb11b746ceb5	921
sepp_nepp	6:fb11b746ceb5	922	/* Note that offset has 10.2 format */
sepp_nepp	6:fb11b746ceb5	923
sepp_nepp	8:2fd7cb217068	924	status = VL53L0X_read_word(VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
sepp_nepp	6:fb11b746ceb5	925	&range_offset_register);
sepp_nepp	6:fb11b746ceb5	926
sepp_nepp	6:fb11b746ceb5	927	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	928	range_offset_register = (range_offset_register & 0x0fff);
sepp_nepp	6:fb11b746ceb5	929
sepp_nepp	6:fb11b746ceb5	930	/* Apply 12 bit 2's compliment conversion */
sepp_nepp	6:fb11b746ceb5	931	if (range_offset_register > c_max_offset) {
sepp_nepp	6:fb11b746ceb5	932	*p_offset_calibration_data_micro_meter =
sepp_nepp	6:fb11b746ceb5	933	(int16_t)(range_offset_register - c_offset_range)
sepp_nepp	6:fb11b746ceb5	934	* 250;
sepp_nepp	6:fb11b746ceb5	935	} else {
sepp_nepp	6:fb11b746ceb5	936	*p_offset_calibration_data_micro_meter =
sepp_nepp	6:fb11b746ceb5	937	(int16_t)range_offset_register * 250;
sepp_nepp	6:fb11b746ceb5	938	}
sepp_nepp	6:fb11b746ceb5	939
sepp_nepp	6:fb11b746ceb5	940	}
sepp_nepp	6:fb11b746ceb5	941
sepp_nepp	6:fb11b746ceb5	942	return status;
sepp_nepp	6:fb11b746ceb5	943	}
sepp_nepp	6:fb11b746ceb5	944
sepp_nepp	8:2fd7cb217068	945	VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(int32_t *p_offset_calibration_data_micro_meter)
sepp_nepp	8:2fd7cb217068	946	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	947
sepp_nepp	6:fb11b746ceb5	948
sepp_nepp	8:2fd7cb217068	949	status = wrapped_VL53L0X_get_offset_calibration_data_micro_meter(p_offset_calibration_data_micro_meter);
sepp_nepp	6:fb11b746ceb5	950
sepp_nepp	6:fb11b746ceb5	951
sepp_nepp	6:fb11b746ceb5	952	return status;
sepp_nepp	6:fb11b746ceb5	953	}
sepp_nepp	6:fb11b746ceb5	954
sepp_nepp	8:2fd7cb217068	955	VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_offset_calibration_data_micro_meter(int32_t offset_calibration_data_micro_meter)
sepp_nepp	8:2fd7cb217068	956	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	957	int32_t c_max_offset_micro_meter = 511000;
sepp_nepp	6:fb11b746ceb5	958	int32_t c_min_offset_micro_meter = -512000;
sepp_nepp	6:fb11b746ceb5	959	int16_t c_offset_range = 4096;
sepp_nepp	6:fb11b746ceb5	960	uint32_t encoded_offset_val;
sepp_nepp	6:fb11b746ceb5	961
sepp_nepp	6:fb11b746ceb5	962
sepp_nepp	6:fb11b746ceb5	963
sepp_nepp	6:fb11b746ceb5	964	if (offset_calibration_data_micro_meter > c_max_offset_micro_meter) {
sepp_nepp	6:fb11b746ceb5	965	offset_calibration_data_micro_meter = c_max_offset_micro_meter;
sepp_nepp	6:fb11b746ceb5	966	} else {
sepp_nepp	6:fb11b746ceb5	967	if (offset_calibration_data_micro_meter < c_min_offset_micro_meter) {
sepp_nepp	6:fb11b746ceb5	968	offset_calibration_data_micro_meter = c_min_offset_micro_meter;
sepp_nepp	6:fb11b746ceb5	969	}
sepp_nepp	6:fb11b746ceb5	970	}
sepp_nepp	6:fb11b746ceb5	971
sepp_nepp	6:fb11b746ceb5	972	/* The offset register is 10.2 format and units are mm
sepp_nepp	6:fb11b746ceb5	973	* therefore conversion is applied by a division of
sepp_nepp	6:fb11b746ceb5	974	* 250.
sepp_nepp	6:fb11b746ceb5	975	*/
sepp_nepp	6:fb11b746ceb5	976	if (offset_calibration_data_micro_meter >= 0) {
sepp_nepp	6:fb11b746ceb5	977	encoded_offset_val =
sepp_nepp	6:fb11b746ceb5	978	offset_calibration_data_micro_meter / 250;
sepp_nepp	6:fb11b746ceb5	979	} else {
sepp_nepp	6:fb11b746ceb5	980	encoded_offset_val =
sepp_nepp	6:fb11b746ceb5	981	c_offset_range +
sepp_nepp	6:fb11b746ceb5	982	offset_calibration_data_micro_meter / 250;
sepp_nepp	6:fb11b746ceb5	983	}
sepp_nepp	6:fb11b746ceb5	984
sepp_nepp	8:2fd7cb217068	985	status = VL53L0X_write_word(VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
sepp_nepp	6:fb11b746ceb5	986	encoded_offset_val);
sepp_nepp	6:fb11b746ceb5	987
sepp_nepp	6:fb11b746ceb5	988
sepp_nepp	6:fb11b746ceb5	989	return status;
sepp_nepp	6:fb11b746ceb5	990	}
sepp_nepp	6:fb11b746ceb5	991
sepp_nepp	8:2fd7cb217068	992	VL53L0X_Error VL53L0X::VL53L0X_set_offset_calibration_data_micro_meter(int32_t offset_calibration_data_micro_meter)
sepp_nepp	8:2fd7cb217068	993	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	994
sepp_nepp	6:fb11b746ceb5	995
sepp_nepp	8:2fd7cb217068	996	status = wrapped_VL53L0X_set_offset_calibration_data_micro_meter(offset_calibration_data_micro_meter);
sepp_nepp	6:fb11b746ceb5	997
sepp_nepp	6:fb11b746ceb5	998
sepp_nepp	6:fb11b746ceb5	999	return status;
sepp_nepp	6:fb11b746ceb5	1000	}
sepp_nepp	6:fb11b746ceb5	1001
sepp_nepp	7:3a1115c2556b	1002	VL53L0X_Error VL53L0X::VL53L0X_apply_offset_adjustment(void)
sepp_nepp	8:2fd7cb217068	1003	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1004	int32_t corrected_offset_micro_meters;
sepp_nepp	6:fb11b746ceb5	1005	int32_t current_offset_micro_meters;
sepp_nepp	6:fb11b746ceb5	1006
sepp_nepp	8:2fd7cb217068	1007	/* if we run on this function we can read all the NVM info used by the API */
sepp_nepp	7:3a1115c2556b	1008	status = VL53L0X_get_info_from_device( 7);
sepp_nepp	6:fb11b746ceb5	1009
sepp_nepp	6:fb11b746ceb5	1010	/* Read back current device offset */
sepp_nepp	6:fb11b746ceb5	1011	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1012	status = VL53L0X_get_offset_calibration_data_micro_meter(&current_offset_micro_meters);
sepp_nepp	6:fb11b746ceb5	1013	}
sepp_nepp	6:fb11b746ceb5	1014
sepp_nepp	6:fb11b746ceb5	1015	/* Apply Offset Adjustment derived from 400mm measurements */
sepp_nepp	6:fb11b746ceb5	1016	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1017
sepp_nepp	6:fb11b746ceb5	1018	/* Store initial device offset */
sepp_nepp	11:d8dbe3b87f9f	1019	Data.Part2PartOffsetNVM_um = current_offset_micro_meters;
sepp_nepp	6:fb11b746ceb5	1020
sepp_nepp	6:fb11b746ceb5	1021	corrected_offset_micro_meters = current_offset_micro_meters +
sepp_nepp	11:d8dbe3b87f9f	1022	(int32_t)Data.Part2PartOffsetAdjustNVM_um;
sepp_nepp	8:2fd7cb217068	1023
sepp_nepp	8:2fd7cb217068	1024	status = VL53L0X_set_offset_calibration_data_micro_meter(corrected_offset_micro_meters);
sepp_nepp	6:fb11b746ceb5	1025
sepp_nepp	6:fb11b746ceb5	1026	/* store current, adjusted offset */
sepp_nepp	6:fb11b746ceb5	1027	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1028	CurrentParameters.RangeOffset_um = corrected_offset_micro_meters;
sepp_nepp	6:fb11b746ceb5	1029	}
sepp_nepp	6:fb11b746ceb5	1030	}
sepp_nepp	6:fb11b746ceb5	1031
sepp_nepp	6:fb11b746ceb5	1032	return status;
sepp_nepp	6:fb11b746ceb5	1033	}
sepp_nepp	6:fb11b746ceb5	1034
sepp_nepp	8:2fd7cb217068	1035	VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(VL53L0X_DeviceModes *p_device_mode)
sepp_nepp	8:2fd7cb217068	1036	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1037
sepp_nepp	6:fb11b746ceb5	1038
sepp_nepp	10:cd1758e186a4	1039	*p_device_mode = CurrentParameters.DeviceMode ;
sepp_nepp	6:fb11b746ceb5	1040
sepp_nepp	6:fb11b746ceb5	1041
sepp_nepp	6:fb11b746ceb5	1042	return status;
sepp_nepp	6:fb11b746ceb5	1043	}
sepp_nepp	6:fb11b746ceb5	1044
sepp_nepp	11:d8dbe3b87f9f	1045	VL53L0X_Error VL53L0X::VL53L0X_get_inter_measurement_period_ms(uint32_t *p_inter_measurement_period_ms)
sepp_nepp	8:2fd7cb217068	1046	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1047	uint16_t osc_calibrate_val;
sepp_nepp	11:d8dbe3b87f9f	1048	uint32_t im_period_ms;
sepp_nepp	6:fb11b746ceb5	1049
sepp_nepp	6:fb11b746ceb5	1050
sepp_nepp	6:fb11b746ceb5	1051
sepp_nepp	7:3a1115c2556b	1052	status = VL53L0X_read_word( VL53L0X_REG_OSC_CALIBRATE_VAL,
sepp_nepp	6:fb11b746ceb5	1053	&osc_calibrate_val);
sepp_nepp	6:fb11b746ceb5	1054
sepp_nepp	6:fb11b746ceb5	1055	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1056	status = VL53L0X_read_dword(VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
sepp_nepp	11:d8dbe3b87f9f	1057	&im_period_ms);
sepp_nepp	6:fb11b746ceb5	1058	}
sepp_nepp	6:fb11b746ceb5	1059
sepp_nepp	6:fb11b746ceb5	1060	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1061	if (osc_calibrate_val != 0) {
sepp_nepp	11:d8dbe3b87f9f	1062	*p_inter_measurement_period_ms =
sepp_nepp	11:d8dbe3b87f9f	1063	im_period_ms / osc_calibrate_val;
sepp_nepp	6:fb11b746ceb5	1064	}
sepp_nepp	11:d8dbe3b87f9f	1065	CurrentParameters.InterMeasurementPeriod_ms = *p_inter_measurement_period_ms;
sepp_nepp	6:fb11b746ceb5	1066	}
sepp_nepp	6:fb11b746ceb5	1067
sepp_nepp	6:fb11b746ceb5	1068
sepp_nepp	6:fb11b746ceb5	1069	return status;
sepp_nepp	6:fb11b746ceb5	1070	}
sepp_nepp	6:fb11b746ceb5	1071
sepp_nepp	11:d8dbe3b87f9f	1072	VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_rate_MHz(FixPoint1616_t *p_xtalk_compensation_rate_MHz)
sepp_nepp	8:2fd7cb217068	1073	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1074	uint16_t value;
sepp_nepp	6:fb11b746ceb5	1075	FixPoint1616_t temp_fix1616;
sepp_nepp	6:fb11b746ceb5	1076
sepp_nepp	6:fb11b746ceb5	1077
sepp_nepp	6:fb11b746ceb5	1078
sepp_nepp	11:d8dbe3b87f9f	1079	status = VL53L0X_read_word(VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MHz, (uint16_t *)&value);
sepp_nepp	6:fb11b746ceb5	1080	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1081	if (value == 0) {
sepp_nepp	6:fb11b746ceb5	1082	/* the Xtalk is disabled return value from memory */
sepp_nepp	11:d8dbe3b87f9f	1083	temp_fix1616 = CurrentParameters.XTalkCompensationRate_MHz ;
sepp_nepp	11:d8dbe3b87f9f	1084	*p_xtalk_compensation_rate_MHz = temp_fix1616;
sepp_nepp	10:cd1758e186a4	1085	CurrentParameters.XTalkCompensationEnable = 0;
sepp_nepp	6:fb11b746ceb5	1086	} else {
sepp_nepp	11:d8dbe3b87f9f	1087	temp_fix1616 = VL53L0X_FP313TOFP1616(value);
sepp_nepp	11:d8dbe3b87f9f	1088	*p_xtalk_compensation_rate_MHz = temp_fix1616;
sepp_nepp	11:d8dbe3b87f9f	1089	CurrentParameters.XTalkCompensationRate_MHz = temp_fix1616;
sepp_nepp	10:cd1758e186a4	1090	CurrentParameters.XTalkCompensationEnable = 1;
sepp_nepp	6:fb11b746ceb5	1091	}
sepp_nepp	6:fb11b746ceb5	1092	}
sepp_nepp	6:fb11b746ceb5	1093
sepp_nepp	6:fb11b746ceb5	1094
sepp_nepp	6:fb11b746ceb5	1095	return status;
sepp_nepp	6:fb11b746ceb5	1096	}
sepp_nepp	6:fb11b746ceb5	1097
sepp_nepp	7:3a1115c2556b	1098	VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_value( uint16_t limit_check_id,
sepp_nepp	6:fb11b746ceb5	1099	FixPoint1616_t *p_limit_check_value)
sepp_nepp	8:2fd7cb217068	1100	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1101	uint8_t enable_zero_value = 0;
sepp_nepp	6:fb11b746ceb5	1102	uint16_t temp16;
sepp_nepp	6:fb11b746ceb5	1103	FixPoint1616_t temp_fix1616;
sepp_nepp	6:fb11b746ceb5	1104
sepp_nepp	6:fb11b746ceb5	1105
sepp_nepp	6:fb11b746ceb5	1106
sepp_nepp	6:fb11b746ceb5	1107	switch (limit_check_id) {
sepp_nepp	6:fb11b746ceb5	1108
sepp_nepp	6:fb11b746ceb5	1109	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	1110	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1111	temp_fix1616 = CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE];
sepp_nepp	6:fb11b746ceb5	1112	enable_zero_value = 0;
sepp_nepp	6:fb11b746ceb5	1113	break;
sepp_nepp	6:fb11b746ceb5	1114
sepp_nepp	6:fb11b746ceb5	1115	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
sepp_nepp	8:2fd7cb217068	1116	status = VL53L0X_read_word(VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
sepp_nepp	6:fb11b746ceb5	1117	&temp16);
sepp_nepp	6:fb11b746ceb5	1118	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1119	temp_fix1616 = VL53L0X_FP97TOFP1616(temp16);
sepp_nepp	6:fb11b746ceb5	1120	}
sepp_nepp	6:fb11b746ceb5	1121
sepp_nepp	6:fb11b746ceb5	1122	enable_zero_value = 1;
sepp_nepp	6:fb11b746ceb5	1123	break;
sepp_nepp	6:fb11b746ceb5	1124
sepp_nepp	6:fb11b746ceb5	1125	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
sepp_nepp	6:fb11b746ceb5	1126	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1127	temp_fix1616 = CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP];
sepp_nepp	6:fb11b746ceb5	1128	enable_zero_value = 0;
sepp_nepp	6:fb11b746ceb5	1129	break;
sepp_nepp	6:fb11b746ceb5	1130
sepp_nepp	6:fb11b746ceb5	1131	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
sepp_nepp	6:fb11b746ceb5	1132	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1133	temp_fix1616 = CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD];
sepp_nepp	6:fb11b746ceb5	1134	enable_zero_value = 0;
sepp_nepp	6:fb11b746ceb5	1135	break;
sepp_nepp	6:fb11b746ceb5	1136
sepp_nepp	6:fb11b746ceb5	1137	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
sepp_nepp	6:fb11b746ceb5	1138	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
sepp_nepp	8:2fd7cb217068	1139	status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
sepp_nepp	6:fb11b746ceb5	1140	&temp16);
sepp_nepp	6:fb11b746ceb5	1141	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1142	temp_fix1616 = VL53L0X_FP97TOFP1616(temp16);
sepp_nepp	6:fb11b746ceb5	1143	}
sepp_nepp	6:fb11b746ceb5	1144
sepp_nepp	6:fb11b746ceb5	1145	enable_zero_value = 0;
sepp_nepp	6:fb11b746ceb5	1146	break;
sepp_nepp	6:fb11b746ceb5	1147
sepp_nepp	6:fb11b746ceb5	1148	default:
sepp_nepp	6:fb11b746ceb5	1149	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1150
sepp_nepp	6:fb11b746ceb5	1151	}
sepp_nepp	6:fb11b746ceb5	1152
sepp_nepp	6:fb11b746ceb5	1153	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1154
sepp_nepp	6:fb11b746ceb5	1155	if (enable_zero_value == 1) {
sepp_nepp	6:fb11b746ceb5	1156
sepp_nepp	6:fb11b746ceb5	1157	if (temp_fix1616 == 0) {
sepp_nepp	6:fb11b746ceb5	1158	/* disabled: return value from memory */
sepp_nepp	10:cd1758e186a4	1159	temp_fix1616 = CurrentParameters.LimitChecksValue[limit_check_id];
sepp_nepp	6:fb11b746ceb5	1160	*p_limit_check_value = temp_fix1616;
sepp_nepp	10:cd1758e186a4	1161	CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
sepp_nepp	6:fb11b746ceb5	1162	} else {
sepp_nepp	6:fb11b746ceb5	1163	*p_limit_check_value = temp_fix1616;
sepp_nepp	10:cd1758e186a4	1164	CurrentParameters.LimitChecksValue[limit_check_id] = temp_fix1616;
sepp_nepp	10:cd1758e186a4	1165	CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
sepp_nepp	6:fb11b746ceb5	1166	}
sepp_nepp	6:fb11b746ceb5	1167	} else {
sepp_nepp	6:fb11b746ceb5	1168	*p_limit_check_value = temp_fix1616;
sepp_nepp	6:fb11b746ceb5	1169	}
sepp_nepp	6:fb11b746ceb5	1170	}
sepp_nepp	6:fb11b746ceb5	1171
sepp_nepp	6:fb11b746ceb5	1172
sepp_nepp	6:fb11b746ceb5	1173	return status;
sepp_nepp	6:fb11b746ceb5	1174
sepp_nepp	6:fb11b746ceb5	1175	}
sepp_nepp	6:fb11b746ceb5	1176
sepp_nepp	7:3a1115c2556b	1177	VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_enable( uint16_t limit_check_id,
sepp_nepp	6:fb11b746ceb5	1178	uint8_t *p_limit_check_enable)
sepp_nepp	8:2fd7cb217068	1179	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1180	uint8_t temp8;
sepp_nepp	6:fb11b746ceb5	1181
sepp_nepp	6:fb11b746ceb5	1182
sepp_nepp	6:fb11b746ceb5	1183
sepp_nepp	6:fb11b746ceb5	1184	if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
sepp_nepp	6:fb11b746ceb5	1185	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1186	*p_limit_check_enable = 0;
sepp_nepp	6:fb11b746ceb5	1187	} else {
sepp_nepp	10:cd1758e186a4	1188	temp8 = CurrentParameters.LimitChecksEnable[limit_check_id];
sepp_nepp	6:fb11b746ceb5	1189	*p_limit_check_enable = temp8;
sepp_nepp	6:fb11b746ceb5	1190	}
sepp_nepp	6:fb11b746ceb5	1191
sepp_nepp	6:fb11b746ceb5	1192
sepp_nepp	6:fb11b746ceb5	1193	return status;
sepp_nepp	6:fb11b746ceb5	1194	}
sepp_nepp	6:fb11b746ceb5	1195
sepp_nepp	8:2fd7cb217068	1196	VL53L0X_Error VL53L0X::VL53L0X_get_wrap_around_check_enable(uint8_t *p_wrap_around_check_enable)
sepp_nepp	8:2fd7cb217068	1197	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1198	uint8_t data;
sepp_nepp	6:fb11b746ceb5	1199
sepp_nepp	6:fb11b746ceb5	1200
sepp_nepp	6:fb11b746ceb5	1201
sepp_nepp	7:3a1115c2556b	1202	status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
sepp_nepp	6:fb11b746ceb5	1203	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1204	Data.SequenceConfig = data;
sepp_nepp	6:fb11b746ceb5	1205	if (data & (0x01 << 7)) {
sepp_nepp	6:fb11b746ceb5	1206	*p_wrap_around_check_enable = 0x01;
sepp_nepp	6:fb11b746ceb5	1207	} else {
sepp_nepp	6:fb11b746ceb5	1208	*p_wrap_around_check_enable = 0x00;
sepp_nepp	6:fb11b746ceb5	1209	}
sepp_nepp	6:fb11b746ceb5	1210	}
sepp_nepp	6:fb11b746ceb5	1211	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	10:cd1758e186a4	1212	CurrentParameters.WrapAroundCheckEnable = *p_wrap_around_check_enable;
sepp_nepp	6:fb11b746ceb5	1213	}
sepp_nepp	6:fb11b746ceb5	1214
sepp_nepp	6:fb11b746ceb5	1215
sepp_nepp	6:fb11b746ceb5	1216	return status;
sepp_nepp	6:fb11b746ceb5	1217	}
sepp_nepp	6:fb11b746ceb5	1218
sepp_nepp	8:2fd7cb217068	1219	VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
sepp_nepp	6:fb11b746ceb5	1220	uint8_t *p_sequence_step_enabled)
sepp_nepp	8:2fd7cb217068	1221	{ VL53L0X_Error Status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1222	*p_sequence_step_enabled = 0;
sepp_nepp	6:fb11b746ceb5	1223
sepp_nepp	6:fb11b746ceb5	1224
sepp_nepp	6:fb11b746ceb5	1225	switch (sequence_step_id) {
sepp_nepp	6:fb11b746ceb5	1226	case VL53L0X_SEQUENCESTEP_TCC:
sepp_nepp	6:fb11b746ceb5	1227	*p_sequence_step_enabled = (sequence_config & 0x10) >> 4;
sepp_nepp	6:fb11b746ceb5	1228	break;
sepp_nepp	6:fb11b746ceb5	1229	case VL53L0X_SEQUENCESTEP_DSS:
sepp_nepp	6:fb11b746ceb5	1230	*p_sequence_step_enabled = (sequence_config & 0x08) >> 3;
sepp_nepp	6:fb11b746ceb5	1231	break;
sepp_nepp	6:fb11b746ceb5	1232	case VL53L0X_SEQUENCESTEP_MSRC:
sepp_nepp	6:fb11b746ceb5	1233	*p_sequence_step_enabled = (sequence_config & 0x04) >> 2;
sepp_nepp	6:fb11b746ceb5	1234	break;
sepp_nepp	6:fb11b746ceb5	1235	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
sepp_nepp	6:fb11b746ceb5	1236	*p_sequence_step_enabled = (sequence_config & 0x40) >> 6;
sepp_nepp	6:fb11b746ceb5	1237	break;
sepp_nepp	6:fb11b746ceb5	1238	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	1239	*p_sequence_step_enabled = (sequence_config & 0x80) >> 7;
sepp_nepp	6:fb11b746ceb5	1240	break;
sepp_nepp	6:fb11b746ceb5	1241	default:
sepp_nepp	6:fb11b746ceb5	1242	Status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1243	}
sepp_nepp	6:fb11b746ceb5	1244
sepp_nepp	6:fb11b746ceb5	1245
sepp_nepp	6:fb11b746ceb5	1246	return Status;
sepp_nepp	6:fb11b746ceb5	1247	}
sepp_nepp	6:fb11b746ceb5	1248
sepp_nepp	8:2fd7cb217068	1249	VL53L0X_Error VL53L0X::VL53L0X_get_sequence_step_enables(VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
sepp_nepp	8:2fd7cb217068	1250	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1251	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	1252
sepp_nepp	6:fb11b746ceb5	1253
sepp_nepp	7:3a1115c2556b	1254	status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sepp_nepp	6:fb11b746ceb5	1255	&sequence_config);
sepp_nepp	6:fb11b746ceb5	1256
sepp_nepp	6:fb11b746ceb5	1257	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1258	status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_TCC, sequence_config,
sepp_nepp	6:fb11b746ceb5	1259	&p_scheduler_sequence_steps->TccOn);
sepp_nepp	6:fb11b746ceb5	1260	}
sepp_nepp	6:fb11b746ceb5	1261	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1262	status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_DSS, sequence_config,
sepp_nepp	6:fb11b746ceb5	1263	&p_scheduler_sequence_steps->DssOn);
sepp_nepp	6:fb11b746ceb5	1264	}
sepp_nepp	6:fb11b746ceb5	1265	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1266	status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
sepp_nepp	6:fb11b746ceb5	1267	&p_scheduler_sequence_steps->MsrcOn);
sepp_nepp	6:fb11b746ceb5	1268	}
sepp_nepp	6:fb11b746ceb5	1269	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1270	status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
sepp_nepp	6:fb11b746ceb5	1271	&p_scheduler_sequence_steps->PreRangeOn);
sepp_nepp	6:fb11b746ceb5	1272	}
sepp_nepp	6:fb11b746ceb5	1273	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1274	status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
sepp_nepp	6:fb11b746ceb5	1275	&p_scheduler_sequence_steps->FinalRangeOn);
sepp_nepp	6:fb11b746ceb5	1276	}
sepp_nepp	6:fb11b746ceb5	1277
sepp_nepp	6:fb11b746ceb5	1278
sepp_nepp	6:fb11b746ceb5	1279	return status;
sepp_nepp	6:fb11b746ceb5	1280	}
sepp_nepp	6:fb11b746ceb5	1281
sepp_nepp	6:fb11b746ceb5	1282	uint8_t VL53L0X::VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg)
sepp_nepp	8:2fd7cb217068	1283	{ /*!
sepp_nepp	6:fb11b746ceb5	1284	* Converts the encoded VCSEL period register value into the real
sepp_nepp	6:fb11b746ceb5	1285	* period in PLL clocks
sepp_nepp	6:fb11b746ceb5	1286	*/
sepp_nepp	6:fb11b746ceb5	1287
sepp_nepp	6:fb11b746ceb5	1288	uint8_t vcsel_period_pclks = 0;
sepp_nepp	6:fb11b746ceb5	1289
sepp_nepp	6:fb11b746ceb5	1290	vcsel_period_pclks = (vcsel_period_reg + 1) << 1;
sepp_nepp	6:fb11b746ceb5	1291
sepp_nepp	6:fb11b746ceb5	1292	return vcsel_period_pclks;
sepp_nepp	6:fb11b746ceb5	1293	}
sepp_nepp	6:fb11b746ceb5	1294
sepp_nepp	6:fb11b746ceb5	1295	uint8_t VL53L0X::lv53l0x_encode_vcsel_period(uint8_t vcsel_period_pclks)
sepp_nepp	8:2fd7cb217068	1296	{ /*!
sepp_nepp	6:fb11b746ceb5	1297	* Converts the encoded VCSEL period register value into the real period
sepp_nepp	6:fb11b746ceb5	1298	* in PLL clocks
sepp_nepp	6:fb11b746ceb5	1299	*/
sepp_nepp	6:fb11b746ceb5	1300
sepp_nepp	6:fb11b746ceb5	1301	uint8_t vcsel_period_reg = 0;
sepp_nepp	6:fb11b746ceb5	1302
sepp_nepp	6:fb11b746ceb5	1303	vcsel_period_reg = (vcsel_period_pclks >> 1) - 1;
sepp_nepp	6:fb11b746ceb5	1304
sepp_nepp	6:fb11b746ceb5	1305	return vcsel_period_reg;
sepp_nepp	6:fb11b746ceb5	1306	}
sepp_nepp	6:fb11b746ceb5	1307
sepp_nepp	8:2fd7cb217068	1308	VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk)
sepp_nepp	8:2fd7cb217068	1309	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1310	uint8_t vcsel_period_reg;
sepp_nepp	6:fb11b746ceb5	1311	uint8_t min_pre_vcsel_period_pclk = 12;
sepp_nepp	6:fb11b746ceb5	1312	uint8_t max_pre_vcsel_period_pclk = 18;
sepp_nepp	6:fb11b746ceb5	1313	uint8_t min_final_vcsel_period_pclk = 8;
sepp_nepp	6:fb11b746ceb5	1314	uint8_t max_final_vcsel_period_pclk = 14;
sepp_nepp	11:d8dbe3b87f9f	1315	uint32_t measurement_timing_budget_us;
sepp_nepp	11:d8dbe3b87f9f	1316	uint32_t final_range_timeout_us;
sepp_nepp	11:d8dbe3b87f9f	1317	uint32_t pre_range_timeout_us;
sepp_nepp	11:d8dbe3b87f9f	1318	uint32_t msrc_timeout_us;
sepp_nepp	6:fb11b746ceb5	1319	uint8_t phase_cal_int = 0;
sepp_nepp	6:fb11b746ceb5	1320
sepp_nepp	6:fb11b746ceb5	1321	/* Check if valid clock period requested */
sepp_nepp	6:fb11b746ceb5	1322
sepp_nepp	6:fb11b746ceb5	1323	if ((vcsel_pulse_period_pclk % 2) != 0) {
sepp_nepp	6:fb11b746ceb5	1324	/* Value must be an even number */
sepp_nepp	6:fb11b746ceb5	1325	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1326	} else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
sepp_nepp	6:fb11b746ceb5	1327	(vcsel_pulse_period_pclk < min_pre_vcsel_period_pclk \|\|
sepp_nepp	6:fb11b746ceb5	1328	vcsel_pulse_period_pclk > max_pre_vcsel_period_pclk)) {
sepp_nepp	6:fb11b746ceb5	1329	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1330	} else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
sepp_nepp	6:fb11b746ceb5	1331	(vcsel_pulse_period_pclk < min_final_vcsel_period_pclk \|\|
sepp_nepp	6:fb11b746ceb5	1332	vcsel_pulse_period_pclk > max_final_vcsel_period_pclk)) {
sepp_nepp	6:fb11b746ceb5	1333
sepp_nepp	6:fb11b746ceb5	1334	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1335	}
sepp_nepp	6:fb11b746ceb5	1336
sepp_nepp	6:fb11b746ceb5	1337	/* Apply specific settings for the requested clock period */
sepp_nepp	6:fb11b746ceb5	1338
sepp_nepp	6:fb11b746ceb5	1339	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1340	return status;
sepp_nepp	6:fb11b746ceb5	1341	}
sepp_nepp	6:fb11b746ceb5	1342
sepp_nepp	6:fb11b746ceb5	1343	if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
sepp_nepp	6:fb11b746ceb5	1344
sepp_nepp	6:fb11b746ceb5	1345	/* Set phase check limits */
sepp_nepp	6:fb11b746ceb5	1346	if (vcsel_pulse_period_pclk == 12) {
sepp_nepp	6:fb11b746ceb5	1347
sepp_nepp	8:2fd7cb217068	1348	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1349	0x18);
sepp_nepp	8:2fd7cb217068	1350	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
sepp_nepp	6:fb11b746ceb5	1351	0x08);
sepp_nepp	6:fb11b746ceb5	1352	} else if (vcsel_pulse_period_pclk == 14) {
sepp_nepp	6:fb11b746ceb5	1353
sepp_nepp	8:2fd7cb217068	1354	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1355	0x30);
sepp_nepp	8:2fd7cb217068	1356	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
sepp_nepp	6:fb11b746ceb5	1357	0x08);
sepp_nepp	6:fb11b746ceb5	1358	} else if (vcsel_pulse_period_pclk == 16) {
sepp_nepp	6:fb11b746ceb5	1359
sepp_nepp	8:2fd7cb217068	1360	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1361	0x40);
sepp_nepp	8:2fd7cb217068	1362	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
sepp_nepp	6:fb11b746ceb5	1363	0x08);
sepp_nepp	6:fb11b746ceb5	1364	} else if (vcsel_pulse_period_pclk == 18) {
sepp_nepp	6:fb11b746ceb5	1365
sepp_nepp	8:2fd7cb217068	1366	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1367	0x50);
sepp_nepp	8:2fd7cb217068	1368	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
sepp_nepp	6:fb11b746ceb5	1369	0x08);
sepp_nepp	6:fb11b746ceb5	1370	}
sepp_nepp	6:fb11b746ceb5	1371	} else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE) {
sepp_nepp	6:fb11b746ceb5	1372
sepp_nepp	6:fb11b746ceb5	1373	if (vcsel_pulse_period_pclk == 8) {
sepp_nepp	6:fb11b746ceb5	1374
sepp_nepp	11:d8dbe3b87f9f	1375	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,0x10);
sepp_nepp	11:d8dbe3b87f9f	1376	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,0x08);
sepp_nepp	6:fb11b746ceb5	1377
sepp_nepp	8:2fd7cb217068	1378	status \|= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
sepp_nepp	8:2fd7cb217068	1379	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
sepp_nepp	6:fb11b746ceb5	1380
sepp_nepp	7:3a1115c2556b	1381	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	11:d8dbe3b87f9f	1382	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,0x30);
sepp_nepp	7:3a1115c2556b	1383	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	6:fb11b746ceb5	1384	} else if (vcsel_pulse_period_pclk == 10) {
sepp_nepp	6:fb11b746ceb5	1385
sepp_nepp	11:d8dbe3b87f9f	1386	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,0x28);
sepp_nepp	11:d8dbe3b87f9f	1387	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,0x08);
sepp_nepp	6:fb11b746ceb5	1388
sepp_nepp	8:2fd7cb217068	1389	status \|= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
sepp_nepp	8:2fd7cb217068	1390	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
sepp_nepp	6:fb11b746ceb5	1391
sepp_nepp	7:3a1115c2556b	1392	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	11:d8dbe3b87f9f	1393	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,0x20);
sepp_nepp	7:3a1115c2556b	1394	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	6:fb11b746ceb5	1395	} else if (vcsel_pulse_period_pclk == 12) {
sepp_nepp	6:fb11b746ceb5	1396
sepp_nepp	8:2fd7cb217068	1397	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1398	0x38);
sepp_nepp	8:2fd7cb217068	1399	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
sepp_nepp	6:fb11b746ceb5	1400	0x08);
sepp_nepp	6:fb11b746ceb5	1401
sepp_nepp	8:2fd7cb217068	1402	status \|= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
sepp_nepp	8:2fd7cb217068	1403	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
sepp_nepp	6:fb11b746ceb5	1404
sepp_nepp	7:3a1115c2556b	1405	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	8:2fd7cb217068	1406	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,
sepp_nepp	6:fb11b746ceb5	1407	0x20);
sepp_nepp	7:3a1115c2556b	1408	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	6:fb11b746ceb5	1409	} else if (vcsel_pulse_period_pclk == 14) {
sepp_nepp	6:fb11b746ceb5	1410
sepp_nepp	8:2fd7cb217068	1411	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
sepp_nepp	6:fb11b746ceb5	1412	0x048);
sepp_nepp	11:d8dbe3b87f9f	1413	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,0x08);
sepp_nepp	6:fb11b746ceb5	1414
sepp_nepp	8:2fd7cb217068	1415	status \|= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
sepp_nepp	8:2fd7cb217068	1416	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
sepp_nepp	6:fb11b746ceb5	1417
sepp_nepp	7:3a1115c2556b	1418	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	11:d8dbe3b87f9f	1419	status \|= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,0x20);
sepp_nepp	7:3a1115c2556b	1420	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	6:fb11b746ceb5	1421	}
sepp_nepp	6:fb11b746ceb5	1422	}
sepp_nepp	6:fb11b746ceb5	1423
sepp_nepp	6:fb11b746ceb5	1424	/* Re-calculate and apply timeouts, in macro periods */
sepp_nepp	6:fb11b746ceb5	1425
sepp_nepp	6:fb11b746ceb5	1426	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1427	vcsel_period_reg = lv53l0x_encode_vcsel_period((uint8_t)
sepp_nepp	6:fb11b746ceb5	1428	vcsel_pulse_period_pclk);
sepp_nepp	6:fb11b746ceb5	1429
sepp_nepp	6:fb11b746ceb5	1430	/* When the VCSEL period for the pre or final range is changed,
sepp_nepp	6:fb11b746ceb5	1431	* the corresponding timeout must be read from the device using
sepp_nepp	6:fb11b746ceb5	1432	* the current VCSEL period, then the new VCSEL period can be
sepp_nepp	6:fb11b746ceb5	1433	* applied. The timeout then must be written back to the device
sepp_nepp	6:fb11b746ceb5	1434	* using the new VCSEL period.
sepp_nepp	6:fb11b746ceb5	1435	*
sepp_nepp	6:fb11b746ceb5	1436	* For the MSRC timeout, the same applies - this timeout being
sepp_nepp	6:fb11b746ceb5	1437	* dependant on the pre-range vcsel period.
sepp_nepp	6:fb11b746ceb5	1438	*/
sepp_nepp	6:fb11b746ceb5	1439	switch (vcsel_period_type) {
sepp_nepp	6:fb11b746ceb5	1440	case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
sepp_nepp	8:2fd7cb217068	1441	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1442	&pre_range_timeout_us);
sepp_nepp	6:fb11b746ceb5	1443
sepp_nepp	6:fb11b746ceb5	1444	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	1445	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
sepp_nepp	11:d8dbe3b87f9f	1446	&msrc_timeout_us);
sepp_nepp	6:fb11b746ceb5	1447
sepp_nepp	6:fb11b746ceb5	1448	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	1449	status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
sepp_nepp	6:fb11b746ceb5	1450	vcsel_period_reg);
sepp_nepp	6:fb11b746ceb5	1451
sepp_nepp	6:fb11b746ceb5	1452	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	7:3a1115c2556b	1453	status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1454	pre_range_timeout_us);
sepp_nepp	6:fb11b746ceb5	1455
sepp_nepp	6:fb11b746ceb5	1456	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	7:3a1115c2556b	1457	status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
sepp_nepp	11:d8dbe3b87f9f	1458	msrc_timeout_us);
sepp_nepp	6:fb11b746ceb5	1459
sepp_nepp	8:2fd7cb217068	1460	Data.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
sepp_nepp	6:fb11b746ceb5	1461	break;
sepp_nepp	6:fb11b746ceb5	1462	case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
sepp_nepp	7:3a1115c2556b	1463	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1464	&final_range_timeout_us);
sepp_nepp	6:fb11b746ceb5	1465
sepp_nepp	6:fb11b746ceb5	1466	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	1467	status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
sepp_nepp	6:fb11b746ceb5	1468	vcsel_period_reg);
sepp_nepp	6:fb11b746ceb5	1469
sepp_nepp	6:fb11b746ceb5	1470	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	8:2fd7cb217068	1471	status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1472	final_range_timeout_us);
sepp_nepp	6:fb11b746ceb5	1473
sepp_nepp	8:2fd7cb217068	1474	Data.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
sepp_nepp	6:fb11b746ceb5	1475	break;
sepp_nepp	6:fb11b746ceb5	1476	default:
sepp_nepp	6:fb11b746ceb5	1477	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1478	}
sepp_nepp	6:fb11b746ceb5	1479	}
sepp_nepp	6:fb11b746ceb5	1480
sepp_nepp	6:fb11b746ceb5	1481	/* Finally, the timing budget must be re-applied */
sepp_nepp	6:fb11b746ceb5	1482	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1483	measurement_timing_budget_us = CurrentParameters.MeasurementTimingBudget_us ;
sepp_nepp	11:d8dbe3b87f9f	1484
sepp_nepp	11:d8dbe3b87f9f	1485	status = VL53L0X_set_measurement_timing_budget_us(measurement_timing_budget_us);
sepp_nepp	6:fb11b746ceb5	1486	}
sepp_nepp	6:fb11b746ceb5	1487
sepp_nepp	6:fb11b746ceb5	1488	/* Perform the phase calibration. This is needed after changing on
sepp_nepp	6:fb11b746ceb5	1489	* vcsel period.
sepp_nepp	6:fb11b746ceb5	1490	* get_data_enable = 0, restore_config = 1 */
sepp_nepp	6:fb11b746ceb5	1491	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	7:3a1115c2556b	1492	status = VL53L0X_perform_phase_calibration(&phase_cal_int, 0, 1);
sepp_nepp	6:fb11b746ceb5	1493
sepp_nepp	6:fb11b746ceb5	1494	return status;
sepp_nepp	6:fb11b746ceb5	1495	}
sepp_nepp	6:fb11b746ceb5	1496
sepp_nepp	8:2fd7cb217068	1497	VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
sepp_nepp	8:2fd7cb217068	1498	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1499
sepp_nepp	6:fb11b746ceb5	1500
sepp_nepp	7:3a1115c2556b	1501	status = wrapped_VL53L0X_set_vcsel_pulse_period( vcsel_period_type,
sepp_nepp	6:fb11b746ceb5	1502	vcsel_pulse_period);
sepp_nepp	6:fb11b746ceb5	1503
sepp_nepp	6:fb11b746ceb5	1504
sepp_nepp	6:fb11b746ceb5	1505	return status;
sepp_nepp	6:fb11b746ceb5	1506	}
sepp_nepp	6:fb11b746ceb5	1507
sepp_nepp	8:2fd7cb217068	1508	VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
sepp_nepp	8:2fd7cb217068	1509	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1510	uint8_t vcsel_period_reg;
sepp_nepp	6:fb11b746ceb5	1511
sepp_nepp	6:fb11b746ceb5	1512	switch (vcsel_period_type) {
sepp_nepp	6:fb11b746ceb5	1513	case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
sepp_nepp	8:2fd7cb217068	1514	status = VL53L0X_read_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
sepp_nepp	6:fb11b746ceb5	1515	&vcsel_period_reg);
sepp_nepp	6:fb11b746ceb5	1516	break;
sepp_nepp	6:fb11b746ceb5	1517	case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
sepp_nepp	8:2fd7cb217068	1518	status = VL53L0X_read_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
sepp_nepp	6:fb11b746ceb5	1519	&vcsel_period_reg);
sepp_nepp	6:fb11b746ceb5	1520	break;
sepp_nepp	6:fb11b746ceb5	1521	default:
sepp_nepp	6:fb11b746ceb5	1522	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1523	}
sepp_nepp	6:fb11b746ceb5	1524
sepp_nepp	6:fb11b746ceb5	1525	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	6:fb11b746ceb5	1526	*p_vcsel_pulse_period_pclk =
sepp_nepp	6:fb11b746ceb5	1527	VL53L0X_decode_vcsel_period(vcsel_period_reg);
sepp_nepp	6:fb11b746ceb5	1528
sepp_nepp	6:fb11b746ceb5	1529	return status;
sepp_nepp	6:fb11b746ceb5	1530	}
sepp_nepp	6:fb11b746ceb5	1531
sepp_nepp	8:2fd7cb217068	1532	VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
sepp_nepp	8:2fd7cb217068	1533	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1534
sepp_nepp	6:fb11b746ceb5	1535
sepp_nepp	7:3a1115c2556b	1536	status = wrapped_VL53L0X_get_vcsel_pulse_period( vcsel_period_type,
sepp_nepp	6:fb11b746ceb5	1537	p_vcsel_pulse_period_pclk);
sepp_nepp	6:fb11b746ceb5	1538
sepp_nepp	6:fb11b746ceb5	1539
sepp_nepp	6:fb11b746ceb5	1540	return status;
sepp_nepp	6:fb11b746ceb5	1541	}
sepp_nepp	6:fb11b746ceb5	1542
sepp_nepp	6:fb11b746ceb5	1543	uint32_t VL53L0X::VL53L0X_decode_timeout(uint16_t encoded_timeout)
sepp_nepp	8:2fd7cb217068	1544	{ /*!
sepp_nepp	6:fb11b746ceb5	1545	* Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
sepp_nepp	6:fb11b746ceb5	1546	*/
sepp_nepp	6:fb11b746ceb5	1547
sepp_nepp	6:fb11b746ceb5	1548	uint32_t timeout_macro_clks = 0;
sepp_nepp	6:fb11b746ceb5	1549
sepp_nepp	6:fb11b746ceb5	1550	timeout_macro_clks = ((uint32_t)(encoded_timeout & 0x00FF)
sepp_nepp	6:fb11b746ceb5	1551	<< (uint32_t)((encoded_timeout & 0xFF00) >> 8)) + 1;
sepp_nepp	6:fb11b746ceb5	1552
sepp_nepp	6:fb11b746ceb5	1553	return timeout_macro_clks;
sepp_nepp	6:fb11b746ceb5	1554	}
sepp_nepp	6:fb11b746ceb5	1555
sepp_nepp	7:3a1115c2556b	1556	uint32_t VL53L0X::VL53L0X_calc_macro_period_ps( uint8_t vcsel_period_pclks)
sepp_nepp	8:2fd7cb217068	1557	{ uint64_t pll_period_ps;
sepp_nepp	6:fb11b746ceb5	1558	uint32_t macro_period_vclks;
sepp_nepp	6:fb11b746ceb5	1559	uint32_t macro_period_ps;
sepp_nepp	6:fb11b746ceb5	1560
sepp_nepp	6:fb11b746ceb5	1561
sepp_nepp	6:fb11b746ceb5	1562
sepp_nepp	6:fb11b746ceb5	1563	/* The above calculation will produce rounding errors,
sepp_nepp	6:fb11b746ceb5	1564	therefore set fixed value
sepp_nepp	6:fb11b746ceb5	1565	*/
sepp_nepp	6:fb11b746ceb5	1566	pll_period_ps = 1655;
sepp_nepp	6:fb11b746ceb5	1567
sepp_nepp	6:fb11b746ceb5	1568	macro_period_vclks = 2304;
sepp_nepp	6:fb11b746ceb5	1569	macro_period_ps = (uint32_t)(macro_period_vclks
sepp_nepp	6:fb11b746ceb5	1570	* vcsel_period_pclks * pll_period_ps);
sepp_nepp	6:fb11b746ceb5	1571
sepp_nepp	6:fb11b746ceb5	1572	return macro_period_ps;
sepp_nepp	6:fb11b746ceb5	1573	}
sepp_nepp	6:fb11b746ceb5	1574
sepp_nepp	6:fb11b746ceb5	1575	/* To convert register value into us */
sepp_nepp	8:2fd7cb217068	1576	uint32_t VL53L0X::VL53L0X_calc_timeout_us(uint16_t timeout_period_mclks,
sepp_nepp	6:fb11b746ceb5	1577	uint8_t vcsel_period_pclks)
sepp_nepp	8:2fd7cb217068	1578	{ uint32_t macro_period_ps;
sepp_nepp	6:fb11b746ceb5	1579	uint32_t macro_period_ns;
sepp_nepp	6:fb11b746ceb5	1580	uint32_t actual_timeout_period_us = 0;
sepp_nepp	6:fb11b746ceb5	1581
sepp_nepp	7:3a1115c2556b	1582	macro_period_ps = VL53L0X_calc_macro_period_ps( vcsel_period_pclks);
sepp_nepp	6:fb11b746ceb5	1583	macro_period_ns = (macro_period_ps + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	1584
sepp_nepp	6:fb11b746ceb5	1585	actual_timeout_period_us =
sepp_nepp	6:fb11b746ceb5	1586	((timeout_period_mclks * macro_period_ns) + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	1587
sepp_nepp	6:fb11b746ceb5	1588	return actual_timeout_period_us;
sepp_nepp	6:fb11b746ceb5	1589	}
sepp_nepp	6:fb11b746ceb5	1590
sepp_nepp	8:2fd7cb217068	1591	VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_SequenceStepId sequence_step_id,
sepp_nepp	6:fb11b746ceb5	1592	uint32_t *p_time_out_micro_secs)
sepp_nepp	8:2fd7cb217068	1593	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1594	uint8_t current_vcsel_pulse_period_p_clk;
sepp_nepp	6:fb11b746ceb5	1595	uint8_t encoded_time_out_byte = 0;
sepp_nepp	11:d8dbe3b87f9f	1596	uint32_t timeout_us = 0;
sepp_nepp	6:fb11b746ceb5	1597	uint16_t pre_range_encoded_time_out = 0;
sepp_nepp	6:fb11b746ceb5	1598	uint16_t msrc_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	1599	uint16_t pre_range_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	1600	uint16_t final_range_time_out_m_clks = 0;
sepp_nepp	6:fb11b746ceb5	1601	uint16_t final_range_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	1602	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
sepp_nepp	6:fb11b746ceb5	1603
sepp_nepp	6:fb11b746ceb5	1604	if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) \|\|
sepp_nepp	6:fb11b746ceb5	1605	(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) \|\|
sepp_nepp	6:fb11b746ceb5	1606	(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
sepp_nepp	6:fb11b746ceb5	1607
sepp_nepp	8:2fd7cb217068	1608	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	1609	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1610	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1611	status = VL53L0X_read_byte(VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
sepp_nepp	6:fb11b746ceb5	1612	&encoded_time_out_byte);
sepp_nepp	6:fb11b746ceb5	1613	}
sepp_nepp	6:fb11b746ceb5	1614	msrc_time_out_m_clks = VL53L0X_decode_timeout(encoded_time_out_byte);
sepp_nepp	6:fb11b746ceb5	1615
sepp_nepp	11:d8dbe3b87f9f	1616	timeout_us = VL53L0X_calc_timeout_us(msrc_time_out_m_clks,
sepp_nepp	6:fb11b746ceb5	1617	current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1618	} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
sepp_nepp	6:fb11b746ceb5	1619	/* Retrieve PRE-RANGE VCSEL Period */
sepp_nepp	8:2fd7cb217068	1620	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	1621	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1622
sepp_nepp	6:fb11b746ceb5	1623	/* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
sepp_nepp	6:fb11b746ceb5	1624	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1625
sepp_nepp	6:fb11b746ceb5	1626	/* Retrieve PRE-RANGE VCSEL Period */
sepp_nepp	8:2fd7cb217068	1627	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	1628	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1629
sepp_nepp	6:fb11b746ceb5	1630	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1631	status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
sepp_nepp	6:fb11b746ceb5	1632	&pre_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	1633	}
sepp_nepp	6:fb11b746ceb5	1634
sepp_nepp	8:2fd7cb217068	1635	pre_range_time_out_m_clks = VL53L0X_decode_timeout(pre_range_encoded_time_out);
sepp_nepp	8:2fd7cb217068	1636
sepp_nepp	11:d8dbe3b87f9f	1637	timeout_us = VL53L0X_calc_timeout_us(pre_range_time_out_m_clks,
sepp_nepp	6:fb11b746ceb5	1638	current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1639	}
sepp_nepp	6:fb11b746ceb5	1640	} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
sepp_nepp	6:fb11b746ceb5	1641
sepp_nepp	7:3a1115c2556b	1642	VL53L0X_get_sequence_step_enables( &scheduler_sequence_steps);
sepp_nepp	6:fb11b746ceb5	1643	pre_range_time_out_m_clks = 0;
sepp_nepp	6:fb11b746ceb5	1644
sepp_nepp	6:fb11b746ceb5	1645	if (scheduler_sequence_steps.PreRangeOn) {
sepp_nepp	6:fb11b746ceb5	1646	/* Retrieve PRE-RANGE VCSEL Period */
sepp_nepp	8:2fd7cb217068	1647	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	1648	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1649
sepp_nepp	6:fb11b746ceb5	1650	/* Retrieve PRE-RANGE Timeout in Macro periods
sepp_nepp	6:fb11b746ceb5	1651	* (MCLKS) */
sepp_nepp	6:fb11b746ceb5	1652	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1653	status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
sepp_nepp	6:fb11b746ceb5	1654	&pre_range_encoded_time_out);
sepp_nepp	8:2fd7cb217068	1655	pre_range_time_out_m_clks = VL53L0X_decode_timeout(pre_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	1656	}
sepp_nepp	6:fb11b746ceb5	1657	}
sepp_nepp	6:fb11b746ceb5	1658
sepp_nepp	6:fb11b746ceb5	1659	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1660	/* Retrieve FINAL-RANGE VCSEL Period */
sepp_nepp	8:2fd7cb217068	1661	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	1662	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1663	}
sepp_nepp	6:fb11b746ceb5	1664
sepp_nepp	6:fb11b746ceb5	1665	/* Retrieve FINAL-RANGE Timeout in Macro periods (MCLKS) */
sepp_nepp	6:fb11b746ceb5	1666	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1667	status = VL53L0X_read_word(VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
sepp_nepp	6:fb11b746ceb5	1668	&final_range_encoded_time_out);
sepp_nepp	8:2fd7cb217068	1669	final_range_time_out_m_clks = VL53L0X_decode_timeout(final_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	1670	}
sepp_nepp	6:fb11b746ceb5	1671
sepp_nepp	6:fb11b746ceb5	1672	final_range_time_out_m_clks -= pre_range_time_out_m_clks;
sepp_nepp	11:d8dbe3b87f9f	1673	timeout_us = VL53L0X_calc_timeout_us(final_range_time_out_m_clks,
sepp_nepp	6:fb11b746ceb5	1674	current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	1675	}
sepp_nepp	6:fb11b746ceb5	1676
sepp_nepp	11:d8dbe3b87f9f	1677	*p_time_out_micro_secs = timeout_us;
sepp_nepp	6:fb11b746ceb5	1678
sepp_nepp	6:fb11b746ceb5	1679	return status;
sepp_nepp	6:fb11b746ceb5	1680	}
sepp_nepp	6:fb11b746ceb5	1681
sepp_nepp	11:d8dbe3b87f9f	1682	VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_measurement_timing_budget_us(uint32_t *p_measurement_timing_budget_us)
sepp_nepp	8:2fd7cb217068	1683	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1684	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
sepp_nepp	11:d8dbe3b87f9f	1685	uint32_t final_range_timeout_us;
sepp_nepp	11:d8dbe3b87f9f	1686	uint32_t msrc_dcc_tcc_timeout_us = 2000;
sepp_nepp	11:d8dbe3b87f9f	1687	uint32_t start_overhead_us = 1910;
sepp_nepp	11:d8dbe3b87f9f	1688	uint32_t end_overhead_us = 960;
sepp_nepp	11:d8dbe3b87f9f	1689	uint32_t msrc_overhead_us = 660;
sepp_nepp	11:d8dbe3b87f9f	1690	uint32_t tcc_overhead_us = 590;
sepp_nepp	11:d8dbe3b87f9f	1691	uint32_t dss_overhead_us = 690;
sepp_nepp	11:d8dbe3b87f9f	1692	uint32_t pre_range_overhead_us = 660;
sepp_nepp	11:d8dbe3b87f9f	1693	uint32_t final_range_overhead_us = 550;
sepp_nepp	11:d8dbe3b87f9f	1694	uint32_t pre_range_timeout_us = 0;
sepp_nepp	6:fb11b746ceb5	1695
sepp_nepp	6:fb11b746ceb5	1696
sepp_nepp	6:fb11b746ceb5	1697
sepp_nepp	6:fb11b746ceb5	1698	/* Start and end overhead times always present */
sepp_nepp	11:d8dbe3b87f9f	1699	*p_measurement_timing_budget_us
sepp_nepp	11:d8dbe3b87f9f	1700	= start_overhead_us + end_overhead_us;
sepp_nepp	6:fb11b746ceb5	1701
sepp_nepp	7:3a1115c2556b	1702	status = VL53L0X_get_sequence_step_enables( &scheduler_sequence_steps);
sepp_nepp	6:fb11b746ceb5	1703
sepp_nepp	6:fb11b746ceb5	1704	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1705
sepp_nepp	6:fb11b746ceb5	1706	return status;
sepp_nepp	6:fb11b746ceb5	1707	}
sepp_nepp	6:fb11b746ceb5	1708
sepp_nepp	6:fb11b746ceb5	1709	if (scheduler_sequence_steps.TccOn \|\|
sepp_nepp	6:fb11b746ceb5	1710	scheduler_sequence_steps.MsrcOn \|\|
sepp_nepp	6:fb11b746ceb5	1711	scheduler_sequence_steps.DssOn) {
sepp_nepp	6:fb11b746ceb5	1712
sepp_nepp	8:2fd7cb217068	1713	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
sepp_nepp	11:d8dbe3b87f9f	1714	&msrc_dcc_tcc_timeout_us);
sepp_nepp	6:fb11b746ceb5	1715
sepp_nepp	6:fb11b746ceb5	1716	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1717	if (scheduler_sequence_steps.TccOn) {
sepp_nepp	11:d8dbe3b87f9f	1718	*p_measurement_timing_budget_us +=
sepp_nepp	11:d8dbe3b87f9f	1719	msrc_dcc_tcc_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	1720	tcc_overhead_us;
sepp_nepp	6:fb11b746ceb5	1721	}
sepp_nepp	6:fb11b746ceb5	1722
sepp_nepp	6:fb11b746ceb5	1723	if (scheduler_sequence_steps.DssOn) {
sepp_nepp	11:d8dbe3b87f9f	1724	*p_measurement_timing_budget_us +=
sepp_nepp	11:d8dbe3b87f9f	1725	2 * (msrc_dcc_tcc_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	1726	dss_overhead_us);
sepp_nepp	6:fb11b746ceb5	1727	} else if (scheduler_sequence_steps.MsrcOn) {
sepp_nepp	11:d8dbe3b87f9f	1728	*p_measurement_timing_budget_us +=
sepp_nepp	11:d8dbe3b87f9f	1729	msrc_dcc_tcc_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	1730	msrc_overhead_us;
sepp_nepp	6:fb11b746ceb5	1731	}
sepp_nepp	6:fb11b746ceb5	1732	}
sepp_nepp	6:fb11b746ceb5	1733	}
sepp_nepp	6:fb11b746ceb5	1734
sepp_nepp	6:fb11b746ceb5	1735	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1736	if (scheduler_sequence_steps.PreRangeOn) {
sepp_nepp	8:2fd7cb217068	1737	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1738	&pre_range_timeout_us);
sepp_nepp	11:d8dbe3b87f9f	1739	*p_measurement_timing_budget_us +=
sepp_nepp	11:d8dbe3b87f9f	1740	pre_range_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	1741	pre_range_overhead_us;
sepp_nepp	6:fb11b746ceb5	1742	}
sepp_nepp	6:fb11b746ceb5	1743	}
sepp_nepp	6:fb11b746ceb5	1744
sepp_nepp	6:fb11b746ceb5	1745	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1746	if (scheduler_sequence_steps.FinalRangeOn) {
sepp_nepp	8:2fd7cb217068	1747	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
sepp_nepp	11:d8dbe3b87f9f	1748	&final_range_timeout_us);
sepp_nepp	11:d8dbe3b87f9f	1749	*p_measurement_timing_budget_us +=
sepp_nepp	11:d8dbe3b87f9f	1750	(final_range_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	1751	final_range_overhead_us);
sepp_nepp	6:fb11b746ceb5	1752	}
sepp_nepp	6:fb11b746ceb5	1753	}
sepp_nepp	6:fb11b746ceb5	1754
sepp_nepp	6:fb11b746ceb5	1755	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1756	CurrentParameters.MeasurementTimingBudget_us = *p_measurement_timing_budget_us;
sepp_nepp	6:fb11b746ceb5	1757	}
sepp_nepp	6:fb11b746ceb5	1758
sepp_nepp	6:fb11b746ceb5	1759
sepp_nepp	6:fb11b746ceb5	1760	return status;
sepp_nepp	6:fb11b746ceb5	1761	}
sepp_nepp	6:fb11b746ceb5	1762
sepp_nepp	11:d8dbe3b87f9f	1763	VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_us(uint32_t *p_measurement_timing_budget_us)
sepp_nepp	8:2fd7cb217068	1764	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1765
sepp_nepp	6:fb11b746ceb5	1766
sepp_nepp	11:d8dbe3b87f9f	1767	status = wrapped_VL53L0X_get_measurement_timing_budget_us(p_measurement_timing_budget_us);
sepp_nepp	6:fb11b746ceb5	1768
sepp_nepp	6:fb11b746ceb5	1769
sepp_nepp	6:fb11b746ceb5	1770	return status;
sepp_nepp	6:fb11b746ceb5	1771	}
sepp_nepp	6:fb11b746ceb5	1772
sepp_nepp	8:2fd7cb217068	1773	VL53L0X_Error VL53L0X::VL53L0X_get_device_parameters(VL53L0X_DeviceParameters_t *p_device_parameters)
sepp_nepp	8:2fd7cb217068	1774	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1775	int i;
sepp_nepp	6:fb11b746ceb5	1776
sepp_nepp	6:fb11b746ceb5	1777
sepp_nepp	6:fb11b746ceb5	1778
sepp_nepp	7:3a1115c2556b	1779	status = VL53L0X_get_device_mode( &(p_device_parameters->DeviceMode));
sepp_nepp	6:fb11b746ceb5	1780
sepp_nepp	6:fb11b746ceb5	1781	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	11:d8dbe3b87f9f	1782	status = VL53L0X_get_inter_measurement_period_ms(&(p_device_parameters->InterMeasurementPeriod_ms));
sepp_nepp	6:fb11b746ceb5	1783
sepp_nepp	6:fb11b746ceb5	1784	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1785	p_device_parameters->XTalkCompensationEnable = 0;
sepp_nepp	6:fb11b746ceb5	1786	}
sepp_nepp	6:fb11b746ceb5	1787
sepp_nepp	6:fb11b746ceb5	1788	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	11:d8dbe3b87f9f	1789	status = VL53L0X_get_x_talk_compensation_rate_MHz(&(p_device_parameters->XTalkCompensationRate_MHz));
sepp_nepp	6:fb11b746ceb5	1790
sepp_nepp	6:fb11b746ceb5	1791	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	11:d8dbe3b87f9f	1792	status = VL53L0X_get_offset_calibration_data_micro_meter(&(p_device_parameters->RangeOffset_um));
sepp_nepp	6:fb11b746ceb5	1793
sepp_nepp	6:fb11b746ceb5	1794	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1795	for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
sepp_nepp	6:fb11b746ceb5	1796	/* get first the values, then the enables.
sepp_nepp	6:fb11b746ceb5	1797	* VL53L0X_GetLimitCheckValue will modify the enable
sepp_nepp	6:fb11b746ceb5	1798	* flags
sepp_nepp	6:fb11b746ceb5	1799	*/
sepp_nepp	6:fb11b746ceb5	1800	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	1801	status \|= VL53L0X_get_limit_check_value( i,
sepp_nepp	6:fb11b746ceb5	1802	&(p_device_parameters->LimitChecksValue[i]));
sepp_nepp	6:fb11b746ceb5	1803	} else {
sepp_nepp	6:fb11b746ceb5	1804	break;
sepp_nepp	6:fb11b746ceb5	1805	}
sepp_nepp	6:fb11b746ceb5	1806	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	1807	status \|= VL53L0X_get_limit_check_enable( i,
sepp_nepp	6:fb11b746ceb5	1808	&(p_device_parameters->LimitChecksEnable[i]));
sepp_nepp	6:fb11b746ceb5	1809	} else {
sepp_nepp	6:fb11b746ceb5	1810	break;
sepp_nepp	6:fb11b746ceb5	1811	}
sepp_nepp	6:fb11b746ceb5	1812	}
sepp_nepp	6:fb11b746ceb5	1813	}
sepp_nepp	6:fb11b746ceb5	1814
sepp_nepp	6:fb11b746ceb5	1815	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	1816	status = VL53L0X_get_wrap_around_check_enable(&(p_device_parameters->WrapAroundCheckEnable));
sepp_nepp	6:fb11b746ceb5	1817	}
sepp_nepp	6:fb11b746ceb5	1818
sepp_nepp	6:fb11b746ceb5	1819	/* Need to be done at the end as it uses VCSELPulsePeriod */
sepp_nepp	6:fb11b746ceb5	1820	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	1821	status = VL53L0X_get_measurement_timing_budget_us(&(p_device_parameters->MeasurementTimingBudget_us));
sepp_nepp	6:fb11b746ceb5	1822	}
sepp_nepp	6:fb11b746ceb5	1823
sepp_nepp	6:fb11b746ceb5	1824
sepp_nepp	6:fb11b746ceb5	1825	return status;
sepp_nepp	6:fb11b746ceb5	1826	}
sepp_nepp	6:fb11b746ceb5	1827
sepp_nepp	7:3a1115c2556b	1828	VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_value( uint16_t limit_check_id,
sepp_nepp	6:fb11b746ceb5	1829	FixPoint1616_t limit_check_value)
sepp_nepp	8:2fd7cb217068	1830	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1831	uint8_t temp8;
sepp_nepp	6:fb11b746ceb5	1832
sepp_nepp	6:fb11b746ceb5	1833
sepp_nepp	6:fb11b746ceb5	1834
sepp_nepp	10:cd1758e186a4	1835	temp8 = CurrentParameters.LimitChecksEnable[limit_check_id];
sepp_nepp	6:fb11b746ceb5	1836
sepp_nepp	6:fb11b746ceb5	1837	if (temp8 == 0) { /* disabled write only internal value */
sepp_nepp	10:cd1758e186a4	1838	CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
sepp_nepp	6:fb11b746ceb5	1839	} else {
sepp_nepp	6:fb11b746ceb5	1840
sepp_nepp	6:fb11b746ceb5	1841	switch (limit_check_id) {
sepp_nepp	6:fb11b746ceb5	1842
sepp_nepp	6:fb11b746ceb5	1843	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	1844	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1845	CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_value;
sepp_nepp	6:fb11b746ceb5	1846	break;
sepp_nepp	6:fb11b746ceb5	1847
sepp_nepp	6:fb11b746ceb5	1848	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	1849
sepp_nepp	8:2fd7cb217068	1850	status = VL53L0X_write_word(VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
sepp_nepp	11:d8dbe3b87f9f	1851	VL53L0X_FP1616TOFP97(limit_check_value));
sepp_nepp	6:fb11b746ceb5	1852
sepp_nepp	6:fb11b746ceb5	1853	break;
sepp_nepp	6:fb11b746ceb5	1854
sepp_nepp	6:fb11b746ceb5	1855	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
sepp_nepp	6:fb11b746ceb5	1856
sepp_nepp	6:fb11b746ceb5	1857	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1858	CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_value;
sepp_nepp	6:fb11b746ceb5	1859	break;
sepp_nepp	6:fb11b746ceb5	1860
sepp_nepp	6:fb11b746ceb5	1861	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
sepp_nepp	6:fb11b746ceb5	1862
sepp_nepp	6:fb11b746ceb5	1863	/* internal computation: */
sepp_nepp	10:cd1758e186a4	1864	CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = limit_check_value;
sepp_nepp	6:fb11b746ceb5	1865	break;
sepp_nepp	6:fb11b746ceb5	1866
sepp_nepp	6:fb11b746ceb5	1867	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
sepp_nepp	6:fb11b746ceb5	1868	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
sepp_nepp	8:2fd7cb217068	1869	status = VL53L0X_write_word(VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
sepp_nepp	11:d8dbe3b87f9f	1870	VL53L0X_FP1616TOFP97(limit_check_value));
sepp_nepp	6:fb11b746ceb5	1871	break;
sepp_nepp	6:fb11b746ceb5	1872
sepp_nepp	6:fb11b746ceb5	1873	default:
sepp_nepp	6:fb11b746ceb5	1874	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	1875	}
sepp_nepp	6:fb11b746ceb5	1876
sepp_nepp	6:fb11b746ceb5	1877	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	10:cd1758e186a4	1878	CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
sepp_nepp	6:fb11b746ceb5	1879	}
sepp_nepp	6:fb11b746ceb5	1880	}
sepp_nepp	6:fb11b746ceb5	1881	return status;
sepp_nepp	6:fb11b746ceb5	1882	}
sepp_nepp	6:fb11b746ceb5	1883
sepp_nepp	10:cd1758e186a4	1884	// instead of passing VL53L0X_DeviceInfo_t *p_VL53L0X_device_info, directly fill Device_Info
sepp_nepp	10:cd1758e186a4	1885	VL53L0X_Error VL53L0X::VL53L0X_get_device_info()
sepp_nepp	8:2fd7cb217068	1886	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	10:cd1758e186a4	1887	uint8_t revision_id;
sepp_nepp	10:cd1758e186a4	1888	uint8_t revision;
sepp_nepp	6:fb11b746ceb5	1889	char *product_id_tmp;
sepp_nepp	6:fb11b746ceb5	1890
sepp_nepp	7:3a1115c2556b	1891	status = VL53L0X_get_info_from_device( 2);
sepp_nepp	6:fb11b746ceb5	1892
sepp_nepp	6:fb11b746ceb5	1893	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	10:cd1758e186a4	1894	if (Data.ModuleId == 0) {
sepp_nepp	10:cd1758e186a4	1895	revision = 0;
sepp_nepp	10:cd1758e186a4	1896	VL53L0X_COPYSTRING(Device_Info.ProductId, "");
sepp_nepp	6:fb11b746ceb5	1897	} else {
sepp_nepp	10:cd1758e186a4	1898	revision = Data.Revision;
sepp_nepp	8:2fd7cb217068	1899	product_id_tmp = Data.ProductId;
sepp_nepp	10:cd1758e186a4	1900	VL53L0X_COPYSTRING(Device_Info.ProductId, product_id_tmp);
sepp_nepp	6:fb11b746ceb5	1901	}
sepp_nepp	6:fb11b746ceb5	1902	}
sepp_nepp	10:cd1758e186a4	1903
sepp_nepp	10:cd1758e186a4	1904	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1905	if (revision == 0) {
sepp_nepp	10:cd1758e186a4	1906	VL53L0X_COPYSTRING(Device_Info.Name,
sepp_nepp	6:fb11b746ceb5	1907	VL53L0X_STRING_DEVICE_INFO_NAME_TS0);
sepp_nepp	6:fb11b746ceb5	1908	} else if ((revision <= 34) && (revision != 32)) {
sepp_nepp	10:cd1758e186a4	1909	VL53L0X_COPYSTRING(Device_Info.Name,
sepp_nepp	6:fb11b746ceb5	1910	VL53L0X_STRING_DEVICE_INFO_NAME_TS1);
sepp_nepp	6:fb11b746ceb5	1911	} else if (revision < 39) {
sepp_nepp	10:cd1758e186a4	1912	VL53L0X_COPYSTRING(Device_Info.Name,
sepp_nepp	6:fb11b746ceb5	1913	VL53L0X_STRING_DEVICE_INFO_NAME_TS2);
sepp_nepp	10:cd1758e186a4	1914	} else {VL53L0X_COPYSTRING(Device_Info.Name,
sepp_nepp	6:fb11b746ceb5	1915	VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
sepp_nepp	6:fb11b746ceb5	1916	}
sepp_nepp	6:fb11b746ceb5	1917
sepp_nepp	10:cd1758e186a4	1918	VL53L0X_COPYSTRING(Device_Info.Type, VL53L0X_STRING_DEVICE_INFO_TYPE);
sepp_nepp	6:fb11b746ceb5	1919	}
sepp_nepp	6:fb11b746ceb5	1920
sepp_nepp	6:fb11b746ceb5	1921	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	1922	status = VL53L0X_read_byte( VL53L0X_REG_IDENTIFICATION_MODEL_ID,
sepp_nepp	10:cd1758e186a4	1923	&Device_Info.ProductType);}
sepp_nepp	6:fb11b746ceb5	1924
sepp_nepp	6:fb11b746ceb5	1925	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	1926	status = VL53L0X_read_byte(VL53L0X_REG_IDENTIFICATION_REVISION_ID,
sepp_nepp	6:fb11b746ceb5	1927	&revision_id);
sepp_nepp	10:cd1758e186a4	1928	Device_Info.ProductRevisionMajor = 1;
sepp_nepp	10:cd1758e186a4	1929	Device_Info.ProductRevisionMinor =
sepp_nepp	6:fb11b746ceb5	1930	(revision_id & 0xF0) >> 4;
sepp_nepp	6:fb11b746ceb5	1931	}
sepp_nepp	6:fb11b746ceb5	1932	return status;
sepp_nepp	6:fb11b746ceb5	1933	}
sepp_nepp	6:fb11b746ceb5	1934
sepp_nepp	8:2fd7cb217068	1935	VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_mask_status(uint32_t *p_interrupt_mask_status)
sepp_nepp	7:3a1115c2556b	1936	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1937	uint8_t byte;
sepp_nepp	6:fb11b746ceb5	1938
sepp_nepp	7:3a1115c2556b	1939	status = VL53L0X_read_byte( VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
sepp_nepp	6:fb11b746ceb5	1940	*p_interrupt_mask_status = byte & 0x07;
sepp_nepp	6:fb11b746ceb5	1941
sepp_nepp	7:3a1115c2556b	1942	if (byte & 0x18) { status = VL53L0X_ERROR_RANGE_ERROR;}
sepp_nepp	7:3a1115c2556b	1943
sepp_nepp	6:fb11b746ceb5	1944	return status;
sepp_nepp	6:fb11b746ceb5	1945	}
sepp_nepp	6:fb11b746ceb5	1946
sepp_nepp	8:2fd7cb217068	1947	VL53L0X_Error VL53L0X::VL53L0X_get_measurement_data_ready(uint8_t *p_measurement_data_ready)
sepp_nepp	7:3a1115c2556b	1948	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1949	uint8_t sys_range_status_register;
sepp_nepp	6:fb11b746ceb5	1950	uint8_t interrupt_config;
sepp_nepp	6:fb11b746ceb5	1951	uint32_t interrupt_mask;
sepp_nepp	6:fb11b746ceb5	1952
sepp_nepp	8:2fd7cb217068	1953	interrupt_config = Data.Pin0GpioFunctionality;
sepp_nepp	6:fb11b746ceb5	1954
sepp_nepp	6:fb11b746ceb5	1955	if (interrupt_config ==
sepp_nepp	6:fb11b746ceb5	1956	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
sepp_nepp	7:3a1115c2556b	1957	status = VL53L0X_get_interrupt_mask_status( &interrupt_mask);
sepp_nepp	6:fb11b746ceb5	1958	if (interrupt_mask ==
sepp_nepp	6:fb11b746ceb5	1959	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
sepp_nepp	6:fb11b746ceb5	1960	*p_measurement_data_ready = 1;
sepp_nepp	6:fb11b746ceb5	1961	} else {
sepp_nepp	6:fb11b746ceb5	1962	*p_measurement_data_ready = 0;
sepp_nepp	6:fb11b746ceb5	1963	}
sepp_nepp	6:fb11b746ceb5	1964	} else {
sepp_nepp	7:3a1115c2556b	1965	status = VL53L0X_read_byte( VL53L0X_REG_RESULT_RANGE_STATUS,
sepp_nepp	6:fb11b746ceb5	1966	&sys_range_status_register);
sepp_nepp	6:fb11b746ceb5	1967	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	1968	if (sys_range_status_register & 0x01) {
sepp_nepp	6:fb11b746ceb5	1969	*p_measurement_data_ready = 1;
sepp_nepp	7:3a1115c2556b	1970	} else { *p_measurement_data_ready = 0; }
sepp_nepp	6:fb11b746ceb5	1971	}
sepp_nepp	6:fb11b746ceb5	1972	}
sepp_nepp	6:fb11b746ceb5	1973
sepp_nepp	6:fb11b746ceb5	1974	return status;
sepp_nepp	6:fb11b746ceb5	1975	}
sepp_nepp	6:fb11b746ceb5	1976
sepp_nepp	7:3a1115c2556b	1977	VL53L0X_Error VL53L0X::VL53L0X_polling_delay(void)
sepp_nepp	7:3a1115c2556b	1978	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1979
sepp_nepp	6:fb11b746ceb5	1980	// do nothing
sepp_nepp	6:fb11b746ceb5	1981	VL53L0X_OsDelay();
sepp_nepp	6:fb11b746ceb5	1982	return status;
sepp_nepp	6:fb11b746ceb5	1983	}
sepp_nepp	6:fb11b746ceb5	1984
sepp_nepp	7:3a1115c2556b	1985	VL53L0X_Error VL53L0X::VL53L0X_measurement_poll_for_completion(void)
sepp_nepp	7:3a1115c2556b	1986	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	1987	uint8_t new_data_ready = 0;
sepp_nepp	6:fb11b746ceb5	1988	uint32_t loop_nb;
sepp_nepp	6:fb11b746ceb5	1989
sepp_nepp	6:fb11b746ceb5	1990	loop_nb = 0;
sepp_nepp	6:fb11b746ceb5	1991
sepp_nepp	12:81f37e50f8f8	1992	do {
sepp_nepp	12:81f37e50f8f8	1993	status = VL53L0X_get_measurement_data_ready( &new_data_ready);
sepp_nepp	6:fb11b746ceb5	1994	if (status != 0) {
sepp_nepp	6:fb11b746ceb5	1995	break; /* the error is set */
sepp_nepp	6:fb11b746ceb5	1996	}
sepp_nepp	6:fb11b746ceb5	1997
sepp_nepp	6:fb11b746ceb5	1998	if (new_data_ready == 1) {
sepp_nepp	6:fb11b746ceb5	1999	break; /* done note that status == 0 */
sepp_nepp	6:fb11b746ceb5	2000	}
sepp_nepp	6:fb11b746ceb5	2001
sepp_nepp	6:fb11b746ceb5	2002	loop_nb++;
sepp_nepp	6:fb11b746ceb5	2003	if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
sepp_nepp	6:fb11b746ceb5	2004	status = VL53L0X_ERROR_TIME_OUT;
sepp_nepp	6:fb11b746ceb5	2005	break;
sepp_nepp	6:fb11b746ceb5	2006	}
sepp_nepp	6:fb11b746ceb5	2007
sepp_nepp	7:3a1115c2556b	2008	VL53L0X_polling_delay();
sepp_nepp	6:fb11b746ceb5	2009	} while (1);
sepp_nepp	6:fb11b746ceb5	2010
sepp_nepp	6:fb11b746ceb5	2011	return status;
sepp_nepp	6:fb11b746ceb5	2012	}
sepp_nepp	6:fb11b746ceb5	2013
sepp_nepp	6:fb11b746ceb5	2014	/* Group PAL Interrupt Functions */
sepp_nepp	7:3a1115c2556b	2015	VL53L0X_Error VL53L0X::VL53L0X_clear_interrupt_mask( uint32_t interrupt_mask)
sepp_nepp	7:3a1115c2556b	2016	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2017	uint8_t loop_count;
sepp_nepp	6:fb11b746ceb5	2018	uint8_t byte;
sepp_nepp	6:fb11b746ceb5	2019
sepp_nepp	6:fb11b746ceb5	2020	/* clear bit 0 range interrupt, bit 1 error interrupt */
sepp_nepp	6:fb11b746ceb5	2021	loop_count = 0;
sepp_nepp	6:fb11b746ceb5	2022	do {
sepp_nepp	7:3a1115c2556b	2023	status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
sepp_nepp	7:3a1115c2556b	2024	status \|= VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
sepp_nepp	7:3a1115c2556b	2025	status \|= VL53L0X_read_byte(VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
sepp_nepp	6:fb11b746ceb5	2026	loop_count++;
sepp_nepp	6:fb11b746ceb5	2027	} while (((byte & 0x07) != 0x00)
sepp_nepp	6:fb11b746ceb5	2028	&& (loop_count < 3)
sepp_nepp	6:fb11b746ceb5	2029	&& (status == VL53L0X_ERROR_NONE));
sepp_nepp	6:fb11b746ceb5	2030
sepp_nepp	6:fb11b746ceb5	2031	if (loop_count >= 3) {
sepp_nepp	6:fb11b746ceb5	2032	status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
sepp_nepp	6:fb11b746ceb5	2033	}
sepp_nepp	6:fb11b746ceb5	2034
sepp_nepp	6:fb11b746ceb5	2035
sepp_nepp	6:fb11b746ceb5	2036	return status;
sepp_nepp	6:fb11b746ceb5	2037	}
sepp_nepp	6:fb11b746ceb5	2038
sepp_nepp	8:2fd7cb217068	2039	VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(uint8_t vhv_init_byte)
sepp_nepp	8:2fd7cb217068	2040	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2041
sepp_nepp	6:fb11b746ceb5	2042	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2043	status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START,
sepp_nepp	6:fb11b746ceb5	2044	VL53L0X_REG_SYSRANGE_MODE_START_STOP \|
sepp_nepp	6:fb11b746ceb5	2045	vhv_init_byte);
sepp_nepp	6:fb11b746ceb5	2046	}
sepp_nepp	6:fb11b746ceb5	2047
sepp_nepp	6:fb11b746ceb5	2048	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2049	status = VL53L0X_measurement_poll_for_completion();}
sepp_nepp	6:fb11b746ceb5	2050
sepp_nepp	6:fb11b746ceb5	2051	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2052	status = VL53L0X_clear_interrupt_mask( 0);}
sepp_nepp	6:fb11b746ceb5	2053
sepp_nepp	6:fb11b746ceb5	2054	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2055	status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START, 0x00);
sepp_nepp	6:fb11b746ceb5	2056	}
sepp_nepp	6:fb11b746ceb5	2057
sepp_nepp	6:fb11b746ceb5	2058	return status;
sepp_nepp	6:fb11b746ceb5	2059	}
sepp_nepp	6:fb11b746ceb5	2060
sepp_nepp	7:3a1115c2556b	2061	VL53L0X_Error VL53L0X::VL53L0X_ref_calibration_io( uint8_t read_not_write,
sepp_nepp	6:fb11b746ceb5	2062	uint8_t vhv_settings, uint8_t phase_cal,
sepp_nepp	6:fb11b746ceb5	2063	uint8_t p_vhv_settings, uint8_t p_phase_cal,
sepp_nepp	6:fb11b746ceb5	2064	const uint8_t vhv_enable, const uint8_t phase_enable)
sepp_nepp	8:2fd7cb217068	2065	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2066	uint8_t phase_calint = 0;
sepp_nepp	6:fb11b746ceb5	2067
sepp_nepp	6:fb11b746ceb5	2068	/* Read VHV from device */
sepp_nepp	7:3a1115c2556b	2069	status \|= VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	2070	status \|= VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	7:3a1115c2556b	2071	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	2072
sepp_nepp	6:fb11b746ceb5	2073	if (read_not_write) {
sepp_nepp	6:fb11b746ceb5	2074	if (vhv_enable) {
sepp_nepp	7:3a1115c2556b	2075	status \|= VL53L0X_read_byte( 0xCB, p_vhv_settings);}
sepp_nepp	6:fb11b746ceb5	2076	if (phase_enable) {
sepp_nepp	7:3a1115c2556b	2077	status \|= VL53L0X_read_byte( 0xEE, &phase_calint);}
sepp_nepp	6:fb11b746ceb5	2078	} else {
sepp_nepp	6:fb11b746ceb5	2079	if (vhv_enable) {
sepp_nepp	7:3a1115c2556b	2080	status \|= VL53L0X_write_byte( 0xCB, vhv_settings);}
sepp_nepp	6:fb11b746ceb5	2081	if (phase_enable) {
sepp_nepp	7:3a1115c2556b	2082	status \|= VL53L0X_update_byte( 0xEE, 0x80, phase_cal);}
sepp_nepp	6:fb11b746ceb5	2083	}
sepp_nepp	6:fb11b746ceb5	2084
sepp_nepp	7:3a1115c2556b	2085	status \|= VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	2086	status \|= VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	2087	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	2088
sepp_nepp	6:fb11b746ceb5	2089	*p_phase_cal = (uint8_t)(phase_calint & 0xEF);
sepp_nepp	6:fb11b746ceb5	2090
sepp_nepp	6:fb11b746ceb5	2091	return status;
sepp_nepp	6:fb11b746ceb5	2092	}
sepp_nepp	6:fb11b746ceb5	2093
sepp_nepp	8:2fd7cb217068	2094	VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(uint8_t *p_vhv_settings, const uint8_t get_data_enable,
sepp_nepp	6:fb11b746ceb5	2095	const uint8_t restore_config)
sepp_nepp	8:2fd7cb217068	2096	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2097	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	2098	uint8_t vhv_settings = 0;
sepp_nepp	6:fb11b746ceb5	2099	uint8_t phase_cal = 0;
sepp_nepp	6:fb11b746ceb5	2100	uint8_t phase_cal_int = 0;
sepp_nepp	6:fb11b746ceb5	2101
sepp_nepp	6:fb11b746ceb5	2102	/* store the value of the sequence config,
sepp_nepp	6:fb11b746ceb5	2103	* this will be reset before the end of the function
sepp_nepp	6:fb11b746ceb5	2104	*/
sepp_nepp	6:fb11b746ceb5	2105
sepp_nepp	6:fb11b746ceb5	2106	if (restore_config) {
sepp_nepp	8:2fd7cb217068	2107	sequence_config = Data.SequenceConfig;
sepp_nepp	6:fb11b746ceb5	2108	}
sepp_nepp	6:fb11b746ceb5	2109
sepp_nepp	6:fb11b746ceb5	2110	/* Run VHV */
sepp_nepp	7:3a1115c2556b	2111	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
sepp_nepp	6:fb11b746ceb5	2112
sepp_nepp	6:fb11b746ceb5	2113	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2114	status = VL53L0X_perform_single_ref_calibration( 0x40);}
sepp_nepp	6:fb11b746ceb5	2115
sepp_nepp	6:fb11b746ceb5	2116	/* Read VHV from device */
sepp_nepp	6:fb11b746ceb5	2117	if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
sepp_nepp	7:3a1115c2556b	2118	status = VL53L0X_ref_calibration_io( 1, vhv_settings, phase_cal, /* Not used here */
sepp_nepp	7:3a1115c2556b	2119	p_vhv_settings, &phase_cal_int, 1, 0);
sepp_nepp	7:3a1115c2556b	2120	} else {*p_vhv_settings = 0; }
sepp_nepp	6:fb11b746ceb5	2121
sepp_nepp	6:fb11b746ceb5	2122	if ((status == VL53L0X_ERROR_NONE) && restore_config) {
sepp_nepp	6:fb11b746ceb5	2123	/* restore the previous Sequence Config */
sepp_nepp	7:3a1115c2556b	2124	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sepp_nepp	6:fb11b746ceb5	2125	sequence_config);
sepp_nepp	6:fb11b746ceb5	2126	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	2127	Data.SequenceConfig = sequence_config; }
sepp_nepp	6:fb11b746ceb5	2128	}
sepp_nepp	6:fb11b746ceb5	2129
sepp_nepp	6:fb11b746ceb5	2130	return status;
sepp_nepp	6:fb11b746ceb5	2131	}
sepp_nepp	6:fb11b746ceb5	2132
sepp_nepp	8:2fd7cb217068	2133	VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(uint8_t *p_phase_cal, const uint8_t get_data_enable,
sepp_nepp	6:fb11b746ceb5	2134	const uint8_t restore_config)
sepp_nepp	7:3a1115c2556b	2135	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2136	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	2137	uint8_t vhv_settings = 0;
sepp_nepp	6:fb11b746ceb5	2138	uint8_t phase_cal = 0;
sepp_nepp	6:fb11b746ceb5	2139	uint8_t vhv_settingsint;
sepp_nepp	6:fb11b746ceb5	2140
sepp_nepp	6:fb11b746ceb5	2141	/* store the value of the sequence config,
sepp_nepp	7:3a1115c2556b	2142	* this will be reset before the end of the function */
sepp_nepp	6:fb11b746ceb5	2143
sepp_nepp	6:fb11b746ceb5	2144	if (restore_config) {
sepp_nepp	8:2fd7cb217068	2145	sequence_config = Data.SequenceConfig;
sepp_nepp	6:fb11b746ceb5	2146	}
sepp_nepp	6:fb11b746ceb5	2147
sepp_nepp	6:fb11b746ceb5	2148	/* Run PhaseCal */
sepp_nepp	7:3a1115c2556b	2149	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
sepp_nepp	6:fb11b746ceb5	2150
sepp_nepp	6:fb11b746ceb5	2151	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2152	status = VL53L0X_perform_single_ref_calibration( 0x0);
sepp_nepp	6:fb11b746ceb5	2153	}
sepp_nepp	6:fb11b746ceb5	2154
sepp_nepp	6:fb11b746ceb5	2155	/* Read PhaseCal from device */
sepp_nepp	6:fb11b746ceb5	2156	if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
sepp_nepp	7:3a1115c2556b	2157	status = VL53L0X_ref_calibration_io( 1,
sepp_nepp	6:fb11b746ceb5	2158	vhv_settings, phase_cal, /* Not used here */
sepp_nepp	6:fb11b746ceb5	2159	&vhv_settingsint, p_phase_cal,
sepp_nepp	6:fb11b746ceb5	2160	0, 1);
sepp_nepp	6:fb11b746ceb5	2161	} else {
sepp_nepp	6:fb11b746ceb5	2162	*p_phase_cal = 0;
sepp_nepp	6:fb11b746ceb5	2163	}
sepp_nepp	6:fb11b746ceb5	2164
sepp_nepp	6:fb11b746ceb5	2165	if ((status == VL53L0X_ERROR_NONE) && restore_config) {
sepp_nepp	6:fb11b746ceb5	2166	/* restore the previous Sequence Config */
sepp_nepp	7:3a1115c2556b	2167	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sepp_nepp	6:fb11b746ceb5	2168	sequence_config);
sepp_nepp	6:fb11b746ceb5	2169	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	2170	Data.SequenceConfig = sequence_config;
sepp_nepp	6:fb11b746ceb5	2171	}
sepp_nepp	6:fb11b746ceb5	2172
sepp_nepp	6:fb11b746ceb5	2173	}
sepp_nepp	6:fb11b746ceb5	2174
sepp_nepp	6:fb11b746ceb5	2175	return status;
sepp_nepp	6:fb11b746ceb5	2176	}
sepp_nepp	6:fb11b746ceb5	2177
sepp_nepp	8:2fd7cb217068	2178	VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(uint8_t p_vhv_settings, uint8_t p_phase_cal, uint8_t get_data_enable)
sepp_nepp	8:2fd7cb217068	2179	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2180	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	2181
sepp_nepp	6:fb11b746ceb5	2182	/* store the value of the sequence config,
sepp_nepp	7:3a1115c2556b	2183	* this will be reset before the end of the function */
sepp_nepp	7:3a1115c2556b	2184
sepp_nepp	8:2fd7cb217068	2185	sequence_config = Data.SequenceConfig;
sepp_nepp	6:fb11b746ceb5	2186
sepp_nepp	6:fb11b746ceb5	2187	/* In the following function we don't save the config to optimize
sepp_nepp	6:fb11b746ceb5	2188	* writes on device. Config is saved and restored only once. */
sepp_nepp	7:3a1115c2556b	2189	status = VL53L0X_perform_vhv_calibration(p_vhv_settings, get_data_enable, 0);
sepp_nepp	6:fb11b746ceb5	2190
sepp_nepp	6:fb11b746ceb5	2191	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2192	status = VL53L0X_perform_phase_calibration(p_phase_cal, get_data_enable, 0); }
sepp_nepp	6:fb11b746ceb5	2193
sepp_nepp	6:fb11b746ceb5	2194	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2195	/* restore the previous Sequence Config */
sepp_nepp	7:3a1115c2556b	2196	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sepp_nepp	6:fb11b746ceb5	2197	sequence_config);
sepp_nepp	6:fb11b746ceb5	2198	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	2199	Data.SequenceConfig = sequence_config; }
sepp_nepp	6:fb11b746ceb5	2200	}
sepp_nepp	6:fb11b746ceb5	2201
sepp_nepp	6:fb11b746ceb5	2202	return status;
sepp_nepp	6:fb11b746ceb5	2203	}
sepp_nepp	6:fb11b746ceb5	2204
sepp_nepp	6:fb11b746ceb5	2205	void VL53L0X::get_next_good_spad(uint8_t good_spad_array[], uint32_t size,
sepp_nepp	6:fb11b746ceb5	2206	uint32_t curr, int32_t *p_next)
sepp_nepp	8:2fd7cb217068	2207	{ uint32_t start_index;
sepp_nepp	6:fb11b746ceb5	2208	uint32_t fine_offset;
sepp_nepp	6:fb11b746ceb5	2209	uint32_t c_spads_per_byte = 8;
sepp_nepp	6:fb11b746ceb5	2210	uint32_t coarse_index;
sepp_nepp	6:fb11b746ceb5	2211	uint32_t fine_index;
sepp_nepp	6:fb11b746ceb5	2212	uint8_t data_byte;
sepp_nepp	6:fb11b746ceb5	2213	uint8_t success = 0;
sepp_nepp	6:fb11b746ceb5	2214
sepp_nepp	7:3a1115c2556b	2215	/* Starting with the current good spad, loop through the array to find
sepp_nepp	6:fb11b746ceb5	2216	* the next. i.e. the next bit set in the sequence.
sepp_nepp	6:fb11b746ceb5	2217	*
sepp_nepp	6:fb11b746ceb5	2218	* The coarse index is the byte index of the array and the fine index is
sepp_nepp	7:3a1115c2556b	2219	* the index of the bit within each byte. */
sepp_nepp	6:fb11b746ceb5	2220
sepp_nepp	6:fb11b746ceb5	2221	*p_next = -1;
sepp_nepp	6:fb11b746ceb5	2222
sepp_nepp	6:fb11b746ceb5	2223	start_index = curr / c_spads_per_byte;
sepp_nepp	6:fb11b746ceb5	2224	fine_offset = curr % c_spads_per_byte;
sepp_nepp	6:fb11b746ceb5	2225
sepp_nepp	6:fb11b746ceb5	2226	for (coarse_index = start_index; ((coarse_index < size) && !success);
sepp_nepp	6:fb11b746ceb5	2227	coarse_index++) {
sepp_nepp	6:fb11b746ceb5	2228	fine_index = 0;
sepp_nepp	6:fb11b746ceb5	2229	data_byte = good_spad_array[coarse_index];
sepp_nepp	6:fb11b746ceb5	2230
sepp_nepp	6:fb11b746ceb5	2231	if (coarse_index == start_index) {
sepp_nepp	6:fb11b746ceb5	2232	/* locate the bit position of the provided current
sepp_nepp	6:fb11b746ceb5	2233	* spad bit before iterating */
sepp_nepp	6:fb11b746ceb5	2234	data_byte >>= fine_offset;
sepp_nepp	6:fb11b746ceb5	2235	fine_index = fine_offset;
sepp_nepp	6:fb11b746ceb5	2236	}
sepp_nepp	6:fb11b746ceb5	2237
sepp_nepp	6:fb11b746ceb5	2238	while (fine_index < c_spads_per_byte) {
sepp_nepp	6:fb11b746ceb5	2239	if ((data_byte & 0x1) == 1) {
sepp_nepp	6:fb11b746ceb5	2240	success = 1;
sepp_nepp	6:fb11b746ceb5	2241	p_next = coarse_index c_spads_per_byte + fine_index;
sepp_nepp	6:fb11b746ceb5	2242	break;
sepp_nepp	6:fb11b746ceb5	2243	}
sepp_nepp	6:fb11b746ceb5	2244	data_byte >>= 1;
sepp_nepp	6:fb11b746ceb5	2245	fine_index++;
sepp_nepp	6:fb11b746ceb5	2246	}
sepp_nepp	6:fb11b746ceb5	2247	}
sepp_nepp	6:fb11b746ceb5	2248	}
sepp_nepp	6:fb11b746ceb5	2249
sepp_nepp	6:fb11b746ceb5	2250	uint8_t VL53L0X::is_aperture(uint32_t spad_index)
sepp_nepp	8:2fd7cb217068	2251	{ /* This function reports if a given spad index is an aperture SPAD by
sepp_nepp	7:3a1115c2556b	2252	* deriving the quadrant.*/
sepp_nepp	6:fb11b746ceb5	2253	uint32_t quadrant;
sepp_nepp	6:fb11b746ceb5	2254	uint8_t is_aperture = 1;
sepp_nepp	6:fb11b746ceb5	2255	quadrant = spad_index >> 6;
sepp_nepp	6:fb11b746ceb5	2256	if (refArrayQuadrants[quadrant] == REF_ARRAY_SPAD_0) {
sepp_nepp	6:fb11b746ceb5	2257	is_aperture = 0;
sepp_nepp	6:fb11b746ceb5	2258	}
sepp_nepp	6:fb11b746ceb5	2259
sepp_nepp	6:fb11b746ceb5	2260	return is_aperture;
sepp_nepp	6:fb11b746ceb5	2261	}
sepp_nepp	6:fb11b746ceb5	2262
sepp_nepp	6:fb11b746ceb5	2263	VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spad_array[], uint32_t size,
sepp_nepp	6:fb11b746ceb5	2264	uint32_t spad_index)
sepp_nepp	7:3a1115c2556b	2265	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2266	uint32_t c_spads_per_byte = 8;
sepp_nepp	6:fb11b746ceb5	2267	uint32_t coarse_index;
sepp_nepp	6:fb11b746ceb5	2268	uint32_t fine_index;
sepp_nepp	6:fb11b746ceb5	2269
sepp_nepp	6:fb11b746ceb5	2270	coarse_index = spad_index / c_spads_per_byte;
sepp_nepp	6:fb11b746ceb5	2271	fine_index = spad_index % c_spads_per_byte;
sepp_nepp	6:fb11b746ceb5	2272	if (coarse_index >= size) {
sepp_nepp	6:fb11b746ceb5	2273	status = VL53L0X_ERROR_REF_SPAD_INIT;
sepp_nepp	6:fb11b746ceb5	2274	} else {
sepp_nepp	6:fb11b746ceb5	2275	spad_array[coarse_index] \|= (1 << fine_index);
sepp_nepp	6:fb11b746ceb5	2276	}
sepp_nepp	6:fb11b746ceb5	2277
sepp_nepp	6:fb11b746ceb5	2278	return status;
sepp_nepp	6:fb11b746ceb5	2279	}
sepp_nepp	6:fb11b746ceb5	2280
sepp_nepp	7:3a1115c2556b	2281	VL53L0X_Error VL53L0X::set_ref_spad_map( uint8_t *p_ref_spad_array)
sepp_nepp	9:cb4c6d4e5030	2282	{ VL53L0X_Error status = VL53L0X_i2c_write(VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
sepp_nepp	6:fb11b746ceb5	2283	p_ref_spad_array, 6);
sepp_nepp	6:fb11b746ceb5	2284
sepp_nepp	6:fb11b746ceb5	2285	return status;
sepp_nepp	6:fb11b746ceb5	2286	}
sepp_nepp	6:fb11b746ceb5	2287
sepp_nepp	7:3a1115c2556b	2288	VL53L0X_Error VL53L0X::get_ref_spad_map( uint8_t *p_ref_spad_array)
sepp_nepp	8:2fd7cb217068	2289	{ VL53L0X_Error status = VL53L0X_read_multi(VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
sepp_nepp	6:fb11b746ceb5	2290	p_ref_spad_array,
sepp_nepp	6:fb11b746ceb5	2291	6);
sepp_nepp	6:fb11b746ceb5	2292	// VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2293	// uint8_t count=0;
sepp_nepp	6:fb11b746ceb5	2294
sepp_nepp	6:fb11b746ceb5	2295	// for (count = 0; count < 6; count++)
sepp_nepp	7:3a1115c2556b	2296	// status = VL53L0X_RdByte( (VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 + count), &refSpadArray[count]);
sepp_nepp	6:fb11b746ceb5	2297	return status;
sepp_nepp	6:fb11b746ceb5	2298	}
sepp_nepp	6:fb11b746ceb5	2299
sepp_nepp	8:2fd7cb217068	2300	VL53L0X_Error VL53L0X::enable_ref_spads(uint8_t aperture_spads,
sepp_nepp	6:fb11b746ceb5	2301	uint8_t good_spad_array[],
sepp_nepp	6:fb11b746ceb5	2302	uint8_t spad_array[],
sepp_nepp	6:fb11b746ceb5	2303	uint32_t size,
sepp_nepp	6:fb11b746ceb5	2304	uint32_t start,
sepp_nepp	6:fb11b746ceb5	2305	uint32_t offset,
sepp_nepp	6:fb11b746ceb5	2306	uint32_t spad_count,
sepp_nepp	6:fb11b746ceb5	2307	uint32_t *p_last_spad)
sepp_nepp	8:2fd7cb217068	2308	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2309	uint32_t index;
sepp_nepp	6:fb11b746ceb5	2310	uint32_t i;
sepp_nepp	6:fb11b746ceb5	2311	int32_t next_good_spad = offset;
sepp_nepp	6:fb11b746ceb5	2312	uint32_t current_spad;
sepp_nepp	6:fb11b746ceb5	2313	uint8_t check_spad_array[6];
sepp_nepp	6:fb11b746ceb5	2314
sepp_nepp	6:fb11b746ceb5	2315	/*
sepp_nepp	6:fb11b746ceb5	2316	* This function takes in a spad array which may or may not have SPADS
sepp_nepp	6:fb11b746ceb5	2317	* already enabled and appends from a given offset a requested number
sepp_nepp	6:fb11b746ceb5	2318	* of new SPAD enables. The 'good spad map' is applied to
sepp_nepp	6:fb11b746ceb5	2319	* determine the next SPADs to enable.
sepp_nepp	6:fb11b746ceb5	2320	*
sepp_nepp	6:fb11b746ceb5	2321	* This function applies to only aperture or only non-aperture spads.
sepp_nepp	6:fb11b746ceb5	2322	* Checks are performed to ensure this.
sepp_nepp	6:fb11b746ceb5	2323	*/
sepp_nepp	6:fb11b746ceb5	2324
sepp_nepp	6:fb11b746ceb5	2325	current_spad = offset;
sepp_nepp	6:fb11b746ceb5	2326	for (index = 0; index < spad_count; index++) {
sepp_nepp	6:fb11b746ceb5	2327	get_next_good_spad(good_spad_array, size, current_spad,
sepp_nepp	6:fb11b746ceb5	2328	&next_good_spad);
sepp_nepp	6:fb11b746ceb5	2329
sepp_nepp	6:fb11b746ceb5	2330	if (next_good_spad == -1) {
sepp_nepp	6:fb11b746ceb5	2331	status = VL53L0X_ERROR_REF_SPAD_INIT;
sepp_nepp	6:fb11b746ceb5	2332	break;
sepp_nepp	6:fb11b746ceb5	2333	}
sepp_nepp	6:fb11b746ceb5	2334
sepp_nepp	6:fb11b746ceb5	2335	/* Confirm that the next good SPAD is non-aperture */
sepp_nepp	6:fb11b746ceb5	2336	if (is_aperture(start + next_good_spad) != aperture_spads) {
sepp_nepp	6:fb11b746ceb5	2337	/* if we can't get the required number of good aperture
sepp_nepp	6:fb11b746ceb5	2338	* spads from the current quadrant then this is an error
sepp_nepp	6:fb11b746ceb5	2339	*/
sepp_nepp	6:fb11b746ceb5	2340	status = VL53L0X_ERROR_REF_SPAD_INIT;
sepp_nepp	6:fb11b746ceb5	2341	break;
sepp_nepp	6:fb11b746ceb5	2342	}
sepp_nepp	6:fb11b746ceb5	2343	current_spad = (uint32_t)next_good_spad;
sepp_nepp	6:fb11b746ceb5	2344	enable_spad_bit(spad_array, size, current_spad);
sepp_nepp	6:fb11b746ceb5	2345	current_spad++;
sepp_nepp	6:fb11b746ceb5	2346	}
sepp_nepp	6:fb11b746ceb5	2347	*p_last_spad = current_spad;
sepp_nepp	6:fb11b746ceb5	2348
sepp_nepp	6:fb11b746ceb5	2349	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2350	status = set_ref_spad_map( spad_array);
sepp_nepp	6:fb11b746ceb5	2351	}
sepp_nepp	6:fb11b746ceb5	2352
sepp_nepp	6:fb11b746ceb5	2353	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2354	status = get_ref_spad_map( check_spad_array);
sepp_nepp	6:fb11b746ceb5	2355
sepp_nepp	6:fb11b746ceb5	2356	i = 0;
sepp_nepp	6:fb11b746ceb5	2357
sepp_nepp	6:fb11b746ceb5	2358	/* Compare spad maps. If not equal report error. */
sepp_nepp	6:fb11b746ceb5	2359	while (i < size) {
sepp_nepp	6:fb11b746ceb5	2360	if (spad_array[i] != check_spad_array[i]) {
sepp_nepp	6:fb11b746ceb5	2361	status = VL53L0X_ERROR_REF_SPAD_INIT;
sepp_nepp	6:fb11b746ceb5	2362	break;
sepp_nepp	6:fb11b746ceb5	2363	}
sepp_nepp	6:fb11b746ceb5	2364	i++;
sepp_nepp	6:fb11b746ceb5	2365	}
sepp_nepp	6:fb11b746ceb5	2366	}
sepp_nepp	6:fb11b746ceb5	2367	return status;
sepp_nepp	6:fb11b746ceb5	2368	}
sepp_nepp	6:fb11b746ceb5	2369
sepp_nepp	7:3a1115c2556b	2370	VL53L0X_Error VL53L0X::VL53L0X_set_device_mode( VL53L0X_DeviceModes device_mode)
sepp_nepp	8:2fd7cb217068	2371	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2372
sepp_nepp	6:fb11b746ceb5	2373	switch (device_mode) {
sepp_nepp	6:fb11b746ceb5	2374	case VL53L0X_DEVICEMODE_SINGLE_RANGING:
sepp_nepp	6:fb11b746ceb5	2375	case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
sepp_nepp	6:fb11b746ceb5	2376	case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
sepp_nepp	6:fb11b746ceb5	2377	case VL53L0X_DEVICEMODE_GPIO_DRIVE:
sepp_nepp	6:fb11b746ceb5	2378	case VL53L0X_DEVICEMODE_GPIO_OSC:
sepp_nepp	6:fb11b746ceb5	2379	/* Supported modes */
sepp_nepp	10:cd1758e186a4	2380	CurrentParameters.DeviceMode = device_mode;
sepp_nepp	6:fb11b746ceb5	2381	break;
sepp_nepp	6:fb11b746ceb5	2382	default:
sepp_nepp	6:fb11b746ceb5	2383	/* Unsupported mode */
sepp_nepp	6:fb11b746ceb5	2384	status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
sepp_nepp	6:fb11b746ceb5	2385	}
sepp_nepp	6:fb11b746ceb5	2386
sepp_nepp	6:fb11b746ceb5	2387
sepp_nepp	6:fb11b746ceb5	2388	return status;
sepp_nepp	6:fb11b746ceb5	2389	}
sepp_nepp	6:fb11b746ceb5	2390
sepp_nepp	8:2fd7cb217068	2391	VL53L0X_Error VL53L0X::VL53L0X_set_interrupt_thresholds(VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
sepp_nepp	6:fb11b746ceb5	2392	FixPoint1616_t threshold_high)
sepp_nepp	8:2fd7cb217068	2393	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2394	uint16_t threshold16;
sepp_nepp	6:fb11b746ceb5	2395
sepp_nepp	6:fb11b746ceb5	2396
sepp_nepp	6:fb11b746ceb5	2397	/* no dependency on DeviceMode for Ewok */
sepp_nepp	6:fb11b746ceb5	2398	/* Need to divide by 2 because the FW will apply a x2 */
sepp_nepp	6:fb11b746ceb5	2399	threshold16 = (uint16_t)((threshold_low >> 17) & 0x00fff);
sepp_nepp	7:3a1115c2556b	2400	status = VL53L0X_write_word( VL53L0X_REG_SYSTEM_THRESH_LOW, threshold16);
sepp_nepp	6:fb11b746ceb5	2401
sepp_nepp	6:fb11b746ceb5	2402	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2403	/* Need to divide by 2 because the FW will apply a x2 */
sepp_nepp	6:fb11b746ceb5	2404	threshold16 = (uint16_t)((threshold_high >> 17) & 0x00fff);
sepp_nepp	7:3a1115c2556b	2405	status = VL53L0X_write_word( VL53L0X_REG_SYSTEM_THRESH_HIGH,
sepp_nepp	6:fb11b746ceb5	2406	threshold16);
sepp_nepp	6:fb11b746ceb5	2407	}
sepp_nepp	6:fb11b746ceb5	2408
sepp_nepp	6:fb11b746ceb5	2409
sepp_nepp	6:fb11b746ceb5	2410	return status;
sepp_nepp	6:fb11b746ceb5	2411	}
sepp_nepp	6:fb11b746ceb5	2412
sepp_nepp	8:2fd7cb217068	2413	VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_thresholds(VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
sepp_nepp	6:fb11b746ceb5	2414	FixPoint1616_t *p_threshold_high)
sepp_nepp	8:2fd7cb217068	2415	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2416	uint16_t threshold16;
sepp_nepp	6:fb11b746ceb5	2417
sepp_nepp	6:fb11b746ceb5	2418
sepp_nepp	6:fb11b746ceb5	2419	/* no dependency on DeviceMode for Ewok */
sepp_nepp	6:fb11b746ceb5	2420
sepp_nepp	7:3a1115c2556b	2421	status = VL53L0X_read_word( VL53L0X_REG_SYSTEM_THRESH_LOW, &threshold16);
sepp_nepp	6:fb11b746ceb5	2422	/* Need to multiply by 2 because the FW will apply a x2 */
sepp_nepp	6:fb11b746ceb5	2423	*p_threshold_low = (FixPoint1616_t)((0x00fff & threshold16) << 17);
sepp_nepp	6:fb11b746ceb5	2424
sepp_nepp	6:fb11b746ceb5	2425	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2426	status = VL53L0X_read_word( VL53L0X_REG_SYSTEM_THRESH_HIGH,
sepp_nepp	6:fb11b746ceb5	2427	&threshold16);
sepp_nepp	6:fb11b746ceb5	2428	/* Need to multiply by 2 because the FW will apply a x2 */
sepp_nepp	6:fb11b746ceb5	2429	*p_threshold_high =
sepp_nepp	6:fb11b746ceb5	2430	(FixPoint1616_t)((0x00fff & threshold16) << 17);
sepp_nepp	6:fb11b746ceb5	2431	}
sepp_nepp	6:fb11b746ceb5	2432
sepp_nepp	6:fb11b746ceb5	2433
sepp_nepp	6:fb11b746ceb5	2434	return status;
sepp_nepp	6:fb11b746ceb5	2435	}
sepp_nepp	6:fb11b746ceb5	2436
sepp_nepp	8:2fd7cb217068	2437	VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(uint8_t *p_tuning_setting_buffer)
sepp_nepp	8:2fd7cb217068	2438	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2439	int i;
sepp_nepp	6:fb11b746ceb5	2440	int index;
sepp_nepp	6:fb11b746ceb5	2441	uint8_t msb;
sepp_nepp	6:fb11b746ceb5	2442	uint8_t lsb;
sepp_nepp	6:fb11b746ceb5	2443	uint8_t select_param;
sepp_nepp	9:cb4c6d4e5030	2444	uint16_t number_of_writes;
sepp_nepp	6:fb11b746ceb5	2445	uint8_t address;
sepp_nepp	6:fb11b746ceb5	2446	uint8_t local_buffer[4]; /* max */
sepp_nepp	6:fb11b746ceb5	2447	uint16_t temp16;
sepp_nepp	8:2fd7cb217068	2448
sepp_nepp	6:fb11b746ceb5	2449	index = 0;
sepp_nepp	6:fb11b746ceb5	2450
sepp_nepp	6:fb11b746ceb5	2451	while ((*(p_tuning_setting_buffer + index) != 0) &&
sepp_nepp	6:fb11b746ceb5	2452	(status == VL53L0X_ERROR_NONE)) {
sepp_nepp	6:fb11b746ceb5	2453	number_of_writes = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2454	index++;
sepp_nepp	6:fb11b746ceb5	2455	if (number_of_writes == 0xFF) {
sepp_nepp	6:fb11b746ceb5	2456	/* internal parameters */
sepp_nepp	6:fb11b746ceb5	2457	select_param = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2458	index++;
sepp_nepp	6:fb11b746ceb5	2459	switch (select_param) {
sepp_nepp	6:fb11b746ceb5	2460	case 0: /* uint16_t SigmaEstRefArray -> 2 bytes */
sepp_nepp	6:fb11b746ceb5	2461	msb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2462	index++;
sepp_nepp	6:fb11b746ceb5	2463	lsb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2464	index++;
sepp_nepp	6:fb11b746ceb5	2465	temp16 = VL53L0X_MAKEUINT16(lsb, msb);
sepp_nepp	8:2fd7cb217068	2466	Data.SigmaEstRefArray = temp16;
sepp_nepp	6:fb11b746ceb5	2467	break;
sepp_nepp	6:fb11b746ceb5	2468	case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
sepp_nepp	6:fb11b746ceb5	2469	msb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2470	index++;
sepp_nepp	6:fb11b746ceb5	2471	lsb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2472	index++;
sepp_nepp	6:fb11b746ceb5	2473	temp16 = VL53L0X_MAKEUINT16(lsb, msb);
sepp_nepp	8:2fd7cb217068	2474	Data.SigmaEstEffPulseWidth = temp16;
sepp_nepp	6:fb11b746ceb5	2475	break;
sepp_nepp	6:fb11b746ceb5	2476	case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
sepp_nepp	6:fb11b746ceb5	2477	msb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2478	index++;
sepp_nepp	6:fb11b746ceb5	2479	lsb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2480	index++;
sepp_nepp	6:fb11b746ceb5	2481	temp16 = VL53L0X_MAKEUINT16(lsb, msb);
sepp_nepp	8:2fd7cb217068	2482	Data.SigmaEstEffAmbWidth = temp16;
sepp_nepp	6:fb11b746ceb5	2483	break;
sepp_nepp	6:fb11b746ceb5	2484	case 3: /* uint16_t targetRefRate -> 2 bytes */
sepp_nepp	6:fb11b746ceb5	2485	msb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2486	index++;
sepp_nepp	6:fb11b746ceb5	2487	lsb = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2488	index++;
sepp_nepp	6:fb11b746ceb5	2489	temp16 = VL53L0X_MAKEUINT16(lsb, msb);
sepp_nepp	8:2fd7cb217068	2490	Data.targetRefRate = temp16;
sepp_nepp	6:fb11b746ceb5	2491	break;
sepp_nepp	6:fb11b746ceb5	2492	default: /* invalid parameter */
sepp_nepp	6:fb11b746ceb5	2493	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	2494	}
sepp_nepp	6:fb11b746ceb5	2495
sepp_nepp	6:fb11b746ceb5	2496	} else if (number_of_writes <= 4) {
sepp_nepp	6:fb11b746ceb5	2497	address = *(p_tuning_setting_buffer + index);
sepp_nepp	6:fb11b746ceb5	2498	index++;
sepp_nepp	6:fb11b746ceb5	2499
sepp_nepp	6:fb11b746ceb5	2500	for (i = 0; i < number_of_writes; i++) {
sepp_nepp	6:fb11b746ceb5	2501	local_buffer[i] = *(p_tuning_setting_buffer +
sepp_nepp	6:fb11b746ceb5	2502	index);
sepp_nepp	6:fb11b746ceb5	2503	index++;
sepp_nepp	6:fb11b746ceb5	2504	}
sepp_nepp	6:fb11b746ceb5	2505
sepp_nepp	9:cb4c6d4e5030	2506	status = VL53L0X_i2c_write( address, local_buffer, number_of_writes);
sepp_nepp	8:2fd7cb217068	2507
sepp_nepp	8:2fd7cb217068	2508	} else { status = VL53L0X_ERROR_INVALID_PARAMS; }
sepp_nepp	6:fb11b746ceb5	2509	}
sepp_nepp	6:fb11b746ceb5	2510	return status;
sepp_nepp	6:fb11b746ceb5	2511	}
sepp_nepp	6:fb11b746ceb5	2512
sepp_nepp	8:2fd7cb217068	2513	VL53L0X_Error VL53L0X::VL53L0X_check_and_load_interrupt_settings(uint8_t start_not_stopflag)
sepp_nepp	8:2fd7cb217068	2514	{ uint8_t interrupt_config;
sepp_nepp	6:fb11b746ceb5	2515	FixPoint1616_t threshold_low;
sepp_nepp	6:fb11b746ceb5	2516	FixPoint1616_t threshold_high;
sepp_nepp	6:fb11b746ceb5	2517	VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2518
sepp_nepp	8:2fd7cb217068	2519	interrupt_config = Data.Pin0GpioFunctionality;
sepp_nepp	6:fb11b746ceb5	2520
sepp_nepp	6:fb11b746ceb5	2521	if ((interrupt_config ==
sepp_nepp	6:fb11b746ceb5	2522	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) \|\|
sepp_nepp	6:fb11b746ceb5	2523	(interrupt_config ==
sepp_nepp	6:fb11b746ceb5	2524	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH) \|\|
sepp_nepp	6:fb11b746ceb5	2525	(interrupt_config ==
sepp_nepp	6:fb11b746ceb5	2526	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
sepp_nepp	6:fb11b746ceb5	2527
sepp_nepp	8:2fd7cb217068	2528	status = VL53L0X_get_interrupt_thresholds(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
sepp_nepp	6:fb11b746ceb5	2529	&threshold_low, &threshold_high);
sepp_nepp	6:fb11b746ceb5	2530
sepp_nepp	6:fb11b746ceb5	2531	if (((threshold_low > 255 * 65536) \|\|
sepp_nepp	6:fb11b746ceb5	2532	(threshold_high > 255 * 65536)) &&
sepp_nepp	6:fb11b746ceb5	2533	(status == VL53L0X_ERROR_NONE)) {
sepp_nepp	6:fb11b746ceb5	2534
sepp_nepp	6:fb11b746ceb5	2535	if (start_not_stopflag != 0) {
sepp_nepp	8:2fd7cb217068	2536	status = VL53L0X_load_tuning_settings(InterruptThresholdSettings);
sepp_nepp	6:fb11b746ceb5	2537	} else {
sepp_nepp	7:3a1115c2556b	2538	status \|= VL53L0X_write_byte( 0xFF, 0x04);
sepp_nepp	7:3a1115c2556b	2539	status \|= VL53L0X_write_byte( 0x70, 0x00);
sepp_nepp	7:3a1115c2556b	2540	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	7:3a1115c2556b	2541	status \|= VL53L0X_write_byte( 0x80, 0x00);
sepp_nepp	6:fb11b746ceb5	2542	}
sepp_nepp	6:fb11b746ceb5	2543	}
sepp_nepp	6:fb11b746ceb5	2544	}
sepp_nepp	6:fb11b746ceb5	2545	return status;
sepp_nepp	6:fb11b746ceb5	2546	}
sepp_nepp	6:fb11b746ceb5	2547
sepp_nepp	7:3a1115c2556b	2548	VL53L0X_Error VL53L0X::VL53L0X_start_measurement(void)
sepp_nepp	8:2fd7cb217068	2549	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2550	VL53L0X_DeviceModes device_mode;
sepp_nepp	6:fb11b746ceb5	2551	uint8_t byte;
sepp_nepp	6:fb11b746ceb5	2552	uint8_t start_stop_byte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
sepp_nepp	6:fb11b746ceb5	2553	uint32_t loop_nb;
sepp_nepp	6:fb11b746ceb5	2554
sepp_nepp	6:fb11b746ceb5	2555
sepp_nepp	6:fb11b746ceb5	2556	/* Get Current DeviceMode */
sepp_nepp	7:3a1115c2556b	2557	VL53L0X_get_device_mode( &device_mode);
sepp_nepp	7:3a1115c2556b	2558
sepp_nepp	7:3a1115c2556b	2559	status = VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	7:3a1115c2556b	2560	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	2561	status = VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	8:2fd7cb217068	2562	status = VL53L0X_write_byte( 0x91, Data.StopVariable);
sepp_nepp	7:3a1115c2556b	2563	status = VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	2564	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	7:3a1115c2556b	2565	status = VL53L0X_write_byte( 0x80, 0x00);
sepp_nepp	6:fb11b746ceb5	2566
sepp_nepp	6:fb11b746ceb5	2567	switch (device_mode) {
sepp_nepp	6:fb11b746ceb5	2568	case VL53L0X_DEVICEMODE_SINGLE_RANGING:
sepp_nepp	7:3a1115c2556b	2569	status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START, 0x01);
sepp_nepp	6:fb11b746ceb5	2570
sepp_nepp	6:fb11b746ceb5	2571	byte = start_stop_byte;
sepp_nepp	6:fb11b746ceb5	2572	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2573	/* Wait until start bit has been cleared */
sepp_nepp	6:fb11b746ceb5	2574	loop_nb = 0;
sepp_nepp	6:fb11b746ceb5	2575	do {
sepp_nepp	6:fb11b746ceb5	2576	if (loop_nb > 0)
sepp_nepp	8:2fd7cb217068	2577	status = VL53L0X_read_byte(VL53L0X_REG_SYSRANGE_START, &byte);
sepp_nepp	6:fb11b746ceb5	2578	loop_nb = loop_nb + 1;
sepp_nepp	6:fb11b746ceb5	2579	} while (((byte & start_stop_byte) == start_stop_byte)
sepp_nepp	6:fb11b746ceb5	2580	&& (status == VL53L0X_ERROR_NONE)
sepp_nepp	6:fb11b746ceb5	2581	&& (loop_nb < VL53L0X_DEFAULT_MAX_LOOP));
sepp_nepp	6:fb11b746ceb5	2582
sepp_nepp	6:fb11b746ceb5	2583	if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
sepp_nepp	6:fb11b746ceb5	2584	status = VL53L0X_ERROR_TIME_OUT;
sepp_nepp	6:fb11b746ceb5	2585	}
sepp_nepp	6:fb11b746ceb5	2586	}
sepp_nepp	6:fb11b746ceb5	2587
sepp_nepp	6:fb11b746ceb5	2588	break;
sepp_nepp	9:cb4c6d4e5030	2589	case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING: /* Back-to-back mode */
sepp_nepp	6:fb11b746ceb5	2590
sepp_nepp	6:fb11b746ceb5	2591	/* Check if need to apply interrupt settings */
sepp_nepp	9:cb4c6d4e5030	2592	if (status == VL53L0X_ERROR_NONE)
sepp_nepp	9:cb4c6d4e5030	2593	{ status = VL53L0X_check_and_load_interrupt_settings( 1); }
sepp_nepp	6:fb11b746ceb5	2594
sepp_nepp	8:2fd7cb217068	2595	status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
sepp_nepp	6:fb11b746ceb5	2596	VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
sepp_nepp	6:fb11b746ceb5	2597	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2598	/* Set PAL State to Running */
sepp_nepp	8:2fd7cb217068	2599	Data.PalState = VL53L0X_STATE_RUNNING;
sepp_nepp	6:fb11b746ceb5	2600	}
sepp_nepp	6:fb11b746ceb5	2601	break;
sepp_nepp	6:fb11b746ceb5	2602	case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
sepp_nepp	6:fb11b746ceb5	2603	/* Continuous mode */
sepp_nepp	6:fb11b746ceb5	2604	/* Check if need to apply interrupt settings */
sepp_nepp	6:fb11b746ceb5	2605	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	2606	status = VL53L0X_check_and_load_interrupt_settings( 1);
sepp_nepp	6:fb11b746ceb5	2607	}
sepp_nepp	6:fb11b746ceb5	2608
sepp_nepp	8:2fd7cb217068	2609	status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
sepp_nepp	6:fb11b746ceb5	2610	VL53L0X_REG_SYSRANGE_MODE_TIMED);
sepp_nepp	6:fb11b746ceb5	2611
sepp_nepp	9:cb4c6d4e5030	2612	if (status == VL53L0X_ERROR_NONE)/* Set PAL State to Running */
sepp_nepp	9:cb4c6d4e5030	2613	{ Data.PalState = VL53L0X_STATE_RUNNING; }
sepp_nepp	6:fb11b746ceb5	2614	break;
sepp_nepp	6:fb11b746ceb5	2615	default:
sepp_nepp	6:fb11b746ceb5	2616	/* Selected mode not supported */
sepp_nepp	6:fb11b746ceb5	2617	status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
sepp_nepp	6:fb11b746ceb5	2618	}
sepp_nepp	9:cb4c6d4e5030	2619
sepp_nepp	6:fb11b746ceb5	2620	return status;
sepp_nepp	6:fb11b746ceb5	2621	}
sepp_nepp	6:fb11b746ceb5	2622
sepp_nepp	6:fb11b746ceb5	2623	/* Group PAL Measurement Functions */
sepp_nepp	7:3a1115c2556b	2624	VL53L0X_Error VL53L0X::VL53L0X_perform_single_measurement(void)
sepp_nepp	8:2fd7cb217068	2625	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	9:cb4c6d4e5030	2626	VL53L0X_DeviceModes device_mode;
sepp_nepp	6:fb11b746ceb5	2627
sepp_nepp	6:fb11b746ceb5	2628	/* Get Current DeviceMode */
sepp_nepp	7:3a1115c2556b	2629	status = VL53L0X_get_device_mode( &device_mode);
sepp_nepp	6:fb11b746ceb5	2630
sepp_nepp	6:fb11b746ceb5	2631	/* Start immediately to run a single ranging measurement in case of
sepp_nepp	6:fb11b746ceb5	2632	* single ranging or single histogram */
sepp_nepp	9:cb4c6d4e5030	2633	if (status == VL53L0X_ERROR_NONE && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {
sepp_nepp	9:cb4c6d4e5030	2634	status = VL53L0X_start_measurement(); }
sepp_nepp	6:fb11b746ceb5	2635
sepp_nepp	6:fb11b746ceb5	2636	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	2637	status = VL53L0X_measurement_poll_for_completion(); }
sepp_nepp	6:fb11b746ceb5	2638
sepp_nepp	6:fb11b746ceb5	2639	/* Change PAL State in case of single ranging or single histogram */
sepp_nepp	7:3a1115c2556b	2640	if (status == VL53L0X_ERROR_NONE && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {
sepp_nepp	8:2fd7cb217068	2641	Data.PalState = VL53L0X_STATE_IDLE; }
sepp_nepp	7:3a1115c2556b	2642
sepp_nepp	6:fb11b746ceb5	2643	return status;
sepp_nepp	6:fb11b746ceb5	2644	}
sepp_nepp	6:fb11b746ceb5	2645
sepp_nepp	8:2fd7cb217068	2646	VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_enable(uint8_t *p_x_talk_compensation_enable)
sepp_nepp	7:3a1115c2556b	2647	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2648	uint8_t temp8;
sepp_nepp	7:3a1115c2556b	2649
sepp_nepp	10:cd1758e186a4	2650	temp8 = CurrentParameters.XTalkCompensationEnable ;
sepp_nepp	6:fb11b746ceb5	2651	*p_x_talk_compensation_enable = temp8;
sepp_nepp	6:fb11b746ceb5	2652
sepp_nepp	6:fb11b746ceb5	2653	return status;
sepp_nepp	6:fb11b746ceb5	2654	}
sepp_nepp	6:fb11b746ceb5	2655
sepp_nepp	8:2fd7cb217068	2656	VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
sepp_nepp	11:d8dbe3b87f9f	2657	FixPoint1616_t *p_total_xtalk_rate_MHz)
sepp_nepp	8:2fd7cb217068	2658	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2659
sepp_nepp	6:fb11b746ceb5	2660	uint8_t xtalk_comp_enable;
sepp_nepp	11:d8dbe3b87f9f	2661	FixPoint1616_t total_xtalk_MHz;
sepp_nepp	11:d8dbe3b87f9f	2662	FixPoint1616_t xtalk_per_spad_MHz;
sepp_nepp	11:d8dbe3b87f9f	2663
sepp_nepp	11:d8dbe3b87f9f	2664	*p_total_xtalk_rate_MHz = 0;
sepp_nepp	6:fb11b746ceb5	2665
sepp_nepp	7:3a1115c2556b	2666	status = VL53L0X_get_x_talk_compensation_enable( &xtalk_comp_enable);
sepp_nepp	6:fb11b746ceb5	2667	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2668
sepp_nepp	6:fb11b746ceb5	2669	if (xtalk_comp_enable) {
sepp_nepp	6:fb11b746ceb5	2670
sepp_nepp	11:d8dbe3b87f9f	2671	xtalk_per_spad_MHz = CurrentParameters.XTalkCompensationRate_MHz ;
sepp_nepp	6:fb11b746ceb5	2672
sepp_nepp	6:fb11b746ceb5	2673	/* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
sepp_nepp	11:d8dbe3b87f9f	2674	total_xtalk_MHz =
sepp_nepp	6:fb11b746ceb5	2675	p_ranging_measurement_data->EffectiveSpadRtnCount *
sepp_nepp	11:d8dbe3b87f9f	2676	xtalk_per_spad_MHz;
sepp_nepp	6:fb11b746ceb5	2677
sepp_nepp	6:fb11b746ceb5	2678	/* FixPoint0824 >> 8 = FixPoint1616 */
sepp_nepp	11:d8dbe3b87f9f	2679	*p_total_xtalk_rate_MHz =
sepp_nepp	11:d8dbe3b87f9f	2680	(total_xtalk_MHz + 0x80) >> 8;
sepp_nepp	6:fb11b746ceb5	2681	}
sepp_nepp	6:fb11b746ceb5	2682	}
sepp_nepp	6:fb11b746ceb5	2683	return status;
sepp_nepp	6:fb11b746ceb5	2684	}
sepp_nepp	6:fb11b746ceb5	2685
sepp_nepp	8:2fd7cb217068	2686	VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
sepp_nepp	11:d8dbe3b87f9f	2687	FixPoint1616_t *p_total_signal_rate_MHz)
sepp_nepp	8:2fd7cb217068	2688	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	11:d8dbe3b87f9f	2689	FixPoint1616_t total_xtalk_MHz;
sepp_nepp	11:d8dbe3b87f9f	2690
sepp_nepp	11:d8dbe3b87f9f	2691	*p_total_signal_rate_MHz =
sepp_nepp	11:d8dbe3b87f9f	2692	p_ranging_measurement_data->SignalRateRtn_MHz;
sepp_nepp	11:d8dbe3b87f9f	2693
sepp_nepp	11:d8dbe3b87f9f	2694	status = VL53L0X_get_total_xtalk_rate(p_ranging_measurement_data, &total_xtalk_MHz);
sepp_nepp	6:fb11b746ceb5	2695
sepp_nepp	6:fb11b746ceb5	2696	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	2697	*p_total_signal_rate_MHz += total_xtalk_MHz; }
sepp_nepp	6:fb11b746ceb5	2698
sepp_nepp	6:fb11b746ceb5	2699	return status;
sepp_nepp	6:fb11b746ceb5	2700	}
sepp_nepp	6:fb11b746ceb5	2701
sepp_nepp	6:fb11b746ceb5	2702	/* To convert ms into register value */
sepp_nepp	8:2fd7cb217068	2703	uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(uint32_t timeout_period_us,
sepp_nepp	6:fb11b746ceb5	2704	uint8_t vcsel_period_pclks)
sepp_nepp	8:2fd7cb217068	2705	{ uint32_t macro_period_ps;
sepp_nepp	6:fb11b746ceb5	2706	uint32_t macro_period_ns;
sepp_nepp	6:fb11b746ceb5	2707	uint32_t timeout_period_mclks = 0;
sepp_nepp	6:fb11b746ceb5	2708
sepp_nepp	7:3a1115c2556b	2709	macro_period_ps = VL53L0X_calc_macro_period_ps( vcsel_period_pclks);
sepp_nepp	6:fb11b746ceb5	2710	macro_period_ns = (macro_period_ps + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	2711
sepp_nepp	9:cb4c6d4e5030	2712	timeout_period_mclks = (uint32_t)(((timeout_period_us * 1000)
sepp_nepp	6:fb11b746ceb5	2713	+ (macro_period_ns / 2)) / macro_period_ns);
sepp_nepp	6:fb11b746ceb5	2714
sepp_nepp	6:fb11b746ceb5	2715	return timeout_period_mclks;
sepp_nepp	6:fb11b746ceb5	2716	}
sepp_nepp	6:fb11b746ceb5	2717
sepp_nepp	6:fb11b746ceb5	2718	uint32_t VL53L0X::VL53L0X_isqrt(uint32_t num)
sepp_nepp	9:cb4c6d4e5030	2719	{ /* Implements an integer square root
sepp_nepp	9:cb4c6d4e5030	2720	* From: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots */
sepp_nepp	6:fb11b746ceb5	2721
sepp_nepp	6:fb11b746ceb5	2722	uint32_t res = 0;
sepp_nepp	6:fb11b746ceb5	2723	uint32_t bit = 1 << 30;
sepp_nepp	9:cb4c6d4e5030	2724	/* The second-to-top bit is set: 1 << 14 for 16-bits, 1 << 30 for 32 bits */
sepp_nepp	6:fb11b746ceb5	2725
sepp_nepp	6:fb11b746ceb5	2726	/* "bit" starts at the highest power of four <= the argument. */
sepp_nepp	9:cb4c6d4e5030	2727	while (bit > num) { bit >>= 2; }
sepp_nepp	6:fb11b746ceb5	2728
sepp_nepp	6:fb11b746ceb5	2729	while (bit != 0) {
sepp_nepp	6:fb11b746ceb5	2730	if (num >= res + bit) {
sepp_nepp	6:fb11b746ceb5	2731	num -= res + bit;
sepp_nepp	6:fb11b746ceb5	2732	res = (res >> 1) + bit;
sepp_nepp	9:cb4c6d4e5030	2733	}
sepp_nepp	9:cb4c6d4e5030	2734	else { res >>= 1; }
sepp_nepp	6:fb11b746ceb5	2735	bit >>= 2;
sepp_nepp	6:fb11b746ceb5	2736	}
sepp_nepp	6:fb11b746ceb5	2737	return res;
sepp_nepp	6:fb11b746ceb5	2738	}
sepp_nepp	6:fb11b746ceb5	2739
sepp_nepp	11:d8dbe3b87f9f	2740	VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(FixPoint1616_t total_signal_rate_MHz,
sepp_nepp	11:d8dbe3b87f9f	2741	FixPoint1616_t total_corr_signal_rate_MHz,
sepp_nepp	6:fb11b746ceb5	2742	FixPoint1616_t pw_mult,
sepp_nepp	6:fb11b746ceb5	2743	uint32_t sigma_estimate_p1,
sepp_nepp	6:fb11b746ceb5	2744	FixPoint1616_t sigma_estimate_p2,
sepp_nepp	6:fb11b746ceb5	2745	uint32_t peak_vcsel_duration_us,
sepp_nepp	6:fb11b746ceb5	2746	uint32_t *pd_max_mm)
sepp_nepp	8:2fd7cb217068	2747	{ const uint32_t c_sigma_limit = 18;
sepp_nepp	6:fb11b746ceb5	2748	const FixPoint1616_t c_signal_limit = 0x4000; /* 0.25 */
sepp_nepp	6:fb11b746ceb5	2749	const FixPoint1616_t c_sigma_est_ref = 0x00000042; /* 0.001 */
sepp_nepp	6:fb11b746ceb5	2750	const uint32_t c_amb_eff_width_sigma_est_ns = 6;
sepp_nepp	6:fb11b746ceb5	2751	const uint32_t c_amb_eff_width_d_max_ns = 7;
sepp_nepp	6:fb11b746ceb5	2752	uint32_t dmax_cal_range_mm;
sepp_nepp	11:d8dbe3b87f9f	2753	FixPoint1616_t dmax_cal_signal_rate_rtn_MHz;
sepp_nepp	6:fb11b746ceb5	2754	FixPoint1616_t min_signal_needed;
sepp_nepp	6:fb11b746ceb5	2755	FixPoint1616_t min_signal_needed_p1;
sepp_nepp	6:fb11b746ceb5	2756	FixPoint1616_t min_signal_needed_p2;
sepp_nepp	6:fb11b746ceb5	2757	FixPoint1616_t min_signal_needed_p3;
sepp_nepp	6:fb11b746ceb5	2758	FixPoint1616_t min_signal_needed_p4;
sepp_nepp	6:fb11b746ceb5	2759	FixPoint1616_t sigma_limit_tmp;
sepp_nepp	6:fb11b746ceb5	2760	FixPoint1616_t sigma_est_sq_tmp;
sepp_nepp	6:fb11b746ceb5	2761	FixPoint1616_t signal_limit_tmp;
sepp_nepp	6:fb11b746ceb5	2762	FixPoint1616_t signal_at0_mm;
sepp_nepp	6:fb11b746ceb5	2763	FixPoint1616_t dmax_dark;
sepp_nepp	6:fb11b746ceb5	2764	FixPoint1616_t dmax_ambient;
sepp_nepp	6:fb11b746ceb5	2765	FixPoint1616_t dmax_dark_tmp;
sepp_nepp	6:fb11b746ceb5	2766	FixPoint1616_t sigma_est_p2_tmp;
sepp_nepp	11:d8dbe3b87f9f	2767	uint32_t signal_rate_temp_MHz;
sepp_nepp	6:fb11b746ceb5	2768
sepp_nepp	6:fb11b746ceb5	2769	VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	2770
sepp_nepp	11:d8dbe3b87f9f	2771	dmax_cal_range_mm = Data.DmaxCalRange_mm;
sepp_nepp	11:d8dbe3b87f9f	2772
sepp_nepp	11:d8dbe3b87f9f	2773	dmax_cal_signal_rate_rtn_MHz = Data.DmaxCalSignalRateRtn_MHz;
sepp_nepp	6:fb11b746ceb5	2774
sepp_nepp	6:fb11b746ceb5	2775	/* uint32 * FixPoint1616 = FixPoint1616 */
sepp_nepp	11:d8dbe3b87f9f	2776	signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_MHz;
sepp_nepp	6:fb11b746ceb5	2777
sepp_nepp	6:fb11b746ceb5	2778	/* FixPoint1616 >> 8 = FixPoint2408 */
sepp_nepp	6:fb11b746ceb5	2779	signal_at0_mm = (signal_at0_mm + 0x80) >> 8;
sepp_nepp	6:fb11b746ceb5	2780	signal_at0_mm *= dmax_cal_range_mm;
sepp_nepp	6:fb11b746ceb5	2781
sepp_nepp	6:fb11b746ceb5	2782	min_signal_needed_p1 = 0;
sepp_nepp	11:d8dbe3b87f9f	2783	if (total_corr_signal_rate_MHz > 0) {
sepp_nepp	6:fb11b746ceb5	2784
sepp_nepp	9:cb4c6d4e5030	2785	/* Shift by 10 bits to increase resolution prior to the division */
sepp_nepp	11:d8dbe3b87f9f	2786	signal_rate_temp_MHz = total_signal_rate_MHz << 10;
sepp_nepp	6:fb11b746ceb5	2787
sepp_nepp	6:fb11b746ceb5	2788	/* Add rounding value prior to division */
sepp_nepp	11:d8dbe3b87f9f	2789	min_signal_needed_p1 = signal_rate_temp_MHz +
sepp_nepp	11:d8dbe3b87f9f	2790	(total_corr_signal_rate_MHz / 2);
sepp_nepp	6:fb11b746ceb5	2791
sepp_nepp	6:fb11b746ceb5	2792	/* FixPoint0626/FixPoint1616 = FixPoint2210 */
sepp_nepp	11:d8dbe3b87f9f	2793	min_signal_needed_p1 /= total_corr_signal_rate_MHz;
sepp_nepp	6:fb11b746ceb5	2794
sepp_nepp	6:fb11b746ceb5	2795	/* Apply a factored version of the speed of light.
sepp_nepp	6:fb11b746ceb5	2796	Correction to be applied at the end */
sepp_nepp	6:fb11b746ceb5	2797	min_signal_needed_p1 *= 3;
sepp_nepp	6:fb11b746ceb5	2798
sepp_nepp	6:fb11b746ceb5	2799	/* FixPoint2210 * FixPoint2210 = FixPoint1220 */
sepp_nepp	6:fb11b746ceb5	2800	min_signal_needed_p1 *= min_signal_needed_p1;
sepp_nepp	6:fb11b746ceb5	2801
sepp_nepp	6:fb11b746ceb5	2802	/* FixPoint1220 >> 16 = FixPoint2804 */
sepp_nepp	6:fb11b746ceb5	2803	min_signal_needed_p1 = (min_signal_needed_p1 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	2804	}
sepp_nepp	6:fb11b746ceb5	2805	min_signal_needed_p2 = pw_mult * sigma_estimate_p1;
sepp_nepp	6:fb11b746ceb5	2806
sepp_nepp	6:fb11b746ceb5	2807	/* FixPoint1616 >> 16 = uint32 */
sepp_nepp	6:fb11b746ceb5	2808	min_signal_needed_p2 = (min_signal_needed_p2 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	2809
sepp_nepp	6:fb11b746ceb5	2810	/* uint32 * uint32 = uint32 */
sepp_nepp	6:fb11b746ceb5	2811	min_signal_needed_p2 *= min_signal_needed_p2;
sepp_nepp	6:fb11b746ceb5	2812
sepp_nepp	6:fb11b746ceb5	2813	/* Check sigmaEstimateP2
sepp_nepp	6:fb11b746ceb5	2814	* If this value is too high there is not enough signal rate
sepp_nepp	6:fb11b746ceb5	2815	* to calculate dmax value so set a suitable value to ensure
sepp_nepp	9:cb4c6d4e5030	2816	* a very small dmax. */
sepp_nepp	6:fb11b746ceb5	2817	sigma_est_p2_tmp = (sigma_estimate_p2 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	2818	sigma_est_p2_tmp = (sigma_est_p2_tmp + c_amb_eff_width_sigma_est_ns / 2) /
sepp_nepp	6:fb11b746ceb5	2819	c_amb_eff_width_sigma_est_ns;
sepp_nepp	6:fb11b746ceb5	2820	sigma_est_p2_tmp *= c_amb_eff_width_d_max_ns;
sepp_nepp	6:fb11b746ceb5	2821
sepp_nepp	6:fb11b746ceb5	2822	if (sigma_est_p2_tmp > 0xffff) {
sepp_nepp	6:fb11b746ceb5	2823	min_signal_needed_p3 = 0xfff00000;
sepp_nepp	6:fb11b746ceb5	2824	} else {
sepp_nepp	9:cb4c6d4e5030	2825	/* DMAX uses a different ambient width from sigma, so apply correction.
sepp_nepp	9:cb4c6d4e5030	2826	* Perform division before multiplication to prevent overflow. */
sepp_nepp	6:fb11b746ceb5	2827	sigma_estimate_p2 = (sigma_estimate_p2 + c_amb_eff_width_sigma_est_ns / 2) /
sepp_nepp	6:fb11b746ceb5	2828	c_amb_eff_width_sigma_est_ns;
sepp_nepp	6:fb11b746ceb5	2829	sigma_estimate_p2 *= c_amb_eff_width_d_max_ns;
sepp_nepp	6:fb11b746ceb5	2830
sepp_nepp	6:fb11b746ceb5	2831	/* FixPoint1616 >> 16 = uint32 */
sepp_nepp	6:fb11b746ceb5	2832	min_signal_needed_p3 = (sigma_estimate_p2 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	2833	min_signal_needed_p3 *= min_signal_needed_p3;
sepp_nepp	6:fb11b746ceb5	2834	}
sepp_nepp	6:fb11b746ceb5	2835
sepp_nepp	6:fb11b746ceb5	2836	/* FixPoint1814 / uint32 = FixPoint1814 */
sepp_nepp	6:fb11b746ceb5	2837	sigma_limit_tmp = ((c_sigma_limit << 14) + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	2838
sepp_nepp	6:fb11b746ceb5	2839	/* FixPoint1814 * FixPoint1814 = FixPoint3628 := FixPoint0428 */
sepp_nepp	6:fb11b746ceb5	2840	sigma_limit_tmp *= sigma_limit_tmp;
sepp_nepp	6:fb11b746ceb5	2841
sepp_nepp	6:fb11b746ceb5	2842	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
sepp_nepp	6:fb11b746ceb5	2843	sigma_est_sq_tmp = c_sigma_est_ref * c_sigma_est_ref;
sepp_nepp	6:fb11b746ceb5	2844
sepp_nepp	6:fb11b746ceb5	2845	/* FixPoint3232 >> 4 = FixPoint0428 */
sepp_nepp	6:fb11b746ceb5	2846	sigma_est_sq_tmp = (sigma_est_sq_tmp + 0x08) >> 4;
sepp_nepp	6:fb11b746ceb5	2847
sepp_nepp	6:fb11b746ceb5	2848	/* FixPoint0428 - FixPoint0428 = FixPoint0428 */
sepp_nepp	6:fb11b746ceb5	2849	sigma_limit_tmp -= sigma_est_sq_tmp;
sepp_nepp	6:fb11b746ceb5	2850
sepp_nepp	6:fb11b746ceb5	2851	/* uint32_t * FixPoint0428 = FixPoint0428 */
sepp_nepp	6:fb11b746ceb5	2852	min_signal_needed_p4 = 4 * 12 * sigma_limit_tmp;
sepp_nepp	6:fb11b746ceb5	2853
sepp_nepp	6:fb11b746ceb5	2854	/* FixPoint0428 >> 14 = FixPoint1814 */
sepp_nepp	6:fb11b746ceb5	2855	min_signal_needed_p4 = (min_signal_needed_p4 + 0x2000) >> 14;
sepp_nepp	6:fb11b746ceb5	2856
sepp_nepp	6:fb11b746ceb5	2857	/* uint32 + uint32 = uint32 */
sepp_nepp	6:fb11b746ceb5	2858	min_signal_needed = (min_signal_needed_p2 + min_signal_needed_p3);
sepp_nepp	6:fb11b746ceb5	2859
sepp_nepp	6:fb11b746ceb5	2860	/* uint32 / uint32 = uint32 */
sepp_nepp	6:fb11b746ceb5	2861	min_signal_needed += (peak_vcsel_duration_us / 2);
sepp_nepp	6:fb11b746ceb5	2862	min_signal_needed /= peak_vcsel_duration_us;
sepp_nepp	6:fb11b746ceb5	2863
sepp_nepp	6:fb11b746ceb5	2864	/* uint32 << 14 = FixPoint1814 */
sepp_nepp	6:fb11b746ceb5	2865	min_signal_needed <<= 14;
sepp_nepp	6:fb11b746ceb5	2866
sepp_nepp	6:fb11b746ceb5	2867	/* FixPoint1814 / FixPoint1814 = uint32 */
sepp_nepp	6:fb11b746ceb5	2868	min_signal_needed += (min_signal_needed_p4 / 2);
sepp_nepp	6:fb11b746ceb5	2869	min_signal_needed /= min_signal_needed_p4;
sepp_nepp	6:fb11b746ceb5	2870
sepp_nepp	6:fb11b746ceb5	2871	/* FixPoint3200 * FixPoint2804 := FixPoint2804*/
sepp_nepp	6:fb11b746ceb5	2872	min_signal_needed *= min_signal_needed_p1;
sepp_nepp	6:fb11b746ceb5	2873
sepp_nepp	6:fb11b746ceb5	2874	/* Apply correction by dividing by 1000000.
sepp_nepp	6:fb11b746ceb5	2875	* This assumes 10E16 on the numerator of the equation
sepp_nepp	6:fb11b746ceb5	2876	* and 10E-22 on the denominator.
sepp_nepp	6:fb11b746ceb5	2877	* We do this because 32bit fix point calculation can't
sepp_nepp	6:fb11b746ceb5	2878	* handle the larger and smaller elements of this equation,
sepp_nepp	6:fb11b746ceb5	2879	* i.e. speed of light and pulse widths.
sepp_nepp	6:fb11b746ceb5	2880	*/
sepp_nepp	6:fb11b746ceb5	2881	min_signal_needed = (min_signal_needed + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	2882	min_signal_needed <<= 4;
sepp_nepp	6:fb11b746ceb5	2883
sepp_nepp	6:fb11b746ceb5	2884	min_signal_needed = (min_signal_needed + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	2885
sepp_nepp	6:fb11b746ceb5	2886	/* FixPoint1616 >> 8 = FixPoint2408 */
sepp_nepp	6:fb11b746ceb5	2887	signal_limit_tmp = (c_signal_limit + 0x80) >> 8;
sepp_nepp	6:fb11b746ceb5	2888
sepp_nepp	6:fb11b746ceb5	2889	/* FixPoint2408/FixPoint2408 = uint32 */
sepp_nepp	6:fb11b746ceb5	2890	if (signal_limit_tmp != 0) {
sepp_nepp	6:fb11b746ceb5	2891	dmax_dark_tmp = (signal_at0_mm + (signal_limit_tmp / 2))
sepp_nepp	6:fb11b746ceb5	2892	/ signal_limit_tmp;
sepp_nepp	9:cb4c6d4e5030	2893	} else { dmax_dark_tmp = 0; }
sepp_nepp	6:fb11b746ceb5	2894
sepp_nepp	6:fb11b746ceb5	2895	dmax_dark = VL53L0X_isqrt(dmax_dark_tmp);
sepp_nepp	6:fb11b746ceb5	2896
sepp_nepp	6:fb11b746ceb5	2897	/* FixPoint2408/FixPoint2408 = uint32 */
sepp_nepp	6:fb11b746ceb5	2898	if (min_signal_needed != 0) {
sepp_nepp	6:fb11b746ceb5	2899	dmax_ambient = (signal_at0_mm + min_signal_needed / 2)
sepp_nepp	6:fb11b746ceb5	2900	/ min_signal_needed;
sepp_nepp	9:cb4c6d4e5030	2901	} else { dmax_ambient = 0; }
sepp_nepp	6:fb11b746ceb5	2902
sepp_nepp	6:fb11b746ceb5	2903	dmax_ambient = VL53L0X_isqrt(dmax_ambient);
sepp_nepp	6:fb11b746ceb5	2904
sepp_nepp	6:fb11b746ceb5	2905	*pd_max_mm = dmax_dark;
sepp_nepp	9:cb4c6d4e5030	2906	if (dmax_dark > dmax_ambient) { *pd_max_mm = dmax_ambient; }
sepp_nepp	6:fb11b746ceb5	2907
sepp_nepp	6:fb11b746ceb5	2908	return status;
sepp_nepp	6:fb11b746ceb5	2909	}
sepp_nepp	6:fb11b746ceb5	2910
sepp_nepp	8:2fd7cb217068	2911	VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
sepp_nepp	12:81f37e50f8f8	2912	FixPoint1616_t p_sigma_estimate, uint32_t p_dmax_mm)
sepp_nepp	8:2fd7cb217068	2913	{ /* Expressed in 100ths of a ns, i.e. centi-ns */
sepp_nepp	6:fb11b746ceb5	2914	const uint32_t c_pulse_effective_width_centi_ns = 800;
sepp_nepp	6:fb11b746ceb5	2915	/* Expressed in 100ths of a ns, i.e. centi-ns */
sepp_nepp	6:fb11b746ceb5	2916	const uint32_t c_ambient_effective_width_centi_ns = 600;
sepp_nepp	6:fb11b746ceb5	2917	const FixPoint1616_t c_dflt_final_range_integration_time_milli_secs = 0x00190000; /* 25ms */
sepp_nepp	6:fb11b746ceb5	2918	const uint32_t c_vcsel_pulse_width_ps = 4700; /* pico secs */
sepp_nepp	6:fb11b746ceb5	2919	const FixPoint1616_t c_sigma_est_max = 0x028F87AE;
sepp_nepp	6:fb11b746ceb5	2920	const FixPoint1616_t c_sigma_est_rtn_max = 0xF000;
sepp_nepp	6:fb11b746ceb5	2921	const FixPoint1616_t c_amb_to_signal_ratio_max = 0xF0000000 /
sepp_nepp	6:fb11b746ceb5	2922	c_ambient_effective_width_centi_ns;
sepp_nepp	6:fb11b746ceb5	2923	/* Time Of Flight per mm (6.6 pico secs) */
sepp_nepp	6:fb11b746ceb5	2924	const FixPoint1616_t c_tof_per_mm_ps = 0x0006999A;
sepp_nepp	6:fb11b746ceb5	2925	const uint32_t c_16bit_rounding_param = 0x00008000;
sepp_nepp	6:fb11b746ceb5	2926	const FixPoint1616_t c_max_x_talk_kcps = 0x00320000;
sepp_nepp	6:fb11b746ceb5	2927	const uint32_t c_pll_period_ps = 1655;
sepp_nepp	6:fb11b746ceb5	2928
sepp_nepp	6:fb11b746ceb5	2929	uint32_t vcsel_total_events_rtn;
sepp_nepp	6:fb11b746ceb5	2930	uint32_t final_range_timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	2931	uint32_t pre_range_timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	2932	uint32_t final_range_integration_time_milli_secs;
sepp_nepp	6:fb11b746ceb5	2933	FixPoint1616_t sigma_estimate_p1;
sepp_nepp	6:fb11b746ceb5	2934	FixPoint1616_t sigma_estimate_p2;
sepp_nepp	6:fb11b746ceb5	2935	FixPoint1616_t sigma_estimate_p3;
sepp_nepp	6:fb11b746ceb5	2936	FixPoint1616_t delta_t_ps;
sepp_nepp	6:fb11b746ceb5	2937	FixPoint1616_t pw_mult;
sepp_nepp	6:fb11b746ceb5	2938	FixPoint1616_t sigma_est_rtn;
sepp_nepp	6:fb11b746ceb5	2939	FixPoint1616_t sigma_estimate;
sepp_nepp	6:fb11b746ceb5	2940	FixPoint1616_t x_talk_correction;
sepp_nepp	6:fb11b746ceb5	2941	FixPoint1616_t ambient_rate_kcps;
sepp_nepp	6:fb11b746ceb5	2942	FixPoint1616_t peak_signal_rate_kcps;
sepp_nepp	11:d8dbe3b87f9f	2943	FixPoint1616_t x_talk_comp_rate_MHz;
sepp_nepp	6:fb11b746ceb5	2944	uint32_t x_talk_comp_rate_kcps;
sepp_nepp	6:fb11b746ceb5	2945	VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	11:d8dbe3b87f9f	2946	FixPoint1616_t diff1_MHz;
sepp_nepp	11:d8dbe3b87f9f	2947	FixPoint1616_t diff2_MHz;
sepp_nepp	6:fb11b746ceb5	2948	FixPoint1616_t sqr1;
sepp_nepp	6:fb11b746ceb5	2949	FixPoint1616_t sqr2;
sepp_nepp	6:fb11b746ceb5	2950	FixPoint1616_t sqr_sum;
sepp_nepp	6:fb11b746ceb5	2951	FixPoint1616_t sqrt_result_centi_ns;
sepp_nepp	6:fb11b746ceb5	2952	FixPoint1616_t sqrt_result;
sepp_nepp	11:d8dbe3b87f9f	2953	FixPoint1616_t total_signal_rate_MHz;
sepp_nepp	11:d8dbe3b87f9f	2954	FixPoint1616_t corrected_signal_rate_MHz;
sepp_nepp	6:fb11b746ceb5	2955	FixPoint1616_t sigma_est_ref;
sepp_nepp	6:fb11b746ceb5	2956	uint32_t vcsel_width;
sepp_nepp	6:fb11b746ceb5	2957	uint32_t final_range_macro_pclks;
sepp_nepp	6:fb11b746ceb5	2958	uint32_t pre_range_macro_pclks;
sepp_nepp	6:fb11b746ceb5	2959	uint32_t peak_vcsel_duration_us;
sepp_nepp	6:fb11b746ceb5	2960	uint8_t final_range_vcsel_pclks;
sepp_nepp	6:fb11b746ceb5	2961	uint8_t pre_range_vcsel_pclks;
sepp_nepp	6:fb11b746ceb5	2962	/*! \addtogroup calc_sigma_estimate
sepp_nepp	6:fb11b746ceb5	2963	* @{
sepp_nepp	6:fb11b746ceb5	2964	*
sepp_nepp	6:fb11b746ceb5	2965	* Estimates the range sigma
sepp_nepp	6:fb11b746ceb5	2966	*/
sepp_nepp	6:fb11b746ceb5	2967
sepp_nepp	11:d8dbe3b87f9f	2968	x_talk_comp_rate_MHz = CurrentParameters.XTalkCompensationRate_MHz ;
sepp_nepp	6:fb11b746ceb5	2969
sepp_nepp	6:fb11b746ceb5	2970	/*
sepp_nepp	11:d8dbe3b87f9f	2971	* We work in kcps rather than MHz as this helps keep within the
sepp_nepp	6:fb11b746ceb5	2972	* confines of the 32 Fix1616 type.
sepp_nepp	6:fb11b746ceb5	2973	*/
sepp_nepp	6:fb11b746ceb5	2974
sepp_nepp	12:81f37e50f8f8	2975	ambient_rate_kcps = (p_ranging_measurement_data->AmbientRateRtn_MHz * 1000) >> 16;
sepp_nepp	12:81f37e50f8f8	2976
sepp_nepp	12:81f37e50f8f8	2977	corrected_signal_rate_MHz = p_ranging_measurement_data->SignalRateRtn_MHz;
sepp_nepp	11:d8dbe3b87f9f	2978
sepp_nepp	11:d8dbe3b87f9f	2979	status = VL53L0X_get_total_signal_rate(p_ranging_measurement_data, &total_signal_rate_MHz);
sepp_nepp	11:d8dbe3b87f9f	2980	status = VL53L0X_get_total_xtalk_rate(p_ranging_measurement_data, &x_talk_comp_rate_MHz);
sepp_nepp	6:fb11b746ceb5	2981
sepp_nepp	6:fb11b746ceb5	2982	/* Signal rate measurement provided by device is the
sepp_nepp	6:fb11b746ceb5	2983	* peak signal rate, not average.
sepp_nepp	6:fb11b746ceb5	2984	*/
sepp_nepp	11:d8dbe3b87f9f	2985	peak_signal_rate_kcps = (total_signal_rate_MHz * 1000);
sepp_nepp	6:fb11b746ceb5	2986	peak_signal_rate_kcps = (peak_signal_rate_kcps + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	2987
sepp_nepp	11:d8dbe3b87f9f	2988	x_talk_comp_rate_kcps = x_talk_comp_rate_MHz * 1000;
sepp_nepp	6:fb11b746ceb5	2989
sepp_nepp	6:fb11b746ceb5	2990	if (x_talk_comp_rate_kcps > c_max_x_talk_kcps) {
sepp_nepp	6:fb11b746ceb5	2991	x_talk_comp_rate_kcps = c_max_x_talk_kcps;
sepp_nepp	6:fb11b746ceb5	2992	}
sepp_nepp	6:fb11b746ceb5	2993
sepp_nepp	6:fb11b746ceb5	2994	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	2995
sepp_nepp	6:fb11b746ceb5	2996	/* Calculate final range macro periods */
sepp_nepp	11:d8dbe3b87f9f	2997	final_range_timeout_micro_secs = Data.FinalRangeTimeout_us;
sepp_nepp	8:2fd7cb217068	2998	final_range_vcsel_pclks = Data.FinalRangeVcselPulsePeriod;
sepp_nepp	7:3a1115c2556b	2999	final_range_macro_pclks = VL53L0X_calc_timeout_mclks( final_range_timeout_micro_secs, final_range_vcsel_pclks);
sepp_nepp	6:fb11b746ceb5	3000
sepp_nepp	6:fb11b746ceb5	3001	/* Calculate pre-range macro periods */
sepp_nepp	11:d8dbe3b87f9f	3002	pre_range_timeout_micro_secs = Data.PreRangeTimeout_us;
sepp_nepp	8:2fd7cb217068	3003	pre_range_vcsel_pclks = Data.PreRangeVcselPulsePeriod;
sepp_nepp	7:3a1115c2556b	3004
sepp_nepp	7:3a1115c2556b	3005	pre_range_macro_pclks = VL53L0X_calc_timeout_mclks(pre_range_timeout_micro_secs, pre_range_vcsel_pclks);
sepp_nepp	6:fb11b746ceb5	3006
sepp_nepp	6:fb11b746ceb5	3007	vcsel_width = 3;
sepp_nepp	6:fb11b746ceb5	3008	if (final_range_vcsel_pclks == 8) {
sepp_nepp	6:fb11b746ceb5	3009	vcsel_width = 2;
sepp_nepp	6:fb11b746ceb5	3010	}
sepp_nepp	6:fb11b746ceb5	3011
sepp_nepp	6:fb11b746ceb5	3012	peak_vcsel_duration_us = vcsel_width * 2048 *
sepp_nepp	6:fb11b746ceb5	3013	(pre_range_macro_pclks + final_range_macro_pclks);
sepp_nepp	6:fb11b746ceb5	3014	peak_vcsel_duration_us = (peak_vcsel_duration_us + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3015	peak_vcsel_duration_us *= c_pll_period_ps;
sepp_nepp	6:fb11b746ceb5	3016	peak_vcsel_duration_us = (peak_vcsel_duration_us + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3017
sepp_nepp	6:fb11b746ceb5	3018	/* Fix1616 >> 8 = Fix2408 */
sepp_nepp	11:d8dbe3b87f9f	3019	total_signal_rate_MHz = (total_signal_rate_MHz + 0x80) >> 8;
sepp_nepp	6:fb11b746ceb5	3020
sepp_nepp	6:fb11b746ceb5	3021	/* Fix2408 * uint32 = Fix2408 */
sepp_nepp	11:d8dbe3b87f9f	3022	vcsel_total_events_rtn = total_signal_rate_MHz *
sepp_nepp	6:fb11b746ceb5	3023	peak_vcsel_duration_us;
sepp_nepp	6:fb11b746ceb5	3024
sepp_nepp	6:fb11b746ceb5	3025	/* Fix2408 >> 8 = uint32 */
sepp_nepp	6:fb11b746ceb5	3026	vcsel_total_events_rtn = (vcsel_total_events_rtn + 0x80) >> 8;
sepp_nepp	6:fb11b746ceb5	3027
sepp_nepp	6:fb11b746ceb5	3028	/* Fix2408 << 8 = Fix1616 = */
sepp_nepp	11:d8dbe3b87f9f	3029	total_signal_rate_MHz <<= 8;
sepp_nepp	6:fb11b746ceb5	3030	}
sepp_nepp	6:fb11b746ceb5	3031
sepp_nepp	12:81f37e50f8f8	3032	if (status != VL53L0X_ERROR_NONE) { return status; }
sepp_nepp	6:fb11b746ceb5	3033
sepp_nepp	6:fb11b746ceb5	3034	if (peak_signal_rate_kcps == 0) {
sepp_nepp	6:fb11b746ceb5	3035	*p_sigma_estimate = c_sigma_est_max;
sepp_nepp	12:81f37e50f8f8	3036	p_ranging_measurement_data->SigmaEstimate = c_sigma_est_max;
sepp_nepp	6:fb11b746ceb5	3037	*p_dmax_mm = 0;
sepp_nepp	6:fb11b746ceb5	3038	} else {
sepp_nepp	12:81f37e50f8f8	3039	if (vcsel_total_events_rtn < 1) { vcsel_total_events_rtn = 1; }
sepp_nepp	6:fb11b746ceb5	3040
sepp_nepp	6:fb11b746ceb5	3041	sigma_estimate_p1 = c_pulse_effective_width_centi_ns;
sepp_nepp	6:fb11b746ceb5	3042
sepp_nepp	6:fb11b746ceb5	3043	/* ((FixPoint1616 << 16)* uint32)/uint32 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3044	sigma_estimate_p2 = (ambient_rate_kcps << 16) / peak_signal_rate_kcps;
sepp_nepp	6:fb11b746ceb5	3045	if (sigma_estimate_p2 > c_amb_to_signal_ratio_max) {
sepp_nepp	6:fb11b746ceb5	3046	/* Clip to prevent overflow. Will ensure safe
sepp_nepp	6:fb11b746ceb5	3047	* max result. */
sepp_nepp	6:fb11b746ceb5	3048	sigma_estimate_p2 = c_amb_to_signal_ratio_max;
sepp_nepp	6:fb11b746ceb5	3049	}
sepp_nepp	6:fb11b746ceb5	3050	sigma_estimate_p2 *= c_ambient_effective_width_centi_ns;
sepp_nepp	6:fb11b746ceb5	3051
sepp_nepp	6:fb11b746ceb5	3052	sigma_estimate_p3 = 2 * VL53L0X_isqrt(vcsel_total_events_rtn * 12);
sepp_nepp	6:fb11b746ceb5	3053
sepp_nepp	6:fb11b746ceb5	3054	/* uint32 * FixPoint1616 = FixPoint1616 */
sepp_nepp	12:81f37e50f8f8	3055	delta_t_ps = p_ranging_measurement_data->Range_mm * c_tof_per_mm_ps;
sepp_nepp	12:81f37e50f8f8	3056
sepp_nepp	12:81f37e50f8f8	3057	/* vcselRate - xtalkCompRate
sepp_nepp	6:fb11b746ceb5	3058	* (uint32 << 16) - FixPoint1616 = FixPoint1616.
sepp_nepp	11:d8dbe3b87f9f	3059	* Divide result by 1000 to convert to MHz.
sepp_nepp	12:81f37e50f8f8	3060	* 500 is added to ensure rounding when integer division truncates. */
sepp_nepp	11:d8dbe3b87f9f	3061	diff1_MHz = (((peak_signal_rate_kcps << 16) -
sepp_nepp	6:fb11b746ceb5	3062	2 * x_talk_comp_rate_kcps) + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3063
sepp_nepp	6:fb11b746ceb5	3064	/* vcselRate + xtalkCompRate */
sepp_nepp	11:d8dbe3b87f9f	3065	diff2_MHz = ((peak_signal_rate_kcps << 16) + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3066
sepp_nepp	12:81f37e50f8f8	3067	/* Shift by 8 bits to increase resolution prior to the division */
sepp_nepp	11:d8dbe3b87f9f	3068	diff1_MHz <<= 8;
sepp_nepp	6:fb11b746ceb5	3069
sepp_nepp	6:fb11b746ceb5	3070	/* FixPoint0824/FixPoint1616 = FixPoint2408 */
sepp_nepp	11:d8dbe3b87f9f	3071	x_talk_correction = diff1_MHz / diff2_MHz;
sepp_nepp	6:fb11b746ceb5	3072
sepp_nepp	6:fb11b746ceb5	3073	/* FixPoint2408 << 8 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3074	x_talk_correction <<= 8;
sepp_nepp	6:fb11b746ceb5	3075
sepp_nepp	6:fb11b746ceb5	3076	if (p_ranging_measurement_data->RangeStatus != 0) {
sepp_nepp	6:fb11b746ceb5	3077	pw_mult = 1 << 16;
sepp_nepp	6:fb11b746ceb5	3078	} else {
sepp_nepp	6:fb11b746ceb5	3079	/* FixPoint1616/uint32 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3080	pw_mult = delta_t_ps / c_vcsel_pulse_width_ps; /* smaller than 1.0f */
sepp_nepp	6:fb11b746ceb5	3081
sepp_nepp	12:81f37e50f8f8	3082	/* FixPoint1616 * FixPoint1616 = FixPoint3232, however both
sepp_nepp	12:81f37e50f8f8	3083	* values are small enough such that32 bits will not be exceeded. */
sepp_nepp	6:fb11b746ceb5	3084	pw_mult *= ((1 << 16) - x_talk_correction);
sepp_nepp	6:fb11b746ceb5	3085
sepp_nepp	6:fb11b746ceb5	3086	/* (FixPoint3232 >> 16) = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3087	pw_mult = (pw_mult + c_16bit_rounding_param) >> 16;
sepp_nepp	6:fb11b746ceb5	3088
sepp_nepp	6:fb11b746ceb5	3089	/* FixPoint1616 + FixPoint1616 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3090	pw_mult += (1 << 16);
sepp_nepp	6:fb11b746ceb5	3091
sepp_nepp	12:81f37e50f8f8	3092	/* At this point the value will be 1.xx, therefore if we square
sepp_nepp	6:fb11b746ceb5	3093	* the value this will exceed 32 bits. To address this perform
sepp_nepp	12:81f37e50f8f8	3094	* a single shift to the right before the multiplication. */
sepp_nepp	6:fb11b746ceb5	3095	pw_mult >>= 1;
sepp_nepp	6:fb11b746ceb5	3096	/* FixPoint1715 * FixPoint1715 = FixPoint3430 */
sepp_nepp	6:fb11b746ceb5	3097	pw_mult = pw_mult * pw_mult;
sepp_nepp	6:fb11b746ceb5	3098
sepp_nepp	6:fb11b746ceb5	3099	/* (FixPoint3430 >> 14) = Fix1616 */
sepp_nepp	6:fb11b746ceb5	3100	pw_mult >>= 14;
sepp_nepp	6:fb11b746ceb5	3101	}
sepp_nepp	6:fb11b746ceb5	3102
sepp_nepp	6:fb11b746ceb5	3103	/* FixPoint1616 * uint32 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3104	sqr1 = pw_mult * sigma_estimate_p1;
sepp_nepp	6:fb11b746ceb5	3105
sepp_nepp	6:fb11b746ceb5	3106	/* (FixPoint1616 >> 16) = FixPoint3200 */
sepp_nepp	6:fb11b746ceb5	3107	sqr1 = (sqr1 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	3108
sepp_nepp	6:fb11b746ceb5	3109	/* FixPoint3200 * FixPoint3200 = FixPoint6400 */
sepp_nepp	6:fb11b746ceb5	3110	sqr1 *= sqr1;
sepp_nepp	6:fb11b746ceb5	3111
sepp_nepp	6:fb11b746ceb5	3112	sqr2 = sigma_estimate_p2;
sepp_nepp	6:fb11b746ceb5	3113
sepp_nepp	6:fb11b746ceb5	3114	/* (FixPoint1616 >> 16) = FixPoint3200 */
sepp_nepp	6:fb11b746ceb5	3115	sqr2 = (sqr2 + 0x8000) >> 16;
sepp_nepp	6:fb11b746ceb5	3116
sepp_nepp	6:fb11b746ceb5	3117	/* FixPoint3200 * FixPoint3200 = FixPoint6400 */
sepp_nepp	6:fb11b746ceb5	3118	sqr2 *= sqr2;
sepp_nepp	6:fb11b746ceb5	3119
sepp_nepp	6:fb11b746ceb5	3120	/* FixPoint64000 + FixPoint6400 = FixPoint6400 */
sepp_nepp	6:fb11b746ceb5	3121	sqr_sum = sqr1 + sqr2;
sepp_nepp	6:fb11b746ceb5	3122
sepp_nepp	6:fb11b746ceb5	3123	/* SQRT(FixPoin6400) = FixPoint3200 */
sepp_nepp	6:fb11b746ceb5	3124	sqrt_result_centi_ns = VL53L0X_isqrt(sqr_sum);
sepp_nepp	6:fb11b746ceb5	3125
sepp_nepp	6:fb11b746ceb5	3126	/* (FixPoint3200 << 16) = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3127	sqrt_result_centi_ns <<= 16;
sepp_nepp	6:fb11b746ceb5	3128
sepp_nepp	12:81f37e50f8f8	3129	/* Note that the Speed Of Light is expressed in um per 1E-10
sepp_nepp	6:fb11b746ceb5	3130	* seconds (2997) Therefore to get mm/ns we have to divide by
sepp_nepp	6:fb11b746ceb5	3131	* 10000
sepp_nepp	6:fb11b746ceb5	3132	*/
sepp_nepp	6:fb11b746ceb5	3133	sigma_est_rtn = (((sqrt_result_centi_ns + 50) / 100) /
sepp_nepp	6:fb11b746ceb5	3134	sigma_estimate_p3);
sepp_nepp	6:fb11b746ceb5	3135	sigma_est_rtn *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
sepp_nepp	6:fb11b746ceb5	3136
sepp_nepp	6:fb11b746ceb5	3137	/* Add 5000 before dividing by 10000 to ensure rounding. */
sepp_nepp	6:fb11b746ceb5	3138	sigma_est_rtn += 5000;
sepp_nepp	6:fb11b746ceb5	3139	sigma_est_rtn /= 10000;
sepp_nepp	6:fb11b746ceb5	3140
sepp_nepp	6:fb11b746ceb5	3141	if (sigma_est_rtn > c_sigma_est_rtn_max) {
sepp_nepp	6:fb11b746ceb5	3142	/* Clip to prevent overflow. Will ensure safe
sepp_nepp	6:fb11b746ceb5	3143	* max result. */
sepp_nepp	6:fb11b746ceb5	3144	sigma_est_rtn = c_sigma_est_rtn_max;
sepp_nepp	6:fb11b746ceb5	3145	}
sepp_nepp	6:fb11b746ceb5	3146	final_range_integration_time_milli_secs =
sepp_nepp	6:fb11b746ceb5	3147	(final_range_timeout_micro_secs + pre_range_timeout_micro_secs + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3148
sepp_nepp	6:fb11b746ceb5	3149	/* sigmaEstRef = 1mm * 25ms/final range integration time (inc pre-range)
sepp_nepp	6:fb11b746ceb5	3150	* sqrt(FixPoint1616/int) = FixPoint2408)
sepp_nepp	6:fb11b746ceb5	3151	*/
sepp_nepp	6:fb11b746ceb5	3152	sigma_est_ref =
sepp_nepp	6:fb11b746ceb5	3153	VL53L0X_isqrt((c_dflt_final_range_integration_time_milli_secs +
sepp_nepp	6:fb11b746ceb5	3154	final_range_integration_time_milli_secs / 2) /
sepp_nepp	6:fb11b746ceb5	3155	final_range_integration_time_milli_secs);
sepp_nepp	6:fb11b746ceb5	3156
sepp_nepp	6:fb11b746ceb5	3157	/* FixPoint2408 << 8 = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3158	sigma_est_ref <<= 8;
sepp_nepp	6:fb11b746ceb5	3159	sigma_est_ref = (sigma_est_ref + 500) / 1000;
sepp_nepp	6:fb11b746ceb5	3160
sepp_nepp	6:fb11b746ceb5	3161	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
sepp_nepp	6:fb11b746ceb5	3162	sqr1 = sigma_est_rtn * sigma_est_rtn;
sepp_nepp	6:fb11b746ceb5	3163	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
sepp_nepp	6:fb11b746ceb5	3164	sqr2 = sigma_est_ref * sigma_est_ref;
sepp_nepp	6:fb11b746ceb5	3165
sepp_nepp	6:fb11b746ceb5	3166	/* sqrt(FixPoint3232) = FixPoint1616 */
sepp_nepp	6:fb11b746ceb5	3167	sqrt_result = VL53L0X_isqrt((sqr1 + sqr2));
sepp_nepp	6:fb11b746ceb5	3168	/*
sepp_nepp	6:fb11b746ceb5	3169	* Note that the Shift by 4 bits increases resolution prior to
sepp_nepp	6:fb11b746ceb5	3170	* the sqrt, therefore the result must be shifted by 2 bits to
sepp_nepp	6:fb11b746ceb5	3171	* the right to revert back to the FixPoint1616 format.
sepp_nepp	6:fb11b746ceb5	3172	*/
sepp_nepp	6:fb11b746ceb5	3173
sepp_nepp	6:fb11b746ceb5	3174	sigma_estimate = 1000 * sqrt_result;
sepp_nepp	6:fb11b746ceb5	3175
sepp_nepp	6:fb11b746ceb5	3176	if ((peak_signal_rate_kcps < 1) \|\| (vcsel_total_events_rtn < 1) \|\|
sepp_nepp	6:fb11b746ceb5	3177	(sigma_estimate > c_sigma_est_max)) {
sepp_nepp	6:fb11b746ceb5	3178	sigma_estimate = c_sigma_est_max;
sepp_nepp	6:fb11b746ceb5	3179	}
sepp_nepp	6:fb11b746ceb5	3180
sepp_nepp	6:fb11b746ceb5	3181	*p_sigma_estimate = (uint32_t)(sigma_estimate);
sepp_nepp	12:81f37e50f8f8	3182	p_ranging_measurement_data->SigmaEstimate = *p_sigma_estimate;
sepp_nepp	11:d8dbe3b87f9f	3183	status = VL53L0X_calc_dmax(total_signal_rate_MHz,
sepp_nepp	11:d8dbe3b87f9f	3184	corrected_signal_rate_MHz,
sepp_nepp	6:fb11b746ceb5	3185	pw_mult,
sepp_nepp	6:fb11b746ceb5	3186	sigma_estimate_p1,
sepp_nepp	6:fb11b746ceb5	3187	sigma_estimate_p2,
sepp_nepp	6:fb11b746ceb5	3188	peak_vcsel_duration_us,
sepp_nepp	6:fb11b746ceb5	3189	p_dmax_mm);
sepp_nepp	6:fb11b746ceb5	3190	}
sepp_nepp	6:fb11b746ceb5	3191
sepp_nepp	6:fb11b746ceb5	3192	return status;
sepp_nepp	6:fb11b746ceb5	3193	}
sepp_nepp	6:fb11b746ceb5	3194
sepp_nepp	8:2fd7cb217068	3195	VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(uint8_t device_range_status,
sepp_nepp	6:fb11b746ceb5	3196	FixPoint1616_t signal_rate,
sepp_nepp	6:fb11b746ceb5	3197	uint16_t effective_spad_rtn_count,
sepp_nepp	6:fb11b746ceb5	3198	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
sepp_nepp	6:fb11b746ceb5	3199	uint8_t *p_pal_range_status)
sepp_nepp	8:2fd7cb217068	3200	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3201	uint8_t none_flag;
sepp_nepp	6:fb11b746ceb5	3202	uint8_t sigma_limitflag = 0;
sepp_nepp	6:fb11b746ceb5	3203	uint8_t signal_ref_clipflag = 0;
sepp_nepp	6:fb11b746ceb5	3204	uint8_t range_ignore_thresholdflag = 0;
sepp_nepp	6:fb11b746ceb5	3205	uint8_t sigma_limit_check_enable = 0;
sepp_nepp	6:fb11b746ceb5	3206	uint8_t signal_rate_final_range_limit_check_enable = 0;
sepp_nepp	6:fb11b746ceb5	3207	uint8_t signal_ref_clip_limit_check_enable = 0;
sepp_nepp	6:fb11b746ceb5	3208	uint8_t range_ignore_threshold_limit_check_enable = 0;
sepp_nepp	6:fb11b746ceb5	3209	FixPoint1616_t sigma_estimate;
sepp_nepp	6:fb11b746ceb5	3210	FixPoint1616_t sigma_limit_value;
sepp_nepp	6:fb11b746ceb5	3211	FixPoint1616_t signal_ref_clip_value;
sepp_nepp	6:fb11b746ceb5	3212	FixPoint1616_t range_ignore_threshold_value;
sepp_nepp	6:fb11b746ceb5	3213	FixPoint1616_t signal_rate_per_spad;
sepp_nepp	6:fb11b746ceb5	3214	uint8_t device_range_status_internal = 0;
sepp_nepp	6:fb11b746ceb5	3215	uint16_t tmp_word = 0;
sepp_nepp	6:fb11b746ceb5	3216	uint8_t temp8;
sepp_nepp	6:fb11b746ceb5	3217	uint32_t dmax_mm = 0;
sepp_nepp	11:d8dbe3b87f9f	3218	FixPoint1616_t last_signal_ref_MHz;
sepp_nepp	9:cb4c6d4e5030	3219
sepp_nepp	9:cb4c6d4e5030	3220	/* VL53L0X has a good ranging when the value of the
sepp_nepp	6:fb11b746ceb5	3221	* DeviceRangeStatus = 11. This function will replace the value 0 with
sepp_nepp	6:fb11b746ceb5	3222	* the value 11 in the DeviceRangeStatus.
sepp_nepp	6:fb11b746ceb5	3223	* In addition, the SigmaEstimator is not included in the VL53L0X
sepp_nepp	9:cb4c6d4e5030	3224	* DeviceRangeStatus, this will be added in the PalRangeStatus. */
sepp_nepp	6:fb11b746ceb5	3225
sepp_nepp	6:fb11b746ceb5	3226	device_range_status_internal = ((device_range_status & 0x78) >> 3);
sepp_nepp	6:fb11b746ceb5	3227
sepp_nepp	6:fb11b746ceb5	3228	if (device_range_status_internal == 0 \|\|
sepp_nepp	6:fb11b746ceb5	3229	device_range_status_internal == 5 \|\|
sepp_nepp	6:fb11b746ceb5	3230	device_range_status_internal == 7 \|\|
sepp_nepp	6:fb11b746ceb5	3231	device_range_status_internal == 12 \|\|
sepp_nepp	6:fb11b746ceb5	3232	device_range_status_internal == 13 \|\|
sepp_nepp	6:fb11b746ceb5	3233	device_range_status_internal == 14 \|\|
sepp_nepp	6:fb11b746ceb5	3234	device_range_status_internal == 15
sepp_nepp	6:fb11b746ceb5	3235	) {
sepp_nepp	6:fb11b746ceb5	3236	none_flag = 1;
sepp_nepp	6:fb11b746ceb5	3237	} else {
sepp_nepp	6:fb11b746ceb5	3238	none_flag = 0;
sepp_nepp	6:fb11b746ceb5	3239	}
sepp_nepp	6:fb11b746ceb5	3240
sepp_nepp	12:81f37e50f8f8	3241	/* Check if Sigma limit is enabled, if yes then do comparison with limit
sepp_nepp	12:81f37e50f8f8	3242	* value and put the result back into pPalRangeStatus. */
sepp_nepp	6:fb11b746ceb5	3243	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3244	status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	3245	&sigma_limit_check_enable);
sepp_nepp	6:fb11b746ceb5	3246	}
sepp_nepp	6:fb11b746ceb5	3247
sepp_nepp	6:fb11b746ceb5	3248	if ((sigma_limit_check_enable != 0) && (status == VL53L0X_ERROR_NONE)) {
sepp_nepp	12:81f37e50f8f8	3249	/* compute the Sigma and check with limit */
sepp_nepp	12:81f37e50f8f8	3250	status = VL53L0X_calc_sigma_estimate(p_ranging_measurement_data, &sigma_estimate, &dmax_mm);
sepp_nepp	12:81f37e50f8f8	3251	if (status == VL53L0X_ERROR_NONE) { p_ranging_measurement_data->RangeDMax_mm = dmax_mm; }
sepp_nepp	6:fb11b746ceb5	3252
sepp_nepp	6:fb11b746ceb5	3253	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3254	status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	3255	&sigma_limit_value);
sepp_nepp	6:fb11b746ceb5	3256
sepp_nepp	12:81f37e50f8f8	3257	if ((sigma_limit_value > 0) && (sigma_estimate > sigma_limit_value))
sepp_nepp	12:81f37e50f8f8	3258	{ sigma_limitflag = 1; } /* Limit Fail */
sepp_nepp	6:fb11b746ceb5	3259	}
sepp_nepp	6:fb11b746ceb5	3260	}
sepp_nepp	6:fb11b746ceb5	3261
sepp_nepp	12:81f37e50f8f8	3262	/* Check if Signal ref clip limit is enabled, if yes then do comparison
sepp_nepp	12:81f37e50f8f8	3263	* with limit value and put the result back into pPalRangeStatus. */
sepp_nepp	6:fb11b746ceb5	3264	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3265	status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
sepp_nepp	6:fb11b746ceb5	3266	&signal_ref_clip_limit_check_enable);
sepp_nepp	6:fb11b746ceb5	3267	}
sepp_nepp	6:fb11b746ceb5	3268
sepp_nepp	6:fb11b746ceb5	3269	if ((signal_ref_clip_limit_check_enable != 0) &&
sepp_nepp	6:fb11b746ceb5	3270	(status == VL53L0X_ERROR_NONE)) {
sepp_nepp	6:fb11b746ceb5	3271
sepp_nepp	8:2fd7cb217068	3272	status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
sepp_nepp	6:fb11b746ceb5	3273	&signal_ref_clip_value);
sepp_nepp	6:fb11b746ceb5	3274
sepp_nepp	11:d8dbe3b87f9f	3275	/* Read LastSignalRef_MHz from device */
sepp_nepp	6:fb11b746ceb5	3276	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3277	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	6:fb11b746ceb5	3278	}
sepp_nepp	6:fb11b746ceb5	3279
sepp_nepp	6:fb11b746ceb5	3280	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3281	status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
sepp_nepp	6:fb11b746ceb5	3282	&tmp_word);
sepp_nepp	6:fb11b746ceb5	3283	}
sepp_nepp	6:fb11b746ceb5	3284
sepp_nepp	6:fb11b746ceb5	3285	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3286	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	3287	}
sepp_nepp	6:fb11b746ceb5	3288
sepp_nepp	11:d8dbe3b87f9f	3289	last_signal_ref_MHz = VL53L0X_FP97TOFP1616(tmp_word);
sepp_nepp	11:d8dbe3b87f9f	3290	Data.LastSignalRef_MHz = last_signal_ref_MHz;
sepp_nepp	6:fb11b746ceb5	3291
sepp_nepp	6:fb11b746ceb5	3292	if ((signal_ref_clip_value > 0) &&
sepp_nepp	11:d8dbe3b87f9f	3293	(last_signal_ref_MHz > signal_ref_clip_value)) {
sepp_nepp	6:fb11b746ceb5	3294	/* Limit Fail */
sepp_nepp	6:fb11b746ceb5	3295	signal_ref_clipflag = 1;
sepp_nepp	6:fb11b746ceb5	3296	}
sepp_nepp	6:fb11b746ceb5	3297	}
sepp_nepp	6:fb11b746ceb5	3298
sepp_nepp	6:fb11b746ceb5	3299	/*
sepp_nepp	6:fb11b746ceb5	3300	* Check if Signal ref clip limit is enabled, if yes then do comparison
sepp_nepp	6:fb11b746ceb5	3301	* with limit value and put the result back into pPalRangeStatus.
sepp_nepp	6:fb11b746ceb5	3302	* EffectiveSpadRtnCount has a format 8.8
sepp_nepp	6:fb11b746ceb5	3303	* If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
sepp_nepp	6:fb11b746ceb5	3304	*/
sepp_nepp	6:fb11b746ceb5	3305	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3306	status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
sepp_nepp	6:fb11b746ceb5	3307	&range_ignore_threshold_limit_check_enable);
sepp_nepp	6:fb11b746ceb5	3308	}
sepp_nepp	6:fb11b746ceb5	3309
sepp_nepp	6:fb11b746ceb5	3310	if ((range_ignore_threshold_limit_check_enable != 0) &&
sepp_nepp	6:fb11b746ceb5	3311	(status == VL53L0X_ERROR_NONE)) {
sepp_nepp	6:fb11b746ceb5	3312
sepp_nepp	6:fb11b746ceb5	3313	/* Compute the signal rate per spad */
sepp_nepp	6:fb11b746ceb5	3314	if (effective_spad_rtn_count == 0) {
sepp_nepp	6:fb11b746ceb5	3315	signal_rate_per_spad = 0;
sepp_nepp	6:fb11b746ceb5	3316	} else {
sepp_nepp	6:fb11b746ceb5	3317	signal_rate_per_spad = (FixPoint1616_t)((256 * signal_rate)
sepp_nepp	6:fb11b746ceb5	3318	/ effective_spad_rtn_count);
sepp_nepp	6:fb11b746ceb5	3319	}
sepp_nepp	6:fb11b746ceb5	3320
sepp_nepp	8:2fd7cb217068	3321	status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
sepp_nepp	6:fb11b746ceb5	3322	&range_ignore_threshold_value);
sepp_nepp	6:fb11b746ceb5	3323
sepp_nepp	6:fb11b746ceb5	3324	if ((range_ignore_threshold_value > 0) &&
sepp_nepp	6:fb11b746ceb5	3325	(signal_rate_per_spad < range_ignore_threshold_value)) {
sepp_nepp	6:fb11b746ceb5	3326	/* Limit Fail add 2^6 to range status */
sepp_nepp	6:fb11b746ceb5	3327	range_ignore_thresholdflag = 1;
sepp_nepp	6:fb11b746ceb5	3328	}
sepp_nepp	6:fb11b746ceb5	3329	}
sepp_nepp	6:fb11b746ceb5	3330
sepp_nepp	6:fb11b746ceb5	3331	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3332	if (none_flag == 1) {
sepp_nepp	6:fb11b746ceb5	3333	p_pal_range_status = 255; / NONE */
sepp_nepp	6:fb11b746ceb5	3334	} else if (device_range_status_internal == 1 \|\|
sepp_nepp	6:fb11b746ceb5	3335	device_range_status_internal == 2 \|\|
sepp_nepp	6:fb11b746ceb5	3336	device_range_status_internal == 3) {
sepp_nepp	6:fb11b746ceb5	3337	p_pal_range_status = 5; / HW fail */
sepp_nepp	6:fb11b746ceb5	3338	} else if (device_range_status_internal == 6 \|\|
sepp_nepp	6:fb11b746ceb5	3339	device_range_status_internal == 9) {
sepp_nepp	6:fb11b746ceb5	3340	p_pal_range_status = 4; / Phase fail */
sepp_nepp	6:fb11b746ceb5	3341	} else if (device_range_status_internal == 8 \|\|
sepp_nepp	6:fb11b746ceb5	3342	device_range_status_internal == 10 \|\|
sepp_nepp	6:fb11b746ceb5	3343	signal_ref_clipflag == 1) {
sepp_nepp	6:fb11b746ceb5	3344	p_pal_range_status = 3; / Min range */
sepp_nepp	6:fb11b746ceb5	3345	} else if (device_range_status_internal == 4 \|\|
sepp_nepp	6:fb11b746ceb5	3346	range_ignore_thresholdflag == 1) {
sepp_nepp	6:fb11b746ceb5	3347	p_pal_range_status = 2; / Signal Fail */
sepp_nepp	6:fb11b746ceb5	3348	} else if (sigma_limitflag == 1) {
sepp_nepp	6:fb11b746ceb5	3349	p_pal_range_status = 1; / Sigma Fail */
sepp_nepp	6:fb11b746ceb5	3350	} else {
sepp_nepp	6:fb11b746ceb5	3351	p_pal_range_status = 0; / Range Valid */
sepp_nepp	6:fb11b746ceb5	3352	}
sepp_nepp	6:fb11b746ceb5	3353	}
sepp_nepp	6:fb11b746ceb5	3354
sepp_nepp	6:fb11b746ceb5	3355	/* DMAX only relevant during range error */
sepp_nepp	6:fb11b746ceb5	3356	if (*p_pal_range_status == 0) {
sepp_nepp	11:d8dbe3b87f9f	3357	p_ranging_measurement_data->RangeDMax_mm = 0;
sepp_nepp	6:fb11b746ceb5	3358	}
sepp_nepp	6:fb11b746ceb5	3359
sepp_nepp	6:fb11b746ceb5	3360	/* fill the Limit Check Status */
sepp_nepp	6:fb11b746ceb5	3361
sepp_nepp	8:2fd7cb217068	3362	status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	3363	&signal_rate_final_range_limit_check_enable);
sepp_nepp	6:fb11b746ceb5	3364
sepp_nepp	6:fb11b746ceb5	3365	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3366	if ((sigma_limit_check_enable == 0) \|\| (sigma_limitflag == 1)) {
sepp_nepp	6:fb11b746ceb5	3367	temp8 = 1;
sepp_nepp	6:fb11b746ceb5	3368	} else {
sepp_nepp	6:fb11b746ceb5	3369	temp8 = 0;
sepp_nepp	6:fb11b746ceb5	3370	}
sepp_nepp	10:cd1758e186a4	3371	CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = temp8;
sepp_nepp	6:fb11b746ceb5	3372
sepp_nepp	6:fb11b746ceb5	3373	if ((device_range_status_internal == 4) \|\|
sepp_nepp	6:fb11b746ceb5	3374	(signal_rate_final_range_limit_check_enable == 0)) {
sepp_nepp	6:fb11b746ceb5	3375	temp8 = 1;
sepp_nepp	6:fb11b746ceb5	3376	} else {
sepp_nepp	6:fb11b746ceb5	3377	temp8 = 0;
sepp_nepp	6:fb11b746ceb5	3378	}
sepp_nepp	10:cd1758e186a4	3379	CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE] = temp8;
sepp_nepp	6:fb11b746ceb5	3380
sepp_nepp	6:fb11b746ceb5	3381	if ((signal_ref_clip_limit_check_enable == 0) \|\|
sepp_nepp	6:fb11b746ceb5	3382	(signal_ref_clipflag == 1)) {
sepp_nepp	6:fb11b746ceb5	3383	temp8 = 1;
sepp_nepp	6:fb11b746ceb5	3384	} else {
sepp_nepp	6:fb11b746ceb5	3385	temp8 = 0;
sepp_nepp	6:fb11b746ceb5	3386	}
sepp_nepp	6:fb11b746ceb5	3387
sepp_nepp	10:cd1758e186a4	3388	CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = temp8;
sepp_nepp	6:fb11b746ceb5	3389
sepp_nepp	6:fb11b746ceb5	3390	if ((range_ignore_threshold_limit_check_enable == 0) \|\|
sepp_nepp	6:fb11b746ceb5	3391	(range_ignore_thresholdflag == 1)) {
sepp_nepp	6:fb11b746ceb5	3392	temp8 = 1;
sepp_nepp	6:fb11b746ceb5	3393	} else {
sepp_nepp	6:fb11b746ceb5	3394	temp8 = 0;
sepp_nepp	6:fb11b746ceb5	3395	}
sepp_nepp	6:fb11b746ceb5	3396
sepp_nepp	10:cd1758e186a4	3397	CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = temp8;
sepp_nepp	6:fb11b746ceb5	3398	}
sepp_nepp	6:fb11b746ceb5	3399
sepp_nepp	6:fb11b746ceb5	3400	return status;
sepp_nepp	6:fb11b746ceb5	3401	}
sepp_nepp	6:fb11b746ceb5	3402
sepp_nepp	8:2fd7cb217068	3403	VL53L0X_Error VL53L0X::VL53L0X_get_ranging_measurement_data(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
sepp_nepp	8:2fd7cb217068	3404	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3405	uint8_t device_range_status;
sepp_nepp	6:fb11b746ceb5	3406	uint8_t range_fractional_enable;
sepp_nepp	6:fb11b746ceb5	3407	uint8_t pal_range_status;
sepp_nepp	6:fb11b746ceb5	3408	uint8_t x_talk_compensation_enable;
sepp_nepp	6:fb11b746ceb5	3409	uint16_t ambient_rate;
sepp_nepp	6:fb11b746ceb5	3410	FixPoint1616_t signal_rate;
sepp_nepp	11:d8dbe3b87f9f	3411	uint16_t x_talk_compensation_rate_MHz;
sepp_nepp	6:fb11b746ceb5	3412	uint16_t effective_spad_rtn_count;
sepp_nepp	6:fb11b746ceb5	3413	uint16_t tmpuint16;
sepp_nepp	6:fb11b746ceb5	3414	uint16_t xtalk_range_milli_meter;
sepp_nepp	6:fb11b746ceb5	3415	uint16_t linearity_corrective_gain;
sepp_nepp	6:fb11b746ceb5	3416	uint8_t localBuffer[12];
sepp_nepp	11:d8dbe3b87f9f	3417
sepp_nepp	6:fb11b746ceb5	3418	/* use multi read even if some registers are not useful, result will
sepp_nepp	9:cb4c6d4e5030	3419	* be more efficient start reading at 0x14 dec20
sepp_nepp	9:cb4c6d4e5030	3420	* end reading at 0x21 dec33 total 14 bytes to read */
sepp_nepp	7:3a1115c2556b	3421	status = VL53L0X_read_multi( 0x14, localBuffer, 12);
sepp_nepp	6:fb11b746ceb5	3422
sepp_nepp	6:fb11b746ceb5	3423	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3424
sepp_nepp	6:fb11b746ceb5	3425	tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11], localBuffer[10]);
sepp_nepp	6:fb11b746ceb5	3426	/* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
sepp_nepp	6:fb11b746ceb5	3427	(format 11.2) else no fractional /
sepp_nepp	6:fb11b746ceb5	3428
sepp_nepp	11:d8dbe3b87f9f	3429	signal_rate = VL53L0X_FP97TOFP1616(VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
sepp_nepp	11:d8dbe3b87f9f	3430	/* peak_signal_count_rate_rtn_MHz */
sepp_nepp	11:d8dbe3b87f9f	3431	p_ranging_measurement_data->SignalRateRtn_MHz = signal_rate;
sepp_nepp	6:fb11b746ceb5	3432
sepp_nepp	6:fb11b746ceb5	3433	ambient_rate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
sepp_nepp	11:d8dbe3b87f9f	3434	p_ranging_measurement_data->AmbientRateRtn_MHz =
sepp_nepp	11:d8dbe3b87f9f	3435	VL53L0X_FP97TOFP1616(ambient_rate);
sepp_nepp	6:fb11b746ceb5	3436
sepp_nepp	6:fb11b746ceb5	3437	effective_spad_rtn_count = VL53L0X_MAKEUINT16(localBuffer[3],
sepp_nepp	6:fb11b746ceb5	3438	localBuffer[2]);
sepp_nepp	6:fb11b746ceb5	3439	/* EffectiveSpadRtnCount is 8.8 format */
sepp_nepp	6:fb11b746ceb5	3440	p_ranging_measurement_data->EffectiveSpadRtnCount =
sepp_nepp	6:fb11b746ceb5	3441	effective_spad_rtn_count;
sepp_nepp	6:fb11b746ceb5	3442
sepp_nepp	6:fb11b746ceb5	3443	device_range_status = localBuffer[0];
sepp_nepp	6:fb11b746ceb5	3444
sepp_nepp	6:fb11b746ceb5	3445	/* Get Linearity Corrective Gain */
sepp_nepp	8:2fd7cb217068	3446	linearity_corrective_gain = Data.LinearityCorrectiveGain;
sepp_nepp	6:fb11b746ceb5	3447
sepp_nepp	6:fb11b746ceb5	3448	/* Get ranging configuration */
sepp_nepp	8:2fd7cb217068	3449	range_fractional_enable = Data.RangeFractionalEnable;
sepp_nepp	6:fb11b746ceb5	3450
sepp_nepp	6:fb11b746ceb5	3451	if (linearity_corrective_gain != 1000) {
sepp_nepp	6:fb11b746ceb5	3452
sepp_nepp	9:cb4c6d4e5030	3453	tmpuint16 = (uint16_t)((linearity_corrective_gain * tmpuint16 + 500) / 1000);
sepp_nepp	6:fb11b746ceb5	3454
sepp_nepp	6:fb11b746ceb5	3455	/* Implement Xtalk */
sepp_nepp	11:d8dbe3b87f9f	3456	x_talk_compensation_rate_MHz = CurrentParameters.XTalkCompensationRate_MHz ;
sepp_nepp	10:cd1758e186a4	3457	x_talk_compensation_enable = CurrentParameters.XTalkCompensationEnable ;
sepp_nepp	6:fb11b746ceb5	3458
sepp_nepp	6:fb11b746ceb5	3459	if (x_talk_compensation_enable) {
sepp_nepp	6:fb11b746ceb5	3460
sepp_nepp	6:fb11b746ceb5	3461	if ((signal_rate
sepp_nepp	11:d8dbe3b87f9f	3462	- ((x_talk_compensation_rate_MHz
sepp_nepp	6:fb11b746ceb5	3463	* effective_spad_rtn_count) >> 8))
sepp_nepp	6:fb11b746ceb5	3464	<= 0) {
sepp_nepp	6:fb11b746ceb5	3465	if (range_fractional_enable) {
sepp_nepp	6:fb11b746ceb5	3466	xtalk_range_milli_meter = 8888;
sepp_nepp	6:fb11b746ceb5	3467	} else {
sepp_nepp	6:fb11b746ceb5	3468	xtalk_range_milli_meter = 8888 << 2;
sepp_nepp	6:fb11b746ceb5	3469	}
sepp_nepp	6:fb11b746ceb5	3470	} else {
sepp_nepp	6:fb11b746ceb5	3471	xtalk_range_milli_meter =
sepp_nepp	6:fb11b746ceb5	3472	(tmpuint16 * signal_rate)
sepp_nepp	6:fb11b746ceb5	3473	/ (signal_rate
sepp_nepp	11:d8dbe3b87f9f	3474	- ((x_talk_compensation_rate_MHz
sepp_nepp	6:fb11b746ceb5	3475	* effective_spad_rtn_count)
sepp_nepp	6:fb11b746ceb5	3476	>> 8));
sepp_nepp	6:fb11b746ceb5	3477	}
sepp_nepp	6:fb11b746ceb5	3478	tmpuint16 = xtalk_range_milli_meter;
sepp_nepp	6:fb11b746ceb5	3479	}
sepp_nepp	6:fb11b746ceb5	3480	}
sepp_nepp	6:fb11b746ceb5	3481
sepp_nepp	6:fb11b746ceb5	3482	if (range_fractional_enable) {
sepp_nepp	11:d8dbe3b87f9f	3483	p_ranging_measurement_data->Range_mm =
sepp_nepp	6:fb11b746ceb5	3484	(uint16_t)((tmpuint16) >> 2);
sepp_nepp	6:fb11b746ceb5	3485	p_ranging_measurement_data->RangeFractionalPart =
sepp_nepp	6:fb11b746ceb5	3486	(uint8_t)((tmpuint16 & 0x03) << 6);
sepp_nepp	6:fb11b746ceb5	3487	} else {
sepp_nepp	11:d8dbe3b87f9f	3488	p_ranging_measurement_data->Range_mm = tmpuint16;
sepp_nepp	6:fb11b746ceb5	3489	p_ranging_measurement_data->RangeFractionalPart = 0;
sepp_nepp	6:fb11b746ceb5	3490	}
sepp_nepp	6:fb11b746ceb5	3491
sepp_nepp	9:cb4c6d4e5030	3492	/* For a standard definition of RangeStatus, this should
sepp_nepp	6:fb11b746ceb5	3493	* return 0 in case of good result after a ranging
sepp_nepp	6:fb11b746ceb5	3494	* The range status depends on the device so call a device
sepp_nepp	6:fb11b746ceb5	3495	* specific function to obtain the right Status.
sepp_nepp	6:fb11b746ceb5	3496	*/
sepp_nepp	7:3a1115c2556b	3497	status \|= VL53L0X_get_pal_range_status( device_range_status,
sepp_nepp	6:fb11b746ceb5	3498	signal_rate, effective_spad_rtn_count,
sepp_nepp	6:fb11b746ceb5	3499	p_ranging_measurement_data, &pal_range_status);
sepp_nepp	6:fb11b746ceb5	3500
sepp_nepp	6:fb11b746ceb5	3501	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3502	p_ranging_measurement_data->RangeStatus = pal_range_status;}
sepp_nepp	6:fb11b746ceb5	3503
sepp_nepp	6:fb11b746ceb5	3504	}
sepp_nepp	6:fb11b746ceb5	3505
sepp_nepp	11:d8dbe3b87f9f	3506	if (status == VL53L0X_ERROR_NONE) { /* Copy last read data into Device buffer */
sepp_nepp	11:d8dbe3b87f9f	3507	LastRangeMeasure.Range_mm = p_ranging_measurement_data->Range_mm;
sepp_nepp	11:d8dbe3b87f9f	3508	LastRangeMeasure.RangeFractionalPart = p_ranging_measurement_data->RangeFractionalPart;
sepp_nepp	11:d8dbe3b87f9f	3509	LastRangeMeasure.RangeDMax_mm = p_ranging_measurement_data->RangeDMax_mm;
sepp_nepp	11:d8dbe3b87f9f	3510	LastRangeMeasure.SignalRateRtn_MHz = p_ranging_measurement_data->SignalRateRtn_MHz;
sepp_nepp	11:d8dbe3b87f9f	3511	LastRangeMeasure.AmbientRateRtn_MHz = p_ranging_measurement_data->AmbientRateRtn_MHz;
sepp_nepp	11:d8dbe3b87f9f	3512	LastRangeMeasure.EffectiveSpadRtnCount = p_ranging_measurement_data->EffectiveSpadRtnCount;
sepp_nepp	11:d8dbe3b87f9f	3513	LastRangeMeasure.RangeStatus = p_ranging_measurement_data->RangeStatus;
sepp_nepp	6:fb11b746ceb5	3514	}
sepp_nepp	9:cb4c6d4e5030	3515
sepp_nepp	6:fb11b746ceb5	3516	return status;
sepp_nepp	6:fb11b746ceb5	3517	}
sepp_nepp	6:fb11b746ceb5	3518
sepp_nepp	8:2fd7cb217068	3519	VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
sepp_nepp	8:2fd7cb217068	3520	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3521
sepp_nepp	6:fb11b746ceb5	3522	/* This function will do a complete single ranging
sepp_nepp	6:fb11b746ceb5	3523	* Here we fix the mode! */
sepp_nepp	7:3a1115c2556b	3524	status = VL53L0X_set_device_mode( VL53L0X_DEVICEMODE_SINGLE_RANGING);
sepp_nepp	6:fb11b746ceb5	3525
sepp_nepp	6:fb11b746ceb5	3526	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3527	status = VL53L0X_perform_single_measurement(); }
sepp_nepp	6:fb11b746ceb5	3528
sepp_nepp	6:fb11b746ceb5	3529	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3530	status = VL53L0X_get_ranging_measurement_data(p_ranging_measurement_data); }
sepp_nepp	6:fb11b746ceb5	3531
sepp_nepp	6:fb11b746ceb5	3532	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3533	status = VL53L0X_clear_interrupt_mask( 0);}
sepp_nepp	9:cb4c6d4e5030	3534
sepp_nepp	6:fb11b746ceb5	3535	return status;
sepp_nepp	6:fb11b746ceb5	3536	}
sepp_nepp	6:fb11b746ceb5	3537
sepp_nepp	8:2fd7cb217068	3538	VL53L0X_Error VL53L0X::perform_ref_signal_measurement(uint16_t *p_ref_signal_rate)
sepp_nepp	8:2fd7cb217068	3539	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3540	VL53L0X_RangingMeasurementData_t ranging_measurement_data;
sepp_nepp	6:fb11b746ceb5	3541
sepp_nepp	6:fb11b746ceb5	3542	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	3543
sepp_nepp	6:fb11b746ceb5	3544	/* store the value of the sequence config,
sepp_nepp	9:cb4c6d4e5030	3545	* this will be reset before the end of the function*/
sepp_nepp	8:2fd7cb217068	3546	sequence_config = Data.SequenceConfig;
sepp_nepp	6:fb11b746ceb5	3547
sepp_nepp	6:fb11b746ceb5	3548	/*
sepp_nepp	6:fb11b746ceb5	3549	* This function performs a reference signal rate measurement.
sepp_nepp	6:fb11b746ceb5	3550	*/
sepp_nepp	6:fb11b746ceb5	3551	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3552	status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);}
sepp_nepp	6:fb11b746ceb5	3553
sepp_nepp	6:fb11b746ceb5	3554	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3555	status = VL53L0X_perform_single_ranging_measurement(&ranging_measurement_data); }
sepp_nepp	6:fb11b746ceb5	3556
sepp_nepp	6:fb11b746ceb5	3557	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3558	status = VL53L0X_write_byte( 0xFF, 0x01); }
sepp_nepp	6:fb11b746ceb5	3559
sepp_nepp	6:fb11b746ceb5	3560	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3561	status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
sepp_nepp	9:cb4c6d4e5030	3562	p_ref_signal_rate);}
sepp_nepp	6:fb11b746ceb5	3563
sepp_nepp	6:fb11b746ceb5	3564	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	9:cb4c6d4e5030	3565	status = VL53L0X_write_byte( 0xFF, 0x00);}
sepp_nepp	6:fb11b746ceb5	3566
sepp_nepp	6:fb11b746ceb5	3567	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3568	/* restore the previous Sequence Config */
sepp_nepp	7:3a1115c2556b	3569	status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sepp_nepp	6:fb11b746ceb5	3570	sequence_config);
sepp_nepp	6:fb11b746ceb5	3571	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3572	Data.SequenceConfig = sequence_config;
sepp_nepp	6:fb11b746ceb5	3573	}
sepp_nepp	6:fb11b746ceb5	3574	}
sepp_nepp	6:fb11b746ceb5	3575	return status;
sepp_nepp	6:fb11b746ceb5	3576	}
sepp_nepp	6:fb11b746ceb5	3577
sepp_nepp	8:2fd7cb217068	3578	VL53L0X_Error VL53L0X::wrapped_VL53L0X_perform_ref_spad_management(uint32_t *ref_spad_count,
sepp_nepp	6:fb11b746ceb5	3579	uint8_t *is_aperture_spads)
sepp_nepp	8:2fd7cb217068	3580	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3581	uint8_t last_spad_array[6];
sepp_nepp	6:fb11b746ceb5	3582	uint8_t start_select = 0xB4;
sepp_nepp	6:fb11b746ceb5	3583	uint32_t minimum_spad_count = 3;
sepp_nepp	6:fb11b746ceb5	3584	uint32_t max_spad_count = 44;
sepp_nepp	6:fb11b746ceb5	3585	uint32_t current_spad_index = 0;
sepp_nepp	6:fb11b746ceb5	3586	uint32_t last_spad_index = 0;
sepp_nepp	6:fb11b746ceb5	3587	int32_t next_good_spad = 0;
sepp_nepp	11:d8dbe3b87f9f	3588	uint16_t target_ref_rate = 0x0A00; /* 20 MHz in 9:7 format */
sepp_nepp	6:fb11b746ceb5	3589	uint16_t peak_signal_rate_ref;
sepp_nepp	6:fb11b746ceb5	3590	uint32_t need_apt_spads = 0;
sepp_nepp	6:fb11b746ceb5	3591	uint32_t index = 0;
sepp_nepp	6:fb11b746ceb5	3592	uint32_t spad_array_size = 6;
sepp_nepp	6:fb11b746ceb5	3593	uint32_t signal_rate_diff = 0;
sepp_nepp	6:fb11b746ceb5	3594	uint32_t last_signal_rate_diff = 0;
sepp_nepp	6:fb11b746ceb5	3595	uint8_t complete = 0;
sepp_nepp	6:fb11b746ceb5	3596	uint8_t vhv_settings = 0;
sepp_nepp	6:fb11b746ceb5	3597	uint8_t phase_cal = 0;
sepp_nepp	6:fb11b746ceb5	3598	uint32_t ref_spad_count_int = 0;
sepp_nepp	6:fb11b746ceb5	3599	uint8_t is_aperture_spads_int = 0;
sepp_nepp	6:fb11b746ceb5	3600
sepp_nepp	6:fb11b746ceb5	3601	/*
sepp_nepp	6:fb11b746ceb5	3602	* The reference SPAD initialization procedure determines the minimum
sepp_nepp	6:fb11b746ceb5	3603	* amount of reference spads to be enables to achieve a target reference
sepp_nepp	6:fb11b746ceb5	3604	* signal rate and should be performed once during initialization.
sepp_nepp	6:fb11b746ceb5	3605	*
sepp_nepp	6:fb11b746ceb5	3606	* Either aperture or non-aperture spads are applied but never both.
sepp_nepp	6:fb11b746ceb5	3607	* Firstly non-aperture spads are set, begining with 5 spads, and
sepp_nepp	6:fb11b746ceb5	3608	* increased one spad at a time until the closest measurement to the
sepp_nepp	6:fb11b746ceb5	3609	* target rate is achieved.
sepp_nepp	6:fb11b746ceb5	3610	*
sepp_nepp	6:fb11b746ceb5	3611	* If the target rate is exceeded when 5 non-aperture spads are enabled,
sepp_nepp	6:fb11b746ceb5	3612	* initialization is performed instead with aperture spads.
sepp_nepp	6:fb11b746ceb5	3613	*
sepp_nepp	6:fb11b746ceb5	3614	* When setting spads, a 'Good Spad Map' is applied.
sepp_nepp	6:fb11b746ceb5	3615	*
sepp_nepp	6:fb11b746ceb5	3616	* This procedure operates within a SPAD window of interest of a maximum
sepp_nepp	6:fb11b746ceb5	3617	* 44 spads.
sepp_nepp	6:fb11b746ceb5	3618	* The start point is currently fixed to 180, which lies towards the end
sepp_nepp	6:fb11b746ceb5	3619	* of the non-aperture quadrant and runs in to the adjacent aperture
sepp_nepp	6:fb11b746ceb5	3620	* quadrant.
sepp_nepp	6:fb11b746ceb5	3621	*/
sepp_nepp	8:2fd7cb217068	3622	target_ref_rate = Data.targetRefRate;
sepp_nepp	6:fb11b746ceb5	3623
sepp_nepp	6:fb11b746ceb5	3624	/*
sepp_nepp	6:fb11b746ceb5	3625	* Initialize Spad arrays.
sepp_nepp	6:fb11b746ceb5	3626	* Currently the good spad map is initialised to 'All good'.
sepp_nepp	6:fb11b746ceb5	3627	* This is a short term implementation. The good spad map will be
sepp_nepp	6:fb11b746ceb5	3628	* provided as an input.
sepp_nepp	6:fb11b746ceb5	3629	* Note that there are 6 bytes. Only the first 44 bits will be used to
sepp_nepp	6:fb11b746ceb5	3630	* represent spads.
sepp_nepp	6:fb11b746ceb5	3631	*/
sepp_nepp	6:fb11b746ceb5	3632	for (index = 0; index < spad_array_size; index++) {
sepp_nepp	11:d8dbe3b87f9f	3633	Data.RefSpadEnables[index] = 0;
sepp_nepp	6:fb11b746ceb5	3634	}
sepp_nepp	6:fb11b746ceb5	3635
sepp_nepp	7:3a1115c2556b	3636	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	6:fb11b746ceb5	3637
sepp_nepp	6:fb11b746ceb5	3638	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3639	status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
sepp_nepp	6:fb11b746ceb5	3640	}
sepp_nepp	6:fb11b746ceb5	3641
sepp_nepp	6:fb11b746ceb5	3642	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3643	status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
sepp_nepp	6:fb11b746ceb5	3644	}
sepp_nepp	6:fb11b746ceb5	3645
sepp_nepp	6:fb11b746ceb5	3646	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3647	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	3648	}
sepp_nepp	6:fb11b746ceb5	3649
sepp_nepp	6:fb11b746ceb5	3650	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3651	status = VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
sepp_nepp	6:fb11b746ceb5	3652	start_select);
sepp_nepp	6:fb11b746ceb5	3653	}
sepp_nepp	6:fb11b746ceb5	3654
sepp_nepp	6:fb11b746ceb5	3655	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3656	status = VL53L0X_write_byte(VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
sepp_nepp	6:fb11b746ceb5	3657	}
sepp_nepp	6:fb11b746ceb5	3658
sepp_nepp	6:fb11b746ceb5	3659	/* Perform ref calibration */
sepp_nepp	6:fb11b746ceb5	3660	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3661	status = VL53L0X_perform_ref_calibration( &vhv_settings,
sepp_nepp	6:fb11b746ceb5	3662	&phase_cal, 0);
sepp_nepp	6:fb11b746ceb5	3663	}
sepp_nepp	6:fb11b746ceb5	3664
sepp_nepp	6:fb11b746ceb5	3665	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3666	/* Enable Minimum NON-APERTURE Spads */
sepp_nepp	6:fb11b746ceb5	3667	current_spad_index = 0;
sepp_nepp	6:fb11b746ceb5	3668	last_spad_index = current_spad_index;
sepp_nepp	6:fb11b746ceb5	3669	need_apt_spads = 0;
sepp_nepp	8:2fd7cb217068	3670	status = enable_ref_spads(need_apt_spads,
sepp_nepp	11:d8dbe3b87f9f	3671	Data.RefGoodSpadMap,
sepp_nepp	11:d8dbe3b87f9f	3672	Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3673	spad_array_size,
sepp_nepp	6:fb11b746ceb5	3674	start_select,
sepp_nepp	6:fb11b746ceb5	3675	current_spad_index,
sepp_nepp	6:fb11b746ceb5	3676	minimum_spad_count,
sepp_nepp	6:fb11b746ceb5	3677	&last_spad_index);
sepp_nepp	6:fb11b746ceb5	3678	}
sepp_nepp	6:fb11b746ceb5	3679
sepp_nepp	6:fb11b746ceb5	3680	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3681	current_spad_index = last_spad_index;
sepp_nepp	6:fb11b746ceb5	3682
sepp_nepp	8:2fd7cb217068	3683	status = perform_ref_signal_measurement(&peak_signal_rate_ref);
sepp_nepp	6:fb11b746ceb5	3684	if ((status == VL53L0X_ERROR_NONE) &&
sepp_nepp	6:fb11b746ceb5	3685	(peak_signal_rate_ref > target_ref_rate)) {
sepp_nepp	6:fb11b746ceb5	3686	/* Signal rate measurement too high,
sepp_nepp	6:fb11b746ceb5	3687	* switch to APERTURE SPADs */
sepp_nepp	6:fb11b746ceb5	3688
sepp_nepp	6:fb11b746ceb5	3689	for (index = 0; index < spad_array_size; index++) {
sepp_nepp	11:d8dbe3b87f9f	3690	Data.RefSpadEnables[index] = 0;
sepp_nepp	6:fb11b746ceb5	3691	}
sepp_nepp	6:fb11b746ceb5	3692
sepp_nepp	6:fb11b746ceb5	3693	/* Increment to the first APERTURE spad */
sepp_nepp	6:fb11b746ceb5	3694	while ((is_aperture(start_select + current_spad_index)
sepp_nepp	6:fb11b746ceb5	3695	== 0) && (current_spad_index < max_spad_count)) {
sepp_nepp	6:fb11b746ceb5	3696	current_spad_index++;
sepp_nepp	6:fb11b746ceb5	3697	}
sepp_nepp	6:fb11b746ceb5	3698
sepp_nepp	6:fb11b746ceb5	3699	need_apt_spads = 1;
sepp_nepp	6:fb11b746ceb5	3700
sepp_nepp	7:3a1115c2556b	3701	status = enable_ref_spads(need_apt_spads,
sepp_nepp	11:d8dbe3b87f9f	3702	Data.RefGoodSpadMap,
sepp_nepp	11:d8dbe3b87f9f	3703	Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3704	spad_array_size,
sepp_nepp	6:fb11b746ceb5	3705	start_select,
sepp_nepp	6:fb11b746ceb5	3706	current_spad_index,
sepp_nepp	6:fb11b746ceb5	3707	minimum_spad_count,
sepp_nepp	6:fb11b746ceb5	3708	&last_spad_index);
sepp_nepp	6:fb11b746ceb5	3709
sepp_nepp	6:fb11b746ceb5	3710	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3711	current_spad_index = last_spad_index;
sepp_nepp	8:2fd7cb217068	3712	status = perform_ref_signal_measurement(&peak_signal_rate_ref);
sepp_nepp	6:fb11b746ceb5	3713
sepp_nepp	6:fb11b746ceb5	3714	if ((status == VL53L0X_ERROR_NONE) &&
sepp_nepp	6:fb11b746ceb5	3715	(peak_signal_rate_ref > target_ref_rate)) {
sepp_nepp	6:fb11b746ceb5	3716	/* Signal rate still too high after
sepp_nepp	6:fb11b746ceb5	3717	* setting the minimum number of
sepp_nepp	6:fb11b746ceb5	3718	* APERTURE spads. Can do no more
sepp_nepp	6:fb11b746ceb5	3719	* therefore set the min number of
sepp_nepp	6:fb11b746ceb5	3720	* aperture spads as the result.
sepp_nepp	6:fb11b746ceb5	3721	*/
sepp_nepp	6:fb11b746ceb5	3722	is_aperture_spads_int = 1;
sepp_nepp	6:fb11b746ceb5	3723	ref_spad_count_int = minimum_spad_count;
sepp_nepp	6:fb11b746ceb5	3724	}
sepp_nepp	6:fb11b746ceb5	3725	}
sepp_nepp	6:fb11b746ceb5	3726	} else {
sepp_nepp	6:fb11b746ceb5	3727	need_apt_spads = 0;
sepp_nepp	6:fb11b746ceb5	3728	}
sepp_nepp	6:fb11b746ceb5	3729	}
sepp_nepp	6:fb11b746ceb5	3730
sepp_nepp	6:fb11b746ceb5	3731	if ((status == VL53L0X_ERROR_NONE) &&
sepp_nepp	6:fb11b746ceb5	3732	(peak_signal_rate_ref < target_ref_rate)) {
sepp_nepp	6:fb11b746ceb5	3733	/* At this point, the minimum number of either aperture
sepp_nepp	6:fb11b746ceb5	3734	* or non-aperture spads have been set. Proceed to add
sepp_nepp	6:fb11b746ceb5	3735	* spads and perform measurements until the target
sepp_nepp	6:fb11b746ceb5	3736	* reference is reached.
sepp_nepp	6:fb11b746ceb5	3737	*/
sepp_nepp	6:fb11b746ceb5	3738	is_aperture_spads_int = need_apt_spads;
sepp_nepp	6:fb11b746ceb5	3739	ref_spad_count_int = minimum_spad_count;
sepp_nepp	6:fb11b746ceb5	3740
sepp_nepp	11:d8dbe3b87f9f	3741	memcpy(last_spad_array, Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3742	spad_array_size);
sepp_nepp	6:fb11b746ceb5	3743	last_signal_rate_diff = abs(peak_signal_rate_ref -
sepp_nepp	6:fb11b746ceb5	3744	target_ref_rate);
sepp_nepp	6:fb11b746ceb5	3745	complete = 0;
sepp_nepp	6:fb11b746ceb5	3746
sepp_nepp	6:fb11b746ceb5	3747	while (!complete) {
sepp_nepp	11:d8dbe3b87f9f	3748	get_next_good_spad(Data.RefGoodSpadMap,
sepp_nepp	6:fb11b746ceb5	3749	spad_array_size, current_spad_index,
sepp_nepp	6:fb11b746ceb5	3750	&next_good_spad);
sepp_nepp	6:fb11b746ceb5	3751
sepp_nepp	6:fb11b746ceb5	3752	if (next_good_spad == -1) {
sepp_nepp	6:fb11b746ceb5	3753	status = VL53L0X_ERROR_REF_SPAD_INIT;
sepp_nepp	6:fb11b746ceb5	3754	break;
sepp_nepp	6:fb11b746ceb5	3755	}
sepp_nepp	6:fb11b746ceb5	3756
sepp_nepp	6:fb11b746ceb5	3757	/* Cannot combine Aperture and Non-Aperture spads, so
sepp_nepp	6:fb11b746ceb5	3758	* ensure the current spad is of the correct type.
sepp_nepp	6:fb11b746ceb5	3759	*/
sepp_nepp	6:fb11b746ceb5	3760	if (is_aperture((uint32_t)start_select + next_good_spad) !=
sepp_nepp	6:fb11b746ceb5	3761	need_apt_spads) {
sepp_nepp	6:fb11b746ceb5	3762	/* At this point we have enabled the maximum
sepp_nepp	6:fb11b746ceb5	3763	* number of Aperture spads.
sepp_nepp	6:fb11b746ceb5	3764	*/
sepp_nepp	6:fb11b746ceb5	3765	complete = 1;
sepp_nepp	6:fb11b746ceb5	3766	break;
sepp_nepp	6:fb11b746ceb5	3767	}
sepp_nepp	6:fb11b746ceb5	3768
sepp_nepp	6:fb11b746ceb5	3769	(ref_spad_count_int)++;
sepp_nepp	6:fb11b746ceb5	3770
sepp_nepp	6:fb11b746ceb5	3771	current_spad_index = next_good_spad;
sepp_nepp	11:d8dbe3b87f9f	3772	status = enable_spad_bit(Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3773	spad_array_size, current_spad_index);
sepp_nepp	6:fb11b746ceb5	3774
sepp_nepp	6:fb11b746ceb5	3775	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3776	current_spad_index++;
sepp_nepp	6:fb11b746ceb5	3777	/* Proceed to apply the additional spad and
sepp_nepp	6:fb11b746ceb5	3778	* perform measurement. */
sepp_nepp	11:d8dbe3b87f9f	3779	status = set_ref_spad_map(Data.RefSpadEnables);
sepp_nepp	6:fb11b746ceb5	3780	}
sepp_nepp	6:fb11b746ceb5	3781
sepp_nepp	6:fb11b746ceb5	3782	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3783	break;
sepp_nepp	6:fb11b746ceb5	3784	}
sepp_nepp	6:fb11b746ceb5	3785
sepp_nepp	7:3a1115c2556b	3786	status = perform_ref_signal_measurement(&peak_signal_rate_ref);
sepp_nepp	6:fb11b746ceb5	3787
sepp_nepp	6:fb11b746ceb5	3788	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3789	break;
sepp_nepp	6:fb11b746ceb5	3790	}
sepp_nepp	6:fb11b746ceb5	3791
sepp_nepp	6:fb11b746ceb5	3792	signal_rate_diff = abs(peak_signal_rate_ref - target_ref_rate);
sepp_nepp	6:fb11b746ceb5	3793
sepp_nepp	6:fb11b746ceb5	3794	if (peak_signal_rate_ref > target_ref_rate) {
sepp_nepp	6:fb11b746ceb5	3795	/* Select the spad map that provides the
sepp_nepp	6:fb11b746ceb5	3796	* measurement closest to the target rate,
sepp_nepp	6:fb11b746ceb5	3797	* either above or below it.
sepp_nepp	6:fb11b746ceb5	3798	*/
sepp_nepp	6:fb11b746ceb5	3799	if (signal_rate_diff > last_signal_rate_diff) {
sepp_nepp	6:fb11b746ceb5	3800	/* Previous spad map produced a closer
sepp_nepp	6:fb11b746ceb5	3801	* measurement, so choose this. */
sepp_nepp	7:3a1115c2556b	3802	status = set_ref_spad_map(last_spad_array);
sepp_nepp	11:d8dbe3b87f9f	3803	memcpy(Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3804	last_spad_array, spad_array_size);
sepp_nepp	6:fb11b746ceb5	3805	(ref_spad_count_int)--;
sepp_nepp	6:fb11b746ceb5	3806	}
sepp_nepp	6:fb11b746ceb5	3807	complete = 1;
sepp_nepp	6:fb11b746ceb5	3808	} else {
sepp_nepp	6:fb11b746ceb5	3809	/* Continue to add spads */
sepp_nepp	6:fb11b746ceb5	3810	last_signal_rate_diff = signal_rate_diff;
sepp_nepp	6:fb11b746ceb5	3811	memcpy(last_spad_array,
sepp_nepp	11:d8dbe3b87f9f	3812	Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3813	spad_array_size);
sepp_nepp	6:fb11b746ceb5	3814	}
sepp_nepp	6:fb11b746ceb5	3815
sepp_nepp	6:fb11b746ceb5	3816	} /* while */
sepp_nepp	6:fb11b746ceb5	3817	}
sepp_nepp	6:fb11b746ceb5	3818
sepp_nepp	6:fb11b746ceb5	3819	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3820	*ref_spad_count = ref_spad_count_int;
sepp_nepp	6:fb11b746ceb5	3821	*is_aperture_spads = is_aperture_spads_int;
sepp_nepp	8:2fd7cb217068	3822	Data.RefSpadsInitialised = 1;
sepp_nepp	8:2fd7cb217068	3823	Data.ReferenceSpadCount = (uint8_t)(*ref_spad_count);
sepp_nepp	9:cb4c6d4e5030	3824	Data.ReferenceSpadType = *is_aperture_spads;
sepp_nepp	6:fb11b746ceb5	3825	}
sepp_nepp	6:fb11b746ceb5	3826
sepp_nepp	6:fb11b746ceb5	3827	return status;
sepp_nepp	6:fb11b746ceb5	3828	}
sepp_nepp	6:fb11b746ceb5	3829
sepp_nepp	8:2fd7cb217068	3830	VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(uint32_t count, uint8_t is_aperture_spads)
sepp_nepp	8:2fd7cb217068	3831	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3832	uint32_t current_spad_index = 0;
sepp_nepp	6:fb11b746ceb5	3833	uint8_t start_select = 0xB4;
sepp_nepp	6:fb11b746ceb5	3834	uint32_t spad_array_size = 6;
sepp_nepp	6:fb11b746ceb5	3835	uint32_t max_spad_count = 44;
sepp_nepp	6:fb11b746ceb5	3836	uint32_t last_spad_index;
sepp_nepp	6:fb11b746ceb5	3837	uint32_t index;
sepp_nepp	6:fb11b746ceb5	3838
sepp_nepp	6:fb11b746ceb5	3839	/*
sepp_nepp	6:fb11b746ceb5	3840	* This function applies a requested number of reference spads, either
sepp_nepp	6:fb11b746ceb5	3841	* aperture or
sepp_nepp	6:fb11b746ceb5	3842	* non-aperture, as requested.
sepp_nepp	6:fb11b746ceb5	3843	* The good spad map will be applied.
sepp_nepp	6:fb11b746ceb5	3844	*/
sepp_nepp	6:fb11b746ceb5	3845
sepp_nepp	7:3a1115c2556b	3846	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	6:fb11b746ceb5	3847
sepp_nepp	6:fb11b746ceb5	3848	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3849	status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
sepp_nepp	6:fb11b746ceb5	3850	}
sepp_nepp	6:fb11b746ceb5	3851
sepp_nepp	6:fb11b746ceb5	3852	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3853	status = VL53L0X_write_byte( VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
sepp_nepp	6:fb11b746ceb5	3854	}
sepp_nepp	6:fb11b746ceb5	3855
sepp_nepp	6:fb11b746ceb5	3856	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3857	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	3858	}
sepp_nepp	6:fb11b746ceb5	3859
sepp_nepp	6:fb11b746ceb5	3860	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3861	status = VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
sepp_nepp	6:fb11b746ceb5	3862	start_select);
sepp_nepp	6:fb11b746ceb5	3863	}
sepp_nepp	6:fb11b746ceb5	3864
sepp_nepp	6:fb11b746ceb5	3865	for (index = 0; index < spad_array_size; index++) {
sepp_nepp	11:d8dbe3b87f9f	3866	Data.RefSpadEnables[index] = 0;
sepp_nepp	6:fb11b746ceb5	3867	}
sepp_nepp	6:fb11b746ceb5	3868
sepp_nepp	6:fb11b746ceb5	3869	if (is_aperture_spads) {
sepp_nepp	6:fb11b746ceb5	3870	/* Increment to the first APERTURE spad */
sepp_nepp	6:fb11b746ceb5	3871	while ((is_aperture(start_select + current_spad_index) == 0) &&
sepp_nepp	6:fb11b746ceb5	3872	(current_spad_index < max_spad_count)) {
sepp_nepp	6:fb11b746ceb5	3873	current_spad_index++;
sepp_nepp	6:fb11b746ceb5	3874	}
sepp_nepp	6:fb11b746ceb5	3875	}
sepp_nepp	7:3a1115c2556b	3876	status = enable_ref_spads(is_aperture_spads,
sepp_nepp	11:d8dbe3b87f9f	3877	Data.RefGoodSpadMap,
sepp_nepp	11:d8dbe3b87f9f	3878	Data.RefSpadEnables,
sepp_nepp	6:fb11b746ceb5	3879	spad_array_size,
sepp_nepp	6:fb11b746ceb5	3880	start_select,
sepp_nepp	6:fb11b746ceb5	3881	current_spad_index,
sepp_nepp	6:fb11b746ceb5	3882	count,
sepp_nepp	6:fb11b746ceb5	3883	&last_spad_index);
sepp_nepp	6:fb11b746ceb5	3884
sepp_nepp	6:fb11b746ceb5	3885	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3886	Data.RefSpadsInitialised = 1;
sepp_nepp	8:2fd7cb217068	3887	Data.ReferenceSpadCount = (uint8_t)(count);
sepp_nepp	8:2fd7cb217068	3888	Data.ReferenceSpadType = is_aperture_spads;
sepp_nepp	6:fb11b746ceb5	3889	}
sepp_nepp	6:fb11b746ceb5	3890
sepp_nepp	6:fb11b746ceb5	3891	return status;
sepp_nepp	6:fb11b746ceb5	3892	}
sepp_nepp	6:fb11b746ceb5	3893
sepp_nepp	7:3a1115c2556b	3894	VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration( uint8_t *p_vhv_settings,
sepp_nepp	6:fb11b746ceb5	3895	uint8_t *p_phase_cal)
sepp_nepp	8:2fd7cb217068	3896	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3897
sepp_nepp	7:3a1115c2556b	3898	status = VL53L0X_perform_ref_calibration( p_vhv_settings, p_phase_cal, 1);
sepp_nepp	6:fb11b746ceb5	3899
sepp_nepp	6:fb11b746ceb5	3900	return status;
sepp_nepp	6:fb11b746ceb5	3901	}
sepp_nepp	6:fb11b746ceb5	3902
sepp_nepp	8:2fd7cb217068	3903	VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(uint32_t ref_spad_count, uint8_t is_aperture_spads)
sepp_nepp	8:2fd7cb217068	3904	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3905
sepp_nepp	7:3a1115c2556b	3906	status = wrapped_VL53L0X_perform_ref_spad_management( ref_spad_count,
sepp_nepp	6:fb11b746ceb5	3907	is_aperture_spads);
sepp_nepp	6:fb11b746ceb5	3908
sepp_nepp	6:fb11b746ceb5	3909	return status;
sepp_nepp	6:fb11b746ceb5	3910	}
sepp_nepp	6:fb11b746ceb5	3911
sepp_nepp	6:fb11b746ceb5	3912	/* Group PAL Init Functions */
sepp_nepp	7:3a1115c2556b	3913	VL53L0X_Error VL53L0X::VL53L0X_set_device_address( uint8_t device_address)
sepp_nepp	7:3a1115c2556b	3914	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3915
sepp_nepp	7:3a1115c2556b	3916	status = VL53L0X_write_byte( VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
sepp_nepp	6:fb11b746ceb5	3917	device_address / 2);
sepp_nepp	6:fb11b746ceb5	3918	return status;
sepp_nepp	6:fb11b746ceb5	3919	}
sepp_nepp	6:fb11b746ceb5	3920
sepp_nepp	7:3a1115c2556b	3921	VL53L0X_Error VL53L0X::VL53L0X_set_gpio_config( uint8_t pin,
sepp_nepp	6:fb11b746ceb5	3922	VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
sepp_nepp	6:fb11b746ceb5	3923	VL53L0X_InterruptPolarity polarity)
sepp_nepp	7:3a1115c2556b	3924	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	3925	uint8_t data;
sepp_nepp	6:fb11b746ceb5	3926
sepp_nepp	6:fb11b746ceb5	3927	if (pin != 0) {
sepp_nepp	6:fb11b746ceb5	3928	status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
sepp_nepp	6:fb11b746ceb5	3929	} else if (device_mode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
sepp_nepp	6:fb11b746ceb5	3930	if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW) {
sepp_nepp	6:fb11b746ceb5	3931	data = 0x10;
sepp_nepp	7:3a1115c2556b	3932	} else {data = 1;}
sepp_nepp	7:3a1115c2556b	3933
sepp_nepp	7:3a1115c2556b	3934	status = VL53L0X_write_byte(VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
sepp_nepp	6:fb11b746ceb5	3935
sepp_nepp	6:fb11b746ceb5	3936	} else {
sepp_nepp	6:fb11b746ceb5	3937	if (device_mode == VL53L0X_DEVICEMODE_GPIO_OSC) {
sepp_nepp	6:fb11b746ceb5	3938
sepp_nepp	7:3a1115c2556b	3939	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	7:3a1115c2556b	3940	status \|= VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	7:3a1115c2556b	3941	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	7:3a1115c2556b	3942	status \|= VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	7:3a1115c2556b	3943	status \|= VL53L0X_write_byte( 0x85, 0x02);
sepp_nepp	7:3a1115c2556b	3944	status \|= VL53L0X_write_byte( 0xff, 0x04);
sepp_nepp	7:3a1115c2556b	3945	status \|= VL53L0X_write_byte( 0xcd, 0x00);
sepp_nepp	7:3a1115c2556b	3946	status \|= VL53L0X_write_byte( 0xcc, 0x11);
sepp_nepp	7:3a1115c2556b	3947	status \|= VL53L0X_write_byte( 0xff, 0x07);
sepp_nepp	7:3a1115c2556b	3948	status \|= VL53L0X_write_byte( 0xbe, 0x00);
sepp_nepp	7:3a1115c2556b	3949	status \|= VL53L0X_write_byte( 0xff, 0x06);
sepp_nepp	7:3a1115c2556b	3950	status \|= VL53L0X_write_byte( 0xcc, 0x09);
sepp_nepp	7:3a1115c2556b	3951	status \|= VL53L0X_write_byte( 0xff, 0x00);
sepp_nepp	7:3a1115c2556b	3952	status \|= VL53L0X_write_byte( 0xff, 0x01);
sepp_nepp	7:3a1115c2556b	3953	status \|= VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	6:fb11b746ceb5	3954
sepp_nepp	6:fb11b746ceb5	3955	} else {
sepp_nepp	6:fb11b746ceb5	3956
sepp_nepp	6:fb11b746ceb5	3957	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3958	switch (functionality) {
sepp_nepp	6:fb11b746ceb5	3959	case VL53L0X_GPIOFUNCTIONALITY_OFF:
sepp_nepp	6:fb11b746ceb5	3960	data = 0x00;
sepp_nepp	6:fb11b746ceb5	3961	break;
sepp_nepp	6:fb11b746ceb5	3962	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
sepp_nepp	6:fb11b746ceb5	3963	data = 0x01;
sepp_nepp	6:fb11b746ceb5	3964	break;
sepp_nepp	6:fb11b746ceb5	3965	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
sepp_nepp	6:fb11b746ceb5	3966	data = 0x02;
sepp_nepp	6:fb11b746ceb5	3967	break;
sepp_nepp	6:fb11b746ceb5	3968	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
sepp_nepp	6:fb11b746ceb5	3969	data = 0x03;
sepp_nepp	6:fb11b746ceb5	3970	break;
sepp_nepp	6:fb11b746ceb5	3971	case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
sepp_nepp	6:fb11b746ceb5	3972	data = 0x04;
sepp_nepp	6:fb11b746ceb5	3973	break;
sepp_nepp	6:fb11b746ceb5	3974	default:
sepp_nepp	11:d8dbe3b87f9f	3975	status = VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
sepp_nepp	6:fb11b746ceb5	3976	}
sepp_nepp	6:fb11b746ceb5	3977	}
sepp_nepp	6:fb11b746ceb5	3978
sepp_nepp	6:fb11b746ceb5	3979	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	3980	status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
sepp_nepp	6:fb11b746ceb5	3981	}
sepp_nepp	6:fb11b746ceb5	3982
sepp_nepp	6:fb11b746ceb5	3983	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	3984	if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW) {
sepp_nepp	6:fb11b746ceb5	3985	data = 0;
sepp_nepp	7:3a1115c2556b	3986	} else { data = (uint8_t)(1 << 4); }
sepp_nepp	7:3a1115c2556b	3987	status = VL53L0X_update_byte(VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
sepp_nepp	6:fb11b746ceb5	3988	}
sepp_nepp	6:fb11b746ceb5	3989
sepp_nepp	6:fb11b746ceb5	3990	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	3991	Data.Pin0GpioFunctionality = functionality; }
sepp_nepp	7:3a1115c2556b	3992
sepp_nepp	7:3a1115c2556b	3993	if (status == VL53L0X_ERROR_NONE) { status = VL53L0X_clear_interrupt_mask( 0); }
sepp_nepp	6:fb11b746ceb5	3994	}
sepp_nepp	6:fb11b746ceb5	3995	}
sepp_nepp	6:fb11b746ceb5	3996	return status;
sepp_nepp	6:fb11b746ceb5	3997	}
sepp_nepp	6:fb11b746ceb5	3998
sepp_nepp	7:3a1115c2556b	3999	VL53L0X_Error VL53L0X::VL53L0X_get_fraction_enable( uint8_t *p_enabled)
sepp_nepp	8:2fd7cb217068	4000	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	7:3a1115c2556b	4001	status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled);
sepp_nepp	7:3a1115c2556b	4002	if (status == VL53L0X_ERROR_NONE) { p_enabled = (p_enabled & 1); }
sepp_nepp	6:fb11b746ceb5	4003	return status;
sepp_nepp	6:fb11b746ceb5	4004	}
sepp_nepp	6:fb11b746ceb5	4005
sepp_nepp	6:fb11b746ceb5	4006	uint16_t VL53L0X::VL53L0X_encode_timeout(uint32_t timeout_macro_clks)
sepp_nepp	7:3a1115c2556b	4007	{ /!Encode timeout in macro periods in (LSByte 2^MSByte) + 1 format*/
sepp_nepp	6:fb11b746ceb5	4008
sepp_nepp	6:fb11b746ceb5	4009	uint16_t encoded_timeout = 0;
sepp_nepp	6:fb11b746ceb5	4010	uint32_t ls_byte = 0;
sepp_nepp	6:fb11b746ceb5	4011	uint16_t ms_byte = 0;
sepp_nepp	6:fb11b746ceb5	4012
sepp_nepp	6:fb11b746ceb5	4013	if (timeout_macro_clks > 0) {
sepp_nepp	6:fb11b746ceb5	4014	ls_byte = timeout_macro_clks - 1;
sepp_nepp	6:fb11b746ceb5	4015
sepp_nepp	6:fb11b746ceb5	4016	while ((ls_byte & 0xFFFFFF00) > 0) {
sepp_nepp	6:fb11b746ceb5	4017	ls_byte = ls_byte >> 1;
sepp_nepp	6:fb11b746ceb5	4018	ms_byte++;
sepp_nepp	6:fb11b746ceb5	4019	}
sepp_nepp	7:3a1115c2556b	4020	encoded_timeout = (ms_byte << 8) + (uint16_t)(ls_byte & 0x000000FF);
sepp_nepp	6:fb11b746ceb5	4021	}
sepp_nepp	6:fb11b746ceb5	4022	return encoded_timeout;
sepp_nepp	6:fb11b746ceb5	4023	}
sepp_nepp	6:fb11b746ceb5	4024
sepp_nepp	8:2fd7cb217068	4025	VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_SequenceStepId sequence_step_id,
sepp_nepp	6:fb11b746ceb5	4026	uint32_t timeout_micro_secs)
sepp_nepp	8:2fd7cb217068	4027	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4028	uint8_t current_vcsel_pulse_period_p_clk;
sepp_nepp	6:fb11b746ceb5	4029	uint8_t msrc_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	4030	uint16_t pre_range_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	4031	uint16_t pre_range_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	4032	uint16_t msrc_range_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	4033	uint32_t final_range_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	4034	uint16_t final_range_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	4035	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
sepp_nepp	6:fb11b746ceb5	4036
sepp_nepp	6:fb11b746ceb5	4037	if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) \|\|
sepp_nepp	6:fb11b746ceb5	4038	(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) \|\|
sepp_nepp	6:fb11b746ceb5	4039	(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
sepp_nepp	6:fb11b746ceb5	4040
sepp_nepp	8:2fd7cb217068	4041	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	4042	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4043
sepp_nepp	6:fb11b746ceb5	4044	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4045	msrc_range_time_out_m_clks = VL53L0X_calc_timeout_mclks(timeout_micro_secs,
sepp_nepp	6:fb11b746ceb5	4046	(uint8_t)current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4047
sepp_nepp	6:fb11b746ceb5	4048	if (msrc_range_time_out_m_clks > 256) {
sepp_nepp	6:fb11b746ceb5	4049	msrc_encoded_time_out = 255;
sepp_nepp	6:fb11b746ceb5	4050	} else {
sepp_nepp	6:fb11b746ceb5	4051	msrc_encoded_time_out =
sepp_nepp	6:fb11b746ceb5	4052	(uint8_t)msrc_range_time_out_m_clks - 1;
sepp_nepp	6:fb11b746ceb5	4053	}
sepp_nepp	8:2fd7cb217068	4054	Data.LastEncodedTimeout = msrc_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	4055	}
sepp_nepp	6:fb11b746ceb5	4056
sepp_nepp	6:fb11b746ceb5	4057	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4058	status = VL53L0X_write_byte(VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
sepp_nepp	6:fb11b746ceb5	4059	msrc_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	4060	}
sepp_nepp	6:fb11b746ceb5	4061	} else {
sepp_nepp	6:fb11b746ceb5	4062
sepp_nepp	6:fb11b746ceb5	4063	if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
sepp_nepp	6:fb11b746ceb5	4064
sepp_nepp	6:fb11b746ceb5	4065	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4066	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	4067	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4068	pre_range_time_out_m_clks =
sepp_nepp	7:3a1115c2556b	4069	VL53L0X_calc_timeout_mclks(timeout_micro_secs,
sepp_nepp	6:fb11b746ceb5	4070	(uint8_t)current_vcsel_pulse_period_p_clk);
sepp_nepp	8:2fd7cb217068	4071	pre_range_encoded_time_out = VL53L0X_encode_timeout(pre_range_time_out_m_clks);
sepp_nepp	8:2fd7cb217068	4072	Data.LastEncodedTimeout = pre_range_encoded_time_out;
sepp_nepp	6:fb11b746ceb5	4073	}
sepp_nepp	6:fb11b746ceb5	4074
sepp_nepp	6:fb11b746ceb5	4075	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4076	status = VL53L0X_write_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
sepp_nepp	6:fb11b746ceb5	4077	pre_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	4078	}
sepp_nepp	6:fb11b746ceb5	4079
sepp_nepp	6:fb11b746ceb5	4080	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4081	Data.PreRangeTimeout_us = timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	4082	}
sepp_nepp	6:fb11b746ceb5	4083	} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
sepp_nepp	6:fb11b746ceb5	4084
sepp_nepp	6:fb11b746ceb5	4085	/* For the final range timeout, the pre-range timeout
sepp_nepp	6:fb11b746ceb5	4086	* must be added. To do this both final and pre-range
sepp_nepp	6:fb11b746ceb5	4087	* timeouts must be expressed in macro periods MClks
sepp_nepp	9:cb4c6d4e5030	4088	* because they have different vcsel periods. */
sepp_nepp	6:fb11b746ceb5	4089
sepp_nepp	7:3a1115c2556b	4090	VL53L0X_get_sequence_step_enables(&scheduler_sequence_steps);
sepp_nepp	6:fb11b746ceb5	4091	pre_range_time_out_m_clks = 0;
sepp_nepp	6:fb11b746ceb5	4092	if (scheduler_sequence_steps.PreRangeOn) {
sepp_nepp	6:fb11b746ceb5	4093
sepp_nepp	6:fb11b746ceb5	4094	/* Retrieve PRE-RANGE VCSEL Period */
sepp_nepp	7:3a1115c2556b	4095	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
sepp_nepp	6:fb11b746ceb5	4096	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4097
sepp_nepp	6:fb11b746ceb5	4098	/* Retrieve PRE-RANGE Timeout in Macro periods
sepp_nepp	6:fb11b746ceb5	4099	* (MCLKS) */
sepp_nepp	6:fb11b746ceb5	4100	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4101	status = VL53L0X_read_word( 0x51, &pre_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	4102	pre_range_time_out_m_clks =
sepp_nepp	7:3a1115c2556b	4103	VL53L0X_decode_timeout( pre_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	4104	}
sepp_nepp	6:fb11b746ceb5	4105	}
sepp_nepp	6:fb11b746ceb5	4106
sepp_nepp	6:fb11b746ceb5	4107	/* Calculate FINAL RANGE Timeout in Macro Periods
sepp_nepp	6:fb11b746ceb5	4108	* (MCLKS) and add PRE-RANGE value
sepp_nepp	6:fb11b746ceb5	4109	*/
sepp_nepp	6:fb11b746ceb5	4110	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4111	status = VL53L0X_get_vcsel_pulse_period( VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	4112	&current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4113	}
sepp_nepp	6:fb11b746ceb5	4114	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	4115	final_range_time_out_m_clks =
sepp_nepp	7:3a1115c2556b	4116	VL53L0X_calc_timeout_mclks( timeout_micro_secs,
sepp_nepp	6:fb11b746ceb5	4117	(uint8_t) current_vcsel_pulse_period_p_clk);
sepp_nepp	6:fb11b746ceb5	4118
sepp_nepp	6:fb11b746ceb5	4119	final_range_time_out_m_clks += pre_range_time_out_m_clks;
sepp_nepp	6:fb11b746ceb5	4120	final_range_encoded_time_out =
sepp_nepp	6:fb11b746ceb5	4121	VL53L0X_encode_timeout(final_range_time_out_m_clks);
sepp_nepp	6:fb11b746ceb5	4122
sepp_nepp	6:fb11b746ceb5	4123	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4124	status = VL53L0X_write_word( 0x71, final_range_encoded_time_out);
sepp_nepp	6:fb11b746ceb5	4125	}
sepp_nepp	6:fb11b746ceb5	4126
sepp_nepp	6:fb11b746ceb5	4127	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4128	Data.FinalRangeTimeout_us = timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	4129	}
sepp_nepp	6:fb11b746ceb5	4130	}
sepp_nepp	6:fb11b746ceb5	4131	} else {
sepp_nepp	6:fb11b746ceb5	4132	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4133	}
sepp_nepp	6:fb11b746ceb5	4134	}
sepp_nepp	6:fb11b746ceb5	4135	return status;
sepp_nepp	6:fb11b746ceb5	4136	}
sepp_nepp	6:fb11b746ceb5	4137
sepp_nepp	11:d8dbe3b87f9f	4138	VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_measurement_timing_budget_us(uint32_t measurement_timing_budget_us)
sepp_nepp	8:2fd7cb217068	4139	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	11:d8dbe3b87f9f	4140	uint32_t final_range_timing_budget_us;
sepp_nepp	6:fb11b746ceb5	4141	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
sepp_nepp	11:d8dbe3b87f9f	4142	uint32_t msrc_dcc_tcc_timeout_us = 2000;
sepp_nepp	11:d8dbe3b87f9f	4143	uint32_t start_overhead_us = 1910;
sepp_nepp	11:d8dbe3b87f9f	4144	uint32_t end_overhead_us = 960;
sepp_nepp	11:d8dbe3b87f9f	4145	uint32_t msrc_overhead_us = 660;
sepp_nepp	11:d8dbe3b87f9f	4146	uint32_t tcc_overhead_us = 590;
sepp_nepp	11:d8dbe3b87f9f	4147	uint32_t dss_overhead_us = 690;
sepp_nepp	11:d8dbe3b87f9f	4148	uint32_t pre_range_overhead_us = 660;
sepp_nepp	11:d8dbe3b87f9f	4149	uint32_t final_range_overhead_us = 550;
sepp_nepp	11:d8dbe3b87f9f	4150	uint32_t pre_range_timeout_us = 0;
sepp_nepp	11:d8dbe3b87f9f	4151	uint32_t c_min_timing_budget_us = 20000;
sepp_nepp	6:fb11b746ceb5	4152	uint32_t sub_timeout = 0;
sepp_nepp	6:fb11b746ceb5	4153
sepp_nepp	11:d8dbe3b87f9f	4154	if (measurement_timing_budget_us < c_min_timing_budget_us)
sepp_nepp	7:3a1115c2556b	4155	{ status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	7:3a1115c2556b	4156	return status;
sepp_nepp	7:3a1115c2556b	4157	}
sepp_nepp	6:fb11b746ceb5	4158
sepp_nepp	11:d8dbe3b87f9f	4159	final_range_timing_budget_us =
sepp_nepp	11:d8dbe3b87f9f	4160	measurement_timing_budget_us -
sepp_nepp	11:d8dbe3b87f9f	4161	(start_overhead_us + end_overhead_us);
sepp_nepp	6:fb11b746ceb5	4162
sepp_nepp	7:3a1115c2556b	4163	status = VL53L0X_get_sequence_step_enables( &scheduler_sequence_steps);
sepp_nepp	6:fb11b746ceb5	4164
sepp_nepp	6:fb11b746ceb5	4165	if (status == VL53L0X_ERROR_NONE &&
sepp_nepp	6:fb11b746ceb5	4166	(scheduler_sequence_steps.TccOn \|\|
sepp_nepp	6:fb11b746ceb5	4167	scheduler_sequence_steps.MsrcOn \|\|
sepp_nepp	6:fb11b746ceb5	4168	scheduler_sequence_steps.DssOn)) {
sepp_nepp	6:fb11b746ceb5	4169
sepp_nepp	6:fb11b746ceb5	4170	/* TCC, MSRC and DSS all share the same timeout */
sepp_nepp	7:3a1115c2556b	4171	status = get_sequence_step_timeout( VL53L0X_SEQUENCESTEP_MSRC,
sepp_nepp	11:d8dbe3b87f9f	4172	&msrc_dcc_tcc_timeout_us);
sepp_nepp	6:fb11b746ceb5	4173
sepp_nepp	6:fb11b746ceb5	4174	/* Subtract the TCC, MSRC and DSS timeouts if they are
sepp_nepp	6:fb11b746ceb5	4175	* enabled. */
sepp_nepp	6:fb11b746ceb5	4176
sepp_nepp	6:fb11b746ceb5	4177	if (status != VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	4178	return status;
sepp_nepp	6:fb11b746ceb5	4179	}
sepp_nepp	6:fb11b746ceb5	4180
sepp_nepp	6:fb11b746ceb5	4181	/* TCC */
sepp_nepp	6:fb11b746ceb5	4182	if (scheduler_sequence_steps.TccOn) {
sepp_nepp	6:fb11b746ceb5	4183
sepp_nepp	11:d8dbe3b87f9f	4184	sub_timeout = msrc_dcc_tcc_timeout_us
sepp_nepp	11:d8dbe3b87f9f	4185	+ tcc_overhead_us;
sepp_nepp	6:fb11b746ceb5	4186
sepp_nepp	6:fb11b746ceb5	4187	if (sub_timeout <
sepp_nepp	11:d8dbe3b87f9f	4188	final_range_timing_budget_us) {
sepp_nepp	11:d8dbe3b87f9f	4189	final_range_timing_budget_us -=
sepp_nepp	6:fb11b746ceb5	4190	sub_timeout;
sepp_nepp	6:fb11b746ceb5	4191	} else {
sepp_nepp	6:fb11b746ceb5	4192	/* Requested timeout too big. */
sepp_nepp	6:fb11b746ceb5	4193	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4194	}
sepp_nepp	6:fb11b746ceb5	4195	}
sepp_nepp	6:fb11b746ceb5	4196
sepp_nepp	7:3a1115c2556b	4197	if (status != VL53L0X_ERROR_NONE) {return status;}
sepp_nepp	6:fb11b746ceb5	4198
sepp_nepp	6:fb11b746ceb5	4199	/* DSS */
sepp_nepp	6:fb11b746ceb5	4200	if (scheduler_sequence_steps.DssOn) {
sepp_nepp	6:fb11b746ceb5	4201
sepp_nepp	11:d8dbe3b87f9f	4202	sub_timeout = 2 * (msrc_dcc_tcc_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	4203	dss_overhead_us);
sepp_nepp	11:d8dbe3b87f9f	4204
sepp_nepp	11:d8dbe3b87f9f	4205	if (sub_timeout < final_range_timing_budget_us) {
sepp_nepp	11:d8dbe3b87f9f	4206	final_range_timing_budget_us
sepp_nepp	6:fb11b746ceb5	4207	-= sub_timeout;
sepp_nepp	6:fb11b746ceb5	4208	} else {
sepp_nepp	6:fb11b746ceb5	4209	/* Requested timeout too big. */
sepp_nepp	6:fb11b746ceb5	4210	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4211	}
sepp_nepp	6:fb11b746ceb5	4212	} else if (scheduler_sequence_steps.MsrcOn) {
sepp_nepp	6:fb11b746ceb5	4213	/* MSRC */
sepp_nepp	11:d8dbe3b87f9f	4214	sub_timeout = msrc_dcc_tcc_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	4215	msrc_overhead_us;
sepp_nepp	11:d8dbe3b87f9f	4216
sepp_nepp	11:d8dbe3b87f9f	4217	if (sub_timeout < final_range_timing_budget_us) {
sepp_nepp	11:d8dbe3b87f9f	4218	final_range_timing_budget_us
sepp_nepp	6:fb11b746ceb5	4219	-= sub_timeout;
sepp_nepp	6:fb11b746ceb5	4220	} else {
sepp_nepp	6:fb11b746ceb5	4221	/* Requested timeout too big. */
sepp_nepp	6:fb11b746ceb5	4222	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4223	}
sepp_nepp	6:fb11b746ceb5	4224	}
sepp_nepp	6:fb11b746ceb5	4225	}
sepp_nepp	6:fb11b746ceb5	4226
sepp_nepp	9:cb4c6d4e5030	4227	if (status != VL53L0X_ERROR_NONE) { return status; }
sepp_nepp	6:fb11b746ceb5	4228
sepp_nepp	6:fb11b746ceb5	4229	if (scheduler_sequence_steps.PreRangeOn) {
sepp_nepp	6:fb11b746ceb5	4230
sepp_nepp	6:fb11b746ceb5	4231	/* Subtract the Pre-range timeout if enabled. */
sepp_nepp	6:fb11b746ceb5	4232
sepp_nepp	8:2fd7cb217068	4233	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
sepp_nepp	11:d8dbe3b87f9f	4234	&pre_range_timeout_us);
sepp_nepp	11:d8dbe3b87f9f	4235
sepp_nepp	11:d8dbe3b87f9f	4236	sub_timeout = pre_range_timeout_us +
sepp_nepp	11:d8dbe3b87f9f	4237	pre_range_overhead_us;
sepp_nepp	11:d8dbe3b87f9f	4238
sepp_nepp	11:d8dbe3b87f9f	4239	if (sub_timeout < final_range_timing_budget_us) {
sepp_nepp	11:d8dbe3b87f9f	4240	final_range_timing_budget_us -= sub_timeout;
sepp_nepp	6:fb11b746ceb5	4241	} else {
sepp_nepp	6:fb11b746ceb5	4242	/* Requested timeout too big. */
sepp_nepp	6:fb11b746ceb5	4243	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4244	}
sepp_nepp	6:fb11b746ceb5	4245	}
sepp_nepp	6:fb11b746ceb5	4246
sepp_nepp	6:fb11b746ceb5	4247	if (status == VL53L0X_ERROR_NONE &&
sepp_nepp	6:fb11b746ceb5	4248	scheduler_sequence_steps.FinalRangeOn) {
sepp_nepp	6:fb11b746ceb5	4249
sepp_nepp	11:d8dbe3b87f9f	4250	final_range_timing_budget_us -=
sepp_nepp	11:d8dbe3b87f9f	4251	final_range_overhead_us;
sepp_nepp	6:fb11b746ceb5	4252
sepp_nepp	6:fb11b746ceb5	4253	/* Final Range Timeout
sepp_nepp	6:fb11b746ceb5	4254	* Note that the final range timeout is determined by the timing
sepp_nepp	6:fb11b746ceb5	4255	* budget and the sum of all other timeouts within the sequence.
sepp_nepp	6:fb11b746ceb5	4256	* If there is no room for the final range timeout, then an error
sepp_nepp	6:fb11b746ceb5	4257	* will be set. Otherwise the remaining time will be applied to
sepp_nepp	6:fb11b746ceb5	4258	* the final range.
sepp_nepp	6:fb11b746ceb5	4259	*/
sepp_nepp	7:3a1115c2556b	4260	status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
sepp_nepp	11:d8dbe3b87f9f	4261	final_range_timing_budget_us);
sepp_nepp	11:d8dbe3b87f9f	4262	CurrentParameters.MeasurementTimingBudget_us = measurement_timing_budget_us;
sepp_nepp	6:fb11b746ceb5	4263	}
sepp_nepp	6:fb11b746ceb5	4264
sepp_nepp	6:fb11b746ceb5	4265	return status;
sepp_nepp	6:fb11b746ceb5	4266	}
sepp_nepp	6:fb11b746ceb5	4267
sepp_nepp	11:d8dbe3b87f9f	4268	VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_us(uint32_t measurement_timing_budget_us)
sepp_nepp	7:3a1115c2556b	4269	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	11:d8dbe3b87f9f	4270	status = wrapped_VL53L0X_set_measurement_timing_budget_us(measurement_timing_budget_us);
sepp_nepp	6:fb11b746ceb5	4271	return status;
sepp_nepp	6:fb11b746ceb5	4272	}
sepp_nepp	6:fb11b746ceb5	4273
sepp_nepp	8:2fd7cb217068	4274	VL53L0X_Error VL53L0X::VL53L0X_set_sequence_step_enable(VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
sepp_nepp	8:2fd7cb217068	4275	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4276	uint8_t sequence_config = 0;
sepp_nepp	6:fb11b746ceb5	4277	uint8_t sequence_config_new = 0;
sepp_nepp	11:d8dbe3b87f9f	4278	uint32_t measurement_timing_budget_us;
sepp_nepp	6:fb11b746ceb5	4279
sepp_nepp	7:3a1115c2556b	4280	status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &sequence_config);
sepp_nepp	6:fb11b746ceb5	4281
sepp_nepp	6:fb11b746ceb5	4282	sequence_config_new = sequence_config;
sepp_nepp	6:fb11b746ceb5	4283
sepp_nepp	6:fb11b746ceb5	4284	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	4285	if (sequence_step_enabled == 1) {
sepp_nepp	6:fb11b746ceb5	4286
sepp_nepp	6:fb11b746ceb5	4287	/* Enable requested sequence step
sepp_nepp	6:fb11b746ceb5	4288	*/
sepp_nepp	6:fb11b746ceb5	4289	switch (sequence_step_id) {
sepp_nepp	6:fb11b746ceb5	4290	case VL53L0X_SEQUENCESTEP_TCC:
sepp_nepp	6:fb11b746ceb5	4291	sequence_config_new \|= 0x10;
sepp_nepp	6:fb11b746ceb5	4292	break;
sepp_nepp	6:fb11b746ceb5	4293	case VL53L0X_SEQUENCESTEP_DSS:
sepp_nepp	6:fb11b746ceb5	4294	sequence_config_new \|= 0x28;
sepp_nepp	6:fb11b746ceb5	4295	break;
sepp_nepp	6:fb11b746ceb5	4296	case VL53L0X_SEQUENCESTEP_MSRC:
sepp_nepp	6:fb11b746ceb5	4297	sequence_config_new \|= 0x04;
sepp_nepp	6:fb11b746ceb5	4298	break;
sepp_nepp	6:fb11b746ceb5	4299	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
sepp_nepp	6:fb11b746ceb5	4300	sequence_config_new \|= 0x40;
sepp_nepp	6:fb11b746ceb5	4301	break;
sepp_nepp	6:fb11b746ceb5	4302	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	4303	sequence_config_new \|= 0x80;
sepp_nepp	6:fb11b746ceb5	4304	break;
sepp_nepp	6:fb11b746ceb5	4305	default:
sepp_nepp	6:fb11b746ceb5	4306	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4307	}
sepp_nepp	6:fb11b746ceb5	4308	} else {
sepp_nepp	7:3a1115c2556b	4309	/* Disable requested sequence step */
sepp_nepp	6:fb11b746ceb5	4310	switch (sequence_step_id) {
sepp_nepp	6:fb11b746ceb5	4311	case VL53L0X_SEQUENCESTEP_TCC:
sepp_nepp	6:fb11b746ceb5	4312	sequence_config_new &= 0xef;
sepp_nepp	6:fb11b746ceb5	4313	break;
sepp_nepp	6:fb11b746ceb5	4314	case VL53L0X_SEQUENCESTEP_DSS:
sepp_nepp	6:fb11b746ceb5	4315	sequence_config_new &= 0xd7;
sepp_nepp	6:fb11b746ceb5	4316	break;
sepp_nepp	6:fb11b746ceb5	4317	case VL53L0X_SEQUENCESTEP_MSRC:
sepp_nepp	6:fb11b746ceb5	4318	sequence_config_new &= 0xfb;
sepp_nepp	6:fb11b746ceb5	4319	break;
sepp_nepp	6:fb11b746ceb5	4320	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
sepp_nepp	6:fb11b746ceb5	4321	sequence_config_new &= 0xbf;
sepp_nepp	6:fb11b746ceb5	4322	break;
sepp_nepp	6:fb11b746ceb5	4323	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	4324	sequence_config_new &= 0x7f;
sepp_nepp	6:fb11b746ceb5	4325	break;
sepp_nepp	6:fb11b746ceb5	4326	default:
sepp_nepp	6:fb11b746ceb5	4327	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4328	}
sepp_nepp	6:fb11b746ceb5	4329	}
sepp_nepp	6:fb11b746ceb5	4330	}
sepp_nepp	6:fb11b746ceb5	4331
sepp_nepp	6:fb11b746ceb5	4332	if (sequence_config_new != sequence_config) {
sepp_nepp	6:fb11b746ceb5	4333	/* Apply New Setting */
sepp_nepp	6:fb11b746ceb5	4334	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4335	status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new);
sepp_nepp	6:fb11b746ceb5	4336	}
sepp_nepp	6:fb11b746ceb5	4337	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4338	Data.SequenceConfig = sequence_config_new;}
sepp_nepp	6:fb11b746ceb5	4339
sepp_nepp	6:fb11b746ceb5	4340	/* Recalculate timing budget */
sepp_nepp	6:fb11b746ceb5	4341	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4342	measurement_timing_budget_us = CurrentParameters.MeasurementTimingBudget_us ;
sepp_nepp	11:d8dbe3b87f9f	4343	VL53L0X_set_measurement_timing_budget_us(measurement_timing_budget_us);
sepp_nepp	6:fb11b746ceb5	4344	}
sepp_nepp	6:fb11b746ceb5	4345	}
sepp_nepp	6:fb11b746ceb5	4346
sepp_nepp	6:fb11b746ceb5	4347	return status;
sepp_nepp	6:fb11b746ceb5	4348	}
sepp_nepp	6:fb11b746ceb5	4349
sepp_nepp	7:3a1115c2556b	4350	VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_enable( uint16_t limit_check_id,
sepp_nepp	6:fb11b746ceb5	4351	uint8_t limit_check_enable)
sepp_nepp	8:2fd7cb217068	4352	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4353	FixPoint1616_t temp_fix1616 = 0;
sepp_nepp	6:fb11b746ceb5	4354	uint8_t limit_check_enable_int = 0;
sepp_nepp	6:fb11b746ceb5	4355	uint8_t limit_check_disable = 0;
sepp_nepp	6:fb11b746ceb5	4356	uint8_t temp8;
sepp_nepp	6:fb11b746ceb5	4357
sepp_nepp	6:fb11b746ceb5	4358	if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
sepp_nepp	6:fb11b746ceb5	4359	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4360	} else {
sepp_nepp	6:fb11b746ceb5	4361	if (limit_check_enable == 0) {
sepp_nepp	6:fb11b746ceb5	4362	temp_fix1616 = 0;
sepp_nepp	6:fb11b746ceb5	4363	limit_check_enable_int = 0;
sepp_nepp	6:fb11b746ceb5	4364	limit_check_disable = 1;
sepp_nepp	6:fb11b746ceb5	4365	} else {
sepp_nepp	10:cd1758e186a4	4366	temp_fix1616 = CurrentParameters.LimitChecksValue[limit_check_id];
sepp_nepp	6:fb11b746ceb5	4367	limit_check_disable = 0;
sepp_nepp	6:fb11b746ceb5	4368	/* this to be sure to have either 0 or 1 */
sepp_nepp	6:fb11b746ceb5	4369	limit_check_enable_int = 1;
sepp_nepp	6:fb11b746ceb5	4370	}
sepp_nepp	6:fb11b746ceb5	4371
sepp_nepp	6:fb11b746ceb5	4372	switch (limit_check_id) {
sepp_nepp	6:fb11b746ceb5	4373
sepp_nepp	6:fb11b746ceb5	4374	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
sepp_nepp	6:fb11b746ceb5	4375	/* internal computation: */
sepp_nepp	10:cd1758e186a4	4376	CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_enable_int;
sepp_nepp	6:fb11b746ceb5	4377	break;
sepp_nepp	6:fb11b746ceb5	4378
sepp_nepp	6:fb11b746ceb5	4379	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
sepp_nepp	7:3a1115c2556b	4380	status = VL53L0X_write_word( VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
sepp_nepp	11:d8dbe3b87f9f	4381	VL53L0X_FP1616TOFP97(temp_fix1616));
sepp_nepp	6:fb11b746ceb5	4382	break;
sepp_nepp	6:fb11b746ceb5	4383
sepp_nepp	7:3a1115c2556b	4384	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:/* internal computation: */
sepp_nepp	10:cd1758e186a4	4385	CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_enable_int;
sepp_nepp	6:fb11b746ceb5	4386	break;
sepp_nepp	6:fb11b746ceb5	4387
sepp_nepp	7:3a1115c2556b	4388	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:/* internal computation: */
sepp_nepp	10:cd1758e186a4	4389	CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = limit_check_enable_int;
sepp_nepp	6:fb11b746ceb5	4390	break;
sepp_nepp	6:fb11b746ceb5	4391
sepp_nepp	6:fb11b746ceb5	4392	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
sepp_nepp	6:fb11b746ceb5	4393	temp8 = (uint8_t)(limit_check_disable << 1);
sepp_nepp	7:3a1115c2556b	4394	status = VL53L0X_update_byte(VL53L0X_REG_MSRC_CONFIG_CONTROL,
sepp_nepp	6:fb11b746ceb5	4395	0xFE, temp8);
sepp_nepp	6:fb11b746ceb5	4396	break;
sepp_nepp	6:fb11b746ceb5	4397
sepp_nepp	6:fb11b746ceb5	4398	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
sepp_nepp	6:fb11b746ceb5	4399
sepp_nepp	6:fb11b746ceb5	4400	temp8 = (uint8_t)(limit_check_disable << 4);
sepp_nepp	7:3a1115c2556b	4401	status = VL53L0X_update_byte(VL53L0X_REG_MSRC_CONFIG_CONTROL,
sepp_nepp	6:fb11b746ceb5	4402	0xEF, temp8);
sepp_nepp	6:fb11b746ceb5	4403	break;
sepp_nepp	6:fb11b746ceb5	4404
sepp_nepp	6:fb11b746ceb5	4405	default:
sepp_nepp	6:fb11b746ceb5	4406	status = VL53L0X_ERROR_INVALID_PARAMS;
sepp_nepp	6:fb11b746ceb5	4407	}
sepp_nepp	6:fb11b746ceb5	4408	}
sepp_nepp	6:fb11b746ceb5	4409
sepp_nepp	6:fb11b746ceb5	4410	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	4411	if (limit_check_enable == 0) {
sepp_nepp	10:cd1758e186a4	4412	CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
sepp_nepp	6:fb11b746ceb5	4413	} else {
sepp_nepp	10:cd1758e186a4	4414	CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
sepp_nepp	6:fb11b746ceb5	4415	}
sepp_nepp	6:fb11b746ceb5	4416	}
sepp_nepp	6:fb11b746ceb5	4417	return status;
sepp_nepp	6:fb11b746ceb5	4418	}
sepp_nepp	6:fb11b746ceb5	4419
sepp_nepp	7:3a1115c2556b	4420	VL53L0X_Error VL53L0X::VL53L0X_static_init(void)
sepp_nepp	8:2fd7cb217068	4421	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4422	VL53L0X_DeviceParameters_t current_parameters = {0};
sepp_nepp	6:fb11b746ceb5	4423	uint8_t *p_tuning_setting_buffer;
sepp_nepp	6:fb11b746ceb5	4424	uint16_t tempword = 0;
sepp_nepp	6:fb11b746ceb5	4425	uint8_t tempbyte = 0;
sepp_nepp	6:fb11b746ceb5	4426	uint8_t use_internal_tuning_settings = 0;
sepp_nepp	6:fb11b746ceb5	4427	uint32_t count = 0;
sepp_nepp	6:fb11b746ceb5	4428	uint8_t is_aperture_spads = 0;
sepp_nepp	6:fb11b746ceb5	4429	uint32_t ref_spad_count = 0;
sepp_nepp	6:fb11b746ceb5	4430	uint8_t aperture_spads = 0;
sepp_nepp	6:fb11b746ceb5	4431	uint8_t vcsel_pulse_period_pclk;
sepp_nepp	6:fb11b746ceb5	4432	uint32_t seq_timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	4433
sepp_nepp	7:3a1115c2556b	4434	status = VL53L0X_get_info_from_device( 1);
sepp_nepp	6:fb11b746ceb5	4435
sepp_nepp	6:fb11b746ceb5	4436	/* set the ref spad from NVM */
sepp_nepp	8:2fd7cb217068	4437	count = (uint32_t)Data.ReferenceSpadCount;
sepp_nepp	8:2fd7cb217068	4438	aperture_spads = Data.ReferenceSpadType;
sepp_nepp	6:fb11b746ceb5	4439
sepp_nepp	6:fb11b746ceb5	4440	/* NVM value invalid */
sepp_nepp	6:fb11b746ceb5	4441	if ((aperture_spads > 1) \|\|
sepp_nepp	6:fb11b746ceb5	4442	((aperture_spads == 1) && (count > 32)) \|\|
sepp_nepp	6:fb11b746ceb5	4443	((aperture_spads == 0) && (count > 12))) {
sepp_nepp	7:3a1115c2556b	4444	status = wrapped_VL53L0X_perform_ref_spad_management( &ref_spad_count,
sepp_nepp	6:fb11b746ceb5	4445	&is_aperture_spads);
sepp_nepp	6:fb11b746ceb5	4446	} else {
sepp_nepp	7:3a1115c2556b	4447	status = VL53L0X_set_reference_spads( count, aperture_spads);
sepp_nepp	6:fb11b746ceb5	4448	}
sepp_nepp	6:fb11b746ceb5	4449
sepp_nepp	6:fb11b746ceb5	4450	/* Initialize tuning settings buffer to prevent compiler warning. */
sepp_nepp	6:fb11b746ceb5	4451	p_tuning_setting_buffer = DefaultTuningSettings;
sepp_nepp	6:fb11b746ceb5	4452
sepp_nepp	6:fb11b746ceb5	4453	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4454	use_internal_tuning_settings = Data.UseInternalTuningSettings;
sepp_nepp	6:fb11b746ceb5	4455
sepp_nepp	6:fb11b746ceb5	4456	if (use_internal_tuning_settings == 0) {
sepp_nepp	8:2fd7cb217068	4457	p_tuning_setting_buffer = Data.pTuningSettingsPointer; }
sepp_nepp	7:3a1115c2556b	4458	else { p_tuning_setting_buffer = DefaultTuningSettings; }
sepp_nepp	6:fb11b746ceb5	4459
sepp_nepp	6:fb11b746ceb5	4460	}
sepp_nepp	6:fb11b746ceb5	4461
sepp_nepp	6:fb11b746ceb5	4462	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4463	status = VL53L0X_load_tuning_settings( p_tuning_setting_buffer); }
sepp_nepp	6:fb11b746ceb5	4464
sepp_nepp	6:fb11b746ceb5	4465	/* Set interrupt config to new sample ready */
sepp_nepp	6:fb11b746ceb5	4466	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4467	status = VL53L0X_set_gpio_config( 0, 0,
sepp_nepp	6:fb11b746ceb5	4468	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
sepp_nepp	6:fb11b746ceb5	4469	VL53L0X_INTERRUPTPOLARITY_LOW);
sepp_nepp	6:fb11b746ceb5	4470	}
sepp_nepp	6:fb11b746ceb5	4471
sepp_nepp	6:fb11b746ceb5	4472	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4473	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	4474	status \|= VL53L0X_read_word ( 0x84, &tempword);
sepp_nepp	7:3a1115c2556b	4475	status \|= VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	4476	}
sepp_nepp	6:fb11b746ceb5	4477
sepp_nepp	6:fb11b746ceb5	4478	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4479	Data.OscFrequency_MHz = VL53L0X_FP412TOFP1616(tempword) ;
sepp_nepp	6:fb11b746ceb5	4480	}
sepp_nepp	6:fb11b746ceb5	4481
sepp_nepp	6:fb11b746ceb5	4482	/* After static init, some device parameters may be changed,
sepp_nepp	6:fb11b746ceb5	4483	* so update them */
sepp_nepp	6:fb11b746ceb5	4484	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4485	status = VL53L0X_get_device_parameters( &current_parameters);
sepp_nepp	6:fb11b746ceb5	4486	}
sepp_nepp	6:fb11b746ceb5	4487
sepp_nepp	6:fb11b746ceb5	4488	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4489	status = VL53L0X_get_fraction_enable( &tempbyte);
sepp_nepp	6:fb11b746ceb5	4490	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4491	Data.RangeFractionalEnable = tempbyte;
sepp_nepp	6:fb11b746ceb5	4492	}
sepp_nepp	6:fb11b746ceb5	4493	}
sepp_nepp	6:fb11b746ceb5	4494
sepp_nepp	6:fb11b746ceb5	4495	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	10:cd1758e186a4	4496	CurrentParameters = current_parameters;
sepp_nepp	6:fb11b746ceb5	4497	}
sepp_nepp	6:fb11b746ceb5	4498
sepp_nepp	6:fb11b746ceb5	4499	/* read the sequence config and save it */
sepp_nepp	6:fb11b746ceb5	4500	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4501	status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
sepp_nepp	6:fb11b746ceb5	4502	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4503	Data.SequenceConfig = tempbyte;
sepp_nepp	6:fb11b746ceb5	4504	}
sepp_nepp	6:fb11b746ceb5	4505	}
sepp_nepp	6:fb11b746ceb5	4506
sepp_nepp	6:fb11b746ceb5	4507	/* Disable MSRC and TCC by default */
sepp_nepp	6:fb11b746ceb5	4508	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4509	status = VL53L0X_set_sequence_step_enable(VL53L0X_SEQUENCESTEP_TCC, 0);
sepp_nepp	6:fb11b746ceb5	4510	}
sepp_nepp	6:fb11b746ceb5	4511
sepp_nepp	6:fb11b746ceb5	4512	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4513	status = VL53L0X_set_sequence_step_enable(VL53L0X_SEQUENCESTEP_MSRC, 0);
sepp_nepp	6:fb11b746ceb5	4514	}
sepp_nepp	6:fb11b746ceb5	4515
sepp_nepp	6:fb11b746ceb5	4516	/* Set PAL State to standby */
sepp_nepp	6:fb11b746ceb5	4517	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4518	Data.PalState = VL53L0X_STATE_IDLE;
sepp_nepp	6:fb11b746ceb5	4519	}
sepp_nepp	6:fb11b746ceb5	4520
sepp_nepp	6:fb11b746ceb5	4521	/* Store pre-range vcsel period */
sepp_nepp	6:fb11b746ceb5	4522	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4523	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,&vcsel_pulse_period_pclk);
sepp_nepp	6:fb11b746ceb5	4524	}
sepp_nepp	6:fb11b746ceb5	4525
sepp_nepp	6:fb11b746ceb5	4526	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4527	Data.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
sepp_nepp	6:fb11b746ceb5	4528	}
sepp_nepp	6:fb11b746ceb5	4529
sepp_nepp	6:fb11b746ceb5	4530	/* Store final-range vcsel period */
sepp_nepp	6:fb11b746ceb5	4531	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4532	status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
sepp_nepp	6:fb11b746ceb5	4533	&vcsel_pulse_period_pclk);
sepp_nepp	6:fb11b746ceb5	4534	}
sepp_nepp	6:fb11b746ceb5	4535
sepp_nepp	6:fb11b746ceb5	4536	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	8:2fd7cb217068	4537	Data.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
sepp_nepp	6:fb11b746ceb5	4538	}
sepp_nepp	6:fb11b746ceb5	4539
sepp_nepp	6:fb11b746ceb5	4540	/* Store pre-range timeout */
sepp_nepp	6:fb11b746ceb5	4541	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4542	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,&seq_timeout_micro_secs);
sepp_nepp	6:fb11b746ceb5	4543	}
sepp_nepp	6:fb11b746ceb5	4544
sepp_nepp	6:fb11b746ceb5	4545	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4546	Data.PreRangeTimeout_us = seq_timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	4547	}
sepp_nepp	6:fb11b746ceb5	4548
sepp_nepp	6:fb11b746ceb5	4549	/* Store final-range timeout */
sepp_nepp	6:fb11b746ceb5	4550	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4551	status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,&seq_timeout_micro_secs);
sepp_nepp	6:fb11b746ceb5	4552	}
sepp_nepp	6:fb11b746ceb5	4553
sepp_nepp	6:fb11b746ceb5	4554	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4555	Data.FinalRangeTimeout_us = seq_timeout_micro_secs;
sepp_nepp	6:fb11b746ceb5	4556	}
sepp_nepp	6:fb11b746ceb5	4557	return status;
sepp_nepp	6:fb11b746ceb5	4558	}
sepp_nepp	6:fb11b746ceb5	4559
sepp_nepp	7:3a1115c2556b	4560	VL53L0X_Error VL53L0X::VL53L0X_stop_measurement(void)
sepp_nepp	8:2fd7cb217068	4561	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4562
sepp_nepp	7:3a1115c2556b	4563	status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START,
sepp_nepp	6:fb11b746ceb5	4564	VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
sepp_nepp	7:3a1115c2556b	4565	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	4566	status = VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	7:3a1115c2556b	4567	status = VL53L0X_write_byte( 0x91, 0x00);
sepp_nepp	7:3a1115c2556b	4568	status = VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	4569	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	6:fb11b746ceb5	4570
sepp_nepp	6:fb11b746ceb5	4571	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	6:fb11b746ceb5	4572	/* Set PAL State to Idle */
sepp_nepp	8:2fd7cb217068	4573	Data.PalState = VL53L0X_STATE_IDLE;
sepp_nepp	6:fb11b746ceb5	4574	}
sepp_nepp	6:fb11b746ceb5	4575
sepp_nepp	6:fb11b746ceb5	4576	/* Check if need to apply interrupt settings */
sepp_nepp	6:fb11b746ceb5	4577	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	7:3a1115c2556b	4578	status = VL53L0X_check_and_load_interrupt_settings( 0);
sepp_nepp	6:fb11b746ceb5	4579	}
sepp_nepp	6:fb11b746ceb5	4580	return status;
sepp_nepp	6:fb11b746ceb5	4581	}
sepp_nepp	6:fb11b746ceb5	4582
sepp_nepp	8:2fd7cb217068	4583	VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(uint32_t *p_stop_status)
sepp_nepp	8:2fd7cb217068	4584	{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
sepp_nepp	6:fb11b746ceb5	4585	uint8_t byte = 0;
sepp_nepp	6:fb11b746ceb5	4586
sepp_nepp	6:fb11b746ceb5	4587
sepp_nepp	7:3a1115c2556b	4588	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	6:fb11b746ceb5	4589
sepp_nepp	6:fb11b746ceb5	4590	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4591	status = VL53L0X_read_byte( 0x04, &byte);}
sepp_nepp	6:fb11b746ceb5	4592
sepp_nepp	6:fb11b746ceb5	4593	if (status == VL53L0X_ERROR_NONE) {
sepp_nepp	11:d8dbe3b87f9f	4594	status = VL53L0X_write_byte( 0xFF, 0x0); }
sepp_nepp	6:fb11b746ceb5	4595
sepp_nepp	6:fb11b746ceb5	4596	*p_stop_status = byte;
sepp_nepp	6:fb11b746ceb5	4597
sepp_nepp	6:fb11b746ceb5	4598	if (byte == 0) {
sepp_nepp	7:3a1115c2556b	4599	status = VL53L0X_write_byte( 0x80, 0x01);
sepp_nepp	7:3a1115c2556b	4600	status = VL53L0X_write_byte( 0xFF, 0x01);
sepp_nepp	7:3a1115c2556b	4601	status = VL53L0X_write_byte( 0x00, 0x00);
sepp_nepp	8:2fd7cb217068	4602	status = VL53L0X_write_byte( 0x91,Data.StopVariable);
sepp_nepp	7:3a1115c2556b	4603	status = VL53L0X_write_byte( 0x00, 0x01);
sepp_nepp	7:3a1115c2556b	4604	status = VL53L0X_write_byte( 0xFF, 0x00);
sepp_nepp	7:3a1115c2556b	4605	status = VL53L0X_write_byte( 0x80, 0x00);
sepp_nepp	6:fb11b746ceb5	4606	}
sepp_nepp	6:fb11b746ceb5	4607	return status;
sepp_nepp	6:fb11b746ceb5	4608	}
sepp_nepp	6:fb11b746ceb5	4609
sepp_nepp	6:fb11b746ceb5	4610	/******************************************************************************/
sepp_nepp	6:fb11b746ceb5	4611
sepp_nepp	6:fb11b746ceb5	4612	/**************** Write and read functions from I2C ***********************/
sepp_nepp	6:fb11b746ceb5	4613
sepp_nepp	7:3a1115c2556b	4614	VL53L0X_Error VL53L0X::VL53L0X_read_multi( uint8_t index, uint8_t *p_data, uint32_t count)
sepp_nepp	9:cb4c6d4e5030	4615	{ if (count >= VL53L0X_MAX_I2C_XFER_SIZE) {
sepp_nepp	9:cb4c6d4e5030	4616	return VL53L0X_ERROR_INVALID_PARAMS;}
sepp_nepp	9:cb4c6d4e5030	4617	else { return VL53L0X_i2c_read(index, p_data, (uint16_t)count); }
sepp_nepp	6:fb11b746ceb5	4618	}
sepp_nepp	6:fb11b746ceb5	4619
sepp_nepp	7:3a1115c2556b	4620	VL53L0X_Error VL53L0X::VL53L0X_write_byte( uint8_t index, uint8_t data)
sepp_nepp	9:cb4c6d4e5030	4621	{ return VL53L0X_i2c_write(index, &data, 1);
sepp_nepp	6:fb11b746ceb5	4622	}
sepp_nepp	6:fb11b746ceb5	4623
sepp_nepp	7:3a1115c2556b	4624	VL53L0X_Error VL53L0X::VL53L0X_write_word( uint8_t index, uint16_t data)
sepp_nepp	8:2fd7cb217068	4625	{ int status;
sepp_nepp	6:fb11b746ceb5	4626	uint8_t buffer[2];
sepp_nepp	6:fb11b746ceb5	4627
sepp_nepp	6:fb11b746ceb5	4628	buffer[0] = data >> 8;
sepp_nepp	6:fb11b746ceb5	4629	buffer[1] = data & 0x00FF;
sepp_nepp	7:3a1115c2556b	4630	status = VL53L0X_i2c_write(index, (uint8_t *)buffer, 2);
sepp_nepp	6:fb11b746ceb5	4631	return status;
sepp_nepp	6:fb11b746ceb5	4632	}
sepp_nepp	6:fb11b746ceb5	4633
sepp_nepp	7:3a1115c2556b	4634	VL53L0X_Error VL53L0X::VL53L0X_write_dword( uint8_t index, uint32_t data)
sepp_nepp	8:2fd7cb217068	4635	{ int status;
sepp_nepp	6:fb11b746ceb5	4636	uint8_t buffer[4];
sepp_nepp	6:fb11b746ceb5	4637
sepp_nepp	6:fb11b746ceb5	4638	buffer[0] = (data >> 24) & 0xFF;
sepp_nepp	6:fb11b746ceb5	4639	buffer[1] = (data >> 16) & 0xFF;
sepp_nepp	6:fb11b746ceb5	4640	buffer[2] = (data >> 8) & 0xFF;
sepp_nepp	6:fb11b746ceb5	4641	buffer[3] = (data >> 0) & 0xFF;
sepp_nepp	7:3a1115c2556b	4642	status = VL53L0X_i2c_write(index, (uint8_t *)buffer, 4);
sepp_nepp	6:fb11b746ceb5	4643	return status;
sepp_nepp	6:fb11b746ceb5	4644	}
sepp_nepp	6:fb11b746ceb5	4645
sepp_nepp	7:3a1115c2556b	4646	VL53L0X_Error VL53L0X::VL53L0X_read_byte( uint8_t index, uint8_t *p_data)
sepp_nepp	9:cb4c6d4e5030	4647	{ return VL53L0X_i2c_read(index, p_data, 1); }
sepp_nepp	6:fb11b746ceb5	4648
sepp_nepp	7:3a1115c2556b	4649	VL53L0X_Error VL53L0X::VL53L0X_read_word( uint8_t index, uint16_t *p_data)
sepp_nepp	8:2fd7cb217068	4650	{ int status;
sepp_nepp	6:fb11b746ceb5	4651	uint8_t buffer[2] = {0, 0};
sepp_nepp	6:fb11b746ceb5	4652
sepp_nepp	7:3a1115c2556b	4653	status = VL53L0X_i2c_read(index, buffer, 2);
sepp_nepp	9:cb4c6d4e5030	4654	if (!status) {*p_data = (buffer[0] << 8) + buffer[1];}
sepp_nepp	6:fb11b746ceb5	4655	return status;
sepp_nepp	6:fb11b746ceb5	4656	}
sepp_nepp	6:fb11b746ceb5	4657
sepp_nepp	7:3a1115c2556b	4658	VL53L0X_Error VL53L0X::VL53L0X_read_dword( uint8_t index, uint32_t *p_data)
sepp_nepp	8:2fd7cb217068	4659	{ int status;
sepp_nepp	6:fb11b746ceb5	4660	uint8_t buffer[4] = {0, 0, 0, 0};
sepp_nepp	6:fb11b746ceb5	4661
sepp_nepp	7:3a1115c2556b	4662	status = VL53L0X_i2c_read(index, buffer, 4);
sepp_nepp	9:cb4c6d4e5030	4663	if (!status) { *p_data = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; }
sepp_nepp	6:fb11b746ceb5	4664	return status;
sepp_nepp	6:fb11b746ceb5	4665	}
sepp_nepp	6:fb11b746ceb5	4666
sepp_nepp	7:3a1115c2556b	4667	VL53L0X_Error VL53L0X::VL53L0X_update_byte( uint8_t index, uint8_t and_data, uint8_t or_data)
sepp_nepp	8:2fd7cb217068	4668	{ int status;
sepp_nepp	6:fb11b746ceb5	4669	uint8_t buffer = 0;
sepp_nepp	6:fb11b746ceb5	4670
sepp_nepp	6:fb11b746ceb5	4671	/* read data direct onto buffer */
sepp_nepp	7:3a1115c2556b	4672	status = VL53L0X_i2c_read(index, &buffer, 1);
sepp_nepp	6:fb11b746ceb5	4673	if (!status) {
sepp_nepp	6:fb11b746ceb5	4674	buffer = (buffer & and_data) \| or_data;
sepp_nepp	7:3a1115c2556b	4675	status = VL53L0X_i2c_write(index, &buffer, (uint8_t)1);
sepp_nepp	6:fb11b746ceb5	4676	}
sepp_nepp	6:fb11b746ceb5	4677	return status;
sepp_nepp	6:fb11b746ceb5	4678	}
sepp_nepp	6:fb11b746ceb5	4679
sepp_nepp	7:3a1115c2556b	4680	VL53L0X_Error VL53L0X::VL53L0X_i2c_write(uint8_t RegisterAddr, uint8_t *p_data,
sepp_nepp	6:fb11b746ceb5	4681	uint16_t NumByteToWrite)
sepp_nepp	8:2fd7cb217068	4682	{ /** Writes a buffer towards the I2C peripheral device. */
sepp_nepp	8:2fd7cb217068	4683	static uint8_t tmp[VL53L0X_MAX_I2C_XFER_SIZE];
sepp_nepp	6:fb11b746ceb5	4684
sepp_nepp	6:fb11b746ceb5	4685	if(NumByteToWrite >= VL53L0X_MAX_I2C_XFER_SIZE) return -2;
sepp_nepp	6:fb11b746ceb5	4686
sepp_nepp	6:fb11b746ceb5	4687	/* First, send device address. Then, send data and STOP condition */
sepp_nepp	6:fb11b746ceb5	4688	tmp[0] = RegisterAddr;
sepp_nepp	8:2fd7cb217068	4689	memcpy(tmp+1, p_data, NumByteToWrite);
sepp_nepp	8:2fd7cb217068	4690
sepp_nepp	8:2fd7cb217068	4691	if (_dev_i2c->write(I2cDevAddr, (const char*)tmp, NumByteToWrite+1, false) != 0 )
sepp_nepp	8:2fd7cb217068	4692	{ return -1; }
sepp_nepp	8:2fd7cb217068	4693	return 0;
sepp_nepp	8:2fd7cb217068	4694	}
sepp_nepp	8:2fd7cb217068	4695
sepp_nepp	8:2fd7cb217068	4696	VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t RegisterAddr, uint8_t *p_data, uint16_t NumByteToRead)
sepp_nepp	8:2fd7cb217068	4697	{ /** Reads a buffer from the I2C peripheral device. */
sepp_nepp	8:2fd7cb217068	4698
sepp_nepp	8:2fd7cb217068	4699	/* First Send device address, with no STOP condition */
sepp_nepp	8:2fd7cb217068	4700	int ret = _dev_i2c->write(I2cDevAddr, (const char*)&RegisterAddr, 1, true);
sepp_nepp	8:2fd7cb217068	4701
sepp_nepp	8:2fd7cb217068	4702	/* all ok ? then Read data, with STOP condition */
sepp_nepp	9:cb4c6d4e5030	4703	if (ret == 0) { ret = _dev_i2c->read(I2cDevAddr, (char*)p_data, NumByteToRead, false); }
sepp_nepp	8:2fd7cb217068	4704
sepp_nepp	6:fb11b746ceb5	4705	if (ret != 0 ){ return -1; }
sepp_nepp	6:fb11b746ceb5	4706	return 0;
sepp_nepp	6:fb11b746ceb5	4707	}
sepp_nepp	6:fb11b746ceb5	4708

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	20 Jun 2019
Imports:	2
Forks:	0
Commits:	14
Dependents:	0
Dependencies:	0
Followers:	1

VL53L0X.cpp@12:81f37e50f8f8, 2019-07-08 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning