VL53L4Cd Init Issue

[BruGenie]

Hello, 

I am encountering an issue with getting my VL53L4CD sensor to begin recording data. I have replicated the provided driver's set up in my own code however, after writing for the sensor to stop ranging in order to set the range timing, the GPIO 1 pin then never begins rising and falling again and instead stays low. 

I will attach the link to my code below, if anyone could provide any insight it would be much appreciated.

code link 

Thanks in advance.

Luca

[John E KVAM]

At a 'start command' the sensor sends and immediate interrupt. 

This has to do with a sensor that was told to only interrupt if something crossed a threshold. Then say the sensor rebooted due to a power glitch. 

Best way to fix that is to send an interrupt on start. 

So try this. 

Issue the start command - Immediately clear the interrupt. Then wait for the real interrupt that should be coming in the next few milliseconds. 

I'm pretty sure the sensor is interrupting, but as you have not cleared the existing one, the next one was hidden from you.

- john

[BruGenie]

Hi John, thanks for your reply. 

I've tried hooking the sensor up to an oscilloscope and have attached the output I get from the GPIO 1 pin. I think you are correct with the fact that the interrupt is never cleared however I am unsure of how to fix this. 

I've attempted to verify my write commands and can see that for 0x86 and 0x87 for stopping and clearing the interrupt, I am reading 0's from the registers after writing to them instead of 1 and 80 respectively again shown in an image below. My write command only throws errors for these registers and only for this not when writing to tell the sensor to start and I am unsure why.  

Any further assistance would be much appreciated and apologies for the strange reply times as I am on Uk time.

p.s. I can confirm the rising and falling for the provided driver works both through the printed output and now viewing it on the oscilloscope.

-Luca

[BruGenie]

I am now sure the issue comes from the interrupt clear not clearing, i have confirmed my write command works for all other registers but this, if anyone had an idea how to fix it it would be much appreciated.

[John E KVAM]

for this you cannot use the debugger. When running, the sensor will fire the interrupt some 30ms after you clear it. 

In fact if you take a lot of time reading the result you can clear the interrupt only to have the sensor deliver another one.

Try this:

Set a lot timing bugdet - 200ms should do it.

wait for the interrupt.

Clear the interrupt. 

the in a loop call:

    status = VL53L4CD_CheckForDataReady(dev, &p_data_ready);

    HAL_Delay(5);  // if you aren't on an STM32, replace this with whatever wait you have.

See how many times you go through that loop.

Note - by default the interrupt pin is High, and goes low when the interrupt is fired

And even if you don't use the interrupt, it will trigger when data is ready. 

- john

[BruGenie]

Thanks for your reply. I wanted to clarify what the debugger is? 

Just some further clarification on the exact issue as this does not appear to have worked for me. I am currently working on translating the driver code into C++ to use gpiod for the a callback-based system. I have succeeded in translated over all of the read and write functions and I am working on copying over the SensorInit() function. As I have mentioned before, the interrupt does not appear to be cleared by my write command, although I have verified that my write command works for writing a single byte to any of the other uint16_t registers except for that one. 

You mentioned previously that the issue may be that the interrupt is too fast. However, I have verified further on the oscilloscope, that even viewing it down to the nanosecond scale there was no rise after the initial interrupt, which causes it to fall. I will attach an image for your reference.

I have also attached the relevant code snippet where I am writing to the registers. The code appears to fail at line 62, following which "I have risen" is printed.

Thank you for any advice that you can offer, and apologies if anything is unclear.

