Tarek Lule
Condensed Version of Public VL53L0X
Diff: VL53L0X.cpp
- Revision:
- 7:41cbc431e1f4
- Parent:
- 6:1976f4afed97
- Child:
- 8:abea9638127a
--- a/VL53L0X.cpp Sat Mar 23 21:42:03 2019 +0000
+++ b/VL53L0X.cpp Sun Mar 24 18:18:54 2019 +0000
@@ -10,7 +10,7 @@
*
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
*
- * Redistribution and use in source and binary forms, with or without modification,
+ * Redistribution and use in source and binary forms,with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
@@ -22,46 +22,69 @@
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES,INCLUDING,BUT NOT LIMITED TO,THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * FOR ANY DIRECT,INDIRECT,INCIDENTAL,SPECIAL,EXEMPLARY,OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING,BUT NOT LIMITED TO,PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE,DATA,OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY,WHETHER IN CONTRACT,STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * OF THIS SOFTWARE,EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
+// Some example regex that were used to replace useless macros
+// \QVL53L0X_SETDEVICESPECIFICPARAMETER(\E([A-Z\d]+)[[:punct:]]([[:space:]]*)([A-Z\d_]+)\Q);\E
+// _device->DeviceSpecificParameters.\1 = \3;
+
+// \QVL53L0X_GETDEVICESPECIFICPARAMETER(\E([A-Z\d]+)\Q);\E
+// _device->DeviceSpecificParameters.\1;
+
+// \QVL53L0X_SETPARAMETERFIELD(\E([A-Z\d]+)[[:punct:]]([[:space:]]*)([A-Z\d_]+)\Q);\E
+// _device->CurrentParameters.\1 = \3;
+
+// \QVL53L0X_GETPARAMETERFIELD(\E([A-Z\d]+)[[:punct:]]([[:space:]]*)([A-Z\d_]+)\Q);\E
+// \3 = _device->CurrentParameters.\1
+
+// \QVL53L0X_SETARRAYPARAMETERFIELD(\E([A-Z\d]+)[[:punct:]](\s*)([A-Z\d_]+)[[:punct:]](\s*)([A-Z\d_]+)\Q);\E
+// _device->CurrentParameters.\1[\3] = \5;
+// is used to replace following macro for ex:
+// #define VL53L0X_SETARRAYPARAMETERFIELD(field, index, value) \
+//_device->CurrentParameters.field[index] = value
+
+// \QVL53L0X_GETARRAYPARAMETERFIELD(\E([A-Z\d]+)[[:punct:]](\s*)([A-Z\d_]+)[[:punct:]](\s*)([A-Z\d_]+)\Q);\E
+// \5 = _device->CurrentParameters.\1[\3]
+// is used to replace following macro for ex:
+// #define VL53L0X_GETARRAYPARAMETERFIELD(field, index, variable) \
+// variable = _device-> CurrentParameters.field[index]
+
+// \QPALDevDataSet(\E([A-Z\d]+)[[:punct:]]([[:space:]]*)([A-Z\d_]+)\Q);\E
+// _device->\1 = \3;
+// is used to replace:
+// #define PALDevDataSet(field, data) (Dev->field)=(data)
+
+
+
/* Includes */
#include <stdlib.h>
-
#include "VL53L0X.h"
-#include "VL53L0X_tuning.h"
-
-#define REF_ARRAY_SPAD_0 0
-#define REF_ARRAY_SPAD_5 5
-#define REF_ARRAY_SPAD_10 10
-
-uint32_t refArrayQuadrants[4] = {REF_ARRAY_SPAD_10, REF_ARRAY_SPAD_5,
- REF_ARRAY_SPAD_0, REF_ARRAY_SPAD_5 };
-
-VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe(VL53L0X_DEV dev)
+
+VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t strobe;
uint32_t loop_nb;
- status |= VL53L0X_write_byte(dev, 0x83, 0x00);
+ status |= VL53L0X_write_byte(0x83,0x00);
/* polling
* use timeout to avoid deadlock*/
if (status == VL53L0X_ERROR_NONE) {
loop_nb = 0;
do {
- status = VL53L0X_read_byte(dev, 0x83, &strobe);
+ status = VL53L0X_read_byte(0x83,&strobe);
if ((strobe != 0x00) || status != VL53L0X_ERROR_NONE) {
break;
}
@@ -74,12 +97,12 @@
}
}
- status |= VL53L0X_write_byte(dev, 0x83, 0x01);
+ status |= VL53L0X_write_byte(0x83,0x01);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device(VL53L0X_DEV dev, uint8_t option)
+VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device(uint8_t option)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte;
@@ -103,39 +126,39 @@
int i;
- read_data_from_device_done = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- ReadDataFromDeviceDone);
+ read_data_from_device_done = _device->DeviceSpecificParameters.ReadDataFromDeviceDone;
+ read_data_from_device_done = _device->DeviceSpecificParameters.ReadDataFromDeviceDone;
/* This access is done only once after that a GetDeviceInfo or
* datainit is done*/
if (read_data_from_device_done != 7) {
- status |= VL53L0X_write_byte(dev, 0x80, 0x01);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x00);
-
- status |= VL53L0X_write_byte(dev, 0xFF, 0x06);
- status |= VL53L0X_read_byte(dev, 0x83, &byte);
- status |= VL53L0X_write_byte(dev, 0x83, byte | 4);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x07);
- status |= VL53L0X_write_byte(dev, 0x81, 0x01);
-
- status |= VL53L0X_polling_delay(dev);
-
- status |= VL53L0X_write_byte(dev, 0x80, 0x01);
+ status |= VL53L0X_write_byte(0x80,0x01);
+ status |= VL53L0X_write_byte(0xFF,0x01);
+ status |= VL53L0X_write_byte(0x00,0x00);
+
+ status |= VL53L0X_write_byte(0xFF,0x06);
+ status |= VL53L0X_read_byte(0x83,&byte);
+ status |= VL53L0X_write_byte(0x83,byte | 4);
+ status |= VL53L0X_write_byte(0xFF,0x07);
+ status |= VL53L0X_write_byte(0x81,0x01);
+
+ status |= VL53L0X_polling_delay();
+
+ status |= VL53L0X_write_byte(0x80,0x01);
if (((option & 1) == 1) &&
((read_data_from_device_done & 1) == 0)) {
- status |= VL53L0X_write_byte(dev, 0x94, 0x6b);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x6b);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
reference_spad_count = (uint8_t)((tmp_dword >> 8) & 0x07f);
reference_spad_type = (uint8_t)((tmp_dword >> 15) & 0x01);
- status |= VL53L0X_write_byte(dev, 0x94, 0x24);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x24);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
nvm_ref_good_spad_map[0] = (uint8_t)((tmp_dword >> 24)
@@ -146,9 +169,9 @@
& 0xff);
nvm_ref_good_spad_map[3] = (uint8_t)(tmp_dword & 0xff);
- status |= VL53L0X_write_byte(dev, 0x94, 0x25);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x25);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
nvm_ref_good_spad_map[4] = (uint8_t)((tmp_dword >> 24)
& 0xff);
@@ -159,17 +182,17 @@
if (((option & 2) == 2) &&
((read_data_from_device_done & 2) == 0)) {
- status |= VL53L0X_write_byte(dev, 0x94, 0x02);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_byte(dev, 0x90, &module_id);
-
- status |= VL53L0X_write_byte(dev, 0x94, 0x7B);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_byte(dev, 0x90, &revision);
-
- status |= VL53L0X_write_byte(dev, 0x94, 0x77);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x02);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_byte(0x90,&module_id);
+
+ status |= VL53L0X_write_byte(0x94,0x7B);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_byte(0x90,&revision);
+
+ status |= VL53L0X_write_byte(0x94,0x77);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
product_id[0] = (char)((tmp_dword >> 25) & 0x07f);
product_id[1] = (char)((tmp_dword >> 18) & 0x07f);
@@ -178,9 +201,9 @@
byte = (uint8_t)((tmp_dword & 0x00f) << 3);
- status |= VL53L0X_write_byte(dev, 0x94, 0x78);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x78);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
product_id[4] = (char)(byte +
((tmp_dword >> 29) & 0x07f));
@@ -191,11 +214,11 @@
byte = (uint8_t)((tmp_dword & 0x001) << 6);
- status |= VL53L0X_write_byte(dev, 0x94, 0x79);
-
- status |= VL53L0X_device_read_strobe(dev);
-
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x79);
+
+ status |= VL53L0X_device_read_strobe();
+
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
product_id[9] = (char)(byte +
((tmp_dword >> 26) & 0x07f));
@@ -205,11 +228,11 @@
byte = (uint8_t)((tmp_dword & 0x01f) << 2);
- status |= VL53L0X_write_byte(dev, 0x94, 0x7A);
-
- status |= VL53L0X_device_read_strobe(dev);
-
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x7A);
+
+ status |= VL53L0X_device_read_strobe();
+
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
product_id[13] = (char)(byte +
((tmp_dword >> 30) & 0x07f));
@@ -224,52 +247,52 @@
if (((option & 4) == 4) &&
((read_data_from_device_done & 4) == 0)) {
- status |= VL53L0X_write_byte(dev, 0x94, 0x7B);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &part_uid_upper);
-
- status |= VL53L0X_write_byte(dev, 0x94, 0x7C);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &part_uid_lower);
-
- status |= VL53L0X_write_byte(dev, 0x94, 0x73);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x7B);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&part_uid_upper);
+
+ status |= VL53L0X_write_byte(0x94,0x7C);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&part_uid_lower);
+
+ status |= VL53L0X_write_byte(0x94,0x73);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
signal_rate_meas_fixed1104_400_mm = (tmp_dword &
0x0000000ff) << 8;
- status |= VL53L0X_write_byte(dev, 0x94, 0x74);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x74);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
signal_rate_meas_fixed1104_400_mm |= ((tmp_dword &
0xff000000) >> 24);
- status |= VL53L0X_write_byte(dev, 0x94, 0x75);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x75);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
dist_meas_fixed1104_400_mm = (tmp_dword & 0x0000000ff)
<< 8;
- status |= VL53L0X_write_byte(dev, 0x94, 0x76);
- status |= VL53L0X_device_read_strobe(dev);
- status |= VL53L0X_read_dword(dev, 0x90, &tmp_dword);
+ status |= VL53L0X_write_byte(0x94,0x76);
+ status |= VL53L0X_device_read_strobe();
+ status |= VL53L0X_read_dword(0x90,&tmp_dword);
dist_meas_fixed1104_400_mm |= ((tmp_dword & 0xff000000)
>> 24);
}
- status |= VL53L0X_write_byte(dev, 0x81, 0x00);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x06);
- status |= VL53L0X_read_byte(dev, 0x83, &byte);
- status |= VL53L0X_write_byte(dev, 0x83, byte & 0xfb);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x01);
-
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
- status |= VL53L0X_write_byte(dev, 0x80, 0x00);
+ status |= VL53L0X_write_byte(0x81,0x00);
+ status |= VL53L0X_write_byte(0xFF,0x06);
+ status |= VL53L0X_read_byte(0x83,&byte);
+ status |= VL53L0X_write_byte(0x83,byte & 0xfb);
+ status |= VL53L0X_write_byte(0xFF,0x01);
+ status |= VL53L0X_write_byte(0x00,0x01);
+
+ status |= VL53L0X_write_byte(0xFF,0x00);
+ status |= VL53L0X_write_byte(0x80,0x00);
}
if ((status == VL53L0X_ERROR_NONE) &&
@@ -277,47 +300,37 @@
/* Assign to variable if status is ok */
if (((option & 1) == 1) &&
((read_data_from_device_done & 1) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadCount, reference_spad_count);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadType, reference_spad_type);
+ _device->DeviceSpecificParameters.ReferenceSpadCount=reference_spad_count;
+ _device->DeviceSpecificParameters.ReferenceSpadType=reference_spad_type;
for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
- dev->SpadData.RefGoodSpadMap[i] =
+ _device->SpadData.RefGoodSpadMap[i] =
nvm_ref_good_spad_map[i];
}
}
if (((option & 2) == 2) &&
((read_data_from_device_done & 2) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ModuleId, module_id);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- Revision, revision);
-
- product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- ProductId);
- strcpy(product_id_tmp, product_id);
+ _device->DeviceSpecificParameters.ModuleId = module_id;
+
+ _device->DeviceSpecificParameters.Revision = revision;
+
+ product_id_tmp = _device->DeviceSpecificParameters.ProductId;
+ strcpy(product_id_tmp,product_id);
}
if (((option & 4) == 4) &&
((read_data_from_device_done & 4) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- PartUIDUpper, part_uid_upper);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- PartUIDLower, part_uid_lower);
+ _device->DeviceSpecificParameters.PartUIDUpper = part_uid_upper;
+
+ _device->DeviceSpecificParameters.PartUIDLower = part_uid_lower;
signal_rate_meas_fixed400_mm_fix =
- VL53L0X_FIXPOINT97TOFIXPOINT1616(
- signal_rate_meas_fixed1104_400_mm);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- SignalRateMeasFixed400mm,
- signal_rate_meas_fixed400_mm_fix);
+ VL53L0X_FIXPOINT97TOFIXPOINT1616(signal_rate_meas_fixed1104_400_mm);
+
+ _device->DeviceSpecificParameters.SignalRateMeasFixed400mm = signal_rate_meas_fixed400_mm_fix;
+ _device->DeviceSpecificParameters.SignalRateMeasFixed400mm = signal_rate_meas_fixed400_mm_fix;
offset_micro_meters = 0;
if (dist_meas_fixed1104_400_mm != 0) {
@@ -329,21 +342,17 @@
offset_micro_meters *= -1;
}
- PALDevDataSet(dev,
- Part2PartOffsetAdjustmentNVMMicroMeter,
- offset_micro_meters);
+ _device->Part2PartOffsetAdjustmentNVMMicroMeter = offset_micro_meters;
}
byte = (uint8_t)(read_data_from_device_done | option);
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone,
- byte);
+ _device->DeviceSpecificParameters.ReadDataFromDeviceDone = byte;
}
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
- int32_t *p_offset_calibration_data_micro_meter)
+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;
@@ -352,8 +361,7 @@
/* Note that offset has 10.2 format */
- status = VL53L0X_read_word(dev,
- 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) {
@@ -374,21 +382,18 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
- int32_t *p_offset_calibration_data_micro_meter)
+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(dev,
- 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(VL53L0X_DEV dev,
- int32_t offset_calibration_data_micro_meter)
+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;
@@ -419,28 +424,25 @@
offset_calibration_data_micro_meter / 250;
}
- status = VL53L0X_write_word(dev,
- 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(VL53L0X_DEV dev,
- int32_t offset_calibration_data_micro_meter)
+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(dev,
- 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(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_apply_offset_adjustment()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
int32_t corrected_offset_micro_meters;
@@ -448,52 +450,43 @@
/* if we run on this function we can read all the NVM info
* used by the API */
- status = VL53L0X_get_info_from_device(dev, 7);
+ 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(dev,
- ¤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(dev, Part2PartOffsetNVMMicroMeter,
- current_offset_micro_meters);
+ _device->Part2PartOffsetNVMMicroMeter = current_offset_micro_meters;
corrected_offset_micro_meters = current_offset_micro_meters +
- (int32_t)PALDevDataGet(dev,
- Part2PartOffsetAdjustmentNVMMicroMeter);
-
- status = VL53L0X_set_offset_calibration_data_micro_meter(dev,
- corrected_offset_micro_meters);
-
- /* store current, adjusted offset */
+ (int32_t) _device->Part2PartOffsetAdjustmentNVMMicroMeter;
+
+ status = VL53L0X_set_offset_calibration_data_micro_meter(corrected_offset_micro_meters);
+
+ /* store current,adjusted offset */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(dev, RangeOffsetMicroMeters,
- corrected_offset_micro_meters);
+ _device->CurrentParameters.RangeOffsetMicroMeters = corrected_offset_micro_meters;
}
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(VL53L0X_DEV dev,
- VL53L0X_DeviceModes *p_device_mode)
+VL53L0X_Error VL53L0X::VL53L0X_get_device_mode(VL53L0X_DeviceModes *p_device_mode)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
-
- VL53L0X_GETPARAMETERFIELD(dev, DeviceMode, *p_device_mode);
-
+ *p_device_mode = _device->CurrentParameters.DeviceMode;
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_inter_measurement_period_milli_seconds(VL53L0X_DEV dev,
- uint32_t *p_inter_measurement_period_milli_seconds)
+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;
@@ -501,12 +494,11 @@
- status = VL53L0X_read_word(dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
+ status = VL53L0X_read_word(VL53L0X_REG_OSC_CALIBRATE_VAL,
&osc_calibrate_val);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_dword(dev,
- VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
+ status = VL53L0X_read_dword(VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
&im_period_milli_seconds);
}
@@ -515,17 +507,15 @@
*p_inter_measurement_period_milli_seconds =
im_period_milli_seconds / osc_calibrate_val;
}
- VL53L0X_SETPARAMETERFIELD(dev,
- InterMeasurementPeriodMilliSeconds,
- *p_inter_measurement_period_milli_seconds);
+ _device->CurrentParameters.InterMeasurementPeriodMilliSeconds=
+ *p_inter_measurement_period_milli_seconds;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_rate_mega_cps(VL53L0X_DEV dev,
- FixPoint1616_t *p_xtalk_compensation_rate_mega_cps)
+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;
@@ -533,23 +523,18 @@
- status = VL53L0X_read_word(dev,
- 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(dev,
- XTalkCompensationRateMegaCps, temp_fix1616);
+ temp_fix1616 = _device->CurrentParameters.XTalkCompensationRateMegaCps;
*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
- 0);
+ _device->CurrentParameters.XTalkCompensationEnable = 0;
} else {
temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(value);
*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD(dev,
- XTalkCompensationRateMegaCps, temp_fix1616);
- VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
- 1);
+ _device->CurrentParameters.XTalkCompensationRateMegaCps = temp_fix1616;
+ _device->CurrentParameters.XTalkCompensationEnable = 1;
}
}
@@ -557,7 +542,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
+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;
@@ -571,14 +556,12 @@
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616);
+ temp_fix1616 = _device->CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE];
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = VL53L0X_read_word(dev,
- 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);
@@ -590,22 +573,19 @@
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp_fix1616);
+ temp_fix1616 = _device->CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP];
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, temp_fix1616);
+ temp_fix1616 = _device->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(dev,
- 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);
@@ -626,19 +606,14 @@
if (temp_fix1616 == 0) {
/* disabled: return value from memory */
- VL53L0X_GETARRAYPARAMETERFIELD(dev,
- LimitChecksValue, limit_check_id,
- temp_fix1616);
+ temp_fix1616 = _device->CurrentParameters.LimitChecksValue[limit_check_id];
*p_limit_check_value = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(dev,
- LimitChecksEnable, limit_check_id, 0);
+ _device->CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
+ _device->CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
} else {
*p_limit_check_value = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(dev,
- LimitChecksValue, limit_check_id,
- temp_fix1616);
- VL53L0X_SETARRAYPARAMETERFIELD(dev,
- LimitChecksEnable, limit_check_id, 1);
+ _device->CurrentParameters.LimitChecksValue[limit_check_id] = temp_fix1616;
+ _device->CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
}
} else {
*p_limit_check_value = temp_fix1616;
@@ -650,7 +625,7 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_get_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
+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;
@@ -662,8 +637,7 @@
status = VL53L0X_ERROR_INVALID_PARAMS;
*p_limit_check_enable = 0;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- limit_check_id, temp8);
+ temp8 = _device->CurrentParameters.LimitChecksEnable[limit_check_id];
*p_limit_check_enable = temp8;
}
@@ -671,17 +645,16 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_wrap_around_check_enable(VL53L0X_DEV dev,
- uint8_t *p_wrap_around_check_enable)
+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(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,&data);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, data);
+ _device->SequenceConfig = data;
if (data & (0x01 << 7)) {
*p_wrap_around_check_enable = 0x01;
} else {
@@ -689,16 +662,15 @@
}
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(dev, WrapAroundCheckEnable,
- *p_wrap_around_check_enable);
+ _device->CurrentParameters.WrapAroundCheckEnable=
+ *p_wrap_around_check_enable;
}
return status;
}
-VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_DEV dev,
- 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;
@@ -729,39 +701,33 @@
return Status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_sequence_step_enables(VL53L0X_DEV dev,
- VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
+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;
- status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
&sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
+ status = sequence_step_enabled(VL53L0X_SEQUENCESTEP_FINAL_RANGE,sequence_config,
&p_scheduler_sequence_steps->FinalRangeOn);
}
@@ -798,8 +764,7 @@
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV dev,
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk)
+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;
@@ -841,120 +806,92 @@
/* Set phase check limits */
if (vcsel_pulse_period_pclk == 12) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ 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,
0x30);
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
+ status |= VL53L0X_write_byte(0xff,0x00);
} else if (vcsel_pulse_period_pclk == 10) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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(dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ 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,
0x20);
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
+ status |= VL53L0X_write_byte(0xff,0x00);
} else if (vcsel_pulse_period_pclk == 12) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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(dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ 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,
0x20);
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
+ status |= VL53L0X_write_byte(0xff,0x00);
} else if (vcsel_pulse_period_pclk == 14) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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(dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
+ 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,
0x20);
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
+ status |= VL53L0X_write_byte(0xff,0x00);
}
}
- /* Re-calculate and apply timeouts, in macro periods */
+ /* Re-calculate and apply timeouts,in macro periods */
if (status == VL53L0X_ERROR_NONE) {
vcsel_period_reg = lv53l0x_encode_vcsel_period((uint8_t)
@@ -962,120 +899,98 @@
/* When the VCSEL period for the pre or final range is changed,
* the corresponding timeout must be read from the device using
- * the current VCSEL period, then the new VCSEL period can be
+ * the current VCSEL period,then the new VCSEL period can be
* applied. The timeout then must be written back to the device
* using the new VCSEL period.
*
- * For the MSRC timeout, the same applies - this timeout being
+ * For the MSRC timeout,the same applies - this timeout being
* dependant on the pre-range vcsel period.
*/
switch (vcsel_period_type) {
case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
- status = get_sequence_step_timeout(dev,
- 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(dev,
- VL53L0X_SEQUENCESTEP_MSRC,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
&msrc_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_write_byte(dev,
- 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(dev,
- VL53L0X_SEQUENCESTEP_PRE_RANGE,
+ status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_PRE_RANGE,
pre_range_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE)
- status = set_sequence_step_timeout(dev,
- VL53L0X_SEQUENCESTEP_MSRC,
+ status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
msrc_timeout_micro_seconds);
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- PreRangeVcselPulsePeriod,
- vcsel_pulse_period_pclk);
+ _device->DeviceSpecificParameters.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
break;
case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
- status = get_sequence_step_timeout(dev,
- VL53L0X_SEQUENCESTEP_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(dev,
- 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(dev,
- VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+ status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
final_range_timeout_micro_seconds);
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- FinalRangeVcselPulsePeriod,
- vcsel_pulse_period_pclk);
+ _device->DeviceSpecificParameters.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
break;
default:
status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
- /* Finally, the timing budget must be re-applied */
+ /* Finally,the timing budget must be re-applied */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(dev,
- MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
-
- status = VL53L0X_set_measurement_timing_budget_micro_seconds(dev,
- measurement_timing_budget_micro_seconds);
+ measurement_timing_budget_micro_seconds = _device->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
* vcsel period.
- * get_data_enable = 0, restore_config = 1 */
+ * get_data_enable = 0,restore_config = 1 */
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_perform_phase_calibration(
- dev, &phase_cal_int, 0, 1);
+ status = VL53L0X_perform_phase_calibration(&phase_cal_int,0,1);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV dev,
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
+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(dev, vcsel_period_type,
+ status = wrapped_VL53L0X_set_vcsel_pulse_period(vcsel_period_type,
vcsel_pulse_period);
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV dev,
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
+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(dev,
- 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(dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+ status = VL53L0X_read_byte(VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
&vcsel_period_reg);
break;
default:
@@ -1089,13 +1004,12 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV dev,
- VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
+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(dev, vcsel_period_type,
+ status = wrapped_VL53L0X_get_vcsel_pulse_period(vcsel_period_type,
p_vcsel_pulse_period_pclk);
@@ -1116,7 +1030,7 @@
return timeout_macro_clks;
}
-uint32_t VL53L0X::VL53L0X_calc_macro_period_ps(VL53L0X_DEV dev, uint8_t vcsel_period_pclks)
+uint32_t VL53L0X::VL53L0X_calc_macro_period_ps(uint8_t vcsel_period_pclks)
{
uint64_t pll_period_ps;
uint32_t macro_period_vclks;
@@ -1136,15 +1050,14 @@
}
/* To convert register value into us */
-uint32_t VL53L0X::VL53L0X_calc_timeout_us(VL53L0X_DEV dev,
- 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_ns;
uint32_t actual_timeout_period_us = 0;
- macro_period_ps = VL53L0X_calc_macro_period_ps(dev, vcsel_period_pclks);
+ macro_period_ps = VL53L0X_calc_macro_period_ps(vcsel_period_pclks);
macro_period_ns = (macro_period_ps + 500) / 1000;
actual_timeout_period_us =
@@ -1153,8 +1066,7 @@
return actual_timeout_period_us;
}
-VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_DEV dev,
- 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;
@@ -1172,87 +1084,72 @@
(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
- status = VL53L0X_get_vcsel_pulse_period(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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) {
- VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
+ VL53L0X_get_sequence_step_enables(&scheduler_sequence_steps);
pre_range_time_out_m_clks = 0;
if (scheduler_sequence_steps.PreRangeOn) {
/* Retrieve PRE-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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);
}
@@ -1261,8 +1158,7 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
- uint32_t *p_measurement_timing_budget_micro_seconds)
+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;
@@ -1283,7 +1179,7 @@
*p_measurement_timing_budget_micro_seconds
= start_overhead_micro_seconds + end_overhead_micro_seconds;
- status = VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
+ status = VL53L0X_get_sequence_step_enables(&scheduler_sequence_steps);
if (status != VL53L0X_ERROR_NONE) {
@@ -1295,8 +1191,7 @@
scheduler_sequence_steps.MsrcOn ||
scheduler_sequence_steps.DssOn) {
- status = get_sequence_step_timeout(dev,
- VL53L0X_SEQUENCESTEP_MSRC,
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
&msrc_dcc_tcc_timeout_micro_seconds);
if (status == VL53L0X_ERROR_NONE) {
@@ -1320,8 +1215,7 @@
if (status == VL53L0X_ERROR_NONE) {
if (scheduler_sequence_steps.PreRangeOn) {
- status = get_sequence_step_timeout(dev,
- 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 +
@@ -1331,8 +1225,7 @@
if (status == VL53L0X_ERROR_NONE) {
if (scheduler_sequence_steps.FinalRangeOn) {
- status = get_sequence_step_timeout(dev,
- 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 +
@@ -1341,41 +1234,36 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(dev,
- MeasurementTimingBudgetMicroSeconds,
- *p_measurement_timing_budget_micro_seconds);
+ _device->CurrentParameters.MeasurementTimingBudgetMicroSeconds =
+ *p_measurement_timing_budget_micro_seconds;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
- uint32_t *p_measurement_timing_budget_micro_seconds)
+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(dev,
- 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_DEV dev,
- VL53L0X_DeviceParameters_t *p_device_parameters)
+VL53L0X_Error VL53L0X::VL53L0X_get_device_parameters(VL53L0X_DeviceParameters_t *p_device_parameters)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
- status = VL53L0X_get_device_mode(dev, &(p_device_parameters->DeviceMode));
+ status = VL53L0X_get_device_mode(&(p_device_parameters->DeviceMode));
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_get_inter_measurement_period_milli_seconds(dev,
- &(p_device_parameters->InterMeasurementPeriodMilliSeconds));
+ status = VL53L0X_get_inter_measurement_period_milli_seconds(&(p_device_parameters->InterMeasurementPeriodMilliSeconds));
if (status == VL53L0X_ERROR_NONE) {
@@ -1383,29 +1271,27 @@
}
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_get_x_talk_compensation_rate_mega_cps(dev,
- &(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(dev,
- &(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++) {
- /* get first the values, then the enables.
+ /* get first the values,then the enables.
* VL53L0X_GetLimitCheckValue will modify the enable
* flags
*/
if (status == VL53L0X_ERROR_NONE) {
- status |= VL53L0X_get_limit_check_value(dev, i,
+ status |= VL53L0X_get_limit_check_value(i,
&(p_device_parameters->LimitChecksValue[i]));
} else {
break;
}
if (status == VL53L0X_ERROR_NONE) {
- status |= VL53L0X_get_limit_check_enable(dev, i,
+ status |= VL53L0X_get_limit_check_enable(i,
&(p_device_parameters->LimitChecksEnable[i]));
} else {
break;
@@ -1414,21 +1300,19 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_wrap_around_check_enable(dev,
- &(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(dev,
- &(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
+ status = VL53L0X_get_measurement_timing_budget_micro_seconds(&(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
+VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_value(uint16_t limit_check_id,
FixPoint1616_t limit_check_value)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -1436,57 +1320,45 @@
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable, limit_check_id,
- temp8);
+ temp8 = _device->CurrentParameters.LimitChecksEnable[limit_check_id];
if (temp8 == 0) { /* disabled write only internal value */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- limit_check_id, limit_check_value);
+ _device->CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
} else {
switch (limit_check_id) {
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- limit_check_value);
+ _device->CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_value;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = VL53L0X_write_word(dev,
- 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(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- limit_check_value);
+ _device->CurrentParameters.LimitChecksValue[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_value;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- limit_check_value);
+ _device->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(dev,
- 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;
@@ -1496,8 +1368,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- limit_check_id, limit_check_value);
+ _device->CurrentParameters.LimitChecksValue[limit_check_id] = limit_check_value;
}
}
@@ -1505,7 +1376,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_data_init(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_data_init()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t CurrentParameters;
@@ -1517,71 +1388,70 @@
/* 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(Dev,
- VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
+ Status = VL53L0X_UpdateByte(VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
0xFE,
0x01);
#endif
/* Set I2C standard mode */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0x88, 0x00);
- }
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone, 0);
+ status = VL53L0X_write_byte(0x88,0x00);
+ }
+
+ _device->DeviceSpecificParameters.ReadDataFromDeviceDone = 0;
+ _device->DeviceSpecificParameters.ReadDataFromDeviceDone = 0;
#ifdef USE_IQC_STATION
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_apply_offset_adjustment(Dev);
+ Status = VL53L0X_apply_offset_adjustment();
}
#endif
/* Default value is 1000 for Linearity Corrective Gain */
- PALDevDataSet(dev, LinearityCorrectiveGain, 1000);
+ _device->LinearityCorrectiveGain = 1000;
/* Dmax default Parameter */
- PALDevDataSet(dev, DmaxCalRangeMilliMeter, 400);
- PALDevDataSet(dev, DmaxCalSignalRateRtnMegaCps,
- (FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
+ _device->DmaxCalRangeMilliMeter = 400;
+ _device->DmaxCalSignalRateRtnMegaCps = (FixPoint1616_t)((0x00016B85)); /* 1.42 No Cover Glass*/
/* Set Default static parameters
*set first temporary values 9.44MHz * 65536 = 618660 */
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, OscFrequencyMHz, 618660);
+ _device->DeviceSpecificParameters.OscFrequencyMHz = 618660;
/* Set Default XTalkCompensationRateMegaCps to 0 */
- VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps, 0);
+ _device->CurrentParameters.XTalkCompensationRateMegaCps = 0;
/* Get default parameters */
- status = VL53L0X_get_device_parameters(dev, &CurrentParameters);
+ status = VL53L0X_get_device_parameters(&CurrentParameters);
if (status == VL53L0X_ERROR_NONE) {
/* initialize PAL values */
CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
- PALDevDataSet(dev, CurrentParameters, CurrentParameters);
+ _device->CurrentParameters = CurrentParameters;
}
/* Sigma estimator variable */
- PALDevDataSet(dev, SigmaEstRefArray, 100);
- PALDevDataSet(dev, SigmaEstEffPulseWidth, 900);
- PALDevDataSet(dev, SigmaEstEffAmbWidth, 500);
- PALDevDataSet(dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
+ _device->SigmaEstRefArray = 100;
+ _device->SigmaEstEffPulseWidth = 900;
+ _device->SigmaEstEffAmbWidth = 500;
+ _device->targetRefRate = 0x0A00; /* 20 MCPS in 9:7 format */
/* Use internal default settings */
- PALDevDataSet(dev, UseInternalTuningSettings, 1);
-
- status |= VL53L0X_write_byte(dev, 0x80, 0x01);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x00);
- status |= VL53L0X_read_byte(dev, 0x91, &StopVariable);
- PALDevDataSet(dev, StopVariable, StopVariable);
- status |= VL53L0X_write_byte(dev, 0x00, 0x01);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
- status |= VL53L0X_write_byte(dev, 0x80, 0x00);
+ _device->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);
+ _device->StopVariable = StopVariable;
+ status |= VL53L0X_write_byte(0x00,0x01);
+ status |= VL53L0X_write_byte(0xFF,0x00);
+ status |= VL53L0X_write_byte(0x80,0x00);
/* Enable all check */
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
if (status == VL53L0X_ERROR_NONE) {
- status |= VL53L0X_set_limit_check_enable(dev, i, 1);
+ status |= VL53L0X_set_limit_check_enable(i,1);
} else {
break;
}
@@ -1590,59 +1460,51 @@
/* Disable the following checks */
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_set_limit_check_enable(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev,
- 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(dev, SequenceConfig, 0xFF);
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ _device->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(dev, PalState, VL53L0X_STATE_WAIT_STATICINIT);
+ _device->PalState = VL53L0X_STATE_WAIT_STATICINIT;
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 0);
+ _device->DeviceSpecificParameters.RefSpadsInitialised = 0;
}
@@ -1650,8 +1512,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_check_part_used(VL53L0X_DEV dev,
- uint8_t *revision,
+VL53L0X_Error VL53L0X::VL53L0X_check_part_used(uint8_t *revision,
VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -1660,19 +1521,18 @@
- status = VL53L0X_get_info_from_device(dev, 2);
+ status = VL53L0X_get_info_from_device(2);
if (status == VL53L0X_ERROR_NONE) {
- module_id_int = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, ModuleId);
+ module_id_int = _device->DeviceSpecificParameters.ModuleId;
if (module_id_int == 0) {
*revision = 0;
- strcpy(p_VL53L0X_device_info->ProductId, "");
+ strcpy(p_VL53L0X_device_info->ProductId,"");
} else {
- *revision = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, Revision);
- product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- ProductId);
- strcpy(p_VL53L0X_device_info->ProductId, product_id_tmp);
+ *revision = _device->DeviceSpecificParameters.Revision;
+ product_id_tmp = _device->DeviceSpecificParameters.ProductId;
+ strcpy(p_VL53L0X_device_info->ProductId,product_id_tmp);
}
}
@@ -1680,14 +1540,13 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_get_device_info(VL53L0X_DEV dev,
- VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
+VL53L0X_Error VL53L0X::VL53L0X_get_device_info(VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t revision_id;
uint8_t revision;
- status = VL53L0X_check_part_used(dev, &revision, p_VL53L0X_device_info);
+ status = VL53L0X_check_part_used(&revision,p_VL53L0X_device_info);
if (status == VL53L0X_ERROR_NONE) {
if (revision == 0) {
@@ -1704,19 +1563,16 @@
VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
}
- strcpy(p_VL53L0X_device_info->Type,
- VL53L0X_STRING_DEVICE_INFO_TYPE);
-
+ strcpy(p_VL53L0X_device_info->Type,VL53L0X_STRING_DEVICE_INFO_TYPE);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
+ status = VL53L0X_read_byte(VL53L0X_REG_IDENTIFICATION_MODEL_ID,
&p_VL53L0X_device_info->ProductType);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(dev,
- VL53L0X_REG_IDENTIFICATION_REVISION_ID,
+ status = VL53L0X_read_byte(VL53L0X_REG_IDENTIFICATION_REVISION_ID,
&revision_id);
p_VL53L0X_device_info->ProductRevisionMajor = 1;
p_VL53L0X_device_info->ProductRevisionMinor =
@@ -1726,24 +1582,13 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_info(VL53L0X_DEV dev,
- VL53L0X_DeviceInfo_t *p_VL53L0X_device_info)
-{
- VL53L0X_Error status = VL53L0X_ERROR_NONE;
-
- status = wrapped_VL53L0X_get_device_info(dev, p_VL53L0X_device_info);
-
- return status;
-}
-
-VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_mask_status(VL53L0X_DEV dev,
- 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;
- status = VL53L0X_read_byte(dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
+ status = VL53L0X_read_byte(VL53L0X_REG_RESULT_INTERRUPT_STATUS,&byte);
*p_interrupt_mask_status = byte & 0x07;
if (byte & 0x18) {
@@ -1754,8 +1599,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_measurement_data_ready(VL53L0X_DEV dev,
- 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;
@@ -1763,12 +1607,11 @@
uint32_t interrupt_mask;
- interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- Pin0GpioFunctionality);
+ interrupt_config = _device->DeviceSpecificParameters.Pin0GpioFunctionality;
if (interrupt_config ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
- status = VL53L0X_get_interrupt_mask_status(dev, &interrupt_mask);
+ status = VL53L0X_get_interrupt_mask_status(&interrupt_mask);
if (interrupt_mask ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
*p_measurement_data_ready = 1;
@@ -1776,7 +1619,7 @@
*p_measurement_data_ready = 0;
}
} else {
- status = VL53L0X_read_byte(dev, VL53L0X_REG_RESULT_RANGE_STATUS,
+ status = VL53L0X_read_byte(VL53L0X_REG_RESULT_RANGE_STATUS,
&sys_range_status_register);
if (status == VL53L0X_ERROR_NONE) {
if (sys_range_status_register & 0x01) {
@@ -1787,11 +1630,10 @@
}
}
-
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_polling_delay( VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_polling_delay()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -1799,7 +1641,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_measurement_poll_for_completion(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_measurement_poll_for_completion()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t new_data_ready = 0;
@@ -1807,13 +1649,13 @@
loop_nb = 0;
- status = VL53L0X_get_measurement_data_ready(dev, &new_data_ready);
-
- while ( (status==0) && (new_data_ready != 1) &&
+ status = VL53L0X_get_measurement_data_ready(&new_data_ready);
+
+ while ((status==0) && (new_data_ready != 1) &&
(loop_nb < VL53L0X_DEFAULT_MAX_LOOP) )
{
- VL53L0X_polling_delay(dev);
- status = VL53L0X_get_measurement_data_ready(dev, &new_data_ready);
+ VL53L0X_polling_delay();
+ status = VL53L0X_get_measurement_data_ready(&new_data_ready);
loop_nb++;
} // while ;
@@ -1823,22 +1665,19 @@
}
/* Group PAL Interrupt Functions */
-VL53L0X_Error VL53L0X::VL53L0X_clear_interrupt_mask(VL53L0X_DEV dev, uint32_t interrupt_mask)
+VL53L0X_Error VL53L0X::VL53L0X_clear_interrupt_mask(uint32_t interrupt_mask)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t loop_count;
uint8_t byte;
- /* clear bit 0 range interrupt, bit 1 error interrupt */
+ /* clear bit 0 range interrupt,bit 1 error interrupt */
loop_count = 0;
do {
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
- status |= VL53L0X_write_byte(dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
- status |= VL53L0X_read_byte(dev,
- VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR,0x01);
+ status |= VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR,0x00);
+ status |= VL53L0X_read_byte(VL53L0X_REG_RESULT_INTERRUPT_STATUS,&byte);
loop_count++;
} while (((byte & 0x07) != 0x00)
&& (loop_count < 3)
@@ -1853,72 +1692,70 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(VL53L0X_DEV dev,
- uint8_t vhv_init_byte)
+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(dev, VL53L0X_REG_SYSRANGE_START,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
VL53L0X_REG_SYSRANGE_MODE_START_STOP |
vhv_init_byte);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_measurement_poll_for_completion(dev);
+ status = VL53L0X_measurement_poll_for_completion();
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_clear_interrupt_mask(dev, 0);
+ status = VL53L0X_clear_interrupt_mask(0);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x00);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,0x00);
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_ref_calibration_io(VL53L0X_DEV dev, uint8_t read_not_write,
- 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 VL53L0X::VL53L0X_ref_calibration_io(uint8_t read_not_write,
+ 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;
uint8_t phase_calint = 0;
/* Read VHV from device */
- status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x00);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status |= VL53L0X_write_byte(0xFF,0x01);
+ status |= VL53L0X_write_byte(0x00,0x00);
+ status |= VL53L0X_write_byte(0xFF,0x00);
if (read_not_write) {
if (vhv_enable) {
- status |= VL53L0X_read_byte(dev, 0xCB, p_vhv_settings);
+ status |= VL53L0X_read_byte(0xCB,p_vhv_settings);
}
if (phase_enable) {
- status |= VL53L0X_read_byte(dev, 0xEE, &phase_calint);
+ status |= VL53L0X_read_byte(0xEE,&phase_calint);
}
} else {
if (vhv_enable) {
- status |= VL53L0X_write_byte(dev, 0xCB, vhv_settings);
+ status |= VL53L0X_write_byte(0xCB,vhv_settings);
}
if (phase_enable) {
- status |= VL53L0X_update_byte(dev, 0xEE, 0x80, phase_cal);
+ status |= VL53L0X_update_byte(0xEE,0x80,phase_cal);
}
}
- status |= VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x01);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status |= VL53L0X_write_byte(0xFF,0x01);
+ status |= VL53L0X_write_byte(0x00,0x01);
+ status |= VL53L0X_write_byte(0xFF,0x00);
*p_phase_cal = (uint8_t)(phase_calint & 0xEF);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(VL53L0X_DEV dev,
- 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;
@@ -1930,24 +1767,21 @@
/* store the value of the sequence config,
* this will be reset before the end of the function
*/
-
- if (restore_config) {
- sequence_config = PALDevDataGet(dev, SequenceConfig);
- }
+ if (restore_config) {sequence_config = _device->SequenceConfig;}
/* Run VHV */
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_single_ref_calibration(dev, 0x40);
+ status = VL53L0X_perform_single_ref_calibration(0x40);
}
/* Read VHV from device */
if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
- status = VL53L0X_ref_calibration_io(dev, 1,
- vhv_settings, phase_cal, /* Not used here */
- p_vhv_settings, &phase_cal_int,
- 1, 0);
+ status = VL53L0X_ref_calibration_io(1,
+ vhv_settings,phase_cal,/* Not used here */
+ p_vhv_settings,&phase_cal_int,
+ 1,0);
} else {
*p_vhv_settings = 0;
}
@@ -1955,10 +1789,10 @@
if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, sequence_config);
+ _device->SequenceConfig = sequence_config;
}
}
@@ -1966,8 +1800,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(VL53L0X_DEV dev,
- 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;
@@ -1981,22 +1814,22 @@
*/
if (restore_config) {
- sequence_config = PALDevDataGet(dev, SequenceConfig);
+ sequence_config = _device-> SequenceConfig;
}
/* Run PhaseCal */
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,0x02);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_single_ref_calibration(dev, 0x0);
+ status = VL53L0X_perform_single_ref_calibration(0x0);
}
/* Read PhaseCal from device */
if ((status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
- status = VL53L0X_ref_calibration_io(dev, 1,
- vhv_settings, phase_cal, /* Not used here */
- &vhv_settingsint, p_phase_cal,
- 0, 1);
+ status = VL53L0X_ref_calibration_io(1,
+ vhv_settings,phase_cal,/* Not used here */
+ &vhv_settingsint,p_phase_cal,
+ 0,1);
} else {
*p_phase_cal = 0;
}
@@ -2004,10 +1837,10 @@
if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, sequence_config);
+ _device->SequenceConfig = sequence_config;
}
}
@@ -2015,8 +1848,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(VL53L0X_DEV dev,
- uint8_t *p_vhv_settings, uint8_t *p_phase_cal, uint8_t get_data_enable)
+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;
@@ -2025,25 +1857,23 @@
* this will be reset before the end of the function
*/
- sequence_config = PALDevDataGet(dev, SequenceConfig);
+ sequence_config = _device-> SequenceConfig;
/* In the following function we don't save the config to optimize
* writes on device. Config is saved and restored only once. */
- status = VL53L0X_perform_vhv_calibration(
- dev, p_vhv_settings, get_data_enable, 0);
+ status = VL53L0X_perform_vhv_calibration(p_vhv_settings,get_data_enable,0);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_phase_calibration(
- dev, p_phase_cal, get_data_enable, 0);
+ 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(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, sequence_config);
+ _device->SequenceConfig = sequence_config;
}
}
@@ -2051,8 +1881,8 @@
return status;
}
-void VL53L0X::get_next_good_spad(uint8_t good_spad_array[], uint32_t size,
- uint32_t curr, int32_t *p_next)
+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 fine_offset;
@@ -2063,7 +1893,7 @@
uint8_t success = 0;
/*
- * Starting with the current good spad, loop through the array to find
+ * Starting with the current good spad,loop through the array to find
* the next. i.e. the next bit set in the sequence.
*
* The coarse index is the byte index of the array and the fine index is
@@ -2115,7 +1945,7 @@
return is_aperture;
}
-VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spad_array[], uint32_t size,
+VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spad_array[],uint32_t size,
uint32_t spad_index)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -2134,31 +1964,28 @@
return status;
}
-VL53L0X_Error VL53L0X::set_ref_spad_map(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
+VL53L0X_Error VL53L0X::set_ref_spad_map(uint8_t *p_ref_spad_array)
{
- VL53L0X_Error status = VL53L0X_write_multi(dev,
- VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
- p_ref_spad_array, 6);
+ 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(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
+VL53L0X_Error VL53L0X::get_ref_spad_map(uint8_t *p_ref_spad_array)
{
- VL53L0X_Error status = VL53L0X_read_multi(dev,
- 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;
// uint8_t count=0;
// for (count = 0; count < 6; count++)
-// status = VL53L0X_RdByte(Dev, (VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 + count), &refSpadArray[count]);
+// status = VL53L0X_RdByte((VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 + count),&refSpadArray[count]);
return status;
}
-VL53L0X_Error VL53L0X::enable_ref_spads(VL53L0X_DEV dev,
- 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,
@@ -2186,7 +2013,7 @@
current_spad = offset;
for (index = 0; index < spad_count; index++) {
- get_next_good_spad(good_spad_array, size, current_spad,
+ get_next_good_spad(good_spad_array,size,current_spad,
&next_good_spad);
if (next_good_spad == -1) {
@@ -2203,18 +2030,18 @@
break;
}
current_spad = (uint32_t)next_good_spad;
- enable_spad_bit(spad_array, size, current_spad);
+ enable_spad_bit(spad_array,size,current_spad);
current_spad++;
}
*p_last_spad = current_spad;
if (status == VL53L0X_ERROR_NONE) {
- status = set_ref_spad_map(dev, spad_array);
+ status = set_ref_spad_map(spad_array);
}
if (status == VL53L0X_ERROR_NONE) {
- status = get_ref_spad_map(dev, check_spad_array);
+ status = get_ref_spad_map(check_spad_array);
i = 0;
@@ -2230,7 +2057,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_device_mode(VL53L0X_DEV dev, VL53L0X_DeviceModes device_mode)
+VL53L0X_Error VL53L0X::VL53L0X_set_device_mode(VL53L0X_DeviceModes device_mode)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -2241,7 +2068,7 @@
case VL53L0X_DEVICEMODE_GPIO_DRIVE:
case VL53L0X_DEVICEMODE_GPIO_OSC:
/* Supported modes */
- VL53L0X_SETPARAMETERFIELD(dev, DeviceMode, device_mode);
+ _device->CurrentParameters.DeviceMode = device_mode;
break;
default:
/* Unsupported mode */
@@ -2252,8 +2079,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_interrupt_thresholds(VL53L0X_DEV dev,
- 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;
@@ -2263,12 +2089,12 @@
/* no dependency on DeviceMode for FlightSense */
/* Need to divide by 2 because the FW will apply a x2 */
threshold16 = (uint16_t)((threshold_low >> 17) & 0x00fff);
- status = VL53L0X_write_word(dev, VL53L0X_REG_SYSTEM_THRESH_LOW, threshold16);
+ status = VL53L0X_write_word(VL53L0X_REG_SYSTEM_THRESH_LOW,threshold16);
if (status == VL53L0X_ERROR_NONE) {
/* Need to divide by 2 because the FW will apply a x2 */
threshold16 = (uint16_t)((threshold_high >> 17) & 0x00fff);
- status = VL53L0X_write_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+ status = VL53L0X_write_word(VL53L0X_REG_SYSTEM_THRESH_HIGH,
threshold16);
}
@@ -2276,8 +2102,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_interrupt_thresholds(VL53L0X_DEV dev,
- 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;
@@ -2286,12 +2111,12 @@
/* no dependency on DeviceMode for FlightSense */
- status = VL53L0X_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &threshold16);
+ status = VL53L0X_read_word(VL53L0X_REG_SYSTEM_THRESH_LOW,&threshold16);
/* Need to multiply by 2 because the FW will apply a x2 */
*p_threshold_low = (FixPoint1616_t)((0x00fff & threshold16) << 17);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+ status = VL53L0X_read_word(VL53L0X_REG_SYSTEM_THRESH_HIGH,
&threshold16);
/* Need to multiply by 2 because the FW will apply a x2 */
*p_threshold_high =
@@ -2302,8 +2127,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(VL53L0X_DEV dev,
- uint8_t *p_tuning_setting_buffer)
+VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(uint8_t *p_tuning_setting_buffer)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
@@ -2334,33 +2158,32 @@
index++;
lsb = *(p_tuning_setting_buffer + index);
index++;
- temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(dev, SigmaEstRefArray, temp16);
+ temp16 = VL53L0X_MAKEUINT16(lsb,msb);
+ _device->SigmaEstRefArray = temp16;
break;
case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
index++;
lsb = *(p_tuning_setting_buffer + index);
index++;
- temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(dev, SigmaEstEffPulseWidth,
- temp16);
+ temp16 = VL53L0X_MAKEUINT16(lsb,msb);
+ _device->SigmaEstEffPulseWidth = temp16;
break;
case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
index++;
lsb = *(p_tuning_setting_buffer + index);
index++;
- temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(dev, SigmaEstEffAmbWidth, temp16);
+ temp16 = VL53L0X_MAKEUINT16(lsb,msb);
+ _device->SigmaEstEffAmbWidth = temp16;
break;
case 3: /* uint16_t targetRefRate -> 2 bytes */
msb = *(p_tuning_setting_buffer + index);
index++;
lsb = *(p_tuning_setting_buffer + index);
index++;
- temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(dev, targetRefRate, temp16);
+ temp16 = VL53L0X_MAKEUINT16(lsb,msb);
+ _device->targetRefRate = temp16;
break;
default: /* invalid parameter */
status = VL53L0X_ERROR_INVALID_PARAMS;
@@ -2376,7 +2199,7 @@
index++;
}
- status = VL53L0X_write_multi(dev, address, local_buffer,
+ status = VL53L0X_write_multi(address,local_buffer,
number_of_writes);
} else {
@@ -2388,16 +2211,14 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_check_and_load_interrupt_settings(VL53L0X_DEV dev,
- uint8_t start_not_stopflag)
+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(dev,
- Pin0GpioFunctionality);
+ interrupt_config = _device->DeviceSpecificParameters.Pin0GpioFunctionality;
if ((interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
@@ -2406,22 +2227,20 @@
(interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
- status = VL53L0X_get_interrupt_thresholds(dev,
- VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
- &threshold_low, &threshold_high);
+ status = VL53L0X_get_interrupt_thresholds(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ &threshold_low,&threshold_high);
if (((threshold_low > 255 * 65536) ||
(threshold_high > 255 * 65536)) &&
(status == VL53L0X_ERROR_NONE)) {
if (start_not_stopflag != 0) {
- status = VL53L0X_load_tuning_settings(dev,
- InterruptThresholdSettings);
+ status = VL53L0X_load_tuning_settings(InterruptThresholdSettings);
} else {
- status |= VL53L0X_write_byte(dev, 0xFF, 0x04);
- status |= VL53L0X_write_byte(dev, 0x70, 0x00);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
- status |= VL53L0X_write_byte(dev, 0x80, 0x00);
+ status |= VL53L0X_write_byte(0xFF,0x04);
+ status |= VL53L0X_write_byte(0x70,0x00);
+ status |= VL53L0X_write_byte(0xFF,0x00);
+ status |= VL53L0X_write_byte(0x80,0x00);
}
}
@@ -2433,7 +2252,7 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_start_measurement(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_start_measurement()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
@@ -2443,19 +2262,19 @@
/* Get Current DeviceMode */
- VL53L0X_get_device_mode(dev, &device_mode);
-
- status = VL53L0X_write_byte(dev, 0x80, 0x01);
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
- status = VL53L0X_write_byte(dev, 0x00, 0x00);
- status = VL53L0X_write_byte(dev, 0x91, PALDevDataGet(dev, StopVariable));
- status = VL53L0X_write_byte(dev, 0x00, 0x01);
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
- status = VL53L0X_write_byte(dev, 0x80, 0x00);
+ VL53L0X_get_device_mode(&device_mode);
+
+ status = VL53L0X_write_byte(0x80,0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
+ status = VL53L0X_write_byte(0x00,0x00);
+ status = VL53L0X_write_byte(0x91,_device-> StopVariable);
+ status = VL53L0X_write_byte(0x00,0x01);
+ status = VL53L0X_write_byte(0xFF,0x00);
+ status = VL53L0X_write_byte(0x80,0x00);
switch (device_mode) {
case VL53L0X_DEVICEMODE_SINGLE_RANGING:
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x01);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,0x01);
byte = start_stop_byte;
if (status == VL53L0X_ERROR_NONE) {
@@ -2463,8 +2282,7 @@
loop_nb = 0;
do {
if (loop_nb > 0)
- status = VL53L0X_read_byte(dev,
- 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)
@@ -2482,31 +2300,29 @@
/* Check if need to apply interrupt settings */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_check_and_load_interrupt_settings(dev, 1);
+ status = VL53L0X_check_and_load_interrupt_settings(1);
}
- status = VL53L0X_write_byte(dev,
- 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(dev, PalState, VL53L0X_STATE_RUNNING);
+ _device->PalState = VL53L0X_STATE_RUNNING;
}
break;
case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
/* Continuous mode */
/* Check if need to apply interrupt settings */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_check_and_load_interrupt_settings(dev, 1);
+ status = VL53L0X_check_and_load_interrupt_settings(1);
}
- status = VL53L0X_write_byte(dev,
- 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(dev, PalState, VL53L0X_STATE_RUNNING);
+ _device->PalState = VL53L0X_STATE_RUNNING;
}
break;
default:
@@ -2520,7 +2336,7 @@
}
/* Group PAL Measurement Functions */
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_measurement(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_perform_single_measurement()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
@@ -2528,25 +2344,25 @@
/* Get Current DeviceMode */
- status = VL53L0X_get_device_mode(dev, &device_mode);
+ status = VL53L0X_get_device_mode(&device_mode);
/* Start immediately to run a single ranging measurement in case of
* single ranging or single histogram */
if (status == VL53L0X_ERROR_NONE
&& device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING) {
- status = VL53L0X_start_measurement(dev);
+ status = VL53L0X_start_measurement();
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_measurement_poll_for_completion(dev);
+ 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(dev, PalState, VL53L0X_STATE_IDLE);
+ _device->PalState = VL53L0X_STATE_IDLE;
}
@@ -2554,22 +2370,20 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_x_talk_compensation_enable(VL53L0X_DEV dev,
- 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(dev, XTalkCompensationEnable, temp8);
+ temp8 = _device->CurrentParameters.XTalkCompensationEnable;
*p_x_talk_compensation_enable = temp8;
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(VL53L0X_DEV dev,
- 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;
@@ -2580,15 +2394,12 @@
*p_total_xtalk_rate_mcps = 0;
- status = VL53L0X_get_x_talk_compensation_enable(dev, &xtalk_comp_enable);
+ status = VL53L0X_get_x_talk_compensation_enable(&xtalk_comp_enable);
if (status == VL53L0X_ERROR_NONE) {
if (xtalk_comp_enable) {
- VL53L0X_GETPARAMETERFIELD(
- dev,
- XTalkCompensationRateMegaCps,
- xtalk_per_spad_mega_cps);
+ xtalk_per_spad_mega_cps = _device->CurrentParameters.XTalkCompensationRateMegaCps;
/* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
total_xtalk_mega_cps =
@@ -2604,8 +2415,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(VL53L0X_DEV dev,
- 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;
@@ -2616,8 +2426,7 @@
*p_total_signal_rate_mcps =
p_ranging_measurement_data->SignalRateRtnMegaCps;
- status = VL53L0X_get_total_xtalk_rate(
- dev, p_ranging_measurement_data, &total_xtalk_mega_cps);
+ status = VL53L0X_get_total_xtalk_rate(p_ranging_measurement_data,&total_xtalk_mega_cps);
if (status == VL53L0X_ERROR_NONE) {
*p_total_signal_rate_mcps += total_xtalk_mega_cps;
@@ -2627,15 +2436,14 @@
}
/* To convert ms into register value */
-uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(VL53L0X_DEV dev,
- 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_ns;
uint32_t timeout_period_mclks = 0;
- macro_period_ps = VL53L0X_calc_macro_period_ps(dev, vcsel_period_pclks);
+ macro_period_ps = VL53L0X_calc_macro_period_ps(vcsel_period_pclks);
macro_period_ns = (macro_period_ps + 500) / 1000;
timeout_period_mclks =
@@ -2656,7 +2464,7 @@
uint32_t res = 0;
uint32_t bit = 1 << 30;
/* The second-to-top bit is set:
- * 1 << 14 for 16-bits, 1 << 30 for 32 bits */
+ * 1 << 14 for 16-bits,1 << 30 for 32 bits */
/* "bit" starts at the highest power of four <= the argument. */
while (bit > num) {
@@ -2678,9 +2486,7 @@
return res;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(
- VL53L0X_DEV dev,
- 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,
@@ -2715,10 +2521,10 @@
dmax_cal_range_mm =
- PALDevDataGet(dev, DmaxCalRangeMilliMeter);
+ _device-> DmaxCalRangeMilliMeter;
dmax_cal_signal_rate_rtn_mcps =
- PALDevDataGet(dev, DmaxCalSignalRateRtnMegaCps);
+ _device-> DmaxCalSignalRateRtnMegaCps;
/* uint32 * FixPoint1616 = FixPoint1616 */
signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_mcps;
@@ -2774,7 +2580,7 @@
min_signal_needed_p3 = 0xfff00000;
} else {
- /* DMAX uses a different ambient width from sigma, so apply
+ /* DMAX uses a different ambient width from sigma,so apply
* correction.
* Perform division before multiplication to prevent overflow.
*/
@@ -2872,14 +2678,13 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(VL53L0X_DEV dev,
- 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 */
+ /* Expressed in 100ths of a ns,i.e. centi-ns */
const uint32_t c_ambient_effective_width_centi_ns = 600;
const FixPoint1616_t c_dflt_final_range_integration_time_milli_secs = 0x00190000; /* 25ms */
const uint32_t c_vcsel_pulse_width_ps = 4700; /* pico secs */
@@ -2934,8 +2739,7 @@
- VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps,
- x_talk_comp_rate_mcps);
+ x_talk_comp_rate_mcps = _device->CurrentParameters.XTalkCompensationRateMegaCps;
/*
* We work in kcps rather than mcps as this helps keep within the
@@ -2949,14 +2753,12 @@
p_ranging_measurement_data->SignalRateRtnMegaCps;
- status = VL53L0X_get_total_signal_rate(
- dev, p_ranging_measurement_data, &total_signal_rate_mcps);
- status = VL53L0X_get_total_xtalk_rate(
- dev, p_ranging_measurement_data, &x_talk_comp_rate_mcps);
+ 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.
+ * peak signal rate,not average.
*/
peak_signal_rate_kcps = (total_signal_rate_mcps * 1000);
peak_signal_rate_kcps = (peak_signal_rate_kcps + 0x8000) >> 16;
@@ -2970,24 +2772,18 @@
if (status == VL53L0X_ERROR_NONE) {
/* Calculate final range macro periods */
- final_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER(
- dev, FinalRangeTimeoutMicroSecs);
-
- final_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
- dev, FinalRangeVcselPulsePeriod);
-
- final_range_macro_pclks = VL53L0X_calc_timeout_mclks(
- dev, final_range_timeout_micro_secs, final_range_vcsel_pclks);
+ final_range_timeout_micro_secs = _device->DeviceSpecificParameters.FinalRangeTimeoutMicroSecs;
+
+ final_range_vcsel_pclks = _device->DeviceSpecificParameters.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(
- dev, PreRangeTimeoutMicroSecs);
-
- pre_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
- dev, PreRangeVcselPulsePeriod);
-
- pre_range_macro_pclks = VL53L0X_calc_timeout_mclks(
- dev, pre_range_timeout_micro_secs, pre_range_vcsel_pclks);
+ pre_range_timeout_micro_secs = _device->DeviceSpecificParameters.PreRangeTimeoutMicroSecs;
+
+ pre_range_vcsel_pclks = _device->DeviceSpecificParameters.PreRangeVcselPulsePeriod;
+
+ pre_range_macro_pclks = VL53L0X_calc_timeout_mclks(pre_range_timeout_micro_secs,pre_range_vcsel_pclks);
vcsel_width = 3;
if (final_range_vcsel_pclks == 8) {
@@ -3022,7 +2818,7 @@
if (peak_signal_rate_kcps == 0) {
*p_sigma_estimate = c_sigma_est_max;
- PALDevDataSet(dev, SigmaEstimate, c_sigma_est_max);
+ _device->SigmaEstimate = c_sigma_est_max;
*p_dmax_mm = 0;
} else {
if (vcsel_total_events_rtn < 1) {
@@ -3065,7 +2861,7 @@
/* FixPoint0824/FixPoint1616 = FixPoint2408 */
// xTalkCorrection = abs(diff1_mcps/diff2_mcps);
-// abs is causing compiler overloading isue in C++, but unsigned types. So, redundant call anyway!
+// abs is causing compiler overloading isue in C++,but unsigned types. So,redundant call anyway!
x_talk_correction = diff1_mcps / diff2_mcps;
/* FixPoint2408 << 8 = FixPoint1616 */
@@ -3078,7 +2874,7 @@
pw_mult = delta_t_ps / c_vcsel_pulse_width_ps; /* smaller than 1.0f */
/*
- * FixPoint1616 * FixPoint1616 = FixPoint3232, however both
+ * FixPoint1616 * FixPoint1616 = FixPoint3232,however both
* values are small enough such that32 bits will not be
* exceeded.
*/
@@ -3091,7 +2887,7 @@
pw_mult += (1 << 16);
/*
- * At this point the value will be 1.xx, therefore if we square
+ * At this point the value will be 1.xx,therefore if we square
* the value this will exceed 32 bits. To address this perform
* a single shift to the right before the multiplication.
*/
@@ -3171,7 +2967,7 @@
sqrt_result = VL53L0X_isqrt((sqr1 + sqr2));
/*
* Note that the Shift by 4 bits increases resolution prior to
- * the sqrt, therefore the result must be shifted by 2 bits to
+ * the sqrt,therefore the result must be shifted by 2 bits to
* the right to revert back to the FixPoint1616 format.
*/
@@ -3183,10 +2979,8 @@
}
*p_sigma_estimate = (uint32_t)(sigma_estimate);
- PALDevDataSet(dev, SigmaEstimate, *p_sigma_estimate);
- status = VL53L0X_calc_dmax(
- dev,
- total_signal_rate_mcps,
+ _device->SigmaEstimate = *p_sigma_estimate;
+ status = VL53L0X_calc_dmax(total_signal_rate_mcps,
corrected_signal_rate_mcps,
pw_mult,
sigma_estimate_p1,
@@ -3199,8 +2993,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(VL53L0X_DEV dev,
- 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,
@@ -3233,13 +3026,13 @@
* VL53L0X has a good ranging when the value of the
* DeviceRangeStatus = 11. This function will replace the value 0 with
* the value 11 in the DeviceRangeStatus.
- * In addition, the SigmaEstimator is not included in the VL53L0X
- * DeviceRangeStatus, this will be added in the PalRangeStatus.
+ * In addition,the SigmaEstimator is not included in the VL53L0X
+ * DeviceRangeStatus,this will be added in the PalRangeStatus.
*/
device_range_status_internal = ((device_range_status & 0x78) >> 3);
- if (device_range_status_internal == 0 ||
+ if ( device_range_status_internal == 0 ||
device_range_status_internal == 5 ||
device_range_status_internal == 7 ||
device_range_status_internal == 12 ||
@@ -3253,12 +3046,11 @@
}
/*
- * Check if Sigma limit is enabled, if yes then do comparison with limit
+ * Check if Sigma limit is enabled,if yes then do comparison with limit
* value and put the result back into pPalRangeStatus.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
&sigma_limit_check_enable);
}
@@ -3266,9 +3058,7 @@
/*
* compute the Sigma and check with limit
*/
- status = VL53L0X_calc_sigma_estimate(
- dev,
- p_ranging_measurement_data,
+ status = VL53L0X_calc_sigma_estimate(p_ranging_measurement_data,
&sigma_estimate,
&dmax_mm);
if (status == VL53L0X_ERROR_NONE) {
@@ -3276,8 +3066,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_value(dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
&sigma_limit_value);
if ((sigma_limit_value > 0) &&
@@ -3289,39 +3078,36 @@
}
/*
- * Check if Signal ref clip limit is enabled, if yes then do comparison
+ * Check if Signal ref clip limit is enabled,if yes then do comparison
* with limit value and put the result back into pPalRangeStatus.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(dev,
- 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(dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ status = VL53L0X_get_limit_check_value(VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
&signal_ref_clip_value);
/* Read LastSignalRefMcps from device */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(dev,
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
&tmp_word);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x00);
}
last_signal_ref_mcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmp_word);
- PALDevDataSet(dev, LastSignalRefMcps, last_signal_ref_mcps);
+ _device->LastSignalRefMcps = last_signal_ref_mcps;
if ((signal_ref_clip_value > 0) &&
(last_signal_ref_mcps > signal_ref_clip_value)) {
@@ -3331,14 +3117,13 @@
}
/*
- * Check if Signal ref clip limit is enabled, if yes then do comparison
+ * Check if Signal ref clip limit is enabled,if yes then do comparison
* with limit value and put the result back into pPalRangeStatus.
* EffectiveSpadRtnCount has a format 8.8
* If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ status = VL53L0X_get_limit_check_enable(VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
&range_ignore_threshold_limit_check_enable);
}
@@ -3353,8 +3138,7 @@
/ effective_spad_rtn_count);
}
- status = VL53L0X_get_limit_check_value(dev,
- 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) &&
@@ -3395,8 +3179,7 @@
/* fill the Limit Check Status */
- status = VL53L0X_get_limit_check_enable(dev,
- 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) {
@@ -3405,8 +3188,7 @@
} else {
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp8);
+ _device->CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = temp8;
if ((device_range_status_internal == 4) ||
(signal_rate_final_range_limit_check_enable == 0)) {
@@ -3414,9 +3196,7 @@
} else {
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- temp8);
+ _device->CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE] = temp8;
if ((signal_ref_clip_limit_check_enable == 0) ||
(signal_ref_clipflag == 1)) {
@@ -3425,8 +3205,7 @@
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp8);
+ _device->CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = temp8;
if ((range_ignore_threshold_limit_check_enable == 0) ||
(range_ignore_thresholdflag == 1)) {
@@ -3435,9 +3214,7 @@
temp8 = 0;
}
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- temp8);
+ _device->CurrentParameters.LimitChecksStatus[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = temp8;
}
@@ -3445,8 +3222,7 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_get_ranging_measurement_data(VL53L0X_DEV dev,
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
+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;
@@ -3466,31 +3242,30 @@
/*
- * use multi read even if some registers are not useful, result will
+ * use multi read even if some registers are not useful,result will
* be more efficient
* start reading at 0x14 dec20
* end reading at 0x21 dec33 total 14 bytes to read
*/
- status = VL53L0X_read_multi(dev, 0x14, localBuffer, 12);
+ status = VL53L0X_read_multi(0x14,localBuffer,12);
if (status == VL53L0X_ERROR_NONE) {
p_ranging_measurement_data->ZoneId = 0; /* Only one zone */
p_ranging_measurement_data->TimeStamp = 0; /* Not Implemented */
- tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11], localBuffer[10]);
+ tmpuint16 = VL53L0X_MAKEUINT16(localBuffer[11],localBuffer[10]);
/* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
*(format 11.2) else no fractional
*/
p_ranging_measurement_data->MeasurementTimeUsec = 0;
- 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;
- ambient_rate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
+ ambient_rate = VL53L0X_MAKEUINT16(localBuffer[9],localBuffer[8]);
p_ranging_measurement_data->AmbientRateRtnMegaCps =
VL53L0X_FIXPOINT97TOFIXPOINT1616(ambient_rate);
@@ -3503,12 +3278,12 @@
device_range_status = localBuffer[0];
/* Get Linearity Corrective Gain */
- linearity_corrective_gain = PALDevDataGet(dev,
- LinearityCorrectiveGain);
+ linearity_corrective_gain = _device->
+ LinearityCorrectiveGain;
/* Get ranging configuration */
- range_fractional_enable = PALDevDataGet(dev,
- RangeFractionalEnable);
+ range_fractional_enable = _device->
+ RangeFractionalEnable;
if (linearity_corrective_gain != 1000) {
@@ -3516,11 +3291,8 @@
* tmpuint16 + 500) / 1000);
/* Implement Xtalk */
- VL53L0X_GETPARAMETERFIELD(dev,
- XTalkCompensationRateMegaCps,
- x_talk_compensation_rate_mega_cps);
- VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationEnable,
- x_talk_compensation_enable);
+ x_talk_compensation_rate_mega_cps = _device->CurrentParameters.XTalkCompensationRateMegaCps;
+ x_talk_compensation_enable = _device->CurrentParameters.XTalkCompensationEnable;
if (x_talk_compensation_enable) {
@@ -3558,14 +3330,14 @@
}
/*
- * For a standard definition of RangeStatus, this should
+ * For a standard definition of RangeStatus,this should
* return 0 in case of good result after a ranging
* The range status depends on the device so call a device
* specific function to obtain the right Status.
*/
- status |= VL53L0X_get_pal_range_status(dev, device_range_status,
- signal_rate, effective_spad_rtn_count,
- p_ranging_measurement_data, &pal_range_status);
+ status |= VL53L0X_get_pal_range_status(device_range_status,
+ signal_rate,effective_spad_rtn_count,
+ p_ranging_measurement_data,&pal_range_status);
if (status == VL53L0X_ERROR_NONE) {
p_ranging_measurement_data->RangeStatus = pal_range_status;
@@ -3575,7 +3347,7 @@
if (status == VL53L0X_ERROR_NONE) {
/* Copy last read data into Dev buffer */
- last_range_data_buffer = PALDevDataGet(dev, LastRangeMeasure);
+ last_range_data_buffer = _device-> LastRangeMeasure;
last_range_data_buffer.RangeMilliMeter =
p_ranging_measurement_data->RangeMilliMeter;
@@ -3594,15 +3366,14 @@
last_range_data_buffer.RangeStatus =
p_ranging_measurement_data->RangeStatus;
- PALDevDataSet(dev, LastRangeMeasure, last_range_data_buffer);
+ _device->LastRangeMeasure = last_range_data_buffer;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(VL53L0X_DEV dev,
- VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
+VL53L0X_Error VL53L0X::VL53L0X_perform_single_ranging_measurement(VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -3610,27 +3381,25 @@
/* This function will do a complete single ranging
* Here we fix the mode! */
- status = VL53L0X_set_device_mode(dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
+ status = VL53L0X_set_device_mode(VL53L0X_DEVICEMODE_SINGLE_RANGING);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_single_measurement(dev);
+ status = VL53L0X_perform_single_measurement();
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_ranging_measurement_data(dev,
- p_ranging_measurement_data);
+ status = VL53L0X_get_ranging_measurement_data(p_ranging_measurement_data);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_clear_interrupt_mask(dev, 0);
+ status = VL53L0X_clear_interrupt_mask(0);
}
return status;
}
-VL53L0X_Error VL53L0X::perform_ref_signal_measurement(VL53L0X_DEV dev,
- uint16_t *p_ref_signal_rate)
+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;
@@ -3641,49 +3410,45 @@
* this will be reset before the end of the function
*/
- sequence_config = PALDevDataGet(dev, SequenceConfig);
+ sequence_config = _device-> SequenceConfig;
/*
* This function performs a reference signal rate measurement.
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- &ranging_measurement_data);
+ status = VL53L0X_perform_single_ranging_measurement(&ranging_measurement_data);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_word(dev,
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ status = VL53L0X_read_word(VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
p_ref_signal_rate);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x00);
}
if (status == VL53L0X_ERROR_NONE) {
/* restore the previous Sequence Config */
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, sequence_config);
+ _device->SequenceConfig = sequence_config;
}
}
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_perform_ref_spad_management(VL53L0X_DEV dev,
- 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;
@@ -3713,22 +3478,22 @@
* signal rate and should be performed once during initialization.
*
* Either aperture or non-aperture spads are applied but never both.
- * Firstly non-aperture spads are set, begining with 5 spads, and
+ * Firstly non-aperture spads are set,begining with 5 spads,and
* increased one spad at a time until the closest measurement to the
* target rate is achieved.
*
* If the target rate is exceeded when 5 non-aperture spads are enabled,
* initialization is performed instead with aperture spads.
*
- * When setting spads, a 'Good Spad Map' is applied.
+ * When setting spads,a 'Good Spad Map' is applied.
*
* This procedure operates within a SPAD window of interest of a maximum
* 44 spads.
- * The start point is currently fixed to 180, which lies towards the end
+ * The start point is currently fixed to 180,which lies towards the end
* of the non-aperture quadrant and runs in to the adjacent aperture
* quadrant.
*/
- target_ref_rate = PALDevDataGet(dev, targetRefRate);
+ target_ref_rate = _device-> targetRefRate;
/*
* Initialize Spad arrays.
@@ -3739,41 +3504,37 @@
* represent spads.
*/
for (index = 0; index < spad_array_size; index++) {
- dev->SpadData.RefSpadEnables[index] = 0;
- }
-
-
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
+ _device->SpadData.RefSpadEnables[index] = 0;
+ }
+
+
+ status = VL53L0X_write_byte(0xFF,0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x00);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
+ status = VL53L0X_write_byte(VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE,0);
}
/* Perform ref calibration */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_perform_ref_calibration(dev, &vhv_settings,
- &phase_cal, 0);
+ status = VL53L0X_perform_ref_calibration(&vhv_settings,
+ &phase_cal,0);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -3781,10 +3542,9 @@
current_spad_index = 0;
last_spad_index = current_spad_index;
need_apt_spads = 0;
- status = enable_ref_spads(dev,
- need_apt_spads,
- dev->SpadData.RefGoodSpadMap,
- dev->SpadData.RefSpadEnables,
+ status = enable_ref_spads(need_apt_spads,
+ _device->SpadData.RefGoodSpadMap,
+ _device->SpadData.RefSpadEnables,
spad_array_size,
start_select,
current_spad_index,
@@ -3795,15 +3555,14 @@
if (status == VL53L0X_ERROR_NONE) {
current_spad_index = last_spad_index;
- status = perform_ref_signal_measurement(dev,
- &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,
* switch to APERTURE SPADs */
for (index = 0; index < spad_array_size; index++) {
- dev->SpadData.RefSpadEnables[index] = 0;
+ _device->SpadData.RefSpadEnables[index] = 0;
}
@@ -3815,10 +3574,9 @@
need_apt_spads = 1;
- status = enable_ref_spads(dev,
- need_apt_spads,
- dev->SpadData.RefGoodSpadMap,
- dev->SpadData.RefSpadEnables,
+ status = enable_ref_spads(need_apt_spads,
+ _device->SpadData.RefGoodSpadMap,
+ _device->SpadData.RefSpadEnables,
spad_array_size,
start_select,
current_spad_index,
@@ -3827,8 +3585,7 @@
if (status == VL53L0X_ERROR_NONE) {
current_spad_index = last_spad_index;
- status = perform_ref_signal_measurement(dev,
- &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)) {
@@ -3849,7 +3606,7 @@
if ((status == VL53L0X_ERROR_NONE) &&
(peak_signal_rate_ref < target_ref_rate)) {
- /* At this point, the minimum number of either aperture
+ /* At this point,the minimum number of either aperture
* or non-aperture spads have been set. Proceed to add
* spads and perform measurements until the target
* reference is reached.
@@ -3857,16 +3614,15 @@
is_aperture_spads_int = need_apt_spads;
ref_spad_count_int = minimum_spad_count;
- memcpy(last_spad_array, dev->SpadData.RefSpadEnables,
+ memcpy(last_spad_array,_device->SpadData.RefSpadEnables,
spad_array_size);
last_signal_rate_diff = abs(peak_signal_rate_ref -
target_ref_rate);
complete = 0;
while (!complete) {
- get_next_good_spad(
- dev->SpadData.RefGoodSpadMap,
- spad_array_size, current_spad_index,
+ get_next_good_spad(_device->SpadData.RefGoodSpadMap,
+ spad_array_size,current_spad_index,
&next_good_spad);
if (next_good_spad == -1) {
@@ -3874,7 +3630,7 @@
break;
}
- /* Cannot combine Aperture and Non-Aperture spads, so
+ /* Cannot combine Aperture and Non-Aperture spads,so
* ensure the current spad is of the correct type.
*/
if (is_aperture((uint32_t)start_select + next_good_spad) !=
@@ -3889,24 +3645,21 @@
(ref_spad_count_int)++;
current_spad_index = next_good_spad;
- status = enable_spad_bit(
- dev->SpadData.RefSpadEnables,
- spad_array_size, current_spad_index);
+ status = enable_spad_bit(_device->SpadData.RefSpadEnables,
+ spad_array_size,current_spad_index);
if (status == VL53L0X_ERROR_NONE) {
current_spad_index++;
/* Proceed to apply the additional spad and
* perform measurement. */
- status = set_ref_spad_map(dev,
- dev->SpadData.RefSpadEnables);
+ status = set_ref_spad_map(_device->SpadData.RefSpadEnables);
}
if (status != VL53L0X_ERROR_NONE) {
break;
}
- status = perform_ref_signal_measurement(dev,
- &peak_signal_rate_ref);
+ status = perform_ref_signal_measurement(&peak_signal_rate_ref);
if (status != VL53L0X_ERROR_NONE) {
break;
@@ -3921,12 +3674,10 @@
*/
if (signal_rate_diff > last_signal_rate_diff) {
/* Previous spad map produced a closer
- * measurement, so choose this. */
- status = set_ref_spad_map(dev,
- last_spad_array);
- memcpy(
- dev->SpadData.RefSpadEnables,
- last_spad_array, spad_array_size);
+ * measurement,so choose this. */
+ status = set_ref_spad_map(last_spad_array);
+ memcpy(_device->SpadData.RefSpadEnables,
+ last_spad_array,spad_array_size);
(ref_spad_count_int)--;
}
@@ -3935,7 +3686,7 @@
/* Continue to add spads */
last_signal_rate_diff = signal_rate_diff;
memcpy(last_spad_array,
- dev->SpadData.RefSpadEnables,
+ _device->SpadData.RefSpadEnables,
spad_array_size);
}
@@ -3946,18 +3697,15 @@
*ref_spad_count = ref_spad_count_int;
*is_aperture_spads = is_aperture_spads_int;
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadCount, (uint8_t)(*ref_spad_count));
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadType, *is_aperture_spads);
+ _device->DeviceSpecificParameters.RefSpadsInitialised = 1;
+ _device->DeviceSpecificParameters.ReferenceSpadCount = (uint8_t)(*ref_spad_count);
+ _device->DeviceSpecificParameters.ReferenceSpadType = *is_aperture_spads;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(VL53L0X_DEV dev,
- uint32_t count, uint8_t is_aperture_spads)
+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;
@@ -3968,36 +3716,33 @@
uint32_t index;
/*
- * This function applies a requested number of reference spads, either
+ * This function applies a requested number of reference spads,either
* aperture or
- * non-aperture, as requested.
+ * non-aperture,as requested.
* The good spad map will be applied.
*/
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- 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(dev,
- 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) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x00);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
+ status = VL53L0X_write_byte(VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
start_select);
}
for (index = 0; index < spad_array_size; index++) {
- dev->SpadData.RefSpadEnables[index] = 0;
+ _device->SpadData.RefSpadEnables[index] = 0;
}
if (is_aperture_spads) {
@@ -4007,10 +3752,9 @@
current_spad_index++;
}
}
- status = enable_ref_spads(dev,
- is_aperture_spads,
- dev->SpadData.RefGoodSpadMap,
- dev->SpadData.RefSpadEnables,
+ status = enable_ref_spads(is_aperture_spads,
+ _device->SpadData.RefGoodSpadMap,
+ _device->SpadData.RefSpadEnables,
spad_array_size,
start_select,
current_spad_index,
@@ -4018,17 +3762,15 @@
&last_spad_index);
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadCount, (uint8_t)(count));
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadType, is_aperture_spads);
+ _device->DeviceSpecificParameters.RefSpadsInitialised = 1;
+ _device->DeviceSpecificParameters.ReferenceSpadCount = (uint8_t)(count);
+ _device->DeviceSpecificParameters.ReferenceSpadType = is_aperture_spads;
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_wait_device_booted(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_wait_device_booted()
{
VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
@@ -4039,26 +3781,25 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(VL53L0X_DEV dev, uint8_t *p_vhv_settings,
+VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(uint8_t *p_vhv_settings,
uint8_t *p_phase_cal)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = VL53L0X_perform_ref_calibration(dev, p_vhv_settings,
- p_phase_cal, 1);
+ status = VL53L0X_perform_ref_calibration(p_vhv_settings,
+ p_phase_cal,1);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(VL53L0X_DEV dev,
- uint32_t *ref_spad_count, uint8_t *is_aperture_spads)
+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(dev, ref_spad_count,
+ status = wrapped_VL53L0X_perform_ref_spad_management(ref_spad_count,
is_aperture_spads);
@@ -4067,20 +3808,20 @@
}
/* Group PAL Init Functions */
-VL53L0X_Error VL53L0X::VL53L0X_set_device_address(VL53L0X_DEV dev, uint8_t device_address)
+VL53L0X_Error VL53L0X::VL53L0X_set_device_address(uint8_t device_address)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = VL53L0X_write_byte(dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
+ status = VL53L0X_write_byte(VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
device_address / 2);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_gpio_config(VL53L0X_DEV dev, uint8_t pin,
- VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
+VL53L0X_Error VL53L0X::VL53L0X_set_gpio_config(uint8_t pin,
+ VL53L0X_DeviceModes device_mode,VL53L0X_GpioFunctionality functionality,
VL53L0X_InterruptPolarity polarity)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -4097,32 +3838,31 @@
data = 1;
}
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
+ status = VL53L0X_write_byte(VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,data);
} else {
if (device_mode == VL53L0X_DEVICEMODE_GPIO_OSC) {
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x00);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
- status |= VL53L0X_write_byte(dev, 0x80, 0x01);
- status |= VL53L0X_write_byte(dev, 0x85, 0x02);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x04);
- status |= VL53L0X_write_byte(dev, 0xcd, 0x00);
- status |= VL53L0X_write_byte(dev, 0xcc, 0x11);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x07);
- status |= VL53L0X_write_byte(dev, 0xbe, 0x00);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x06);
- status |= VL53L0X_write_byte(dev, 0xcc, 0x09);
-
- status |= VL53L0X_write_byte(dev, 0xff, 0x00);
- status |= VL53L0X_write_byte(dev, 0xff, 0x01);
- status |= VL53L0X_write_byte(dev, 0x00, 0x00);
+ status |= VL53L0X_write_byte(0xff,0x01);
+ status |= VL53L0X_write_byte(0x00,0x00);
+
+ status |= VL53L0X_write_byte(0xff,0x00);
+ status |= VL53L0X_write_byte(0x80,0x01);
+ status |= VL53L0X_write_byte(0x85,0x02);
+
+ status |= VL53L0X_write_byte(0xff,0x04);
+ status |= VL53L0X_write_byte(0xcd,0x00);
+ status |= VL53L0X_write_byte(0xcc,0x11);
+
+ status |= VL53L0X_write_byte(0xff,0x07);
+ status |= VL53L0X_write_byte(0xbe,0x00);
+
+ status |= VL53L0X_write_byte(0xff,0x06);
+ status |= VL53L0X_write_byte(0xcc,0x09);
+
+ status |= VL53L0X_write_byte(0xff,0x00);
+ status |= VL53L0X_write_byte(0xff,0x01);
+ status |= VL53L0X_write_byte(0x00,0x00);
} else {
@@ -4150,8 +3890,7 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO,data);
}
if (status == VL53L0X_ERROR_NONE) {
@@ -4160,17 +3899,15 @@
} else {
data = (uint8_t)(1 << 4);
}
- status = VL53L0X_update_byte(dev,
- VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
+ status = VL53L0X_update_byte(VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,0xEF,data);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- Pin0GpioFunctionality, functionality);
+ _device->DeviceSpecificParameters.Pin0GpioFunctionality = functionality;
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_clear_interrupt_mask(dev, 0);
+ status = VL53L0X_clear_interrupt_mask(0);
}
}
}
@@ -4178,12 +3915,12 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_fraction_enable(VL53L0X_DEV dev, uint8_t *p_enabled)
+VL53L0X_Error VL53L0X::VL53L0X_get_fraction_enable(uint8_t *p_enabled)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled);
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_RANGE_CONFIG,p_enabled);
if (status == VL53L0X_ERROR_NONE) {
*p_enabled = (*p_enabled & 1);
@@ -4219,8 +3956,7 @@
}
-VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_DEV dev,
- 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;
@@ -4237,13 +3973,11 @@
(sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
(sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
- status = VL53L0X_get_vcsel_pulse_period(dev,
- 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(dev,
- 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) {
@@ -4253,14 +3987,11 @@
(uint8_t)msrc_range_time_out_m_clks - 1;
}
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
- LastEncodedTimeout,
- msrc_encoded_time_out);
+ _device->DeviceSpecificParameters.LastEncodedTimeout = msrc_encoded_time_out;
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
+ status = VL53L0X_write_byte(VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
msrc_encoded_time_out);
}
} else {
@@ -4268,59 +3999,47 @@
if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_vcsel_pulse_period(dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_PRE_RANGE,
¤t_vcsel_pulse_period_p_clk);
pre_range_time_out_m_clks =
- VL53L0X_calc_timeout_mclks(dev,
- timeout_micro_secs,
+ 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(dev,
- LastEncodedTimeout,
- pre_range_encoded_time_out);
+ pre_range_encoded_time_out = VL53L0X_encode_timeout(pre_range_time_out_m_clks);
+
+ _device->DeviceSpecificParameters.LastEncodedTimeout = pre_range_encoded_time_out;
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_word(dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+ status = VL53L0X_write_word(VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
pre_range_encoded_time_out);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- PreRangeTimeoutMicroSecs,
- timeout_micro_secs);
+ _device->DeviceSpecificParameters.PreRangeTimeoutMicroSecs=timeout_micro_secs;
}
} else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
- /* For the final range timeout, the pre-range timeout
+ /* For the final range timeout,the pre-range timeout
* must be added. To do this both final and pre-range
* timeouts must be expressed in macro periods MClks
* because they have different vcsel periods.
*/
- VL53L0X_get_sequence_step_enables(dev,
- &scheduler_sequence_steps);
+ VL53L0X_get_sequence_step_enables(&scheduler_sequence_steps);
pre_range_time_out_m_clks = 0;
if (scheduler_sequence_steps.PreRangeOn) {
/* Retrieve PRE-RANGE VCSEL Period */
- status = VL53L0X_get_vcsel_pulse_period(dev,
- 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(dev, 0x51,
+ status = VL53L0X_read_word(0x51,
&pre_range_encoded_time_out);
pre_range_time_out_m_clks =
- VL53L0X_decode_timeout(
- pre_range_encoded_time_out);
+ VL53L0X_decode_timeout(pre_range_encoded_time_out);
}
}
@@ -4328,14 +4047,12 @@
* (MCLKS) and add PRE-RANGE value
*/
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_vcsel_pulse_period(dev,
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+ status = VL53L0X_get_vcsel_pulse_period(VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
¤t_vcsel_pulse_period_p_clk);
}
if (status == VL53L0X_ERROR_NONE) {
final_range_time_out_m_clks =
- VL53L0X_calc_timeout_mclks(dev,
- timeout_micro_secs,
+ VL53L0X_calc_timeout_mclks(timeout_micro_secs,
(uint8_t) current_vcsel_pulse_period_p_clk);
final_range_time_out_m_clks += pre_range_time_out_m_clks;
@@ -4344,15 +4061,12 @@
VL53L0X_encode_timeout(final_range_time_out_m_clks);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_word(dev, 0x71,
+ status = VL53L0X_write_word(0x71,
final_range_encoded_time_out);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- FinalRangeTimeoutMicroSecs,
- timeout_micro_secs);
+ _device->DeviceSpecificParameters.FinalRangeTimeoutMicroSecs = timeout_micro_secs;
}
}
} else {
@@ -4363,8 +4077,7 @@
return status;
}
-VL53L0X_Error VL53L0X::wrapped_VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
- uint32_t measurement_timing_budget_micro_seconds)
+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;
@@ -4393,19 +4106,18 @@
measurement_timing_budget_micro_seconds -
(start_overhead_micro_seconds + end_overhead_micro_seconds);
- status = VL53L0X_get_sequence_step_enables(dev, &scheduler_sequence_steps);
+ status = VL53L0X_get_sequence_step_enables(&scheduler_sequence_steps);
if (status == VL53L0X_ERROR_NONE &&
(scheduler_sequence_steps.TccOn ||
scheduler_sequence_steps.MsrcOn ||
scheduler_sequence_steps.DssOn)) {
- /* TCC, MSRC and DSS all share the same timeout */
- status = get_sequence_step_timeout(dev,
- VL53L0X_SEQUENCESTEP_MSRC,
+ /* TCC,MSRC and DSS all share the same timeout */
+ status = get_sequence_step_timeout(VL53L0X_SEQUENCESTEP_MSRC,
&msrc_dcc_tcc_timeout_micro_seconds);
- /* Subtract the TCC, MSRC and DSS timeouts if they are
+ /* Subtract the TCC,MSRC and DSS timeouts if they are
* enabled. */
if (status != VL53L0X_ERROR_NONE) {
@@ -4471,8 +4183,7 @@
/* Subtract the Pre-range timeout if enabled. */
- status = get_sequence_step_timeout(dev,
- 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 +
@@ -4496,17 +4207,14 @@
/* Final Range Timeout
* Note that the final range timeout is determined by the timing
* budget and the sum of all other timeouts within the sequence.
- * If there is no room for the final range timeout, then an error
+ * If there is no room for the final range timeout,then an error
* will be set. Otherwise the remaining time will be applied to
* the final range.
*/
- status = set_sequence_step_timeout(dev,
- VL53L0X_SEQUENCESTEP_FINAL_RANGE,
+ status = set_sequence_step_timeout(VL53L0X_SEQUENCESTEP_FINAL_RANGE,
final_range_timing_budget_micro_seconds);
- VL53L0X_SETPARAMETERFIELD(dev,
- MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
+ _device->CurrentParameters.MeasurementTimingBudgetMicroSeconds = measurement_timing_budget_micro_seconds;
}
@@ -4514,22 +4222,17 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
- 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(dev,
- 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_DEV dev,
- VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
+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;
@@ -4537,7 +4240,7 @@
uint32_t measurement_timing_budget_micro_seconds;
- status = VL53L0X_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
&sequence_config);
sequence_config_new = sequence_config;
@@ -4594,22 +4297,18 @@
if (sequence_config_new != sequence_config) {
/* Apply New Setting */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev,
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new);
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,sequence_config_new);
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, sequence_config_new);
+ _device->SequenceConfig = sequence_config_new;
}
/* Recalculate timing budget */
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(dev,
- MeasurementTimingBudgetMicroSeconds,
- measurement_timing_budget_micro_seconds);
-
- VL53L0X_set_measurement_timing_budget_micro_seconds(dev,
- measurement_timing_budget_micro_seconds);
+ measurement_timing_budget_micro_seconds = _device->CurrentParameters.MeasurementTimingBudgetMicroSeconds;
+
+ VL53L0X_set_measurement_timing_budget_micro_seconds(measurement_timing_budget_micro_seconds);
}
}
@@ -4618,7 +4317,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
+VL53L0X_Error VL53L0X::VL53L0X_set_limit_check_enable(uint16_t limit_check_id,
uint8_t limit_check_enable)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -4638,8 +4337,7 @@
limit_check_disable = 1;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
- limit_check_id, temp_fix1616);
+ temp_fix1616 = _device->CurrentParameters.LimitChecksValue[limit_check_id];
limit_check_disable = 0;
/* this to be sure to have either 0 or 1 */
limit_check_enable_int = 1;
@@ -4649,16 +4347,13 @@
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- limit_check_enable_int);
+ _device->CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = VL53L0X_write_word(dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+ status = VL53L0X_write_word(VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
VL53L0X_FIXPOINT1616TOFIXPOINT97(temp_fix1616));
break;
@@ -4666,36 +4361,30 @@
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- limit_check_enable_int);
+ _device->CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- limit_check_enable_int);
+ _device->CurrentParameters.LimitChecksEnable[VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD] = limit_check_enable_int;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
temp8 = (uint8_t)(limit_check_disable << 1);
- status = VL53L0X_update_byte(dev,
- VL53L0X_REG_MSRC_CONFIG_CONTROL,
- 0xFE, temp8);
+ status = VL53L0X_update_byte(VL53L0X_REG_MSRC_CONFIG_CONTROL,
+ 0xFE,temp8);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
temp8 = (uint8_t)(limit_check_disable << 4);
- status = VL53L0X_update_byte(dev,
- VL53L0X_REG_MSRC_CONFIG_CONTROL,
- 0xEF, temp8);
+ status = VL53L0X_update_byte(VL53L0X_REG_MSRC_CONFIG_CONTROL,
+ 0xEF,temp8);
break;
@@ -4709,11 +4398,9 @@
if (status == VL53L0X_ERROR_NONE) {
if (limit_check_enable == 0) {
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- limit_check_id, 0);
+ _device->CurrentParameters.LimitChecksEnable[limit_check_id] = 0;
} else {
- VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
- limit_check_id, 1);
+ _device->CurrentParameters.LimitChecksEnable[limit_check_id] = 1;
}
}
@@ -4721,7 +4408,7 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_static_init(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_static_init()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t current_parameters = {0};
@@ -4738,22 +4425,20 @@
- status = VL53L0X_get_info_from_device(dev, 1);
+ status = VL53L0X_get_info_from_device(1);
/* set the ref spad from NVM */
- count = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadCount);
- aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
- ReferenceSpadType);
+ count = (uint32_t)_device->DeviceSpecificParameters.ReferenceSpadCount;
+ aperture_spads = _device->DeviceSpecificParameters.ReferenceSpadType;
/* NVM value invalid */
if ((aperture_spads > 1) ||
((aperture_spads == 1) && (count > 32)) ||
((aperture_spads == 0) && (count > 12))) {
- status = wrapped_VL53L0X_perform_ref_spad_management(dev, &ref_spad_count,
+ status = wrapped_VL53L0X_perform_ref_spad_management(&ref_spad_count,
&is_aperture_spads);
} else {
- status = VL53L0X_set_reference_spads(dev, count, aperture_spads);
+ status = VL53L0X_set_reference_spads(count,aperture_spads);
}
@@ -4761,12 +4446,10 @@
p_tuning_setting_buffer = DefaultTuningSettings;
if (status == VL53L0X_ERROR_NONE) {
- use_internal_tuning_settings = PALDevDataGet(dev,
- UseInternalTuningSettings);
+ use_internal_tuning_settings = _device->UseInternalTuningSettings;
if (use_internal_tuning_settings == 0) {
- p_tuning_setting_buffer = PALDevDataGet(dev,
- pTuningSettingsPointer);
+ p_tuning_setting_buffer = _device->pTuningSettingsPointer;
} else {
p_tuning_setting_buffer = DefaultTuningSettings;
}
@@ -4774,131 +4457,112 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_load_tuning_settings(dev, p_tuning_setting_buffer);
+ 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(dev, 0, 0,
+ status = VL53L0X_set_gpio_config(0,0,
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
VL53L0X_INTERRUPTPOLARITY_LOW);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
- status |= VL53L0X_read_word(dev, 0x84, &tempword);
- status |= VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x01);
+ status |= VL53L0X_read_word(0x84,&tempword);
+ status |= VL53L0X_write_byte(0xFF,0x00);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(dev, OscFrequencyMHz,
- VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
- }
-
- /* After static init, some device parameters may be changed,
+ _device->DeviceSpecificParameters.OscFrequencyMHz=
+ VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword);
+ }
+
+ /* After static init,some device parameters may be changed,
* so update them */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_device_parameters(dev, ¤t_parameters);
+ status = VL53L0X_get_device_parameters(¤t_parameters);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_get_fraction_enable(dev, &tempbyte);
+ status = VL53L0X_get_fraction_enable(&tempbyte);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, RangeFractionalEnable, tempbyte);
+ _device->RangeFractionalEnable = tempbyte;
}
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, CurrentParameters, current_parameters);
+ _device->CurrentParameters = current_parameters;
}
/* read the sequence config and save it */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(dev,
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
+ status = VL53L0X_read_byte(VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,&tempbyte);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(dev, SequenceConfig, tempbyte);
+ _device->SequenceConfig = tempbyte;
}
}
/* Disable MSRC and TCC by default */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_set_sequence_step_enable(dev,
- 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(dev,
- 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(dev, PalState, VL53L0X_STATE_IDLE);
+ _device->PalState = VL53L0X_STATE_IDLE;
}
/* Store pre-range vcsel period */
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_get_vcsel_pulse_period(
- dev,
VL53L0X_VCSEL_PERIOD_PRE_RANGE,
&vcsel_pulse_period_pclk);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- PreRangeVcselPulsePeriod,
- vcsel_pulse_period_pclk);
+ _device->DeviceSpecificParameters.PreRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
}
/* Store final-range vcsel period */
if (status == VL53L0X_ERROR_NONE) {
status = VL53L0X_get_vcsel_pulse_period(
- dev,
VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
&vcsel_pulse_period_pclk);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- FinalRangeVcselPulsePeriod,
- vcsel_pulse_period_pclk);
+ _device->DeviceSpecificParameters.FinalRangeVcselPulsePeriod = vcsel_pulse_period_pclk;
}
/* Store pre-range timeout */
if (status == VL53L0X_ERROR_NONE) {
status = get_sequence_step_timeout(
- dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
&seq_timeout_micro_secs);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- PreRangeTimeoutMicroSecs,
- seq_timeout_micro_secs);
+ _device->DeviceSpecificParameters.PreRangeTimeoutMicroSecs = seq_timeout_micro_secs;
}
/* Store final-range timeout */
if (status == VL53L0X_ERROR_NONE) {
status = get_sequence_step_timeout(
- dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
&seq_timeout_micro_secs);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(
- dev,
- FinalRangeTimeoutMicroSecs,
- seq_timeout_micro_secs);
+ _device->DeviceSpecificParameters.FinalRangeTimeoutMicroSecs = seq_timeout_micro_secs;
}
@@ -4906,62 +4570,60 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_stop_measurement(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::VL53L0X_stop_measurement()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- status = VL53L0X_write_byte(dev, VL53L0X_REG_SYSRANGE_START,
+ status = VL53L0X_write_byte(VL53L0X_REG_SYSRANGE_START,
VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
- status = VL53L0X_write_byte(dev, 0x00, 0x00);
- status = VL53L0X_write_byte(dev, 0x91, 0x00);
- status = VL53L0X_write_byte(dev, 0x00, 0x01);
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
+ status = VL53L0X_write_byte(0xFF,0x01);
+ status = VL53L0X_write_byte(0x00,0x00);
+ status = VL53L0X_write_byte(0x91,0x00);
+ status = VL53L0X_write_byte(0x00,0x01);
+ status = VL53L0X_write_byte(0xFF,0x00);
if (status == VL53L0X_ERROR_NONE) {
/* Set PAL State to Idle */
- PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
+ _device->PalState = VL53L0X_STATE_IDLE;
}
/* Check if need to apply interrupt settings */
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_check_and_load_interrupt_settings(dev, 0);
+ status = VL53L0X_check_and_load_interrupt_settings(0);
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(VL53L0X_DEV dev,
- uint32_t *p_stop_status)
+VL53L0X_Error VL53L0X::VL53L0X_get_stop_completed_status(uint32_t *p_stop_status)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte = 0;
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_read_byte(dev, 0x04, &byte);
+ status = VL53L0X_read_byte(0x04,&byte);
}
if (status == VL53L0X_ERROR_NONE) {
- status = VL53L0X_write_byte(dev, 0xFF, 0x0);
+ status = VL53L0X_write_byte(0xFF,0x0);
}
*p_stop_status = byte;
if (byte == 0) {
- status = VL53L0X_write_byte(dev, 0x80, 0x01);
- status = VL53L0X_write_byte(dev, 0xFF, 0x01);
- status = VL53L0X_write_byte(dev, 0x00, 0x00);
- status = VL53L0X_write_byte(dev, 0x91,
- PALDevDataGet(dev, StopVariable));
- status = VL53L0X_write_byte(dev, 0x00, 0x01);
- status = VL53L0X_write_byte(dev, 0xFF, 0x00);
- status = VL53L0X_write_byte(dev, 0x80, 0x00);
+ status = VL53L0X_write_byte(0x80,0x01);
+ status = VL53L0X_write_byte(0xFF,0x01);
+ status = VL53L0X_write_byte(0x00,0x00);
+ status = VL53L0X_write_byte(0x91,_device->StopVariable);
+ status = VL53L0X_write_byte(0x00,0x01);
+ status = VL53L0X_write_byte(0xFF,0x00);
+ status = VL53L0X_write_byte(0x80,0x00);
}
@@ -4970,15 +4632,15 @@
/****************** Write and read functions from I2C *************************/
-VL53L0X_Error VL53L0X::VL53L0X_write_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
+VL53L0X_Error VL53L0X::VL53L0X_write_multi(uint8_t index,uint8_t *p_data,uint32_t count)
{
int status;
- status = VL53L0X_i2c_write(dev->I2cDevAddr, index, p_data, (uint16_t)count);
+ status = VL53L0X_i2c_write(index,p_data,(uint16_t)count);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_read_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
+VL53L0X_Error VL53L0X::VL53L0X_read_multi(uint8_t index,uint8_t *p_data,uint32_t count)
{
int status;
@@ -4986,32 +4648,32 @@
status = VL53L0X_ERROR_INVALID_PARAMS;
}
- status = VL53L0X_i2c_read(dev->I2cDevAddr, index, p_data, (uint16_t)count);
+ status = VL53L0X_i2c_read(index,p_data,(uint16_t)count);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_write_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
+VL53L0X_Error VL53L0X::VL53L0X_write_byte(uint8_t index,uint8_t data)
{
int status;
- status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, &data, 1);
+ status = VL53L0X_i2c_write(index,&data,1);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_write_word(VL53L0X_DEV dev, uint8_t index, uint16_t data)
+VL53L0X_Error VL53L0X::VL53L0X_write_word(uint8_t index,uint16_t data)
{
int status;
uint8_t buffer[2];
buffer[0] = data >> 8;
buffer[1] = data & 0x00FF;
- status = VL53L0X_i2c_write(dev->I2cDevAddr, index, (uint8_t *)buffer, 2);
+ status = VL53L0X_i2c_write(index,(uint8_t *)buffer,2);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_write_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
+VL53L0X_Error VL53L0X::VL53L0X_write_dword(uint8_t index,uint32_t data)
{
int status;
uint8_t buffer[4];
@@ -5020,16 +4682,16 @@
buffer[1] = (data >> 16) & 0xFF;
buffer[2] = (data >> 8) & 0xFF;
buffer[3] = (data >> 0) & 0xFF;
- status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, (uint8_t *)buffer, 4);
+ status = VL53L0X_i2c_write(index,(uint8_t *)buffer,4);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_read_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t *p_data)
+VL53L0X_Error VL53L0X::VL53L0X_read_byte(uint8_t index,uint8_t *p_data)
{
int status;
- status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, p_data, 1);
+ status = VL53L0X_i2c_read(index,p_data,1);
if (status) {
return -1;
@@ -5038,12 +4700,12 @@
return 0;
}
-VL53L0X_Error VL53L0X::VL53L0X_read_word(VL53L0X_DEV Dev, uint8_t index, uint16_t *p_data)
+VL53L0X_Error VL53L0X::VL53L0X_read_word(uint8_t index,uint16_t *p_data)
{
int status;
- uint8_t buffer[2] = {0, 0};
-
- status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, buffer, 2);
+ uint8_t buffer[2] = {0,0};
+
+ status = VL53L0X_i2c_read(index,buffer,2);
if (!status) {
*p_data = (buffer[0] << 8) + buffer[1];
}
@@ -5051,12 +4713,12 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_read_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t *p_data)
+VL53L0X_Error VL53L0X::VL53L0X_read_dword(uint8_t index,uint32_t *p_data)
{
int status;
- uint8_t buffer[4] = {0, 0, 0, 0};
-
- status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, buffer, 4);
+ uint8_t buffer[4] = {0,0,0,0};
+
+ status = VL53L0X_i2c_read(index,buffer,4);
if (!status) {
*p_data = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
}
@@ -5064,26 +4726,26 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_update_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t and_data, uint8_t or_data)
+VL53L0X_Error VL53L0X::VL53L0X_update_byte(uint8_t index,uint8_t and_data,uint8_t or_data)
{
int status;
uint8_t buffer = 0;
/* read data direct onto buffer */
- status = VL53L0X_i2c_read(Dev->I2cDevAddr, index, &buffer, 1);
+ status = VL53L0X_i2c_read(index,&buffer,1);
if (!status) {
buffer = (buffer & and_data) | or_data;
- status = VL53L0X_i2c_write(Dev->I2cDevAddr, index, &buffer, (uint8_t)1);
+ status = VL53L0X_i2c_write(index,&buffer,(uint8_t)1);
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_i2c_write(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
+VL53L0X_Error VL53L0X::VL53L0X_i2c_write(uint8_t RegisterAddr,uint8_t *p_data,
uint16_t NumByteToWrite)
{
int ret;
- ret = _dev_i2c->i2c_write(p_data, DeviceAddr, RegisterAddr, NumByteToWrite);
+ ret = _dev_i2c->i2c_write(p_data,_device->I2cDevAddr,RegisterAddr,NumByteToWrite);
if (ret) {
return -1;
@@ -5091,12 +4753,12 @@
return 0;
}
-VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
+VL53L0X_Error VL53L0X::VL53L0X_i2c_read(uint8_t RegisterAddr,uint8_t *p_data,
uint16_t NumByteToRead)
{
int ret;
- ret = _dev_i2c->i2c_read(p_data, DeviceAddr, RegisterAddr, NumByteToRead);
+ ret = _dev_i2c->i2c_read(p_data,_device->I2cDevAddr,RegisterAddr,NumByteToRead);
if (ret) {
return -1;
@@ -5109,7 +4771,7 @@
int status = 0;
uint16_t rl_id = 0;
- status = VL53L0X_read_word(_device, VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
+ status = VL53L0X_read_word(VL53L0X_REG_IDENTIFICATION_MODEL_ID,&rl_id);
if (rl_id == 0xEEAA) {
return status;
}
@@ -5118,7 +4780,7 @@
}
-VL53L0X_Error VL53L0X::wait_measurement_data_ready(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::wait_measurement_data_ready()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t new_dat_ready = 0;
@@ -5129,12 +4791,12 @@
if (status == VL53L0X_ERROR_NONE) {
loop_nb = 0;
do {
- status = VL53L0X_get_measurement_data_ready(dev, &new_dat_ready);
+ status = VL53L0X_get_measurement_data_ready(&new_dat_ready);
if ((new_dat_ready == 0x01) || status != VL53L0X_ERROR_NONE) {
break;
}
loop_nb = loop_nb + 1;
- VL53L0X_polling_delay(dev);
+ VL53L0X_polling_delay();
} while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
@@ -5145,7 +4807,7 @@
return status;
}
-VL53L0X_Error VL53L0X::wait_stop_completed(VL53L0X_DEV dev)
+VL53L0X_Error VL53L0X::wait_stop_completed()
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t stop_completed = 0;
@@ -5156,12 +4818,12 @@
if (status == VL53L0X_ERROR_NONE) {
loop_nb = 0;
do {
- status = VL53L0X_get_stop_completed_status(dev, &stop_completed);
+ status = VL53L0X_get_stop_completed_status(&stop_completed);
if ((stop_completed == 0x00) || status != VL53L0X_ERROR_NONE) {
break;
}
loop_nb = loop_nb + 1;
- VL53L0X_polling_delay(dev);
+ VL53L0X_polling_delay();
} while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
@@ -5181,7 +4843,7 @@
VL53L0X_off();
VL53L0X_on();
-// status=VL53L0X_WaitDeviceBooted(Device);
+// status=VL53L0X_WaitDeviceBooted(ice);
// if(status)
// printf("WaitDeviceBooted fail\n\r");
status = is_present();
@@ -5193,7 +4855,7 @@
}
// deduce silicon version
- status = VL53L0X_get_device_info(&_my_device, &_device_info);
+ status = VL53L0X_get_device_info(&_device_info);
status = prepare();
if (status != VL53L0X_ERROR_NONE) {
@@ -5219,11 +4881,9 @@
{
int status;
- status = VL53L0X_stop_measurement(_device); // it is safer to do this while sensor is stopped
-
-// status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
-
- status = VL53L0X_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ status = VL53L0X_stop_measurement(); // it is safer to do this while sensor is stopped
+
+ status = VL53L0X_set_gpio_config(0,VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
VL53L0X_INTERRUPTPOLARITY_HIGH);
@@ -5233,7 +4893,7 @@
}
clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS | VL53L0X_REG_RESULT_RANGE_STATUS);
- // NB: return value was previously only passed to logging macro, but did not get passed back
+ // NB: return value was previously only passed to logging macro,but did not get passed back
if (!status) {
status = range_start_continuous_mode();
@@ -5242,14 +4902,14 @@
}
-int VL53L0X::start_measurement(OperatingMode operating_mode, void (*fptr)(void))
+int VL53L0X::start_measurement(OperatingMode operating_mode,void (*fptr)(void))
{
int Status = VL53L0X_ERROR_NONE;
uint8_t VhvSettings;
uint8_t PhaseCal;
- // *** from mass market cube expansion v1.1, ranging with satellites.
- // default settings, for normal range.
+ // *** from mass market cube expansion v1.1,ranging with satellites.
+ // default settings,for normal range.
FixPoint1616_t signalLimit = (FixPoint1616_t)(0.25 * 65536);
FixPoint1616_t sigmaLimit = (FixPoint1616_t)(18 * 65536);
uint32_t timingBudget = 33000;
@@ -5262,11 +4922,9 @@
return 1;
}
- Status = VL53L0X_stop_measurement(_device); // it is safer to do this while sensor is stopped
-
-// Status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
-
- Status = VL53L0X_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ Status = VL53L0X_stop_measurement(); // it is safer to do this while sensor is stopped
+
+ Status = VL53L0X_set_gpio_config(0,VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
VL53L0X_INTERRUPTPOLARITY_HIGH);
@@ -5276,35 +4934,35 @@
}
clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS | VL53L0X_REG_RESULT_RANGE_STATUS);
- // NB: return value was previously only passed to logging macro, but did not get passed back
+ // NB: return value was previously only passed to logging macro,but did not get passed back
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
+ Status = VL53L0X_set_device_mode(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_start_measurement(_device);
+ Status = VL53L0X_start_measurement();
}
}
if (operating_mode == range_single_shot_polling) {
- // singelshot, polled ranging
+ // singelshot,polled ranging
if (Status == VL53L0X_ERROR_NONE) {
// no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
- Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
+ Status = VL53L0X_set_device_mode(VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
}
// Enable/Disable Sigma and Signal check
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_enable(_device,
- 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(_device,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+ Status = VL53L0X_set_limit_check_enable(
+ VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,1);
}
-// *** from mass market cube expansion v1.1, ranging with satellites.
+// *** from mass market cube expansion v1.1,ranging with satellites.
/* Ranging configuration */
//*
// switch(rangingConfig) {
@@ -5335,31 +4993,31 @@
*/
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_limit_check_value(_device,
- 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(_device,
- 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(_device, timingBudget);
+ Status = VL53L0X_set_measurement_timing_budget_micro_seconds(timingBudget);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_set_vcsel_pulse_period(_device,
- 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(_device,
- 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(_device, &VhvSettings, &PhaseCal);
+ Status = VL53L0X_perform_ref_calibration(&VhvSettings,&PhaseCal);
}
}
@@ -5367,12 +5025,12 @@
if (operating_mode == range_continuous_polling) {
if (Status == VL53L0X_ERROR_NONE) {
//printf("Call of VL53L0X_SetDeviceMode\n");
- Status = VL53L0X_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
+ Status = VL53L0X_set_device_mode(VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
}
if (Status == VL53L0X_ERROR_NONE) {
//printf("Call of VL53L0X_StartMeasurement\n");
- Status = VL53L0X_start_measurement(_device);
+ Status = VL53L0X_start_measurement();
}
}
@@ -5380,31 +5038,31 @@
}
-int VL53L0X::get_measurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *p_data)
+int VL53L0X::get_measurement(OperatingMode operating_mode,VL53L0X_RangingMeasurementData_t *p_data)
{
int Status = VL53L0X_ERROR_NONE;
if (operating_mode == range_single_shot_polling) {
- Status = VL53L0X_perform_single_ranging_measurement(_device, p_data);
+ Status = VL53L0X_perform_single_ranging_measurement(p_data);
}
if (operating_mode == range_continuous_polling) {
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_measurement_poll_for_completion(_device);
+ Status = VL53L0X_measurement_poll_for_completion();
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_get_ranging_measurement_data(_device, p_data);
+ Status = VL53L0X_get_ranging_measurement_data(p_data);
// Clear the interrupt
- VL53L0X_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
- VL53L0X_polling_delay(_device);
+ VL53L0X_clear_interrupt_mask(VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+ VL53L0X_polling_delay();
}
}
if (operating_mode == range_continuous_interrupt) {
- Status = VL53L0X_get_ranging_measurement_data(_device, p_data);
- VL53L0X_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR | VL53L0X_REG_RESULT_INTERRUPT_STATUS);
+ Status = VL53L0X_get_ranging_measurement_data(p_data);
+ VL53L0X_clear_interrupt_mask(VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR | VL53L0X_REG_RESULT_INTERRUPT_STATUS);
}
return Status;
@@ -5424,16 +5082,16 @@
// continuous mode
if (status == VL53L0X_ERROR_NONE) {
//printf("Call of VL53L0X_StopMeasurement\n");
- status = VL53L0X_stop_measurement(_device);
+ status = VL53L0X_stop_measurement();
}
if (status == VL53L0X_ERROR_NONE) {
//printf("Wait Stop to be competed\n");
- status = wait_stop_completed(_device);
+ status = wait_stop_completed();
}
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_clear_interrupt_mask(_device,
+ status = VL53L0X_clear_interrupt_mask(
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
}
@@ -5441,13 +5099,12 @@
}
-int VL53L0X::handle_irq(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data)
+int VL53L0X::handle_irq(OperatingMode operating_mode,VL53L0X_RangingMeasurementData_t *data)
{
int status;
- status = get_measurement(operating_mode, data);
+ status = get_measurement(operating_mode,data);
enable_interrupt_measure_detection_irq();
return status;
}
-
/******************************************************************************/