Tarek Lule
Greatly simplified Architecture, Identical Functions Removed: Platform Interfaces, STP6001 interface
Diff: VL53L0X.cpp
- Revision:
- 8:2fd7cb217068
- Parent:
- 7:3a1115c2556b
- Child:
- 9:cb4c6d4e5030
--- a/VL53L0X.cpp Thu Jun 20 12:54:25 2019 +0000
+++ b/VL53L0X.cpp Thu Jun 20 15:19:03 2019 +0000
@@ -35,14 +35,27 @@
******************************************************************************
*/
+/* Some example regular expressinos used to simplify the code:
+b) Search for: \QRead_Byte(\E([A-Za-z_\d]+)[[:punct:]](\s*)\Q&\E([A-Za-z\d_]+)\Q);\E
+ Replace by: \3 = Read_Byte\(\1\);
+ to replace: Read_Byte(0x90,&module_id);
+ by this: module_id = Read_Byte(0x90);
+
+c) Search for: ([A-Za-z_\d]+)\Q(\E\r\n(\s*)
+ Replace by: \1\(
+ To join lines where the first line has an open bracket, and the next line starts listing the parameters.
+ for example: Status = VL53L0X_UpdateByte(V
+ L53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV, ....
+ becomes: Status = VL53L0X_UpdateByte(VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV, ....
+
+*/
+
/* Includes */
#include <stdlib.h>
#include "VL53L0X.h"
-
int VL53L0X::read_id(uint8_t *id)
-{
- int status = 0;
+{ int status = 0;
uint16_t rl_id = 0;
status = VL53L0X_read_word(VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
@@ -52,18 +65,12 @@
return -1;
}
-
-
int VL53L0X::init_sensor(uint8_t new_addr)
{ int status;
VL53L0X_off();
VL53L0X_on();
-// status=VL53L0X_WaitDeviceBooted(Device);
-// if(status)
-// printf("WaitDeviceBooted fail\n\r");
-
// Verify if the device is actually present
uint8_t id = 0;
status = read_id(&id);
@@ -93,13 +100,11 @@
return status;
}
}
-
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_data_init(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t CurrentParameters;
int i;
uint8_t StopVariable;
@@ -107,8 +112,7 @@
/* by default the I2C is running at 1V8 if you want to change it you
* need to include this define at compilation level. */
#ifdef USE_I2C_2V8
- Status = VL53L0X_UpdateByte(
- VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
+ Status = VL53L0X_UpdateByte(VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
0xFE,0x01);
#endif
@@ -117,7 +121,8 @@
status = VL53L0X_write_byte( 0x88, 0x00);
}
- VL53L0X_SETDEVICESPECIFICPARAMETER( ReadDataFromDeviceDone, 0);
+ Data.ReadDataFromDeviceDone = 0;
+ Data.ReadDataFromDeviceDone = 0;
#ifdef USE_IQC_STATION
if (Status == VL53L0X_ERROR_NONE) {
@@ -126,19 +131,18 @@
#endif
/* Default value is 1000 for Linearity Corrective Gain */
- PALDevDataSet( LinearityCorrectiveGain, 1000);
+ Data.LinearityCorrectiveGain = 1000;
/* Dmax default Parameter */
- PALDevDataSet( DmaxCalRangeMilliMeter, 400);
- PALDevDataSet( DmaxCalSignalRateRtnMegaCps,
- (FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
+ Data.DmaxCalRangeMilliMeter = 400;
+ Data.DmaxCalSignalRateRtnMegaCps = (FixPoint1616_t)((0x00016B85)); /* 1.42 No Cover Glass*/
/* Set Default static parameters
*set first temporary values 9.44MHz * 65536 = 618660 */
- VL53L0X_SETDEVICESPECIFICPARAMETER( OscFrequencyMHz, 618660);
+ Data.OscFrequencyMHz = 618660;
/* Set Default XTalkCompensationRateMegaCps to 0 */
- VL53L0X_SETPARAMETERFIELD( XTalkCompensationRateMegaCps, 0);
+ Data.CurrentParameters.XTalkCompensationRateMegaCps = 0;
/* Get default parameters */
status = VL53L0X_get_device_parameters( &CurrentParameters);
@@ -146,23 +150,23 @@
/* initialize PAL values */
CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
- PALDevDataSet( CurrentParameters, CurrentParameters);
+ Data.CurrentParameters = CurrentParameters;
}
/* Sigma estimator variable */
- PALDevDataSet( SigmaEstRefArray, 100);
- PALDevDataSet( SigmaEstEffPulseWidth, 900);
- PALDevDataSet( SigmaEstEffAmbWidth, 500);
- PALDevDataSet( targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
+ Data.SigmaEstRefArray = 100;
+ Data.SigmaEstEffPulseWidth = 900;
+ Data.SigmaEstEffAmbWidth = 500;
+ Data.targetRefRate = 0x0A00; /* 20 MCPS in 9:7 format */
/* Use internal default settings */
- PALDevDataSet( UseInternalTuningSettings, 1);
+ Data.UseInternalTuningSettings = 1;
status |= VL53L0X_write_byte( 0x80, 0x01);
status |= VL53L0X_write_byte( 0xFF, 0x01);
status |= VL53L0X_write_byte( 0x00, 0x00);
status |= VL53L0X_read_byte( 0x91, &StopVariable);
- PALDevDataSet( StopVariable, StopVariable);
+ Data.StopVariable = StopVariable;
status |= VL53L0X_write_byte( 0x00, 0x01);
status |= VL53L0X_write_byte( 0xFF, 0x00);
status |= VL53L0X_write_byte( 0x80, 0x00);
@@ -171,74 +175,61 @@
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
if (status == VL53L0X_ERROR_NONE) {
status |= VL53L0X_set_limit_check_enable( i, 1);
- } else {
- break;
- }
-
+ } else { break; }
}
/* Disable the following checks */
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
+ status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+ status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
+ status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
+ status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
/* Limit default values */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
(FixPoint1616_t)(18 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+ status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
(FixPoint1616_t)(25 * 65536 / 100));
/* 0.25 * 65536 */
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
(FixPoint1616_t)(35 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
(FixPoint1616_t)(0 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, 0xFF);
+ Data.SequenceConfig = 0xFF;
status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,0xFF);
/* Set PAL state to tell that we are waiting for call to VL53L0X_StaticInit */
- PALDevDataSet( PalState, VL53L0X_STATE_WAIT_STATICINIT);
+ Data.PalState = VL53L0X_STATE_WAIT_STATICINIT;
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER( RefSpadsInitialised, 0);
+ Data.RefSpadsInitialised = 0;
}
return status;
}
-
int VL53L0X::prepare()
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t ref_spad_count;
uint8_t is_aperture_spads;
uint8_t vhv_settings;
@@ -263,7 +254,6 @@
return status;
}
-
int VL53L0X::start_measurement(OperatingMode operating_mode, void (*fptr)(void),
VL53L0X_RangingConfig rangingConfig)
{ int Status = VL53L0X_ERROR_NONE;
@@ -318,12 +308,10 @@
// Enable/Disable Sigma and Signal check
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+ Status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+ Status = VL53L0X_set_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
}
/* Preselected Ranging configurations */
@@ -362,23 +350,19 @@
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);}
+ Status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_value(
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);}
+ Status = VL53L0X_set_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);}
if (Status == VL53L0X_ERROR_NONE) {
Status = VL53L0X_set_measurement_timing_budget_micro_seconds( timingBudget);}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);}
+ Status = VL53L0X_set_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);}
+ Status = VL53L0X_set_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);}
if (Status == VL53L0X_ERROR_NONE) {
Status = VL53L0X_perform_ref_calibration( &VhvSettings, &PhaseCal);}
@@ -396,13 +380,11 @@
Status = VL53L0X_start_measurement();
}
}
-
return Status;
}
int VL53L0X::range_meas_int_continuous_mode(void (*fptr)(void))
-{
- int status, clr_status;
+{ int status, clr_status;
status = VL53L0X_stop_measurement(); // it is safer to do this while sensor is stopped
@@ -426,10 +408,8 @@
return status;
}
-
VL53L0X_Error VL53L0X::wait_measurement_data_ready(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t new_dat_ready = 0;
uint32_t loop_nb;
@@ -454,9 +434,28 @@
return status;
}
-VL53L0X_Error VL53L0X::wait_stop_completed(void)
+int VL53L0X::get_distance(uint32_t *p_data)
{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ int status = 0;
+ VL53L0X_RangingMeasurementData_t p_ranging_measurement_data;
+
+ status = start_measurement(range_single_shot_polling, NULL);
+ if (!status) {
+ status = get_measurement(range_single_shot_polling, &p_ranging_measurement_data);
+ }
+ if (p_ranging_measurement_data.RangeStatus == 0) {
+ // we have a valid range.
+ *p_data = p_ranging_measurement_data.RangeMilliMeter;
+ } else {
+ *p_data = 0;
+ status = VL53L0X_ERROR_RANGE_ERROR;
+ }
+ stop_measurement(range_single_shot_polling);
+ return status;
+}
+
+VL53L0X_Error VL53L0X::wait_stop_completed(void)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t stop_completed = 0;
uint32_t loop_nb;
@@ -483,8 +482,7 @@
}
int VL53L0X::get_measurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *p_data)
-{
- int Status = VL53L0X_ERROR_NONE;
+{ int Status = VL53L0X_ERROR_NONE;
if (operating_mode == range_single_shot_polling) {
Status = VL53L0X_perform_single_ranging_measurement( p_data);
@@ -512,11 +510,8 @@
return Status;
}
-
int VL53L0X::stop_measurement(OperatingMode operating_mode)
-{
- int status = VL53L0X_ERROR_NONE;
-
+{ int status = VL53L0X_ERROR_NONE;
// don't need to stop for a singleshot range!
if (operating_mode == range_single_shot_polling) {
@@ -535,16 +530,14 @@
}
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_clear_interrupt_mask(
- VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+ status = VL53L0X_clear_interrupt_mask(VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
}
return status;
}
int VL53L0X::handle_irq(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data)
-{
- int status;
+{ int status;
status = get_measurement(operating_mode, data);
enable_interrupt_measure_detection_irq();
return status;
@@ -560,10 +553,8 @@
return status;
}
-
VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t strobe;
uint32_t loop_nb;
@@ -589,14 +580,12 @@
}
status |= VL53L0X_write_byte( 0x83, 0x01);
-
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device( uint8_t option)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte;
uint32_t tmp_dword;
uint8_t module_id;
@@ -617,8 +606,9 @@
uint8_t nvm_ref_good_spad_map[VL53L0X_REF_SPAD_BUFFER_SIZE];
int i;
- read_data_from_device_done = VL53L0X_GETDEVICESPECIFICPARAMETER(
- ReadDataFromDeviceDone);
+ read_data_from_device_done = Data.ReadDataFromDeviceDone;
+ read_data_from_device_done = Data.ReadDataFromDeviceDone;
+ read_data_from_device_done = Data.ReadDataFromDeviceDone;
/* This access is done only once after that a GetDeviceInfo or
* datainit is done*/
@@ -651,7 +641,6 @@
status |= VL53L0X_device_read_strobe();
status |= VL53L0X_read_dword( 0x90, &tmp_dword);
-
nvm_ref_good_spad_map[0] = (uint8_t)((tmp_dword >> 24)
& 0xff);
nvm_ref_good_spad_map[1] = (uint8_t)((tmp_dword >> 16)
@@ -791,11 +780,9 @@
/* Assign to variable if status is ok */
if (((option & 1) == 1) &&
((read_data_from_device_done & 1) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- ReferenceSpadCount, reference_spad_count);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- ReferenceSpadType, reference_spad_type);
+ Data.ReferenceSpadCount = reference_spad_count;
+
+ Data.ReferenceSpadType = reference_spad_type;
for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
Data.SpadData.RefGoodSpadMap[i] =
@@ -805,33 +792,25 @@
if (((option & 2) == 2) &&
((read_data_from_device_done & 2) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- ModuleId, module_id);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- Revision, revision);
-
- product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(
- ProductId);
+ Data.ModuleId = module_id;
+
+ Data.Revision = revision;
+
+ product_id_tmp = Data.ProductId;
VL53L0X_COPYSTRING(product_id_tmp, product_id);
}
if (((option & 4) == 4) &&
((read_data_from_device_done & 4) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- PartUIDUpper, part_uid_upper);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- PartUIDLower, part_uid_lower);
+ Data.PartUIDUpper = part_uid_upper;
+
+ Data.PartUIDLower = part_uid_lower;
signal_rate_meas_fixed400_mm_fix =
- VL53L0X_FIXPOINT97TOFIXPOINT1616(
- signal_rate_meas_fixed1104_400_mm);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- SignalRateMeasFixed400mm,
- signal_rate_meas_fixed400_mm_fix);
+ VL53L0X_FIXPOINT97TOFIXPOINT1616(signal_rate_meas_fixed1104_400_mm);
+
+ Data.SignalRateMeasFixed400mm = signal_rate_meas_fixed400_mm_fix;
offset_micro_meters = 0;
if (dist_meas_fixed1104_400_mm != 0) {
@@ -843,29 +822,23 @@
offset_micro_meters *= -1;
}
- PALDevDataSet(
- Part2PartOffsetAdjustmentNVMMicroMeter,
- offset_micro_meters);
+ Data.Part2PartOffsetAdjustmentNVMMicroMeter = offset_micro_meters;
}
byte = (uint8_t)(read_data_from_device_done | option);
- VL53L0X_SETDEVICESPECIFICPARAMETER( ReadDataFromDeviceDone,
- byte);
+ Data.ReadDataFromDeviceDone = byte;
}
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_offset_calibration_data_micro_meter(
- int32_t *p_offset_calibration_data_micro_meter)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_offset_calibration_data_micro_meter(int32_t *p_offset_calibration_data_micro_meter)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t range_offset_register;
int16_t c_max_offset = 2047;
int16_t c_offset_range = 4096;
/* Note that offset has 10.2 format */
- status = VL53L0X_read_word(
- VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+ status = VL53L0X_read_word(VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
&range_offset_register);
if (status == VL53L0X_ERROR_NONE) {
@@ -886,23 +859,18 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(
- int32_t *p_offset_calibration_data_micro_meter)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(int32_t *p_offset_calibration_data_micro_meter)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = wrapped_VL53L0X_get_offset_calibration_data_micro_meter(
- p_offset_calibration_data_micro_meter);
+ status = wrapped_VL53L0X_get_offset_calibration_data_micro_meter(p_offset_calibration_data_micro_meter);
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_offset_calibration_data_micro_meter(
- int32_t offset_calibration_data_micro_meter)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_offset_calibration_data_micro_meter(int32_t offset_calibration_data_micro_meter)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int32_t c_max_offset_micro_meter = 511000;
int32_t c_min_offset_micro_meter = -512000;
int16_t c_offset_range = 4096;
@@ -931,83 +899,68 @@
offset_calibration_data_micro_meter / 250;
}
- status = VL53L0X_write_word(
- VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+ status = VL53L0X_write_word(VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
encoded_offset_val);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_offset_calibration_data_micro_meter(
- int32_t offset_calibration_data_micro_meter)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_set_offset_calibration_data_micro_meter(int32_t offset_calibration_data_micro_meter)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = wrapped_VL53L0X_set_offset_calibration_data_micro_meter(
- offset_calibration_data_micro_meter);
+ status = wrapped_VL53L0X_set_offset_calibration_data_micro_meter(offset_calibration_data_micro_meter);
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_apply_offset_adjustment(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int32_t corrected_offset_micro_meters;
int32_t current_offset_micro_meters;
- /* if we run on this function we can read all the NVM info
- * used by the API */
+ /* if we run on this function we can read all the NVM info used by the API */
status = VL53L0X_get_info_from_device( 7);
/* Read back current device offset */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_offset_calibration_data_micro_meter(
- ¤t_offset_micro_meters);
+ status = VL53L0X_get_offset_calibration_data_micro_meter(¤t_offset_micro_meters);
}
/* Apply Offset Adjustment derived from 400mm measurements */
if (status == VL53L0X_ERROR_NONE) {
/* Store initial device offset */
- PALDevDataSet( Part2PartOffsetNVMMicroMeter,
- current_offset_micro_meters);
+ Data.Part2PartOffsetNVMMicroMeter = current_offset_micro_meters;
corrected_offset_micro_meters = current_offset_micro_meters +
- (int32_t)PALDevDataGet(
- Part2PartOffsetAdjustmentNVMMicroMeter);
-
- status = VL53L0X_set_offset_calibration_data_micro_meter(
- corrected_offset_micro_meters);
+ (int32_t)Data.Part2PartOffsetAdjustmentNVMMicroMeter;
+
+ status = VL53L0X_set_offset_calibration_data_micro_meter(corrected_offset_micro_meters);
/* store current, adjusted offset */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD( RangeOffsetMicroMeters,
- corrected_offset_micro_meters);
+ Data.CurrentParameters.RangeOffsetMicroMeters = corrected_offset_micro_meters;
}
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(
- VL53L0X_DeviceModes *p_device_mode)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(VL53L0X_DeviceModes *p_device_mode)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
- VL53L0X_GETPARAMETERFIELD( DeviceMode, *p_device_mode);
+ *p_device_mode = Data.CurrentParameters.DeviceMode ;
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_inter_measurement_period_milli_seconds(
- uint32_t *p_inter_measurement_period_milli_seconds)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_inter_measurement_period_milli_seconds(uint32_t *p_inter_measurement_period_milli_seconds)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t osc_calibrate_val;
uint32_t im_period_milli_seconds;
@@ -1017,8 +970,7 @@
&osc_calibrate_val);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_dword(
- VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
+ status = VL53L0X_read_dword(VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
&im_period_milli_seconds);
}
@@ -1027,41 +979,32 @@
*p_inter_measurement_period_milli_seconds =
im_period_milli_seconds / osc_calibrate_val;
}
- VL53L0X_SETPARAMETERFIELD(
- InterMeasurementPeriodMilliSeconds,
- *p_inter_measurement_period_milli_seconds);
+ Data.CurrentParameters.InterMeasurementPeriodMilliSeconds = *p_inter_measurement_period_milli_seconds;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_rate_mega_cps(
- FixPoint1616_t *p_xtalk_compensation_rate_mega_cps)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_rate_mega_cps(FixPoint1616_t *p_xtalk_compensation_rate_mega_cps)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t value;
FixPoint1616_t temp_fix1616;
- status = VL53L0X_read_word(
- VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&value);
+ status = VL53L0X_read_word(VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&value);
if (status == VL53L0X_ERROR_NONE) {
if (value == 0) {
/* the Xtalk is disabled return value from memory */
- VL53L0X_GETPARAMETERFIELD(
- XTalkCompensationRateMegaCps, temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.XTalkCompensationRateMegaCps ;
*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD( XTalkCompensationEnable,
- 0);
+ Data.CurrentParameters.XTalkCompensationEnable = 0;
} else {
temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(value);
*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD(
- XTalkCompensationRateMegaCps, temp_fix1616);
- VL53L0X_SETPARAMETERFIELD( XTalkCompensationEnable,
- 1);
+ Data.CurrentParameters.XTalkCompensationRateMegaCps = temp_fix1616;
+ Data.CurrentParameters.XTalkCompensationEnable = 1;
}
}
@@ -1071,8 +1014,7 @@
VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_value( uint16_t limit_check_id,
FixPoint1616_t *p_limit_check_value)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t enable_zero_value = 0;
uint16_t temp16;
FixPoint1616_t temp_fix1616;
@@ -1083,47 +1025,40 @@
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE];
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = VL53L0X_read_word(
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+ status = VL53L0X_read_word(VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
&temp16);
if (status == VL53L0X_ERROR_NONE) {
temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
}
-
enable_zero_value = 1;
break;
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP];
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD];
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
- status = VL53L0X_read_word(
- VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+ status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
&temp16);
if (status == VL53L0X_ERROR_NONE) {
temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
}
-
enable_zero_value = 0;
break;
@@ -1138,19 +1073,13 @@
if (temp_fix1616 == 0) {
/* disabled: return value from memory */
- VL53L0X_GETARRAYPARAMETERFIELD(
- LimitChecksValue, limit_check_id,
- temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.LimitChecksValue[limit_check_id];
*p_limit_check_value = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(
- LimitChecksEnable, limit_check_id, 0);
+ Data.CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
} else {
*p_limit_check_value = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(
- LimitChecksValue, limit_check_id,
- temp_fix1616);
- VL53L0X_SETARRAYPARAMETERFIELD(
- LimitChecksEnable, limit_check_id, 1);
+ Data.CurrentParameters.LimitChecksValue[limit_check_id] = temp_fix1616;
+ Data.CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
}
} else {
*p_limit_check_value = temp_fix1616;
@@ -1164,8 +1093,7 @@
VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_enable( uint16_t limit_check_id,
uint8_t *p_limit_check_enable)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t temp8;
@@ -1174,8 +1102,7 @@
status = VL53L0X_ERROR_INVALID_PARAMS;
*p_limit_check_enable = 0;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksEnable,
- limit_check_id, temp8);
+ temp8 = Data.CurrentParameters.LimitChecksEnable[limit_check_id];
*p_limit_check_enable = temp8;
}
@@ -1183,17 +1110,15 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_wrap_around_check_enable(
- uint8_t *p_wrap_around_check_enable)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_wrap_around_check_enable(uint8_t *p_wrap_around_check_enable)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t data;
status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, data);
+ Data.SequenceConfig = data;
if (data & (0x01 << 7)) {
*p_wrap_around_check_enable = 0x01;
} else {
@@ -1201,19 +1126,16 @@
}
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD( WrapAroundCheckEnable,
- *p_wrap_around_check_enable);
+ Data.CurrentParameters.WrapAroundCheckEnable = *p_wrap_around_check_enable;
}
return status;
}
-VL53L0X_Error VL53L0X::sequence_step_enabled(
- VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
+VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
uint8_t *p_sequence_step_enabled)
-{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error Status = VL53L0X_ERROR_NONE;
*p_sequence_step_enabled = 0;
@@ -1241,10 +1163,8 @@
return Status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_sequence_step_enables(
- VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_sequence_step_enables(VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
@@ -1252,28 +1172,23 @@
&sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(
- VL53L0X_SEQUENCESTEP_TCC, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_TCC, sequence_config,
&p_scheduler_sequence_steps->TccOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(
- VL53L0X_SEQUENCESTEP_DSS, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_DSS, sequence_config,
&p_scheduler_sequence_steps->DssOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(
- VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
&p_scheduler_sequence_steps->MsrcOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(
- VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
&p_scheduler_sequence_steps->PreRangeOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(
- VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
&p_scheduler_sequence_steps->FinalRangeOn);
}
@@ -1282,8 +1197,7 @@
}
uint8_t VL53L0X::VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg)
-{
- /*!
+{ /*!
* Converts the encoded VCSEL period register value into the real
* period in PLL clocks
*/
@@ -1296,8 +1210,7 @@
}
uint8_t VL53L0X::lv53l0x_encode_vcsel_period(uint8_t vcsel_period_pclks)
-{
- /*!
+{ /*!
* Converts the encoded VCSEL period register value into the real period
* in PLL clocks
*/
@@ -1309,11 +1222,8 @@
return vcsel_period_reg;
}
-
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_vcsel_pulse_period(
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t vcsel_period_reg;
uint8_t min_pre_vcsel_period_pclk = 12;
uint8_t max_pre_vcsel_period_pclk = 18;
@@ -1347,125 +1257,95 @@
return status;
}
-
if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
/* Set phase check limits */
if (vcsel_pulse_period_pclk == 12) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
0x18);
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
} else if (vcsel_pulse_period_pclk == 14) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
0x30);
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
} else if (vcsel_pulse_period_pclk == 16) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
0x40);
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
} else if (vcsel_pulse_period_pclk == 18) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
0x50);
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
}
} else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE) {
if (vcsel_pulse_period_pclk == 8) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
0x10);
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
+ status |= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
status |= VL53L0X_write_byte( 0xff, 0x01);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,
0x30);
status |= VL53L0X_write_byte( 0xff, 0x00);
} else if (vcsel_pulse_period_pclk == 10) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
0x28);
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
+ status |= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
status |= VL53L0X_write_byte( 0xff, 0x01);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,
0x20);
status |= VL53L0X_write_byte( 0xff, 0x00);
} else if (vcsel_pulse_period_pclk == 12) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
0x38);
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
+ status |= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
status |= VL53L0X_write_byte( 0xff, 0x01);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,
0x20);
status |= VL53L0X_write_byte( 0xff, 0x00);
} else if (vcsel_pulse_period_pclk == 14) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
0x048);
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
0x08);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
+ status |= VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
status |= VL53L0X_write_byte( 0xff, 0x01);
- status |= VL53L0X_write_byte(
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ status |= VL53L0X_write_byte(VL53L0X_REG_ALGO_PHASECAL_LIM,
0x20);
status |= VL53L0X_write_byte( 0xff, 0x00);
}
}
-
/* Re-calculate and apply timeouts, in macro periods */
if (status == VL53L0X_ERROR_NONE) {
@@ -1483,48 +1363,40 @@
*/
switch (vcsel_period_type) {
case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_PRE_RANGE,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
&pre_range_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE)
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_MSRC,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
&msrc_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_write_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
+ status = VL53L0X_write_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
vcsel_period_reg);
-
if (status == VL53L0X_ERROR_NONE)
status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
pre_range_timeout_micro_seconds);
-
if (status == VL53L0X_ERROR_NONE)
status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
msrc_timeout_micro_seconds);
- VL53L0X_SETDEVICESPECIFICPARAMETER( PreRangeVcselPulsePeriod,vcsel_pulse_period_pclk);
+ Data.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
break;
case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
&final_range_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_write_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+ status = VL53L0X_write_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
vcsel_period_reg);
-
if (status == VL53L0X_ERROR_NONE)
- status = set_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+ status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
final_range_timeout_micro_seconds);
- VL53L0X_SETDEVICESPECIFICPARAMETER(FinalRangeVcselPulsePeriod,vcsel_pulse_period_pclk);
+ Data.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
break;
default:
status = VL53L0X_ERROR_INVALID_PARAMS;
@@ -1533,12 +1405,9 @@
/* Finally, the timing budget must be re-applied */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(
- MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
-
- status = VL53L0X_set_measurement_timing_budget_micro_seconds(
- measurement_timing_budget_micro_seconds);
+ measurement_timing_budget_micro_seconds = Data.CurrentParameters.MeasurementTimingBudgetMicroSeconds ;
+
+ status = VL53L0X_set_measurement_timing_budget_micro_seconds(measurement_timing_budget_micro_seconds);
}
/* Perform the phase calibration. This is needed after changing on
@@ -1550,10 +1419,8 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = wrapped_VL53L0X_set_vcsel_pulse_period( vcsel_period_type,
@@ -1563,21 +1430,17 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t vcsel_period_reg;
switch (vcsel_period_type) {
case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
- status = VL53L0X_read_byte(
- VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
+ status = VL53L0X_read_byte(VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
&vcsel_period_reg);
break;
case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
- status = VL53L0X_read_byte(
- VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+ status = VL53L0X_read_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
&vcsel_period_reg);
break;
default:
@@ -1591,10 +1454,8 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = wrapped_VL53L0X_get_vcsel_pulse_period( vcsel_period_type,
@@ -1605,8 +1466,7 @@
}
uint32_t VL53L0X::VL53L0X_decode_timeout(uint16_t encoded_timeout)
-{
- /*!
+{ /*!
* Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
*/
@@ -1619,8 +1479,7 @@
}
uint32_t VL53L0X::VL53L0X_calc_macro_period_ps( uint8_t vcsel_period_pclks)
-{
- uint64_t pll_period_ps;
+{ uint64_t pll_period_ps;
uint32_t macro_period_vclks;
uint32_t macro_period_ps;
@@ -1639,11 +1498,9 @@
}
/* To convert register value into us */
-uint32_t VL53L0X::VL53L0X_calc_timeout_us(
- uint16_t timeout_period_mclks,
+uint32_t VL53L0X::VL53L0X_calc_timeout_us(uint16_t timeout_period_mclks,
uint8_t vcsel_period_pclks)
-{
- uint32_t macro_period_ps;
+{ uint32_t macro_period_ps;
uint32_t macro_period_ns;
uint32_t actual_timeout_period_us = 0;
@@ -1656,11 +1513,9 @@
return actual_timeout_period_us;
}
-VL53L0X_Error VL53L0X::get_sequence_step_timeout(
- VL53L0X_SequenceStepId sequence_step_id,
+VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_SequenceStepId sequence_step_id,
uint32_t *p_time_out_micro_secs)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t current_vcsel_pulse_period_p_clk;
uint8_t encoded_time_out_byte = 0;
uint32_t timeout_micro_seconds = 0;
@@ -1675,44 +1530,36 @@
(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(
- VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
+ status = VL53L0X_read_byte(VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
&encoded_time_out_byte);
}
msrc_time_out_m_clks = VL53L0X_decode_timeout(encoded_time_out_byte);
- timeout_micro_seconds = VL53L0X_calc_timeout_us(
- msrc_time_out_m_clks,
+ timeout_micro_seconds = VL53L0X_calc_timeout_us(msrc_time_out_m_clks,
current_vcsel_pulse_period_p_clk);
} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
/* Retrieve PRE-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
/* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
if (status == VL53L0X_ERROR_NONE) {
/* Retrieve PRE-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+ status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
&pre_range_encoded_time_out);
}
- pre_range_time_out_m_clks = VL53L0X_decode_timeout(
- pre_range_encoded_time_out);
-
- timeout_micro_seconds = VL53L0X_calc_timeout_us(
- pre_range_time_out_m_clks,
+ pre_range_time_out_m_clks = VL53L0X_decode_timeout(pre_range_encoded_time_out);
+
+ timeout_micro_seconds = VL53L0X_calc_timeout_us(pre_range_time_out_m_clks,
current_vcsel_pulse_period_p_clk);
}
} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
@@ -1722,40 +1569,33 @@
if (scheduler_sequence_steps.PreRangeOn) {
/* Retrieve PRE-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
/* Retrieve PRE-RANGE Timeout in Macro periods
* (MCLKS) */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+ status = VL53L0X_read_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
&pre_range_encoded_time_out);
- pre_range_time_out_m_clks = VL53L0X_decode_timeout(
- pre_range_encoded_time_out);
+ pre_range_time_out_m_clks = VL53L0X_decode_timeout(pre_range_encoded_time_out);
}
}
if (status == VL53L0X_ERROR_NONE) {
/* Retrieve FINAL-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
¤t_vcsel_pulse_period_p_clk);
}
/* Retrieve FINAL-RANGE Timeout in Macro periods (MCLKS) */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(
- VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+ status = VL53L0X_read_word(VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
&final_range_encoded_time_out);
- final_range_time_out_m_clks = VL53L0X_decode_timeout(
- final_range_encoded_time_out);
+ final_range_time_out_m_clks = VL53L0X_decode_timeout(final_range_encoded_time_out);
}
final_range_time_out_m_clks -= pre_range_time_out_m_clks;
- timeout_micro_seconds = VL53L0X_calc_timeout_us(
- final_range_time_out_m_clks,
+ timeout_micro_seconds = VL53L0X_calc_timeout_us(final_range_time_out_m_clks,
current_vcsel_pulse_period_p_clk);
}
@@ -1764,10 +1604,8 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(
- uint32_t *p_measurement_timing_budget_micro_seconds)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(uint32_t *p_measurement_timing_budget_micro_seconds)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
uint32_t final_range_timeout_micro_seconds;
uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
@@ -1793,13 +1631,11 @@
return status;
}
-
if (scheduler_sequence_steps.TccOn ||
scheduler_sequence_steps.MsrcOn ||
scheduler_sequence_steps.DssOn) {
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_MSRC,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
&msrc_dcc_tcc_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE) {
@@ -1823,8 +1659,7 @@
if (status == VL53L0X_ERROR_NONE) {
if (scheduler_sequence_steps.PreRangeOn) {
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_PRE_RANGE,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
&pre_range_timeout_micro_seconds);
*p_measurement_timing_budget_micro_seconds +=
pre_range_timeout_micro_seconds +
@@ -1834,8 +1669,7 @@
if (status == VL53L0X_ERROR_NONE) {
if (scheduler_sequence_steps.FinalRangeOn) {
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
&final_range_timeout_micro_seconds);
*p_measurement_timing_budget_micro_seconds +=
(final_range_timeout_micro_seconds +
@@ -1844,32 +1678,25 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(
- MeasurementTimingBudgetMicroSeconds,
- *p_measurement_timing_budget_micro_seconds);
+ Data.CurrentParameters.MeasurementTimingBudgetMicroSeconds = *p_measurement_timing_budget_micro_seconds;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_micro_seconds(
- uint32_t *p_measurement_timing_budget_micro_seconds)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_micro_seconds(uint32_t *p_measurement_timing_budget_micro_seconds)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(
- p_measurement_timing_budget_micro_seconds);
+ status = wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(p_measurement_timing_budget_micro_seconds);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_parameters(
- VL53L0X_DeviceParameters_t *p_device_parameters)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_device_parameters(VL53L0X_DeviceParameters_t *p_device_parameters)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
@@ -1877,23 +1704,17 @@
status = VL53L0X_get_device_mode( &(p_device_parameters->DeviceMode));
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_get_inter_measurement_period_milli_seconds(
- &(p_device_parameters->InterMeasurementPeriodMilliSeconds));
-
+ status = VL53L0X_get_inter_measurement_period_milli_seconds(&(p_device_parameters->InterMeasurementPeriodMilliSeconds));
if (status == VL53L0X_ERROR_NONE) {
p_device_parameters->XTalkCompensationEnable = 0;
}
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_get_x_talk_compensation_rate_mega_cps(
- &(p_device_parameters->XTalkCompensationRateMegaCps));
-
+ status = VL53L0X_get_x_talk_compensation_rate_mega_cps(&(p_device_parameters->XTalkCompensationRateMegaCps));
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_get_offset_calibration_data_micro_meter(
- &(p_device_parameters->RangeOffsetMicroMeters));
-
+ status = VL53L0X_get_offset_calibration_data_micro_meter(&(p_device_parameters->RangeOffsetMicroMeters));
if (status == VL53L0X_ERROR_NONE) {
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
@@ -1917,14 +1738,12 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_wrap_around_check_enable(
- &(p_device_parameters->WrapAroundCheckEnable));
+ status = VL53L0X_get_wrap_around_check_enable(&(p_device_parameters->WrapAroundCheckEnable));
}
/* Need to be done at the end as it uses VCSELPulsePeriod */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_measurement_timing_budget_micro_seconds(
- &(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
+ status = VL53L0X_get_measurement_timing_budget_micro_seconds(&(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
}
@@ -1933,63 +1752,50 @@
VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_value( uint16_t limit_check_id,
FixPoint1616_t limit_check_value)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t temp8;
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksEnable, limit_check_id,
- temp8);
+ temp8 = Data.CurrentParameters.LimitChecksEnable[limit_check_id];
if (temp8 == 0) { /* disabled write only internal value */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksValue,
- limit_check_id, limit_check_value);
+ Data.CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
} else {
switch (limit_check_id) {
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- limit_check_value);
+ Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_value;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = VL53L0X_write_word(
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
- VL53L0X_FIXPOINT1616TOFIXPOINT97(
- limit_check_value));
+ status = VL53L0X_write_word(VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+ VL53L0X_FIXPOINT1616TOFIXPOINT97(limit_check_value));
break;
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- limit_check_value);
+ Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_value;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksValue,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- limit_check_value);
+ Data.CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = limit_check_value;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
- status = VL53L0X_write_word(
- VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
- VL53L0X_FIXPOINT1616TOFIXPOINT97(
- limit_check_value));
+ status = VL53L0X_write_word(VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+ VL53L0X_FIXPOINT1616TOFIXPOINT97(limit_check_value));
break;
@@ -1999,8 +1805,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksValue,
- limit_check_id, limit_check_value);
+ Data.CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
}
}
@@ -2008,34 +1813,30 @@
return status;
}
-
-
VL53L0X_Error VL53L0X::VL53L0X_check_part_used( uint8_t *revision,
VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t module_id_int;
char *product_id_tmp;
status = VL53L0X_get_info_from_device( 2);
if (status == VL53L0X_ERROR_NONE) {
- module_id_int = VL53L0X_GETDEVICESPECIFICPARAMETER( ModuleId);
+ module_id_int = Data.ModuleId;
if (module_id_int == 0) {
*revision = 0;
VL53L0X_COPYSTRING(p_VL53L0X_device_info->ProductId, "");
} else {
- *revision = VL53L0X_GETDEVICESPECIFICPARAMETER( Revision);
- product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(ProductId);
+ *revision = Data.Revision;
+ product_id_tmp = Data.ProductId;
VL53L0X_COPYSTRING(p_VL53L0X_device_info->ProductId, product_id_tmp);
}
}
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_device_info(
- VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_device_info(VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t revision_id;
uint8_t revision;
@@ -2075,18 +1876,15 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_info(
- VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_device_info(VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = wrapped_VL53L0X_get_device_info( p_VL53L0X_device_info);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_mask_status(
- uint32_t *p_interrupt_mask_status)
+VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_mask_status(uint32_t *p_interrupt_mask_status)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte;
@@ -2098,14 +1896,13 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_measurement_data_ready(
- uint8_t *p_measurement_data_ready)
+VL53L0X_Error VL53L0X::VL53L0X_get_measurement_data_ready(uint8_t *p_measurement_data_ready)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sys_range_status_register;
uint8_t interrupt_config;
uint32_t interrupt_mask;
- interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Pin0GpioFunctionality);
+ interrupt_config = Data.Pin0GpioFunctionality;
if (interrupt_config ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
@@ -2182,7 +1979,6 @@
&& (loop_count < 3)
&& (status == VL53L0X_ERROR_NONE));
-
if (loop_count >= 3) {
status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
}
@@ -2191,10 +1987,8 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(
- uint8_t vhv_init_byte)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(uint8_t vhv_init_byte)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START,
@@ -2219,8 +2013,7 @@
uint8_t vhv_settings, uint8_t phase_cal,
uint8_t *p_vhv_settings, uint8_t *p_phase_cal,
const uint8_t vhv_enable, const uint8_t phase_enable)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t phase_calint = 0;
/* Read VHV from device */
@@ -2249,11 +2042,9 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(
- uint8_t *p_vhv_settings, const uint8_t get_data_enable,
+VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(uint8_t *p_vhv_settings, const uint8_t get_data_enable,
const uint8_t restore_config)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
uint8_t vhv_settings = 0;
uint8_t phase_cal = 0;
@@ -2264,7 +2055,7 @@
*/
if (restore_config) {
- sequence_config = PALDevDataGet( SequenceConfig);
+ sequence_config = Data.SequenceConfig;
}
/* Run VHV */
@@ -2279,20 +2070,18 @@
p_vhv_settings, &phase_cal_int, 1, 0);
} else {*p_vhv_settings = 0; }
-
if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, sequence_config); }
+ Data.SequenceConfig = sequence_config; }
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(
- uint8_t *p_phase_cal, const uint8_t get_data_enable,
+VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(uint8_t *p_phase_cal, const uint8_t get_data_enable,
const uint8_t restore_config)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
@@ -2304,7 +2093,7 @@
* this will be reset before the end of the function */
if (restore_config) {
- sequence_config = PALDevDataGet( SequenceConfig);
+ sequence_config = Data.SequenceConfig;
}
/* Run PhaseCal */
@@ -2324,13 +2113,12 @@
*p_phase_cal = 0;
}
-
if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, sequence_config);
+ Data.SequenceConfig = sequence_config;
}
}
@@ -2338,16 +2126,14 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(
- uint8_t *p_vhv_settings, uint8_t *p_phase_cal, uint8_t get_data_enable)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(uint8_t *p_vhv_settings, uint8_t *p_phase_cal, uint8_t get_data_enable)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
/* store the value of the sequence config,
* this will be reset before the end of the function */
- sequence_config = PALDevDataGet( SequenceConfig);
+ sequence_config = Data.SequenceConfig;
/* In the following function we don't save the config to optimize
* writes on device. Config is saved and restored only once. */
@@ -2356,13 +2142,12 @@
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_perform_phase_calibration(p_phase_cal, get_data_enable, 0); }
-
if (status == VL53L0X_ERROR_NONE) {
/* restore the previous Sequence Config */
status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, sequence_config); }
+ Data.SequenceConfig = sequence_config; }
}
return status;
@@ -2370,8 +2155,7 @@
void VL53L0X::get_next_good_spad(uint8_t good_spad_array[], uint32_t size,
uint32_t curr, int32_t *p_next)
-{
- uint32_t start_index;
+{ uint32_t start_index;
uint32_t fine_offset;
uint32_t c_spads_per_byte = 8;
uint32_t coarse_index;
@@ -2415,8 +2199,7 @@
}
uint8_t VL53L0X::is_aperture(uint32_t spad_index)
-{
- /* This function reports if a given spad index is an aperture SPAD by
+{ /* This function reports if a given spad index is an aperture SPAD by
* deriving the quadrant.*/
uint32_t quadrant;
uint8_t is_aperture = 1;
@@ -2447,17 +2230,14 @@
}
VL53L0X_Error VL53L0X::set_ref_spad_map( uint8_t *p_ref_spad_array)
-{ VL53L0X_Error status = VL53L0X_write_multi(
- VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
+{ VL53L0X_Error status = VL53L0X_write_multi(VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
p_ref_spad_array, 6);
return status;
}
VL53L0X_Error VL53L0X::get_ref_spad_map( uint8_t *p_ref_spad_array)
-{
- VL53L0X_Error status = VL53L0X_read_multi(
- VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
+{ VL53L0X_Error status = VL53L0X_read_multi(VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
p_ref_spad_array,
6);
// VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -2468,8 +2248,7 @@
return status;
}
-VL53L0X_Error VL53L0X::enable_ref_spads(
- uint8_t aperture_spads,
+VL53L0X_Error VL53L0X::enable_ref_spads(uint8_t aperture_spads,
uint8_t good_spad_array[],
uint8_t spad_array[],
uint32_t size,
@@ -2477,8 +2256,7 @@
uint32_t offset,
uint32_t spad_count,
uint32_t *p_last_spad)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t index;
uint32_t i;
int32_t next_good_spad = offset;
@@ -2523,7 +2301,6 @@
status = set_ref_spad_map( spad_array);
}
-
if (status == VL53L0X_ERROR_NONE) {
status = get_ref_spad_map( check_spad_array);
@@ -2542,8 +2319,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_set_device_mode( VL53L0X_DeviceModes device_mode)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
switch (device_mode) {
case VL53L0X_DEVICEMODE_SINGLE_RANGING:
@@ -2552,7 +2328,7 @@
case VL53L0X_DEVICEMODE_GPIO_DRIVE:
case VL53L0X_DEVICEMODE_GPIO_OSC:
/* Supported modes */
- VL53L0X_SETPARAMETERFIELD( DeviceMode, device_mode);
+ Data.CurrentParameters.DeviceMode = device_mode;
break;
default:
/* Unsupported mode */
@@ -2563,11 +2339,9 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_interrupt_thresholds(
- VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
+VL53L0X_Error VL53L0X::VL53L0X_set_interrupt_thresholds(VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
FixPoint1616_t threshold_high)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t threshold16;
@@ -2587,11 +2361,9 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_thresholds(
- VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
+VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_thresholds(VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
FixPoint1616_t *p_threshold_high)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t threshold16;
@@ -2613,10 +2385,8 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(
- uint8_t *p_tuning_setting_buffer)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(uint8_t *p_tuning_setting_buffer)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
int index;
uint8_t msb;
@@ -2626,9 +2396,7 @@
uint8_t address;
uint8_t local_buffer[4]; /* max */
uint16_t temp16;
-
-
-
+
index = 0;
while ((*(p_tuning_setting_buffer + index) != 0) &&
@@ -2646,7 +2414,7 @@
lsb = *(p_tuning_setting_buffer + index);
index++;
temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet( SigmaEstRefArray, temp16);
+ Data.SigmaEstRefArray = temp16;
break;
case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
@@ -2654,8 +2422,7 @@
lsb = *(p_tuning_setting_buffer + index);
index++;
temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet( SigmaEstEffPulseWidth,
- temp16);
+ Data.SigmaEstEffPulseWidth = temp16;
break;
case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
@@ -2663,7 +2430,7 @@
lsb = *(p_tuning_setting_buffer + index);
index++;
temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet( SigmaEstEffAmbWidth, temp16);
+ Data.SigmaEstEffAmbWidth = temp16;
break;
case 3: /* uint16_t targetRefRate -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
@@ -2671,7 +2438,7 @@
lsb = *(p_tuning_setting_buffer + index);
index++;
temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet( targetRefRate, temp16);
+ Data.targetRefRate = temp16;
break;
default: /* invalid parameter */
status = VL53L0X_ERROR_INVALID_PARAMS;
@@ -2687,27 +2454,20 @@
index++;
}
- status = VL53L0X_write_multi( address, local_buffer,
- number_of_writes);
-
- } else {
- status = VL53L0X_ERROR_INVALID_PARAMS;
- }
+ status = VL53L0X_write_multi( address, local_buffer, number_of_writes);
+
+ } else { status = VL53L0X_ERROR_INVALID_PARAMS; }
}
-
-
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_check_and_load_interrupt_settings(
- uint8_t start_not_stopflag)
-{
- uint8_t interrupt_config;
+VL53L0X_Error VL53L0X::VL53L0X_check_and_load_interrupt_settings(uint8_t start_not_stopflag)
+{ uint8_t interrupt_config;
FixPoint1616_t threshold_low;
FixPoint1616_t threshold_high;
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Pin0GpioFunctionality);
+ interrupt_config = Data.Pin0GpioFunctionality;
if ((interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
@@ -2716,8 +2476,7 @@
(interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
- status = VL53L0X_get_interrupt_thresholds(
- VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ status = VL53L0X_get_interrupt_thresholds(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
&threshold_low, &threshold_high);
if (((threshold_low > 255 * 65536) ||
@@ -2725,27 +2484,20 @@
(status == VL53L0X_ERROR_NONE)) {
if (start_not_stopflag != 0) {
- status = VL53L0X_load_tuning_settings(
- InterruptThresholdSettings);
+ status = VL53L0X_load_tuning_settings(InterruptThresholdSettings);
} else {
status |= VL53L0X_write_byte( 0xFF, 0x04);
status |= VL53L0X_write_byte( 0x70, 0x00);
status |= VL53L0X_write_byte( 0xFF, 0x00);
status |= VL53L0X_write_byte( 0x80, 0x00);
}
-
}
-
-
}
-
return status;
-
}
VL53L0X_Error VL53L0X::VL53L0X_start_measurement(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
uint8_t byte;
uint8_t start_stop_byte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
@@ -2758,7 +2510,7 @@
status = VL53L0X_write_byte( 0x80, 0x01);
status = VL53L0X_write_byte( 0xFF, 0x01);
status = VL53L0X_write_byte( 0x00, 0x00);
- status = VL53L0X_write_byte( 0x91, PALDevDataGet( StopVariable));
+ status = VL53L0X_write_byte( 0x91, Data.StopVariable);
status = VL53L0X_write_byte( 0x00, 0x01);
status = VL53L0X_write_byte( 0xFF, 0x00);
status = VL53L0X_write_byte( 0x80, 0x00);
@@ -2773,8 +2525,7 @@
loop_nb = 0;
do {
if (loop_nb > 0)
- status = VL53L0X_read_byte(
- VL53L0X_REG_SYSRANGE_START, &byte);
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSRANGE_START, &byte);
loop_nb = loop_nb + 1;
} while (((byte & start_stop_byte) == start_stop_byte)
&& (status == VL53L0X_ERROR_NONE)
@@ -2795,12 +2546,11 @@
status = VL53L0X_check_and_load_interrupt_settings( 1);
}
- status = VL53L0X_write_byte(
- VL53L0X_REG_SYSRANGE_START,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
if (status == VL53L0X_ERROR_NONE) {
/* Set PAL State to Running */
- PALDevDataSet( PalState, VL53L0X_STATE_RUNNING);
+ Data.PalState = VL53L0X_STATE_RUNNING;
}
break;
case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
@@ -2810,13 +2560,12 @@
status = VL53L0X_check_and_load_interrupt_settings( 1);
}
- status = VL53L0X_write_byte(
- VL53L0X_REG_SYSRANGE_START,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
VL53L0X_REG_SYSRANGE_MODE_TIMED);
if (status == VL53L0X_ERROR_NONE) {
/* Set PAL State to Running */
- PALDevDataSet( PalState, VL53L0X_STATE_RUNNING);
+ Data.PalState = VL53L0X_STATE_RUNNING;
}
break;
default:
@@ -2824,15 +2573,13 @@
status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
}
-
return status;
}
/* Group PAL Measurement Functions */
VL53L0X_Error VL53L0X::VL53L0X_perform_single_measurement(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
@@ -2847,35 +2594,30 @@
status = VL53L0X_start_measurement();
}
-
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_measurement_poll_for_completion();
}
-
/* Change PAL State in case of single ranging or single histogram */
if (status == VL53L0X_ERROR_NONE && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {
- PALDevDataSet( PalState, VL53L0X_STATE_IDLE); }
+ Data.PalState = VL53L0X_STATE_IDLE; }
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_enable(
- uint8_t *p_x_talk_compensation_enable)
+VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_enable(uint8_t *p_x_talk_compensation_enable)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t temp8;
- VL53L0X_GETPARAMETERFIELD( XTalkCompensationEnable, temp8);
+ temp8 = Data.CurrentParameters.XTalkCompensationEnable ;
*p_x_talk_compensation_enable = temp8;
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
FixPoint1616_t *p_total_xtalk_rate_mcps)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t xtalk_comp_enable;
FixPoint1616_t total_xtalk_mega_cps;
@@ -2888,9 +2630,7 @@
if (xtalk_comp_enable) {
- VL53L0X_GETPARAMETERFIELD(
- XTalkCompensationRateMegaCps,
- xtalk_per_spad_mega_cps);
+ xtalk_per_spad_mega_cps = Data.CurrentParameters.XTalkCompensationRateMegaCps ;
/* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
total_xtalk_mega_cps =
@@ -2906,11 +2646,9 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
FixPoint1616_t *p_total_signal_rate_mcps)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
FixPoint1616_t total_xtalk_mega_cps;
@@ -2928,11 +2666,9 @@
}
/* To convert ms into register value */
-uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(
- uint32_t timeout_period_us,
+uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(uint32_t timeout_period_us,
uint8_t vcsel_period_pclks)
-{
- uint32_t macro_period_ps;
+{ uint32_t macro_period_ps;
uint32_t macro_period_ns;
uint32_t timeout_period_mclks = 0;
@@ -2947,8 +2683,7 @@
}
uint32_t VL53L0X::VL53L0X_isqrt(uint32_t num)
-{
- /*
+{ /*
* Implements an integer square root
*
* From: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
@@ -2964,7 +2699,6 @@
bit >>= 2;
}
-
while (bit != 0) {
if (num >= res + bit) {
num -= res + bit;
@@ -2979,17 +2713,14 @@
return res;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(
-
- FixPoint1616_t total_signal_rate_mcps,
+VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(FixPoint1616_t total_signal_rate_mcps,
FixPoint1616_t total_corr_signal_rate_mcps,
FixPoint1616_t pw_mult,
uint32_t sigma_estimate_p1,
FixPoint1616_t sigma_estimate_p2,
uint32_t peak_vcsel_duration_us,
uint32_t *pd_max_mm)
-{
- const uint32_t c_sigma_limit = 18;
+{ const uint32_t c_sigma_limit = 18;
const FixPoint1616_t c_signal_limit = 0x4000; /* 0.25 */
const FixPoint1616_t c_sigma_est_ref = 0x00000042; /* 0.001 */
const uint32_t c_amb_eff_width_sigma_est_ns = 6;
@@ -3016,10 +2747,10 @@
dmax_cal_range_mm =
- PALDevDataGet( DmaxCalRangeMilliMeter);
+ Data.DmaxCalRangeMilliMeter;
dmax_cal_signal_rate_rtn_mcps =
- PALDevDataGet( DmaxCalSignalRateRtnMegaCps);
+ Data.DmaxCalSignalRateRtnMegaCps;
/* uint32 * FixPoint1616 = FixPoint1616 */
signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_mcps;
@@ -3173,12 +2904,10 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
FixPoint1616_t *p_sigma_estimate,
uint32_t *p_dmax_mm)
-{
- /* Expressed in 100ths of a ns, i.e. centi-ns */
+{ /* Expressed in 100ths of a ns, i.e. centi-ns */
const uint32_t c_pulse_effective_width_centi_ns = 800;
/* Expressed in 100ths of a ns, i.e. centi-ns */
const uint32_t c_ambient_effective_width_centi_ns = 600;
@@ -3235,8 +2964,7 @@
- VL53L0X_GETPARAMETERFIELD( XTalkCompensationRateMegaCps,
- x_talk_comp_rate_mcps);
+ x_talk_comp_rate_mcps = Data.CurrentParameters.XTalkCompensationRateMegaCps ;
/*
* We work in kcps rather than mcps as this helps keep within the
@@ -3249,11 +2977,9 @@
corrected_signal_rate_mcps =
p_ranging_measurement_data->SignalRateRtnMegaCps;
-
status = VL53L0X_get_total_signal_rate(p_ranging_measurement_data, &total_signal_rate_mcps);
status = VL53L0X_get_total_xtalk_rate(p_ranging_measurement_data, &x_talk_comp_rate_mcps);
-
/* Signal rate measurement provided by device is the
* peak signal rate, not average.
*/
@@ -3269,13 +2995,13 @@
if (status == VL53L0X_ERROR_NONE) {
/* Calculate final range macro periods */
- final_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER( FinalRangeTimeoutMicroSecs);
- final_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER( FinalRangeVcselPulsePeriod);
+ final_range_timeout_micro_secs = Data.FinalRangeTimeoutMicroSecs;
+ final_range_vcsel_pclks = Data.FinalRangeVcselPulsePeriod;
final_range_macro_pclks = VL53L0X_calc_timeout_mclks( final_range_timeout_micro_secs, final_range_vcsel_pclks);
/* Calculate pre-range macro periods */
- pre_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER( PreRangeTimeoutMicroSecs);
- pre_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER( PreRangeVcselPulsePeriod);
+ pre_range_timeout_micro_secs = Data.PreRangeTimeoutMicroSecs;
+ pre_range_vcsel_pclks = Data.PreRangeVcselPulsePeriod;
pre_range_macro_pclks = VL53L0X_calc_timeout_mclks(pre_range_timeout_micro_secs, pre_range_vcsel_pclks);
@@ -3284,7 +3010,6 @@
vcsel_width = 2;
}
-
peak_vcsel_duration_us = vcsel_width * 2048 *
(pre_range_macro_pclks + final_range_macro_pclks);
peak_vcsel_duration_us = (peak_vcsel_duration_us + 500) / 1000;
@@ -3312,7 +3037,7 @@
if (peak_signal_rate_kcps == 0) {
*p_sigma_estimate = c_sigma_est_max;
- PALDevDataSet( SigmaEstimate, c_sigma_est_max);
+ Data.SigmaEstimate = c_sigma_est_max;
*p_dmax_mm = 0;
} else {
if (vcsel_total_events_rtn < 1) {
@@ -3473,7 +3198,7 @@
}
*p_sigma_estimate = (uint32_t)(sigma_estimate);
- PALDevDataSet( SigmaEstimate, *p_sigma_estimate);
+ Data.SigmaEstimate = *p_sigma_estimate;
status = VL53L0X_calc_dmax(total_signal_rate_mcps,
corrected_signal_rate_mcps,
pw_mult,
@@ -3487,14 +3212,12 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(
- uint8_t device_range_status,
+VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(uint8_t device_range_status,
FixPoint1616_t signal_rate,
uint16_t effective_spad_rtn_count,
VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
uint8_t *p_pal_range_status)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t none_flag;
uint8_t sigma_limitflag = 0;
uint8_t signal_ref_clipflag = 0;
@@ -3516,7 +3239,6 @@
-
/*
* VL53L0X has a good ranging when the value of the
* DeviceRangeStatus = 11. This function will replace the value 0 with
@@ -3545,8 +3267,7 @@
* value and put the result back into pPalRangeStatus.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
&sigma_limit_check_enable);
}
@@ -3562,8 +3283,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_value(
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
&sigma_limit_value);
if ((sigma_limit_value > 0) &&
@@ -3579,16 +3299,14 @@
* with limit value and put the result back into pPalRangeStatus.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
&signal_ref_clip_limit_check_enable);
}
if ((signal_ref_clip_limit_check_enable != 0) &&
(status == VL53L0X_ERROR_NONE)) {
- status = VL53L0X_get_limit_check_value(
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
&signal_ref_clip_value);
/* Read LastSignalRefMcps from device */
@@ -3597,8 +3315,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
&tmp_word);
}
@@ -3607,7 +3324,7 @@
}
last_signal_ref_mcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmp_word);
- PALDevDataSet( LastSignalRefMcps, last_signal_ref_mcps);
+ Data.LastSignalRefMcps = last_signal_ref_mcps;
if ((signal_ref_clip_value > 0) &&
(last_signal_ref_mcps > signal_ref_clip_value)) {
@@ -3623,8 +3340,7 @@
* If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
&range_ignore_threshold_limit_check_enable);
}
@@ -3639,8 +3355,7 @@
/ effective_spad_rtn_count);
}
- status = VL53L0X_get_limit_check_value(
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
&range_ignore_threshold_value);
if ((range_ignore_threshold_value > 0) &&
@@ -3681,8 +3396,7 @@
/* fill the Limit Check Status */
- status = VL53L0X_get_limit_check_enable(
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
&signal_rate_final_range_limit_check_enable);
if (status == VL53L0X_ERROR_NONE) {
@@ -3691,8 +3405,7 @@
} else {
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp8);
+ Data.CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = temp8;
if ((device_range_status_internal == 4) ||
(signal_rate_final_range_limit_check_enable == 0)) {
@@ -3700,9 +3413,7 @@
} else {
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- temp8);
+ Data.CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE] = temp8;
if ((signal_ref_clip_limit_check_enable == 0) ||
(signal_ref_clipflag == 1)) {
@@ -3711,8 +3422,7 @@
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp8);
+ Data.CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = temp8;
if ((range_ignore_threshold_limit_check_enable == 0) ||
(range_ignore_thresholdflag == 1)) {
@@ -3721,9 +3431,7 @@
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksStatus,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- temp8);
+ Data.CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = temp8;
}
@@ -3731,10 +3439,8 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_get_ranging_measurement_data(
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_ranging_measurement_data(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t device_range_status;
uint8_t range_fractional_enable;
uint8_t pal_range_status;
@@ -3764,8 +3470,7 @@
/* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
*(format 11.2) else no fractional */
- signal_rate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
- VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
+ signal_rate = VL53L0X_FIXPOINT97TOFIXPOINT1616(VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
/* peak_signal_count_rate_rtn_mcps */
p_ranging_measurement_data->SignalRateRtnMegaCps = signal_rate;
@@ -3782,11 +3487,10 @@
device_range_status = localBuffer[0];
/* Get Linearity Corrective Gain */
- linearity_corrective_gain = PALDevDataGet(
- LinearityCorrectiveGain);
+ linearity_corrective_gain = Data.LinearityCorrectiveGain;
/* Get ranging configuration */
- range_fractional_enable = PALDevDataGet(RangeFractionalEnable);
+ range_fractional_enable = Data.RangeFractionalEnable;
if (linearity_corrective_gain != 1000) {
@@ -3794,11 +3498,8 @@
* tmpuint16 + 500) / 1000);
/* Implement Xtalk */
- VL53L0X_GETPARAMETERFIELD(
- XTalkCompensationRateMegaCps,
- x_talk_compensation_rate_mega_cps);
- VL53L0X_GETPARAMETERFIELD( XTalkCompensationEnable,
- x_talk_compensation_enable);
+ x_talk_compensation_rate_mega_cps = Data.CurrentParameters.XTalkCompensationRateMegaCps ;
+ x_talk_compensation_enable = Data.CurrentParameters.XTalkCompensationEnable ;
if (x_talk_compensation_enable) {
@@ -3852,7 +3553,7 @@
if (status == VL53L0X_ERROR_NONE) {
/* Copy last read data into Device buffer */
- last_range_data_buffer = PALDevDataGet( LastRangeMeasure);
+ last_range_data_buffer = Data.LastRangeMeasure;
last_range_data_buffer.RangeMilliMeter =
p_ranging_measurement_data->RangeMilliMeter;
@@ -3869,17 +3570,15 @@
last_range_data_buffer.RangeStatus =
p_ranging_measurement_data->RangeStatus;
- PALDevDataSet( LastRangeMeasure, last_range_data_buffer);
+ Data.LastRangeMeasure = last_range_data_buffer;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -3892,8 +3591,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_ranging_measurement_data(
- p_ranging_measurement_data);
+ status = VL53L0X_get_ranging_measurement_data(p_ranging_measurement_data);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -3904,10 +3602,8 @@
return status;
}
-VL53L0X_Error VL53L0X::perform_ref_signal_measurement(
- uint16_t *p_ref_signal_rate)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::perform_ref_signal_measurement(uint16_t *p_ref_signal_rate)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_RangingMeasurementData_t ranging_measurement_data;
uint8_t sequence_config = 0;
@@ -3916,19 +3612,17 @@
* this will be reset before the end of the function
*/
- sequence_config = PALDevDataGet( SequenceConfig);
+ sequence_config = Data.SequenceConfig;
/*
* This function performs a reference signal rate measurement.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_single_ranging_measurement(
- &ranging_measurement_data);
+ status = VL53L0X_perform_single_ranging_measurement(&ranging_measurement_data);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -3936,8 +3630,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
p_ref_signal_rate);
}
@@ -3950,18 +3643,16 @@
status = VL53L0X_write_byte( VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, sequence_config);
+ Data.SequenceConfig = sequence_config;
}
}
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_perform_ref_spad_management(
- uint32_t *ref_spad_count,
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_perform_ref_spad_management(uint32_t *ref_spad_count,
uint8_t *is_aperture_spads)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t last_spad_array[6];
uint8_t start_select = 0xB4;
uint32_t minimum_spad_count = 3;
@@ -4003,7 +3694,7 @@
* of the non-aperture quadrant and runs in to the adjacent aperture
* quadrant.
*/
- target_ref_rate = PALDevDataGet( targetRefRate);
+ target_ref_rate = Data.targetRefRate;
/*
* Initialize Spad arrays.
@@ -4017,17 +3708,14 @@
Data.SpadData.RefSpadEnables[index] = 0;
}
-
status = VL53L0X_write_byte( 0xFF, 0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
+ status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
+ status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -4035,14 +3723,12 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
+ status = VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
start_select);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
+ status = VL53L0X_write_byte(VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
}
/* Perform ref calibration */
@@ -4056,8 +3742,7 @@
current_spad_index = 0;
last_spad_index = current_spad_index;
need_apt_spads = 0;
- status = enable_ref_spads(
- need_apt_spads,
+ status = enable_ref_spads(need_apt_spads,
Data.SpadData.RefGoodSpadMap,
Data.SpadData.RefSpadEnables,
spad_array_size,
@@ -4070,8 +3755,7 @@
if (status == VL53L0X_ERROR_NONE) {
current_spad_index = last_spad_index;
- status = perform_ref_signal_measurement(
- &peak_signal_rate_ref);
+ status = perform_ref_signal_measurement(&peak_signal_rate_ref);
if ((status == VL53L0X_ERROR_NONE) &&
(peak_signal_rate_ref > target_ref_rate)) {
/* Signal rate measurement too high,
@@ -4081,7 +3765,6 @@
Data.SpadData.RefSpadEnables[index] = 0;
}
-
/* Increment to the first APERTURE spad */
while ((is_aperture(start_select + current_spad_index)
== 0) && (current_spad_index < max_spad_count)) {
@@ -4101,8 +3784,7 @@
if (status == VL53L0X_ERROR_NONE) {
current_spad_index = last_spad_index;
- status = perform_ref_signal_measurement(
- &peak_signal_rate_ref);
+ status = perform_ref_signal_measurement(&peak_signal_rate_ref);
if ((status == VL53L0X_ERROR_NONE) &&
(peak_signal_rate_ref > target_ref_rate)) {
@@ -4138,8 +3820,7 @@
complete = 0;
while (!complete) {
- get_next_good_spad(
- Data.SpadData.RefGoodSpadMap,
+ get_next_good_spad(Data.SpadData.RefGoodSpadMap,
spad_array_size, current_spad_index,
&next_good_spad);
@@ -4214,18 +3895,16 @@
*ref_spad_count = ref_spad_count_int;
*is_aperture_spads = is_aperture_spads_int;
- VL53L0X_SETDEVICESPECIFICPARAMETER(RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(ReferenceSpadCount, (uint8_t)(*ref_spad_count));
- VL53L0X_SETDEVICESPECIFICPARAMETER(ReferenceSpadType, *is_aperture_spads);
+ Data.RefSpadsInitialised = 1;
+ Data.ReferenceSpadCount = (uint8_t)(*ref_spad_count);
+ Data.ReferenceSpadType = *is_aperture_spads;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(
- uint32_t count, uint8_t is_aperture_spads)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(uint32_t count, uint8_t is_aperture_spads)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t current_spad_index = 0;
uint8_t start_select = 0xB4;
uint32_t spad_array_size = 6;
@@ -4243,8 +3922,7 @@
status = VL53L0X_write_byte( 0xFF, 0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(
- VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
+ status = VL53L0X_write_byte(VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -4281,9 +3959,9 @@
&last_spad_index);
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(ReferenceSpadCount, (uint8_t)(count));
- VL53L0X_SETDEVICESPECIFICPARAMETER(ReferenceSpadType, is_aperture_spads);
+ Data.RefSpadsInitialised = 1;
+ Data.ReferenceSpadCount = (uint8_t)(count);
+ Data.ReferenceSpadType = is_aperture_spads;
}
return status;
@@ -4291,18 +3969,15 @@
VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration( uint8_t *p_vhv_settings,
uint8_t *p_phase_cal)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = VL53L0X_perform_ref_calibration( p_vhv_settings, p_phase_cal, 1);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(
- uint32_t *ref_spad_count, uint8_t *is_aperture_spads)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(uint32_t *ref_spad_count, uint8_t *is_aperture_spads)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = wrapped_VL53L0X_perform_ref_spad_management( ref_spad_count,
is_aperture_spads);
@@ -4390,7 +4065,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Pin0GpioFunctionality, functionality); }
+ Data.Pin0GpioFunctionality = functionality; }
if (status == VL53L0X_ERROR_NONE) { status = VL53L0X_clear_interrupt_mask( 0); }
}
@@ -4400,8 +4075,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_get_fraction_enable( uint8_t *p_enabled)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = VL53L0X_read_byte( VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled);
@@ -4430,11 +4104,9 @@
return encoded_timeout;
}
-VL53L0X_Error VL53L0X::set_sequence_step_timeout(
- VL53L0X_SequenceStepId sequence_step_id,
+VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_SequenceStepId sequence_step_id,
uint32_t timeout_micro_secs)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t current_vcsel_pulse_period_p_clk;
uint8_t msrc_encoded_time_out;
uint16_t pre_range_encoded_time_out;
@@ -4448,13 +4120,11 @@
(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
if (status == VL53L0X_ERROR_NONE) {
- msrc_range_time_out_m_clks = VL53L0X_calc_timeout_mclks(
- timeout_micro_secs,
+ msrc_range_time_out_m_clks = VL53L0X_calc_timeout_mclks(timeout_micro_secs,
(uint8_t)current_vcsel_pulse_period_p_clk);
if (msrc_range_time_out_m_clks > 256) {
@@ -4463,7 +4133,7 @@
msrc_encoded_time_out =
(uint8_t)msrc_range_time_out_m_clks - 1;
}
- VL53L0X_SETDEVICESPECIFICPARAMETER(LastEncodedTimeout,msrc_encoded_time_out);
+ Data.LastEncodedTimeout = msrc_encoded_time_out;
}
if (status == VL53L0X_ERROR_NONE) {
@@ -4480,10 +4150,9 @@
pre_range_time_out_m_clks =
VL53L0X_calc_timeout_mclks(timeout_micro_secs,
(uint8_t)current_vcsel_pulse_period_p_clk);
- pre_range_encoded_time_out = VL53L0X_encode_timeout(
- pre_range_time_out_m_clks);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(LastEncodedTimeout,pre_range_encoded_time_out);
+ pre_range_encoded_time_out = VL53L0X_encode_timeout(pre_range_time_out_m_clks);
+
+ Data.LastEncodedTimeout = pre_range_encoded_time_out;
}
if (status == VL53L0X_ERROR_NONE) {
@@ -4492,7 +4161,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(PreRangeTimeoutMicroSecs,timeout_micro_secs);
+ Data.PreRangeTimeoutMicroSecs = timeout_micro_secs;
}
} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
@@ -4541,7 +4210,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(FinalRangeTimeoutMicroSecs,timeout_micro_secs);
+ Data.FinalRangeTimeoutMicroSecs = timeout_micro_secs;
}
}
} else {
@@ -4552,10 +4221,8 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(
- uint32_t measurement_timing_budget_micro_seconds)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(uint32_t measurement_timing_budget_micro_seconds)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t final_range_timing_budget_micro_seconds;
VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
@@ -4653,8 +4320,7 @@
/* Subtract the Pre-range timeout if enabled. */
- status = get_sequence_step_timeout(
- VL53L0X_SEQUENCESTEP_PRE_RANGE,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
&pre_range_timeout_micro_seconds);
sub_timeout = pre_range_timeout_micro_seconds +
@@ -4668,7 +4334,6 @@
}
}
-
if (status == VL53L0X_ERROR_NONE &&
scheduler_sequence_steps.FinalRangeOn) {
@@ -4684,27 +4349,22 @@
*/
status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
final_range_timing_budget_micro_seconds);
- VL53L0X_SETPARAMETERFIELD(MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
+ Data.CurrentParameters.MeasurementTimingBudgetMicroSeconds = measurement_timing_budget_micro_seconds;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_micro_seconds(
- uint32_t measurement_timing_budget_micro_seconds)
+VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_micro_seconds(uint32_t measurement_timing_budget_micro_seconds)
{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(
- measurement_timing_budget_micro_seconds);
+ status = wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(measurement_timing_budget_micro_seconds);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_sequence_step_enable(
- VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_set_sequence_step_enable(VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
uint8_t sequence_config_new = 0;
uint32_t measurement_timing_budget_micro_seconds;
@@ -4767,15 +4427,13 @@
status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new);
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, sequence_config_new);}
+ Data.SequenceConfig = sequence_config_new;}
/* Recalculate timing budget */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
-
- VL53L0X_set_measurement_timing_budget_micro_seconds(
- measurement_timing_budget_micro_seconds);
+ measurement_timing_budget_micro_seconds = Data.CurrentParameters.MeasurementTimingBudgetMicroSeconds ;
+
+ VL53L0X_set_measurement_timing_budget_micro_seconds(measurement_timing_budget_micro_seconds);
}
}
@@ -4784,8 +4442,7 @@
VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_enable( uint16_t limit_check_id,
uint8_t limit_check_enable)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
FixPoint1616_t temp_fix1616 = 0;
uint8_t limit_check_enable_int = 0;
uint8_t limit_check_disable = 0;
@@ -4799,8 +4456,7 @@
limit_check_enable_int = 0;
limit_check_disable = 1;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD( LimitChecksValue,
- limit_check_id, temp_fix1616);
+ temp_fix1616 = Data.CurrentParameters.LimitChecksValue[limit_check_id];
limit_check_disable = 0;
/* this to be sure to have either 0 or 1 */
limit_check_enable_int = 1;
@@ -4810,9 +4466,7 @@
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksEnable,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- limit_check_enable_int);
+ Data.CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
@@ -4821,15 +4475,11 @@
break;
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksEnable,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- limit_check_enable_int);
+ Data.CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksEnable,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- limit_check_enable_int);
+ Data.CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
@@ -4852,17 +4502,16 @@
if (status == VL53L0X_ERROR_NONE) {
if (limit_check_enable == 0) {
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksEnable,limit_check_id, 0);
+ Data.CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
} else {
- VL53L0X_SETARRAYPARAMETERFIELD( LimitChecksEnable,limit_check_id, 1);
+ Data.CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
}
}
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_static_init(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t current_parameters = {0};
uint8_t *p_tuning_setting_buffer;
uint16_t tempword = 0;
@@ -4878,8 +4527,8 @@
status = VL53L0X_get_info_from_device( 1);
/* set the ref spad from NVM */
- count = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(ReferenceSpadCount);
- aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(ReferenceSpadType);
+ count = (uint32_t)Data.ReferenceSpadCount;
+ aperture_spads = Data.ReferenceSpadType;
/* NVM value invalid */
if ((aperture_spads > 1) ||
@@ -4891,15 +4540,14 @@
status = VL53L0X_set_reference_spads( count, aperture_spads);
}
-
/* Initialize tuning settings buffer to prevent compiler warning. */
p_tuning_setting_buffer = DefaultTuningSettings;
if (status == VL53L0X_ERROR_NONE) {
- use_internal_tuning_settings = PALDevDataGet( UseInternalTuningSettings);
+ use_internal_tuning_settings = Data.UseInternalTuningSettings;
if (use_internal_tuning_settings == 0) {
- p_tuning_setting_buffer = PALDevDataGet(pTuningSettingsPointer); }
+ p_tuning_setting_buffer = Data.pTuningSettingsPointer; }
else { p_tuning_setting_buffer = DefaultTuningSettings; }
}
@@ -4907,7 +4555,6 @@
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_load_tuning_settings( p_tuning_setting_buffer); }
-
/* Set interrupt config to new sample ready */
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_set_gpio_config( 0, 0,
@@ -4922,7 +4569,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER( OscFrequencyMHz,VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
+ Data.OscFrequencyMHz = VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword) ;
}
/* After static init, some device parameters may be changed,
@@ -4931,42 +4578,37 @@
status = VL53L0X_get_device_parameters( ¤t_parameters);
}
-
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_get_fraction_enable( &tempbyte);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( RangeFractionalEnable, tempbyte);
+ Data.RangeFractionalEnable = tempbyte;
}
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( CurrentParameters, current_parameters);
+ Data.CurrentParameters = current_parameters;
}
-
/* read the sequence config and save it */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( SequenceConfig, tempbyte);
+ Data.SequenceConfig = tempbyte;
}
}
/* Disable MSRC and TCC by default */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_sequence_step_enable(
- VL53L0X_SEQUENCESTEP_TCC, 0);
+ status = VL53L0X_set_sequence_step_enable(VL53L0X_SEQUENCESTEP_TCC, 0);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_sequence_step_enable(
- VL53L0X_SEQUENCESTEP_MSRC, 0);
+ status = VL53L0X_set_sequence_step_enable(VL53L0X_SEQUENCESTEP_MSRC, 0);
}
/* Set PAL State to standby */
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet( PalState, VL53L0X_STATE_IDLE);
+ Data.PalState = VL53L0X_STATE_IDLE;
}
/* Store pre-range vcsel period */
@@ -4975,18 +4617,17 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(PreRangeVcselPulsePeriod,vcsel_pulse_period_pclk);
+ Data.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
}
/* Store final-range vcsel period */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_vcsel_pulse_period(
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
&vcsel_pulse_period_pclk);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(FinalRangeVcselPulsePeriod,vcsel_pulse_period_pclk);
+ Data.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
}
/* Store pre-range timeout */
@@ -4995,7 +4636,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(PreRangeTimeoutMicroSecs,seq_timeout_micro_secs);
+ Data.PreRangeTimeoutMicroSecs = seq_timeout_micro_secs;
}
/* Store final-range timeout */
@@ -5004,15 +4645,13 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(FinalRangeTimeoutMicroSecs,seq_timeout_micro_secs);
+ Data.FinalRangeTimeoutMicroSecs = seq_timeout_micro_secs;
}
return status;
}
-
VL53L0X_Error VL53L0X::VL53L0X_stop_measurement(void)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
status = VL53L0X_write_byte( VL53L0X_REG_SYSRANGE_START,
@@ -5026,7 +4665,7 @@
if (status == VL53L0X_ERROR_NONE) {
/* Set PAL State to Idle */
- PALDevDataSet( PalState, VL53L0X_STATE_IDLE);
+ Data.PalState = VL53L0X_STATE_IDLE;
}
/* Check if need to apply interrupt settings */
@@ -5038,10 +4677,8 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(
- uint32_t *p_stop_status)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
+VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(uint32_t *p_stop_status)
+{ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte = 0;
@@ -5061,56 +4698,45 @@
status = VL53L0X_write_byte( 0x80, 0x01);
status = VL53L0X_write_byte( 0xFF, 0x01);
status = VL53L0X_write_byte( 0x00, 0x00);
- status = VL53L0X_write_byte( 0x91,
- PALDevDataGet( StopVariable));
+ status = VL53L0X_write_byte( 0x91,Data.StopVariable);
status = VL53L0X_write_byte( 0x00, 0x01);
status = VL53L0X_write_byte( 0xFF, 0x00);
status = VL53L0X_write_byte( 0x80, 0x00);
}
-
-
return status;
}
-
-
/******************************************************************************/
/****************** Write and read functions from I2C *************************/
VL53L0X_Error VL53L0X::VL53L0X_write_multi( uint8_t index, uint8_t *p_data, uint32_t count)
-{
- int status;
+{ int status;
status = VL53L0X_i2c_write(index, p_data, (uint16_t)count);
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_read_multi( uint8_t index, uint8_t *p_data, uint32_t count)
-{
- int status;
+{ int status;
if (count >= VL53L0X_MAX_I2C_XFER_SIZE) {
- status = VL53L0X_ERROR_INVALID_PARAMS;
- }
+ status = VL53L0X_ERROR_INVALID_PARAMS;}
status = VL53L0X_i2c_read(index, p_data, (uint16_t)count);
return status;
}
-
VL53L0X_Error VL53L0X::VL53L0X_write_byte( uint8_t index, uint8_t data)
-{
- int status;
+{ int status;
status = VL53L0X_i2c_write(index, &data, 1);
return status;
}
VL53L0X_Error VL53L0X::VL53L0X_write_word( uint8_t index, uint16_t data)
-{
- int status;
+{ int status;
uint8_t buffer[2];
buffer[0] = data >> 8;
@@ -5120,8 +4746,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_write_dword( uint8_t index, uint32_t data)
-{
- int status;
+{ int status;
uint8_t buffer[4];
buffer[0] = (data >> 24) & 0xFF;
@@ -5132,10 +4757,8 @@
return status;
}
-
VL53L0X_Error VL53L0X::VL53L0X_read_byte( uint8_t index, uint8_t *p_data)
-{
- int status;
+{ int status;
status = VL53L0X_i2c_read(index, p_data, 1);
@@ -5147,8 +4770,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_read_word( uint8_t index, uint16_t *p_data)
-{
- int status;
+{ int status;
uint8_t buffer[2] = {0, 0};
status = VL53L0X_i2c_read(index, buffer, 2);
@@ -5160,8 +4782,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_read_dword( uint8_t index, uint32_t *p_data)
-{
- int status;
+{ int status;
uint8_t buffer[4] = {0, 0, 0, 0};
status = VL53L0X_i2c_read(index, buffer, 4);
@@ -5173,8 +4794,7 @@
}
VL53L0X_Error VL53L0X::VL53L0X_update_byte( uint8_t index, uint8_t and_data, uint8_t or_data)
-{
- int status;
+{ int status;
uint8_t buffer = 0;
/* read data direct onto buffer */
@@ -5188,59 +4808,30 @@
VL53L0X_Error VL53L0X::VL53L0X_i2c_write(uint8_t RegisterAddr, uint8_t *p_data,
uint16_t NumByteToWrite)
-{
- int ret;
-
- ret = i2c_write(p_data, I2cDevAddr, RegisterAddr, NumByteToWrite);
-
- if (ret) {
- return -1;
- }
- return 0;
-}
-
-VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t RegisterAddr, uint8_t *p_data,
- uint16_t NumByteToRead)
-{
- int ret;
-
- ret = i2c_read(p_data, I2cDevAddr, RegisterAddr, NumByteToRead);
-
- if (ret) {
- return -1;
- }
- return 0;
-}
-
-/** Writes a buffer towards the I2C peripheral device. */
-int VL53L0X::i2c_write(uint8_t* pBuffer, uint8_t DeviceAddr, uint8_t RegisterAddr,
- uint16_t NumByteToWrite)
-{
- int ret;
- uint8_t tmp[VL53L0X_MAX_I2C_XFER_SIZE];
+{ /** Writes a buffer towards the I2C peripheral device. */
+ static uint8_t tmp[VL53L0X_MAX_I2C_XFER_SIZE];
if(NumByteToWrite >= VL53L0X_MAX_I2C_XFER_SIZE) return -2;
/* First, send device address. Then, send data and STOP condition */
tmp[0] = RegisterAddr;
- memcpy(tmp+1, pBuffer, NumByteToWrite);
-
- ret = _dev_i2c->write(DeviceAddr, (const char*)tmp, NumByteToWrite+1, false);
-
+ memcpy(tmp+1, p_data, NumByteToWrite);
+
+ if (_dev_i2c->write(I2cDevAddr, (const char*)tmp, NumByteToWrite+1, false) != 0 )
+ { return -1; }
+ return 0;
+}
+
+VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t RegisterAddr, uint8_t *p_data, uint16_t NumByteToRead)
+{ /** Reads a buffer from the I2C peripheral device. */
+
+ /* First Send device address, with no STOP condition */
+ int ret = _dev_i2c->write(I2cDevAddr, (const char*)&RegisterAddr, 1, true);
+
+ /* all ok ? then Read data, with STOP condition */
+ if(ret == 0) { ret = _dev_i2c->read(I2cDevAddr, (char*)p_data, NumByteToRead, false); }
+
if (ret != 0 ){ return -1; }
return 0;
}
-/** Reads a buffer from the I2C peripheral device. */
-int VL53L0X::i2c_read(uint8_t* pBuffer, uint8_t DeviceAddr, uint8_t RegisterAddr,
- uint16_t NumByteToRead)
-{ int ret;
-
- /* Send device address, with no STOP condition */
- ret = _dev_i2c->write(DeviceAddr, (const char*)&RegisterAddr, 1, true);
- if(!ret) { /* Read data, with STOP condition */
- ret = _dev_i2c->read(DeviceAddr, (char*)pBuffer, NumByteToRead, false); }
-
- if (ret != 0 ){ return -1; }
- return 0;
-}
\ No newline at end of file