//adding a while loop to check if the sensor has booted 
	
	uint8_t continue_loop = (uint8_t)1;
	uint8_t tmp;
	uint16_t i = 0;

	do{
		tmp = i2c_read_Byte(
				VL53L4CD_FIRMWARE__SYSTEM_STATUS);

		if(tmp == (uint8_t)0x3) //Sensor booted
		{
			continue_loop = (uint8_t)0;
			printf("sensor booted\n");
			printf("sensor boot value:%x\n",tmp);
		}
		else if(i < (uint16_t)1000)       //Wait for boot
		{
			i++;
			printf("waiting for sensor boot\n");
		}
		else // Timeout 1000ms reached
		{
			continue_loop = (uint8_t)0;
		}
		usleep(1000);
	}while(continue_loop == (uint8_t)1);


	//setting up sensor configuration
	for (Addr = (uint16_t)0x2D; Addr <= (uint16_t)0x87; Addr++)
	{	
		I2C_WrByte(Addr,
				VL53L4CD_DEFAULT_CONFIGURATION[
                                  Addr - (uint16_t)0x2D]);
	
	//printf("16bit:%X\n8bit:%X\n",Addr,(uint8_t)Addr);
	}

	
	
	running = true;
	
	//continue_loop = (uint8_t)0;

	//}while(continue_loop == (uint8_t)1);

	I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x40);

	//Clearing System Interrupt
	I2C_WrByte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR, (uint8_t)0x01);

	//waiting for data ready before moving on

	//adding a gpio event type to wait on 
	
	int ret = gpiod_line_request_rising_edge_events(pinDRDY,"Consumer");

	const struct timespec ts = {1,0};
	gpiod_line_event_wait(pinDRDY, &ts);

	printf("I have risen :)\n\n");

	//Clearing System Interrupt
	I2C_WrByte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR, (uint8_t)0x01);

	//stopping ranging
	I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x80);

	//setting ????
	I2C_WrByte(VL53L4CD_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND,(uint8_t)0x09);

	I2C_WrByte(0x0B, (uint8_t)0);

	I2C_WrWord(0x0024, (uint8_t)0x500);


	VL53L4CD_SetRangeTiming_RealTime(50, 0);

[John E KVAM]

Try clearly the interrupt AFTER you start the chip. If the chip is not running, clearing the interrupt makes little sense. 

The I2C interface is a separate IP from the ranging engine. 

Until you start ranging the, the ranging IP is basically off. 

So, no one is paying one bit of attention to your clear_interrupt command.

- john

[BruGenie]

Hello again, 

Sorry that this issue is still unresolved, but I was hoping to get further clarification. I am attaching the full edited version of the VL53L4CD_api.cpp file for your reference. I was under the impression that I was clearing the interrupt after the chip is already running, but I might be wrong. I have verified that my write function works for starting the system. Our issue appears to be on line 253.

Thank you for any help that you can offer and apologies if I've just missed something simple,

Luca

/**
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/


/**
* @file vl53l4cd_api.c
* @brief Functions implementation
*/

#include <string.h>
#include <math.h>
#include <thread>
#include <stdio.h>
#include "VL53L4CD_api.h"
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>



static const uint8_t VL53L4CD_DEFAULT_CONFIGURATION[] = {
#ifdef VL53L4CD_I2C_FAST_MODE_PLUS
0x12, /* 0x2d : set bit 2 and 5 to 1 for fast plus mode (1MHz I2C),
else don't touch */
#else
0x00, /* 0x2d : set bit 2 and 5 to 1 for fast plus mode (1MHz I2C),
else don't touch */
#endif
0x00, /* 0x2e : bit 0 if I2C pulled up at 1.8V, else set bit 0 to 1
(pull up at AVDD) */
0x00, /* 0x2f : bit 0 if GPIO pulled up at 1.8V, else set bit 0 to 1
(pull up at AVDD) */
0x11, /* 0x30 : set bit 4 to 0 for active high interrupt and 1 for active low
(bits 3:0 must be 0x1), use SetInterruptPolarity() */
0x02, /* 0x31 : bit 1 = interrupt depending on the polarity,
use CheckForDataReady() */
0x00, /* 0x32 : not user-modifiable */
0x02, /* 0x33 : not user-modifiable */
0x08, /* 0x34 : not user-modifiable */
0x00, /* 0x35 : not user-modifiable */
0x08, /* 0x36 : not user-modifiable */
0x10, /* 0x37 : not user-modifiable */
0x01, /* 0x38 : not user-modifiable */
0x01, /* 0x39 : not user-modifiable */
0x00, /* 0x3a : not user-modifiable */
0x00, /* 0x3b : not user-modifiable */
0x00, /* 0x3c : not user-modifiable */
0x00, /* 0x3d : not user-modifiable */
0xff, /* 0x3e : not user-modifiable */
0x00, /* 0x3f : not user-modifiable */
0x0F, /* 0x40 : not user-modifiable */
0x00, /* 0x41 : not user-modifiable */
0x00, /* 0x42 : not user-modifiable */
0x00, /* 0x43 : not user-modifiable */
0x00, /* 0x44 : not user-modifiable */
0x00, /* 0x45 : not user-modifiable */
0x20, /* 0x46 : interrupt configuration 0->level low detection, 1-> level high,
2-> Out of window, 3->In window, 0x20-> New sample ready , TBC */
0x0b, /* 0x47 : not user-modifiable */
0x00, /* 0x48 : not user-modifiable */
0x00, /* 0x49 : not user-modifiable */
0x02, /* 0x4a : not user-modifiable */
0x14, /* 0x4b : not user-modifiable */
0x21, /* 0x4c : not user-modifiable */
0x00, /* 0x4d : not user-modifiable */
0x00, /* 0x4e : not user-modifiable */
0x05, /* 0x4f : not user-modifiable */
0x00, /* 0x50 : not user-modifiable */
0x00, /* 0x51 : not user-modifiable */
0x00, /* 0x52 : not user-modifiable */
0x00, /* 0x53 : not user-modifiable */
0xc8, /* 0x54 : not user-modifiable */
0x00, /* 0x55 : not user-modifiable */
0x00, /* 0x56 : not user-modifiable */
0x38, /* 0x57 : not user-modifiable */
0xff, /* 0x58 : not user-modifiable */
0x01, /* 0x59 : not user-modifiable */
0x00, /* 0x5a : not user-modifiable */
0x08, /* 0x5b : not user-modifiable */
0x00, /* 0x5c : not user-modifiable */
0x00, /* 0x5d : not user-modifiable */
0x01, /* 0x5e : not user-modifiable */
0xcc, /* 0x5f : not user-modifiable */
0x07, /* 0x60 : not user-modifiable */
0x01, /* 0x61 : not user-modifiable */
0xf1, /* 0x62 : not user-modifiable */
0x05, /* 0x63 : not user-modifiable */
0x00, /* 0x64 : Sigma threshold MSB (mm in 14.2 format for MSB+LSB),
use SetSigmaThreshold(), default value 90 mm */
0xa0, /* 0x65 : Sigma threshold LSB */
0x00, /* 0x66 : Min count Rate MSB (MCPS in 9.7 format for MSB+LSB),
use SetSignalThreshold() */
0x80, /* 0x67 : Min count Rate LSB */
0x08, /* 0x68 : not user-modifiable */
0x38, /* 0x69 : not user-modifiable */
0x00, /* 0x6a : not user-modifiable */
0x00, /* 0x6b : not user-modifiable */
0x00, /* 0x6c : Intermeasurement period MSB, 32 bits register,
use SetIntermeasurementInMs() */
0x00, /* 0x6d : Intermeasurement period */
0x0f, /* 0x6e : Intermeasurement period */
0x89, /* 0x6f : Intermeasurement period LSB */
0x00, /* 0x70 : not user-modifiable */
0x00, /* 0x71 : not user-modifiable */
0x00, /* 0x72 : distance threshold high MSB (in mm, MSB+LSB),
use SetD:tanceThreshold() */
0x00, /* 0x73 : distance threshold high LSB */
0x00, /* 0x74 : distance threshold low MSB ( in mm, MSB+LSB),
use SetD:tanceThreshold() */
0x00, /* 0x75 : distance threshold low LSB */
0x00, /* 0x76 : not user-modifiable */
0x01, /* 0x77 : not user-modifiable */
0x07, /* 0x78 : not user-modifiable */
0x05, /* 0x79 : not user-modifiable */
0x06, /* 0x7a : not user-modifiable */
0x06, /* 0x7b : not user-modifiable */
0x00, /* 0x7c : not user-modifiable */
0x00, /* 0x7d : not user-modifiable */
0x02, /* 0x7e : not user-modifiable */
0xc7, /* 0x7f : not user-modifiable */
0xff, /* 0x80 : not user-modifiable */
0x9B, /* 0x81 : not user-modifiable */
0x00, /* 0x82 : not user-modifiable */
0x00, /* 0x83 : not user-modifiable */
0x00, /* 0x84 : not user-modifiable */
0x01, /* 0x85 : not user-modifiable */
0x00, /* 0x86 : clear interrupt, use ClearInterrupt() */
0x00 /* 0x87 : start ranging, use StartRanging() or StopRanging(),
If you want an automatic start after VL53L4CD_init() call,
put 0x40 in location 0x87 */
};

/*added by BruGenie*/

//Interrupt Based Callback

void VL53L4CD_API::start_recording_data()
{ 
interrupt_pin = Default_interrupt_pin;
chip = drdy_chip;

uint8_t Addr;

//assigning pin and chip for interrupt
chipDRDY = gpiod_chip_open_by_number(chip);
pinDRDY = gpiod_chip_get_line(chipDRDY,interrupt_pin);

//setting the I2C bus being used
char gpioFilename[19] ="/dev/i2c-1";

fd_i2c = open(gpioFilename, O_RDWR);

if(fd_i2c <0 ){
char i2copen[] = "failed to open i2c\n";

//checking if the device opened
#ifdef DEBUG
fprintf(stderr,i2copen);
#endif 
throw i2copen;
}
if (ioctl(fd_i2c,I2C_SLAVE,address)){
char i2cslave[] = "Could not access I2C address!";

//throwing error if the address could not be accessed
#ifdef DEBUG
fprintf(stderr,i2cslave);
#endif

throw i2cslave;
}

#ifdef DEBUG
fprintf(stderr,"Init.\n");
#endif

//adding a while loop to check if the sensor has booted 
uint8_t continue_loop = (uint8_t)1;
uint8_t tmp;
uint16_t i = 0;

do{
tmp = i2c_read_Byte(
VL53L4CD_FIRMWARE__SYSTEM_STATUS);

if(tmp == (uint8_t)0x3) //Sensor booted
{
continue_loop = (uint8_t)0;
printf("sensor booted\n");
printf("sensor boot value:%x\n",tmp);
}
else if(i < (uint16_t)1000) //Wait for boot
{
i++;
printf("waiting for sensor boot\n");
}
else // Timeout 1000ms reached
{
continue_loop = (uint8_t)0;
}
usleep(1000);
}while(continue_loop == (uint8_t)1);

printf("interrupt setting register:%x\n\n",i2c_read_Byte(0x87));
//setting up sensor configuration
for (Addr = (uint16_t)0x2D; Addr <= (uint16_t)0x87; Addr++)
{ 
I2C_WrByte(Addr,
VL53L4CD_DEFAULT_CONFIGURATION[
Addr - (uint16_t)0x2D]);
//printf("16bit:%X\n8bit:%X\n",Addr,(uint8_t)Addr);
}

printf("interrupt setting register:%x\n\n",i2c_read_Byte(0x87));
running = true;
//continue_loop = (uint8_t)0;

//}while(continue_loop == (uint8_t)1);

printf("first start %x and interrupt%x\n",i2c_read_Byte(VL53L4CD_SYSTEM_START),i2c_read_Byte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR));

I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x40);

printf("first start %x and interrupt%x\n",i2c_read_Byte(VL53L4CD_SYSTEM_START),i2c_read_Byte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR)); 

//waiting for data ready before moving on

//adding a gpio event type to wait on 
int ret = gpiod_line_request_falling_edge_events(pinDRDY,"Consumer");

const struct timespec ts = {1,0};
gpiod_line_event_wait(pinDRDY, &ts);

//I2C_WrByte(0x86, 0x01);

printf("first start and interrupt%x\n",i2c_read_Byte(VL53L4CD_SYSTEM_START));

printf("I have risen :)\n\n");

//Clearing System Interrupt

I2C_WrByte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR, 0x01);

//stopping ranging
I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x80);

//setting ????
I2C_WrByte(VL53L4CD_VHV_CONFIG__TIMEOUT_MACROP_LOOP_BOUND,(uint8_t)0x09);

I2C_WrByte(0x0B, (uint8_t)0);

I2C_WrWord(0x0024, (uint8_t)0x500);

printf("Setting range timing\n");

VL53L4CD_SetRangeTiming_RealTime(50,0);

//setting the sensor to begin recording data
//I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x40);

tmp = i2c_read_conversion(VL53L4CD_INTERMEASUREMENT_MS);
/* Sensor runs in continuous mode */
if(tmp == (uint8_t)0){

I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x21);
}
/* Sensor runs in autonomous mode */
else{
I2C_WrByte(VL53L4CD_SYSTEM_START, (uint8_t)0x40);
}


for(int i=0;i<50;i++){
I2C_WrByte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR, 0x01);
worker();
printf("i'm here");
usleep(100000);
}

//thr = std::thread(&VL53L4CD_API::worker,this);

//worker();

}

uint8_t VL53L4CD_API::I2C_WrWord(uint16_t reg, uint16_t value)
{ 

uint8_t original_value = i2c_read_conversion(reg);
uint8_t data_write[4];
data_write[0] = (reg >> 8) & 0xFF;
data_write[1] = reg & 0xFF;
data_write[2] = (value >> 8) & 0xFF;
data_write[3] = value & 0xFF;
long int r = write(fd_i2c,&data_write,4);
if(r < 0){
printf("%i",r);
#ifdef DEBUG
fprintf(stderr,"Could not read word from %02x. ret=%d.\n",address,r);
#endif
throw "Could not read from i2c.";
}


//printf("Register:%x\nValue:%x\n",reg,value);

//printf("datawrite[1]:%x\ndatawrite[2]:%x\n",data_write[1],data_write[2]);

uint16_t written_value = i2c_read_conversion(reg);

if(written_value != (uint16_t)value){

printf("oh this word is wrong\n");

}

//if (written_value != original_value){


// printf("we have a printer\n");
//}


}

uint8_t VL53L4CD_API::I2C_Wr_four_bytes(uint16_t reg, uint32_t value)
{ 

uint8_t original_value = i2c_read_conversion(reg);
uint8_t data_write[6];
data_write[0] = (reg >> 8) & 0xFF;
data_write[1] = reg & 0xFF;
data_write[2] = (value >> 24) & 0xFF;
data_write[3] = (value >> 16) & 0xFF;
data_write[4] = (value >> 8) & 0xFF;
data_write[5] = value & 0xFF;
long int r = write(fd_i2c,&data_write,6);

//printf("you are writing a 32 bit number of; %x\n\n",value);
if(r < 0){
printf("%i",r);
#ifdef DEBUG
fprintf(stderr,"Could not read word from %02x. ret=%d.\n",address,r);
#endif
throw "Could not read from i2c.";
}


//printf("Register:%x\nValue:%x\n",reg,value);

//printf("datawrite[1]:%x\ndatawrite[2]:%x\n",data_write[1],data_write[2]);

uint16_t written_value = i2c_read_conversion(reg);

if(written_value != (uint32_t)value){

printf("oh these 4 bytes are wrong\n");

}

//if (written_value != original_value){


// printf("we have a 4 byte printer\n");
//}


}

uint8_t VL53L4CD_API::I2C_WrByte(uint16_t reg, uint8_t value)
{ 


uint8_t original_value = i2c_read_Byte(reg);
uint8_t data_write[3];
data_write[0] = (reg >> 8) & 0xFF;
data_write[1] = reg & 0xFF;
data_write[2] = value;
long int r = write(fd_i2c,&data_write,3);
if(r < 0){
printf("%i",r);
#ifdef DEBUG
fprintf(stderr,"Could not read word from %02x. ret=%d.\n",address,r);
#endif
throw "Could not read from i2c.";
}

//printf("Register:%x\nValue:%x\n",reg,value);


uint8_t written_value = i2c_read_Byte(reg);

if(written_value != value){

printf("\noh this byte could be wrong:%x\n",reg);
printf("you wanted to write:%x\nI read:%x\n",value,written_value);
printf("here's what I have stored in array element[0],[1].[2] :%x,%x,%x\n\n",data_write[0],data_write[1],data_write[2]);

}

//if (written_value != original_value){


// printf("we have a printer\n");
//}


}


void VL53L4CD_API::DataReady(){
// printf("I Have Data For You\n");
uint16_t v = i2c_read_conversion(VL53L4CD_RESULT__DISTANCE);
for(auto &cb: adsCallbackInterface){
cb -> hasVL53L4CDSample(v);
}

printf("%u\n",v);
}

void VL53L4CD_API::stop_recording_data(){
if(!running) return;
running = false;
//thr.join();
gpiod_line_release(pinDRDY);
gpiod_chip_close(chipDRDY);
close(fd_i2c);
}

void VL53L4CD_API::worker()
{
while(running) {

I2C_WrByte(VL53L4CD_SYSTEM__INTERRUPT_CLEAR, 0x01);
//timespec with constant timeout duration
const struct timespec ts = {1,0};
gpiod_line_event_wait(pinDRDY, &ts);
struct gpiod_line_event event;
gpiod_line_event_read(pinDRDY, &event);
DataReady();
}
}

int VL53L4CD_API::i2c_read_conversion(uint8_t reg){

uint8_t data_array[2];
data_array[0] = (reg>>8) & 0xFF;
data_array[1] = reg & 0xFF;
write(fd_i2c,data_array,2);


uint8_t read_data[2];
long int r = read(fd_i2c, read_data, 2);


if(r < 0){
#ifdef DEBUG
fprintf(stderr,"Could not read word from %02x. ret=%d.\n",address,r);
#endif
throw "Could not read from i2c.";
}

return (((unsigned)(read_data[0])) << 8) | ((unsigned)(read_data[1]));

};

int VL53L4CD_API::i2c_read_Byte(uint16_t reg){

uint8_t data_array[2];
data_array[0] = (reg>>8) & 0xFF;
data_array[1] = reg & 0xFF;
write(fd_i2c,data_array,2);


uint8_t read_data[1];
long int r = read(fd_i2c, read_data, 1);


if(r < 0){
#ifdef DEBUG
fprintf(stderr,"Could not read word from %02x. ret=%d.\n",address,r);
#endif
throw "Could not read from i2c.";
}

return ((uint8_t)(read_data[0]));



};

void VL53L4CD_API::VL53L4CD_SetRangeTiming_RealTime(
uint32_t timing_budget_ms,
uint32_t inter_measurement_ms)
{
uint16_t clock_pll, osc_frequency, ms_byte;
uint32_t macro_period_us = 0, timing_budget_us = 0, ls_byte, tmp;
float_t inter_measurement_factor = (float_t)1.055;

if(osc_frequency != (uint16_t)0)
{
timing_budget_us = timing_budget_ms*(uint32_t)1000;
macro_period_us = (uint32_t)((uint32_t)2304 *
((uint32_t)0x40000000 / (uint32_t)osc_frequency)) >> 6;
}
else
{
printf("\nRead Conversion Fail\n");
}

//Timing budget check validity 
if ((timing_budget_ms < (uint32_t)10) 
|| (timing_budget_ms > (uint32_t)200))
{
printf("\nTiming Budget Fail\n");
}
//Sensor runs in continuous mode
else if(inter_measurement_ms == (uint32_t)0)
{
I2C_Wr_four_bytes(VL53L4CD_INTERMEASUREMENT_MS, 0);
printf("you have selected continuous mode\n");
timing_budget_us -= (uint32_t)2500;
}
//Sensor runs in autonomous low power mode
else if(inter_measurement_ms > timing_budget_ms)
{ 
printf("you have selected autonomous low power mode\n");
clock_pll = i2c_read_conversion(
VL53L4CD_RESULT__OSC_CALIBRATE_VAL);
clock_pll = clock_pll & (uint16_t)0x3FF;
inter_measurement_factor = inter_measurement_factor
* (float_t)inter_measurement_ms
* (float_t)clock_pll;
I2C_Wr_four_bytes(VL53L4CD_INTERMEASUREMENT_MS,
(uint32_t)inter_measurement_factor);

timing_budget_us -= (uint32_t)4300;
timing_budget_us /= (uint32_t)2;

}

ms_byte = 0;
timing_budget_us = timing_budget_us << 12;
tmp = macro_period_us*(uint32_t)16;
ls_byte = ((timing_budget_us + ((tmp >> 6)>>1)) /(tmp>> 6))
- (uint32_t)1;

while ((ls_byte & 0xFFFFFF00U) > 0U) {
ls_byte = ls_byte >> 1;
ms_byte++;
}
ms_byte = (uint16_t)(ms_byte << 8)
+ (uint16_t) (ls_byte & (uint32_t)0xFF);
I2C_WrWord(VL53L4CD_RANGE_CONFIG_A,ms_byte);

ms_byte = 0;
tmp = macro_period_us*(uint32_t)12;
ls_byte = ((timing_budget_us + ((tmp >> 6)>>1)) /(tmp>> 6))
- (uint32_t)1;

while ((ls_byte & 0xFFFFFF00U) > 0U) {
ls_byte = ls_byte >> 1;
ms_byte++;
}
ms_byte = (uint16_t)(ms_byte << 8)
+ (uint16_t) (ls_byte & (uint32_t)0xFF);
I2C_WrWord(VL53L4CD_RANGE_CONFIG_B,ms_byte);

}


/*end of added by BruGenie*/