ST Expansion SW Team
Updates to follow mbed SDK coding style guidelines.
Dependencies: ST_INTERFACES X_NUCLEO_COMMON
Dependents: 53L0A1_Satellites_with_Interrupts_OS5 Display_53L0A1_OS5
Fork of
X_NUCLEO_53L0A1
by 
ST
Diff: Components/VL53L0X/vl53l0x_class.cpp
- Revision:
- 16:98ce55ddbb1a
- Parent:
- 15:932d8b4e52c9
- Child:
- 17:1b842521063a
--- a/Components/VL53L0X/vl53l0x_class.cpp Tue Jun 20 16:00:31 2017 +0000
+++ b/Components/VL53L0X/vl53l0x_class.cpp Thu Jun 22 09:55:10 2017 +0000
@@ -80,523 +80,523 @@
-VL53L0X_Error VL53L0X::VL53L0X_device_read_strobe(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_device_read_strobe(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t strobe;
- uint32_t LoopNb;
+ uint32_t loop_nb;
LOG_FUNCTION_START("");
- Status |= VL53L0X_WrByte(Dev, 0x83, 0x00);
+ status |= vl53l0x_write_byte(dev, 0x83, 0x00);
/* polling
* use timeout to avoid deadlock*/
- if (Status == VL53L0X_ERROR_NONE) {
- LoopNb = 0;
+ if (status == VL53L0X_ERROR_NONE) {
+ loop_nb = 0;
do {
- Status = VL53L0X_RdByte(Dev, 0x83, &strobe);
- if ((strobe != 0x00) || Status != VL53L0X_ERROR_NONE)
+ status = vl53l0x_read_byte(dev, 0x83, &strobe);
+ if ((strobe != 0x00) || status != VL53L0X_ERROR_NONE)
break;
- LoopNb = LoopNb + 1;
- } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
-
- if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP)
- Status = VL53L0X_ERROR_TIME_OUT;
+ loop_nb = loop_nb + 1;
+ } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
+
+ if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP)
+ status = VL53L0X_ERROR_TIME_OUT;
}
- Status |= VL53L0X_WrByte(Dev, 0x83, 0x01);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status |= vl53l0x_write_byte(dev, 0x83, 0x01);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option)
+VL53L0X_Error VL53L0X::vl53l0x_get_info_from_device(VL53L0X_DEV dev, uint8_t option)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte;
- uint32_t TmpDWord;
- uint8_t ModuleId;
- uint8_t Revision;
- uint8_t ReferenceSpadCount = 0;
- uint8_t ReferenceSpadType = 0;
- uint32_t PartUIDUpper = 0;
- uint32_t PartUIDLower = 0;
- uint32_t OffsetFixed1104_mm = 0;
- int16_t OffsetMicroMeters = 0;
- uint32_t DistMeasTgtFixed1104_mm = 400 << 4;
- uint32_t DistMeasFixed1104_400_mm = 0;
- uint32_t SignalRateMeasFixed1104_400_mm = 0;
- char ProductId[19];
- char *ProductId_tmp;
- uint8_t ReadDataFromDeviceDone;
- FixPoint1616_t SignalRateMeasFixed400mmFix = 0;
- uint8_t NvmRefGoodSpadMap[VL53L0X_REF_SPAD_BUFFER_SIZE];
+ uint32_t tmp_dword;
+ uint8_t module_id;
+ uint8_t revision;
+ uint8_t reference_spad_count = 0;
+ uint8_t reference_spad_type = 0;
+ uint32_t part_uid_upper = 0;
+ uint32_t part_uid_lower = 0;
+ uint32_t offset_fixed1104_mm = 0;
+ int16_t offset_micro_meters = 0;
+ uint32_t dist_meas_tgt_fixed1104_mm = 400 << 4;
+ uint32_t dist_meas_fixed1104_400_mm = 0;
+ uint32_t signal_rate_meas_fixed1104_400_mm = 0;
+ char product_id[19];
+ char *product_id_tmp;
+ uint8_t read_data_from_device_done;
+ FixPoint1616_t signal_rate_meas_fixed400_mm_fix = 0;
+ uint8_t nvm_ref_good_spad_map[VL53L0X_REF_SPAD_BUFFER_SIZE];
int i;
LOG_FUNCTION_START("");
- ReadDataFromDeviceDone = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- ReadDataFromDeviceDone);
+ read_data_from_device_done = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
+ ReadDataFromDeviceDone);
/* This access is done only once after that a GetDeviceInfo or
* datainit is done*/
- if (ReadDataFromDeviceDone != 7) {
-
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
-
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x06);
- Status |= VL53L0X_RdByte(Dev, 0x83, &byte);
- Status |= VL53L0X_WrByte(Dev, 0x83, byte|4);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x07);
- Status |= VL53L0X_WrByte(Dev, 0x81, 0x01);
-
- Status |= VL53L0X_PollingDelay(Dev);
-
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
+ 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);
if (((option & 1) == 1) &&
- ((ReadDataFromDeviceDone & 1) == 0)) {
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x6b);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- ReferenceSpadCount = (uint8_t)((TmpDWord >> 8) & 0x07f);
- ReferenceSpadType = (uint8_t)((TmpDWord >> 15) & 0x01);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x24);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
-
- NvmRefGoodSpadMap[0] = (uint8_t)((TmpDWord >> 24)
- & 0xff);
- NvmRefGoodSpadMap[1] = (uint8_t)((TmpDWord >> 16)
- & 0xff);
- NvmRefGoodSpadMap[2] = (uint8_t)((TmpDWord >> 8)
- & 0xff);
- NvmRefGoodSpadMap[3] = (uint8_t)(TmpDWord & 0xff);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x25);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- NvmRefGoodSpadMap[4] = (uint8_t)((TmpDWord >> 24)
- & 0xff);
- NvmRefGoodSpadMap[5] = (uint8_t)((TmpDWord >> 16)
- & 0xff);
+ ((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);
+
+ 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);
+
+
+ nvm_ref_good_spad_map[0] = (uint8_t)((tmp_dword >> 24)
+ & 0xff);
+ nvm_ref_good_spad_map[1] = (uint8_t)((tmp_dword >> 16)
+ & 0xff);
+ nvm_ref_good_spad_map[2] = (uint8_t)((tmp_dword >> 8)
+ & 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);
+
+ nvm_ref_good_spad_map[4] = (uint8_t)((tmp_dword >> 24)
+ & 0xff);
+ nvm_ref_good_spad_map[5] = (uint8_t)((tmp_dword >> 16)
+ & 0xff);
}
if (((option & 2) == 2) &&
- ((ReadDataFromDeviceDone & 2) == 0)) {
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x02);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdByte(Dev, 0x90, &ModuleId);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x7B);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdByte(Dev, 0x90, &Revision);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x77);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- ProductId[0] = (char)((TmpDWord >> 25) & 0x07f);
- ProductId[1] = (char)((TmpDWord >> 18) & 0x07f);
- ProductId[2] = (char)((TmpDWord >> 11) & 0x07f);
- ProductId[3] = (char)((TmpDWord >> 4) & 0x07f);
-
- byte = (uint8_t)((TmpDWord & 0x00f) << 3);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x78);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- ProductId[4] = (char)(byte +
- ((TmpDWord >> 29) & 0x07f));
- ProductId[5] = (char)((TmpDWord >> 22) & 0x07f);
- ProductId[6] = (char)((TmpDWord >> 15) & 0x07f);
- ProductId[7] = (char)((TmpDWord >> 8) & 0x07f);
- ProductId[8] = (char)((TmpDWord >> 1) & 0x07f);
-
- byte = (uint8_t)((TmpDWord & 0x001) << 6);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x79);
-
- Status |= VL53L0X_device_read_strobe(Dev);
-
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- ProductId[9] = (char)(byte +
- ((TmpDWord >> 26) & 0x07f));
- ProductId[10] = (char)((TmpDWord >> 19) & 0x07f);
- ProductId[11] = (char)((TmpDWord >> 12) & 0x07f);
- ProductId[12] = (char)((TmpDWord >> 5) & 0x07f);
-
- byte = (uint8_t)((TmpDWord & 0x01f) << 2);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x7A);
-
- Status |= VL53L0X_device_read_strobe(Dev);
-
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- ProductId[13] = (char)(byte +
- ((TmpDWord >> 30) & 0x07f));
- ProductId[14] = (char)((TmpDWord >> 23) & 0x07f);
- ProductId[15] = (char)((TmpDWord >> 16) & 0x07f);
- ProductId[16] = (char)((TmpDWord >> 9) & 0x07f);
- ProductId[17] = (char)((TmpDWord >> 2) & 0x07f);
- ProductId[18] = '\0';
+ ((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);
+
+ product_id[0] = (char)((tmp_dword >> 25) & 0x07f);
+ product_id[1] = (char)((tmp_dword >> 18) & 0x07f);
+ product_id[2] = (char)((tmp_dword >> 11) & 0x07f);
+ product_id[3] = (char)((tmp_dword >> 4) & 0x07f);
+
+ 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);
+
+ product_id[4] = (char)(byte +
+ ((tmp_dword >> 29) & 0x07f));
+ product_id[5] = (char)((tmp_dword >> 22) & 0x07f);
+ product_id[6] = (char)((tmp_dword >> 15) & 0x07f);
+ product_id[7] = (char)((tmp_dword >> 8) & 0x07f);
+ product_id[8] = (char)((tmp_dword >> 1) & 0x07f);
+
+ 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);
+
+ product_id[9] = (char)(byte +
+ ((tmp_dword >> 26) & 0x07f));
+ product_id[10] = (char)((tmp_dword >> 19) & 0x07f);
+ product_id[11] = (char)((tmp_dword >> 12) & 0x07f);
+ product_id[12] = (char)((tmp_dword >> 5) & 0x07f);
+
+ 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);
+
+ product_id[13] = (char)(byte +
+ ((tmp_dword >> 30) & 0x07f));
+ product_id[14] = (char)((tmp_dword >> 23) & 0x07f);
+ product_id[15] = (char)((tmp_dword >> 16) & 0x07f);
+ product_id[16] = (char)((tmp_dword >> 9) & 0x07f);
+ product_id[17] = (char)((tmp_dword >> 2) & 0x07f);
+ product_id[18] = '\0';
}
if (((option & 4) == 4) &&
- ((ReadDataFromDeviceDone & 4) == 0)) {
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x7B);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &PartUIDUpper);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x7C);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &PartUIDLower);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x73);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- SignalRateMeasFixed1104_400_mm = (TmpDWord &
- 0x0000000ff) << 8;
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x74);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- SignalRateMeasFixed1104_400_mm |= ((TmpDWord &
- 0xff000000) >> 24);
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x75);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- DistMeasFixed1104_400_mm = (TmpDWord & 0x0000000ff)
- << 8;
-
- Status |= VL53L0X_WrByte(Dev, 0x94, 0x76);
- Status |= VL53L0X_device_read_strobe(Dev);
- Status |= VL53L0X_RdDWord(Dev, 0x90, &TmpDWord);
-
- DistMeasFixed1104_400_mm |= ((TmpDWord & 0xff000000)
- >> 24);
+ ((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);
+
+ 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);
+
+ 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);
+
+ 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);
+
+ dist_meas_fixed1104_400_mm |= ((tmp_dword & 0xff000000)
+ >> 24);
}
- Status |= VL53L0X_WrByte(Dev, 0x81, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x06);
- Status |= VL53L0X_RdByte(Dev, 0x83, &byte);
- Status |= VL53L0X_WrByte(Dev, 0x83, byte&0xfb);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
-
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+ 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);
}
- if ((Status == VL53L0X_ERROR_NONE) &&
- (ReadDataFromDeviceDone != 7)) {
+ if ((status == VL53L0X_ERROR_NONE) &&
+ (read_data_from_device_done != 7)) {
/* Assign to variable if status is ok */
if (((option & 1) == 1) &&
- ((ReadDataFromDeviceDone & 1) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadCount, ReferenceSpadCount);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadType, ReferenceSpadType);
+ ((read_data_from_device_done & 1) == 0)) {
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ ReferenceSpadCount, reference_spad_count);
+
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ ReferenceSpadType, reference_spad_type);
for (i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++) {
- Dev->Data.SpadData.RefGoodSpadMap[i] =
- NvmRefGoodSpadMap[i];
+ dev->Data.SpadData.RefGoodSpadMap[i] =
+ nvm_ref_good_spad_map[i];
}
}
if (((option & 2) == 2) &&
- ((ReadDataFromDeviceDone & 2) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ModuleId, ModuleId);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- Revision, Revision);
-
- ProductId_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- ProductId);
- VL53L0X_COPYSTRING(ProductId_tmp, ProductId);
+ ((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);
+ VL53L0X_COPYSTRING(product_id_tmp, product_id);
}
if (((option & 4) == 4) &&
- ((ReadDataFromDeviceDone & 4) == 0)) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- PartUIDUpper, PartUIDUpper);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- PartUIDLower, PartUIDLower);
-
- SignalRateMeasFixed400mmFix =
+ ((read_data_from_device_done & 4) == 0)) {
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ PartUIDUpper, part_uid_upper);
+
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ PartUIDLower, part_uid_lower);
+
+ signal_rate_meas_fixed400_mm_fix =
VL53L0X_FIXPOINT97TOFIXPOINT1616(
- SignalRateMeasFixed1104_400_mm);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+ signal_rate_meas_fixed1104_400_mm);
+
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
SignalRateMeasFixed400mm,
- SignalRateMeasFixed400mmFix);
-
- OffsetMicroMeters = 0;
- if (DistMeasFixed1104_400_mm != 0) {
- OffsetFixed1104_mm =
- DistMeasFixed1104_400_mm -
- DistMeasTgtFixed1104_mm;
- OffsetMicroMeters = (OffsetFixed1104_mm
- * 1000) >> 4;
- OffsetMicroMeters *= -1;
+ signal_rate_meas_fixed400_mm_fix);
+
+ offset_micro_meters = 0;
+ if (dist_meas_fixed1104_400_mm != 0) {
+ offset_fixed1104_mm =
+ dist_meas_fixed1104_400_mm -
+ dist_meas_tgt_fixed1104_mm;
+ offset_micro_meters = (offset_fixed1104_mm
+ * 1000) >> 4;
+ offset_micro_meters *= -1;
}
- PALDevDataSet(Dev,
+ PALDevDataSet(dev,
Part2PartOffsetAdjustmentNVMMicroMeter,
- OffsetMicroMeters);
+ offset_micro_meters);
}
- byte = (uint8_t)(ReadDataFromDeviceDone|option);
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone,
+ byte = (uint8_t)(read_data_from_device_done|option);
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone,
byte);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
- int32_t *pOffsetCalibrationDataMicroMeter)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
+ int32_t *p_offset_calibration_data_micro_meter)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint16_t RangeOffsetRegister;
- int16_t cMaxOffset = 2047;
- int16_t cOffsetRange = 4096;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint16_t range_offset_register;
+ int16_t c_max_offset = 2047;
+ int16_t c_offset_range = 4096;
/* Note that offset has 10.2 format */
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
- &RangeOffsetRegister);
-
- if (Status == VL53L0X_ERROR_NONE) {
- RangeOffsetRegister = (RangeOffsetRegister & 0x0fff);
+ status = vl53l0x_read_word(dev,
+ VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+ &range_offset_register);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ range_offset_register = (range_offset_register & 0x0fff);
/* Apply 12 bit 2's compliment conversion */
- if (RangeOffsetRegister > cMaxOffset)
- *pOffsetCalibrationDataMicroMeter =
- (int16_t)(RangeOffsetRegister - cOffsetRange)
+ if (range_offset_register > c_max_offset)
+ *p_offset_calibration_data_micro_meter =
+ (int16_t)(range_offset_register - c_offset_range)
* 250;
else
- *pOffsetCalibrationDataMicroMeter =
- (int16_t)RangeOffsetRegister * 250;
+ *p_offset_calibration_data_micro_meter =
+ (int16_t)range_offset_register * 250;
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
int32_t *pOffsetCalibrationDataMicroMeter)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_get_offset_calibration_data_micro_meter(Dev,
+ status = wrapped_vl53l0x_get_offset_calibration_data_micro_meter(Dev,
pOffsetCalibrationDataMicroMeter);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
- int32_t OffsetCalibrationDataMicroMeter)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
+ int32_t offset_calibration_data_micro_meter)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- int32_t cMaxOffsetMicroMeter = 511000;
- int32_t cMinOffsetMicroMeter = -512000;
- int16_t cOffsetRange = 4096;
- uint32_t encodedOffsetVal;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ int32_t c_max_offset_micro_meter = 511000;
+ int32_t c_min_offset_micro_meter = -512000;
+ int16_t c_offset_range = 4096;
+ uint32_t encoded_offset_val;
LOG_FUNCTION_START("");
- if (OffsetCalibrationDataMicroMeter > cMaxOffsetMicroMeter)
- OffsetCalibrationDataMicroMeter = cMaxOffsetMicroMeter;
- else if (OffsetCalibrationDataMicroMeter < cMinOffsetMicroMeter)
- OffsetCalibrationDataMicroMeter = cMinOffsetMicroMeter;
+ if (offset_calibration_data_micro_meter > c_max_offset_micro_meter)
+ offset_calibration_data_micro_meter = c_max_offset_micro_meter;
+ else if (offset_calibration_data_micro_meter < c_min_offset_micro_meter)
+ offset_calibration_data_micro_meter = c_min_offset_micro_meter;
/* The offset register is 10.2 format and units are mm
* therefore conversion is applied by a division of
* 250.
*/
- if (OffsetCalibrationDataMicroMeter >= 0) {
- encodedOffsetVal =
- OffsetCalibrationDataMicroMeter/250;
+ if (offset_calibration_data_micro_meter >= 0) {
+ encoded_offset_val =
+ offset_calibration_data_micro_meter/250;
} else {
- encodedOffsetVal =
- cOffsetRange +
- OffsetCalibrationDataMicroMeter/250;
+ encoded_offset_val =
+ c_offset_range +
+ offset_calibration_data_micro_meter/250;
}
- Status = VL53L0X_WrWord(Dev,
- VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
- encodedOffsetVal);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = vl53l0x_write_word(dev,
+ VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
+ encoded_offset_val);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetOffsetCalibrationDataMicroMeter(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
int32_t OffsetCalibrationDataMicroMeter)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_set_offset_calibration_data_micro_meter(Dev,
+ status = wrapped_vl53l0x_set_offset_calibration_data_micro_meter(Dev,
OffsetCalibrationDataMicroMeter);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_apply_offset_adjustment(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- int32_t CorrectedOffsetMicroMeters;
- int32_t CurrentOffsetMicroMeters;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ int32_t corrected_offset_micro_meters;
+ int32_t current_offset_micro_meters;
/* if we run on this function we can read all the NVM info
* used by the API */
- Status = VL53L0X_get_info_from_device(Dev, 7);
+ status = vl53l0x_get_info_from_device(dev, 7);
/* Read back current device offset */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetOffsetCalibrationDataMicroMeter(Dev,
- &CurrentOffsetMicroMeters);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_offset_calibration_data_micro_meter(dev,
+ ¤t_offset_micro_meters);
}
/* Apply Offset Adjustment derived from 400mm measurements */
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
/* Store initial device offset */
- PALDevDataSet(Dev, Part2PartOffsetNVMMicroMeter,
- CurrentOffsetMicroMeters);
-
- CorrectedOffsetMicroMeters = CurrentOffsetMicroMeters +
- (int32_t)PALDevDataGet(Dev,
- Part2PartOffsetAdjustmentNVMMicroMeter);
-
- Status = VL53L0X_SetOffsetCalibrationDataMicroMeter(Dev,
- CorrectedOffsetMicroMeters);
+ PALDevDataSet(dev, 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 */
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(Dev, RangeOffsetMicroMeters,
- CorrectedOffsetMicroMeters);
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_SETPARAMETERFIELD(dev, RangeOffsetMicroMeters,
+ corrected_offset_micro_meters);
}
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetDeviceMode(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_device_mode(VL53L0X_DEV Dev,
VL53L0X_DeviceModes *pDeviceMode)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
VL53L0X_GETPARAMETERFIELD(Dev, DeviceMode, *pDeviceMode);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetInterMeasurementPeriodMilliSeconds(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_inter_measurement_period_milli_seconds(VL53L0X_DEV Dev,
uint32_t *pInterMeasurementPeriodMilliSeconds)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t osc_calibrate_val;
- uint32_t IMPeriodMilliSeconds;
+ uint32_t im_period_milli_seconds;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdWord(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
- &osc_calibrate_val);
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdDWord(Dev,
- VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
- &IMPeriodMilliSeconds);
+ status = vl53l0x_read_word(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
+ &osc_calibrate_val);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_dword(Dev,
+ VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
+ &im_period_milli_seconds);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
if (osc_calibrate_val != 0) {
*pInterMeasurementPeriodMilliSeconds =
- IMPeriodMilliSeconds / osc_calibrate_val;
+ im_period_milli_seconds / osc_calibrate_val;
}
VL53L0X_SETPARAMETERFIELD(Dev,
InterMeasurementPeriodMilliSeconds,
*pInterMeasurementPeriodMilliSeconds);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetXTalkCompensationRateMegaCps(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_rate_mega_cps(VL53L0X_DEV Dev,
FixPoint1616_t *pXTalkCompensationRateMegaCps)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint16_t Value;
- FixPoint1616_t TempFix1616;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint16_t value;
+ FixPoint1616_t temp_fix1616;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, (uint16_t *)&Value);
- if (Status == VL53L0X_ERROR_NONE) {
- if (Value == 0) {
+ status = vl53l0x_read_word(Dev,
+ 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, TempFix1616);
- *pXTalkCompensationRateMegaCps = TempFix1616;
+ XTalkCompensationRateMegaCps, temp_fix1616);
+ *pXTalkCompensationRateMegaCps = temp_fix1616;
VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
0);
} else {
- TempFix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(Value);
- *pXTalkCompensationRateMegaCps = TempFix1616;
+ temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(value);
+ *pXTalkCompensationRateMegaCps = temp_fix1616;
VL53L0X_SETPARAMETERFIELD(Dev,
- XTalkCompensationRateMegaCps, TempFix1616);
+ XTalkCompensationRateMegaCps, temp_fix1616);
VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
1);
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_value(VL53L0X_DEV Dev, uint16_t LimitCheckId,
FixPoint1616_t *pLimitCheckValue)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t EnableZeroValue = 0;
- uint16_t Temp16;
- FixPoint1616_t TempFix1616;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t enable_zero_value = 0;
+ uint16_t temp16;
+ FixPoint1616_t temp_fix1616;
LOG_FUNCTION_START("");
@@ -605,126 +605,126 @@
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, TempFix1616);
- EnableZeroValue = 0;
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616);
+ enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
- &Temp16);
- if (Status == VL53L0X_ERROR_NONE)
- TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
-
-
- EnableZeroValue = 1;
+ status = vl53l0x_read_word(Dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+ &temp16);
+ if (status == VL53L0X_ERROR_NONE)
+ temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
+
+
+ enable_zero_value = 1;
break;
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, TempFix1616);
- EnableZeroValue = 0;
+ VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp_fix1616);
+ enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, TempFix1616);
- EnableZeroValue = 0;
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, temp_fix1616);
+ enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
- &Temp16);
- if (Status == VL53L0X_ERROR_NONE)
- TempFix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(Temp16);
-
-
- EnableZeroValue = 0;
+ status = vl53l0x_read_word(Dev,
+ VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+ &temp16);
+ if (status == VL53L0X_ERROR_NONE)
+ temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616(temp16);
+
+
+ enable_zero_value = 0;
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
- if (Status == VL53L0X_ERROR_NONE) {
-
- if (EnableZeroValue == 1) {
-
- if (TempFix1616 == 0) {
+ if (status == VL53L0X_ERROR_NONE) {
+
+ if (enable_zero_value == 1) {
+
+ if (temp_fix1616 == 0) {
/* disabled: return value from memory */
VL53L0X_GETARRAYPARAMETERFIELD(Dev,
LimitChecksValue, LimitCheckId,
- TempFix1616);
- *pLimitCheckValue = TempFix1616;
+ temp_fix1616);
+ *pLimitCheckValue = temp_fix1616;
VL53L0X_SETARRAYPARAMETERFIELD(Dev,
LimitChecksEnable, LimitCheckId, 0);
} else {
- *pLimitCheckValue = TempFix1616;
+ *pLimitCheckValue = temp_fix1616;
VL53L0X_SETARRAYPARAMETERFIELD(Dev,
LimitChecksValue, LimitCheckId,
- TempFix1616);
+ temp_fix1616);
VL53L0X_SETARRAYPARAMETERFIELD(Dev,
LimitChecksEnable, LimitCheckId, 1);
}
} else {
- *pLimitCheckValue = TempFix1616;
+ *pLimitCheckValue = temp_fix1616;
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_enable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
uint8_t *pLimitCheckEnable)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t Temp8;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t temp8;
LOG_FUNCTION_START("");
if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
*pLimitCheckEnable = 0;
} else {
VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
- LimitCheckId, Temp8);
- *pLimitCheckEnable = Temp8;
+ LimitCheckId, temp8);
+ *pLimitCheckEnable = temp8;
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetWrapAroundCheckEnable(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_wrap_around_check_enable(VL53L0X_DEV Dev,
uint8_t *pWrapAroundCheckEnable)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t data;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
- if (Status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_byte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
+ if (status == VL53L0X_ERROR_NONE) {
PALDevDataSet(Dev, SequenceConfig, data);
if (data & (0x01 << 7))
*pWrapAroundCheckEnable = 0x01;
else
*pWrapAroundCheckEnable = 0x00;
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
*pWrapAroundCheckEnable);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_DEV Dev,
@@ -755,51 +755,51 @@
Status = VL53L0X_ERROR_INVALID_PARAMS;
}
- LOG_FUNCTION_END(Status);
+ LOG_FUNCTION_END(status);
return Status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetSequenceStepEnables(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_enables(VL53L0X_DEV Dev,
VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t SequenceConfig = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sequence_config = 0;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- &SequenceConfig);
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = sequence_step_enabled(Dev,
- VL53L0X_SEQUENCESTEP_TCC, SequenceConfig,
+ status = vl53l0x_read_byte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ &sequence_config);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = sequence_step_enabled(Dev,
+ VL53L0X_SEQUENCESTEP_TCC, sequence_config,
&pSchedulerSequenceSteps->TccOn);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = sequence_step_enabled(Dev,
- VL53L0X_SEQUENCESTEP_DSS, SequenceConfig,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = sequence_step_enabled(Dev,
+ VL53L0X_SEQUENCESTEP_DSS, sequence_config,
&pSchedulerSequenceSteps->DssOn);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = sequence_step_enabled(Dev,
- VL53L0X_SEQUENCESTEP_MSRC, SequenceConfig,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = sequence_step_enabled(Dev,
+ VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
&pSchedulerSequenceSteps->MsrcOn);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = sequence_step_enabled(Dev,
- VL53L0X_SEQUENCESTEP_PRE_RANGE, SequenceConfig,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = sequence_step_enabled(Dev,
+ VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
&pSchedulerSequenceSteps->PreRangeOn);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = sequence_step_enabled(Dev,
- VL53L0X_SEQUENCESTEP_FINAL_RANGE, SequenceConfig,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = sequence_step_enabled(Dev,
+ VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
&pSchedulerSequenceSteps->FinalRangeOn);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-uint8_t VL53L0X::VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg)
+uint8_t VL53L0X::vl53l0x_decode_vcsel_period(uint8_t vcsel_period_reg)
{
/*!
* Converts the encoded VCSEL period register value into the real
@@ -813,7 +813,7 @@
return vcsel_period_pclks;
}
-uint8_t VL53L0X::VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks)
+uint8_t VL53L0X::lv53l0x_encode_vcsel_period(uint8_t vcsel_period_pclks)
{
/*!
* Converts the encoded VCSEL period register value into the real period
@@ -828,166 +828,166 @@
}
-VL53L0X_Error VL53L0X::VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
- VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK)
+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 Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t vcsel_period_reg;
- uint8_t MinPreVcselPeriodPCLK = 12;
- uint8_t MaxPreVcselPeriodPCLK = 18;
- uint8_t MinFinalVcselPeriodPCLK = 8;
- uint8_t MaxFinalVcselPeriodPCLK = 14;
- uint32_t MeasurementTimingBudgetMicroSeconds;
- uint32_t FinalRangeTimeoutMicroSeconds;
- uint32_t PreRangeTimeoutMicroSeconds;
- uint32_t MsrcTimeoutMicroSeconds;
- uint8_t PhaseCalInt = 0;
+ uint8_t min_pre_vcsel_period_pclk = 12;
+ uint8_t max_pre_vcsel_period_pclk = 18;
+ uint8_t min_final_vcsel_period_pclk = 8;
+ uint8_t max_final_vcsel_period_pclk = 14;
+ uint32_t measurement_timing_budget_micro_seconds;
+ uint32_t final_range_timeout_micro_seconds;
+ uint32_t pre_range_timeout_micro_seconds;
+ uint32_t msrc_timeout_micro_seconds;
+ uint8_t phase_cal_int = 0;
/* Check if valid clock period requested */
- if ((VCSELPulsePeriodPCLK % 2) != 0) {
+ if ((vcsel_pulse_period_pclk % 2) != 0) {
/* Value must be an even number */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
- } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
- (VCSELPulsePeriodPCLK < MinPreVcselPeriodPCLK ||
- VCSELPulsePeriodPCLK > MaxPreVcselPeriodPCLK)) {
- Status = VL53L0X_ERROR_INVALID_PARAMS;
- } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
- (VCSELPulsePeriodPCLK < MinFinalVcselPeriodPCLK ||
- VCSELPulsePeriodPCLK > MaxFinalVcselPeriodPCLK)) {
-
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
+ } else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
+ (vcsel_pulse_period_pclk < min_pre_vcsel_period_pclk ||
+ vcsel_pulse_period_pclk > max_pre_vcsel_period_pclk)) {
+ status = VL53L0X_ERROR_INVALID_PARAMS;
+ } else if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
+ (vcsel_pulse_period_pclk < min_final_vcsel_period_pclk ||
+ vcsel_pulse_period_pclk > max_final_vcsel_period_pclk)) {
+
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
/* Apply specific settings for the requested clock period */
- if (Status != VL53L0X_ERROR_NONE)
- return Status;
-
-
- if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
+ if (status != VL53L0X_ERROR_NONE)
+ return status;
+
+
+ if (vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE) {
/* Set phase check limits */
- if (VCSELPulsePeriodPCLK == 12) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x18);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
- } else if (VCSELPulsePeriodPCLK == 14) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x30);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
- } else if (VCSELPulsePeriodPCLK == 16) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x40);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
- } else if (VCSELPulsePeriodPCLK == 18) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x50);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
+ if (vcsel_pulse_period_pclk == 12) {
+
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
+ 0x18);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x30);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x40);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x50);
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
+ 0x08);
}
- } else if (VcselPeriodType == VL53L0X_VCSEL_PERIOD_FINAL_RANGE) {
-
- if (VCSELPulsePeriodPCLK == 8) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x10);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
-
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
- 0x30);
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
- } else if (VCSELPulsePeriodPCLK == 10) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x28);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
-
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
- 0x20);
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
- } else if (VCSELPulsePeriodPCLK == 12) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x38);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
-
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
- 0x20);
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
- } else if (VCSELPulsePeriodPCLK == 14) {
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
- 0x048);
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
- 0x08);
-
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_ALGO_PHASECAL_LIM,
- 0x20);
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
+ } 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,
+ 0x10);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x30);
+ status |= vl53l0x_write_byte(dev, 0xff, 0x00);
+ } else if (vcsel_pulse_period_pclk == 10) {
+
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ 0x28);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x20);
+ status |= vl53l0x_write_byte(dev, 0xff, 0x00);
+ } else if (vcsel_pulse_period_pclk == 12) {
+
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ 0x38);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x20);
+ status |= vl53l0x_write_byte(dev, 0xff, 0x00);
+ } else if (vcsel_pulse_period_pclk == 14) {
+
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
+ 0x048);
+ status = vl53l0x_write_byte(dev,
+ 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,
+ 0x20);
+ status |= vl53l0x_write_byte(dev, 0xff, 0x00);
}
}
/* Re-calculate and apply timeouts, in macro periods */
- if (Status == VL53L0X_ERROR_NONE) {
- vcsel_period_reg = VL53L0X_encode_vcsel_period((uint8_t)
- VCSELPulsePeriodPCLK);
+ if (status == VL53L0X_ERROR_NONE) {
+ vcsel_period_reg = lv53l0x_encode_vcsel_period((uint8_t)
+ vcsel_pulse_period_pclk);
/* When the VCSEL period for the pre or final range is changed,
* the corresponding timeout must be read from the device using
@@ -998,140 +998,140 @@
* For the MSRC timeout, the same applies - this timeout being
* dependant on the pre-range vcsel period.
*/
- switch (VcselPeriodType) {
+ switch (vcsel_period_type) {
case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
- Status = get_sequence_step_timeout(Dev,
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
- &PreRangeTimeoutMicroSeconds);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = get_sequence_step_timeout(Dev,
+ &pre_range_timeout_micro_seconds);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_MSRC,
- &MsrcTimeoutMicroSeconds);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
- vcsel_period_reg);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = set_sequence_step_timeout(Dev,
+ &msrc_timeout_micro_seconds);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ 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,
- PreRangeTimeoutMicroSeconds);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = set_sequence_step_timeout(Dev,
+ pre_range_timeout_micro_seconds);
+
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = set_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_MSRC,
- MsrcTimeoutMicroSeconds);
+ msrc_timeout_micro_seconds);
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
PreRangeVcselPulsePeriod,
- VCSELPulsePeriodPCLK);
+ vcsel_pulse_period_pclk);
break;
case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
- Status = get_sequence_step_timeout(Dev,
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
- &FinalRangeTimeoutMicroSeconds);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
- vcsel_period_reg);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = set_sequence_step_timeout(Dev,
+ &final_range_timeout_micro_seconds);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ 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,
- FinalRangeTimeoutMicroSeconds);
+ final_range_timeout_micro_seconds);
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
FinalRangeVcselPulsePeriod,
- VCSELPulsePeriodPCLK);
+ vcsel_pulse_period_pclk);
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
/* Finally, the timing budget must be re-applied */
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_GETPARAMETERFIELD(dev,
MeasurementTimingBudgetMicroSeconds,
- MeasurementTimingBudgetMicroSeconds);
-
- Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
- MeasurementTimingBudgetMicroSeconds);
+ measurement_timing_budget_micro_seconds);
+
+ status = vl53l0x_set_measurement_timing_budget_micro_seconds(dev,
+ measurement_timing_budget_micro_seconds);
}
/* Perform the phase calibration. This is needed after changing on
* vcsel period.
* get_data_enable = 0, restore_config = 1 */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_perform_phase_calibration(
- Dev, &PhaseCalInt, 0, 1);
-
- return Status;
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_perform_phase_calibration(
+ dev, &phase_cal_int, 0, 1);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetVcselPulsePeriod(VL53L0X_DEV Dev,
- VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK)
+VL53L0X_Error VL53L0X::vl53l0x_set_vcsel_pulse_period(VL53L0X_DEV dev,
+ VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period)
+{
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ LOG_FUNCTION_START("");
+
+ status = wrapped_vl53l0x_set_vcsel_pulse_period(dev, vcsel_period_type,
+ vcsel_pulse_period);
+
+ LOG_FUNCTION_END(status);
+ 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 Status = VL53L0X_ERROR_NONE;
- LOG_FUNCTION_START("");
-
- Status = VL53L0X_set_vcsel_pulse_period(Dev, VcselPeriodType,
- VCSELPulsePeriodPCLK);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ 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,
+ &vcsel_period_reg);
+ break;
+ case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
+ status = vl53l0x_read_byte(dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
+ &vcsel_period_reg);
+ break;
+ default:
+ status = VL53L0X_ERROR_INVALID_PARAMS;
+ }
+
+ if (status == VL53L0X_ERROR_NONE)
+ *p_vcsel_pulse_period_pclk =
+ vl53l0x_decode_vcsel_period(vcsel_period_reg);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_vcsel_pulse_period(VL53L0X_DEV Dev,
VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t vcsel_period_reg;
-
- switch (VcselPeriodType) {
- case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
- &vcsel_period_reg);
- break;
- case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
- &vcsel_period_reg);
- break;
- default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
- }
-
- if (Status == VL53L0X_ERROR_NONE)
- *pVCSELPulsePeriodPCLK =
- VL53L0X_decode_vcsel_period(vcsel_period_reg);
-
- return Status;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ LOG_FUNCTION_START("");
+
+ status = wrapped_vl53l0x_get_vcsel_pulse_period(Dev, VcselPeriodType,
+ pVCSELPulsePeriodPCLK);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetVcselPulsePeriod(VL53L0X_DEV Dev,
- VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
-{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- LOG_FUNCTION_START("");
-
- Status = VL53L0X_get_vcsel_pulse_period(Dev, VcselPeriodType,
- pVCSELPulsePeriodPCLK);
-
- LOG_FUNCTION_END(Status);
- return Status;
-}
-
-uint32_t VL53L0X::VL53L0X_decode_timeout(uint16_t encoded_timeout)
+uint32_t VL53L0X::vl53l0x_decode_timeout(uint16_t encoded_timeout)
{
/*!
* Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
@@ -1145,9 +1145,9 @@
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(VL53L0X_DEV dev, uint8_t vcsel_period_pclks)
{
- uint64_t PLL_period_ps;
+ uint64_t pll_period_ps;
uint32_t macro_period_vclks;
uint32_t macro_period_ps;
@@ -1156,18 +1156,18 @@
/* The above calculation will produce rounding errors,
therefore set fixed value
*/
- PLL_period_ps = 1655;
+ pll_period_ps = 1655;
macro_period_vclks = 2304;
macro_period_ps = (uint32_t)(macro_period_vclks
- * vcsel_period_pclks * PLL_period_ps);
+ * vcsel_period_pclks * pll_period_ps);
LOG_FUNCTION_END("");
return macro_period_ps;
}
/* To convert register value into us */
-uint32_t VL53L0X::VL53L0X_calc_timeout_us(VL53L0X_DEV Dev,
+uint32_t VL53L0X::vl53l0x_calc_timeout_us(VL53L0X_DEV dev,
uint16_t timeout_period_mclks,
uint8_t vcsel_period_pclks)
{
@@ -1175,7 +1175,7 @@
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(dev, vcsel_period_pclks);
macro_period_ns = (macro_period_ps + 500) / 1000;
actual_timeout_period_us =
@@ -1184,360 +1184,360 @@
return actual_timeout_period_us;
}
-VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_DEV Dev,
- VL53L0X_SequenceStepId SequenceStepId,
- uint32_t *pTimeOutMicroSecs)
+VL53L0X_Error VL53L0X::get_sequence_step_timeout(VL53L0X_DEV dev,
+ VL53L0X_SequenceStepId sequence_step_id,
+ uint32_t *p_time_out_micro_secs)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t CurrentVCSELPulsePeriodPClk;
- uint8_t EncodedTimeOutByte = 0;
- uint32_t TimeoutMicroSeconds = 0;
- uint16_t PreRangeEncodedTimeOut = 0;
- uint16_t MsrcTimeOutMClks;
- uint16_t PreRangeTimeOutMClks;
- uint16_t FinalRangeTimeOutMClks = 0;
- uint16_t FinalRangeEncodedTimeOut;
- VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
-
- if ((SequenceStepId == VL53L0X_SEQUENCESTEP_TCC) ||
- (SequenceStepId == VL53L0X_SEQUENCESTEP_DSS) ||
- (SequenceStepId == VL53L0X_SEQUENCESTEP_MSRC)) {
-
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
- &EncodedTimeOutByte);
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t current_vcsel_pulse_period_p_clk;
+ uint8_t encoded_time_out_byte = 0;
+ uint32_t timeout_micro_seconds = 0;
+ uint16_t pre_range_encoded_time_out = 0;
+ uint16_t msrc_time_out_m_clks;
+ uint16_t pre_range_time_out_m_clks;
+ uint16_t final_range_time_out_m_clks = 0;
+ uint16_t final_range_encoded_time_out;
+ VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
+
+ if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) ||
+ (sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
+ (sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
+
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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,
+ &encoded_time_out_byte);
}
- MsrcTimeOutMClks = VL53L0X_decode_timeout(EncodedTimeOutByte);
-
- TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
- MsrcTimeOutMClks,
- CurrentVCSELPulsePeriodPClk);
- } else if (SequenceStepId == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
+ 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,
+ current_vcsel_pulse_period_p_clk);
+ } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
/* Retrieve PRE-RANGE VCSEL Period */
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ ¤t_vcsel_pulse_period_p_clk);
/* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
/* Retrieve PRE-RANGE VCSEL Period */
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
- &PreRangeEncodedTimeOut);
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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,
+ &pre_range_encoded_time_out);
}
- PreRangeTimeOutMClks = VL53L0X_decode_timeout(
- PreRangeEncodedTimeOut);
-
- TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
- PreRangeTimeOutMClks,
- CurrentVCSELPulsePeriodPClk);
+ 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,
+ current_vcsel_pulse_period_p_clk);
}
- } else if (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
-
- VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
- PreRangeTimeOutMClks = 0;
-
- if (SchedulerSequenceSteps.PreRangeOn) {
+ } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
+
+ vl53l0x_get_sequence_step_enables(dev, &scheduler_sequence_steps);
+ pre_range_time_out_m_clks = 0;
+
+ if (scheduler_sequence_steps.PreRangeOn) {
/* Retrieve PRE-RANGE VCSEL Period */
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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_RdWord(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
- &PreRangeEncodedTimeOut);
- PreRangeTimeOutMClks = VL53L0X_decode_timeout(
- PreRangeEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_word(dev,
+ 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);
}
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
/* Retrieve FINAL-RANGE VCSEL Period */
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
- &CurrentVCSELPulsePeriodPClk);
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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_RdWord(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
- &FinalRangeEncodedTimeOut);
- FinalRangeTimeOutMClks = VL53L0X_decode_timeout(
- FinalRangeEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_word(dev,
+ 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);
}
- FinalRangeTimeOutMClks -= PreRangeTimeOutMClks;
- TimeoutMicroSeconds = VL53L0X_calc_timeout_us(Dev,
- FinalRangeTimeOutMClks,
- CurrentVCSELPulsePeriodPClk);
+ 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,
+ current_vcsel_pulse_period_p_clk);
}
- *pTimeOutMicroSecs = TimeoutMicroSeconds;
-
- return Status;
+ *p_time_out_micro_secs = timeout_micro_seconds;
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
- uint32_t *pMeasurementTimingBudgetMicroSeconds)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
+ uint32_t *p_measurement_timing_budget_micro_seconds)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
- uint32_t FinalRangeTimeoutMicroSeconds;
- uint32_t MsrcDccTccTimeoutMicroSeconds = 2000;
- uint32_t StartOverheadMicroSeconds = 1910;
- uint32_t EndOverheadMicroSeconds = 960;
- uint32_t MsrcOverheadMicroSeconds = 660;
- uint32_t TccOverheadMicroSeconds = 590;
- uint32_t DssOverheadMicroSeconds = 690;
- uint32_t PreRangeOverheadMicroSeconds = 660;
- uint32_t FinalRangeOverheadMicroSeconds = 550;
- uint32_t PreRangeTimeoutMicroSeconds = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
+ uint32_t final_range_timeout_micro_seconds;
+ uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
+ uint32_t start_overhead_micro_seconds = 1910;
+ uint32_t end_overhead_micro_seconds = 960;
+ uint32_t msrc_overhead_micro_seconds = 660;
+ uint32_t tcc_overhead_micro_seconds = 590;
+ uint32_t dss_overhead_micro_seconds = 690;
+ uint32_t pre_range_overhead_micro_seconds = 660;
+ uint32_t final_range_overhead_micro_seconds = 550;
+ uint32_t pre_range_timeout_micro_seconds = 0;
LOG_FUNCTION_START("");
/* Start and end overhead times always present */
- *pMeasurementTimingBudgetMicroSeconds
- = StartOverheadMicroSeconds + EndOverheadMicroSeconds;
-
- Status = VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
-
- if (Status != VL53L0X_ERROR_NONE) {
- LOG_FUNCTION_END(Status);
- return Status;
+ *p_measurement_timing_budget_micro_seconds
+ = start_overhead_micro_seconds + end_overhead_micro_seconds;
+
+ status = vl53l0x_get_sequence_step_enables(dev, &scheduler_sequence_steps);
+
+ if (status != VL53L0X_ERROR_NONE) {
+ LOG_FUNCTION_END(status);
+ return status;
}
- if (SchedulerSequenceSteps.TccOn ||
- SchedulerSequenceSteps.MsrcOn ||
- SchedulerSequenceSteps.DssOn) {
-
- Status = get_sequence_step_timeout(Dev,
+ if (scheduler_sequence_steps.TccOn ||
+ scheduler_sequence_steps.MsrcOn ||
+ scheduler_sequence_steps.DssOn) {
+
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_MSRC,
- &MsrcDccTccTimeoutMicroSeconds);
-
- if (Status == VL53L0X_ERROR_NONE) {
- if (SchedulerSequenceSteps.TccOn) {
- *pMeasurementTimingBudgetMicroSeconds +=
- MsrcDccTccTimeoutMicroSeconds +
- TccOverheadMicroSeconds;
+ &msrc_dcc_tcc_timeout_micro_seconds);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ if (scheduler_sequence_steps.TccOn) {
+ *p_measurement_timing_budget_micro_seconds +=
+ msrc_dcc_tcc_timeout_micro_seconds +
+ tcc_overhead_micro_seconds;
}
- if (SchedulerSequenceSteps.DssOn) {
- *pMeasurementTimingBudgetMicroSeconds +=
- 2 * (MsrcDccTccTimeoutMicroSeconds +
- DssOverheadMicroSeconds);
- } else if (SchedulerSequenceSteps.MsrcOn) {
- *pMeasurementTimingBudgetMicroSeconds +=
- MsrcDccTccTimeoutMicroSeconds +
- MsrcOverheadMicroSeconds;
+ if (scheduler_sequence_steps.DssOn) {
+ *p_measurement_timing_budget_micro_seconds +=
+ 2 * (msrc_dcc_tcc_timeout_micro_seconds +
+ dss_overhead_micro_seconds);
+ } else if (scheduler_sequence_steps.MsrcOn) {
+ *p_measurement_timing_budget_micro_seconds +=
+ msrc_dcc_tcc_timeout_micro_seconds +
+ msrc_overhead_micro_seconds;
}
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- if (SchedulerSequenceSteps.PreRangeOn) {
- Status = get_sequence_step_timeout(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ if (scheduler_sequence_steps.PreRangeOn) {
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
- &PreRangeTimeoutMicroSeconds);
- *pMeasurementTimingBudgetMicroSeconds +=
- PreRangeTimeoutMicroSeconds +
- PreRangeOverheadMicroSeconds;
+ &pre_range_timeout_micro_seconds);
+ *p_measurement_timing_budget_micro_seconds +=
+ pre_range_timeout_micro_seconds +
+ pre_range_overhead_micro_seconds;
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- if (SchedulerSequenceSteps.FinalRangeOn) {
- Status = get_sequence_step_timeout(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ if (scheduler_sequence_steps.FinalRangeOn) {
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
- &FinalRangeTimeoutMicroSeconds);
- *pMeasurementTimingBudgetMicroSeconds +=
- (FinalRangeTimeoutMicroSeconds +
- FinalRangeOverheadMicroSeconds);
+ &final_range_timeout_micro_seconds);
+ *p_measurement_timing_budget_micro_seconds +=
+ (final_range_timeout_micro_seconds +
+ final_range_overhead_micro_seconds);
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_SETPARAMETERFIELD(dev,
MeasurementTimingBudgetMicroSeconds,
- *pMeasurementTimingBudgetMicroSeconds);
+ *p_measurement_timing_budget_micro_seconds);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
uint32_t *pMeasurementTimingBudgetMicroSeconds)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_get_measurement_timing_budget_micro_seconds(Dev,
+ status = wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds(Dev,
pMeasurementTimingBudgetMicroSeconds);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetDeviceParameters(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_device_parameters(VL53L0X_DEV Dev,
VL53L0X_DeviceParameters_t *pDeviceParameters)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
LOG_FUNCTION_START("");
- Status = VL53L0X_GetDeviceMode(Dev, &(pDeviceParameters->DeviceMode));
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_GetInterMeasurementPeriodMilliSeconds(Dev,
+ status = vl53l0x_get_device_mode(Dev, &(pDeviceParameters->DeviceMode));
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_inter_measurement_period_milli_seconds(Dev,
&(pDeviceParameters->InterMeasurementPeriodMilliSeconds));
- if (Status == VL53L0X_ERROR_NONE)
+ if (status == VL53L0X_ERROR_NONE)
pDeviceParameters->XTalkCompensationEnable = 0;
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_GetXTalkCompensationRateMegaCps(Dev,
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_x_talk_compensation_rate_mega_cps(Dev,
&(pDeviceParameters->XTalkCompensationRateMegaCps));
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_GetOffsetCalibrationDataMicroMeter(Dev,
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_offset_calibration_data_micro_meter(Dev,
&(pDeviceParameters->RangeOffsetMicroMeters));
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
/* get first the values, then the enables.
* VL53L0X_GetLimitCheckValue will modify the enable
* flags
*/
- if (Status == VL53L0X_ERROR_NONE) {
- Status |= VL53L0X_GetLimitCheckValue(Dev, i,
- &(pDeviceParameters->LimitChecksValue[i]));
+ if (status == VL53L0X_ERROR_NONE) {
+ status |= vl53l0x_get_limit_check_value(Dev, i,
+ &(pDeviceParameters->LimitChecksValue[i]));
} else {
break;
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status |= VL53L0X_GetLimitCheckEnable(Dev, i,
- &(pDeviceParameters->LimitChecksEnable[i]));
+ if (status == VL53L0X_ERROR_NONE) {
+ status |= vl53l0x_get_limit_check_enable(Dev, i,
+ &(pDeviceParameters->LimitChecksEnable[i]));
} else {
break;
}
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetWrapAroundCheckEnable(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_wrap_around_check_enable(Dev,
&(pDeviceParameters->WrapAroundCheckEnable));
}
/* Need to be done at the end as it uses VCSELPulsePeriod */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetMeasurementTimingBudgetMicroSeconds(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_measurement_timing_budget_micro_seconds(Dev,
&(pDeviceParameters->MeasurementTimingBudgetMicroSeconds));
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetLimitCheckValue(VL53L0X_DEV Dev, uint16_t LimitCheckId,
- FixPoint1616_t LimitCheckValue)
+VL53L0X_Error VL53L0X::vl53l0x_set_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
+ FixPoint1616_t limit_check_value)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t Temp8;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t temp8;
LOG_FUNCTION_START("");
- VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable, LimitCheckId,
- Temp8);
-
- if (Temp8 == 0) { /* disabled write only internal value */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- LimitCheckId, LimitCheckValue);
+ VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable, limit_check_id,
+ temp8);
+
+ if (temp8 == 0) { /* disabled write only internal value */
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
+ limit_check_id, limit_check_value);
} else {
- switch (LimitCheckId) {
+ switch (limit_check_id) {
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- LimitCheckValue);
+ limit_check_value);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- Status = VL53L0X_WrWord(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
- VL53L0X_FIXPOINT1616TOFIXPOINT97(
- LimitCheckValue));
+ status = vl53l0x_write_word(dev,
+ 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_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- LimitCheckValue);
+ limit_check_value);
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- LimitCheckValue);
+ limit_check_value);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
- Status = VL53L0X_WrWord(Dev,
- VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
- VL53L0X_FIXPOINT1616TOFIXPOINT97(
- LimitCheckValue));
+ status = vl53l0x_write_word(dev,
+ VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
+ VL53L0X_FIXPOINT1616TOFIXPOINT97(
+ limit_check_value));
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- LimitCheckId, LimitCheckValue);
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksValue,
+ limit_check_id, limit_check_value);
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_DataInit(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_data_init(VL53L0X_DEV Dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t CurrentParameters;
int i;
uint8_t StopVariable;
@@ -1554,8 +1554,8 @@
#endif
/* Set I2C standard mode */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0x88, 0x00);
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(Dev, 0x88, 0x00);
VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone, 0);
@@ -1580,8 +1580,8 @@
VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps, 0);
/* Get default parameters */
- Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
- if (Status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_device_parameters(Dev, &CurrentParameters);
+ if (status == VL53L0X_ERROR_NONE) {
/* initialize PAL values */
CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
@@ -1597,226 +1597,226 @@
/* Use internal default settings */
PALDevDataSet(Dev, UseInternalTuningSettings, 1);
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
- Status |= VL53L0X_RdByte(Dev, 0x91, &StopVariable);
+ 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_WrByte(Dev, 0x00, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+ status |= vl53l0x_write_byte(Dev, 0x00, 0x01);
+ status |= vl53l0x_write_byte(Dev, 0xFF, 0x00);
+ status |= vl53l0x_write_byte(Dev, 0x80, 0x00);
/* Enable all check */
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
- if (Status == VL53L0X_ERROR_NONE)
- Status |= VL53L0X_SetLimitCheckEnable(Dev, i, 1);
+ if (status == VL53L0X_ERROR_NONE)
+ status |= vl53l0x_set_limit_check_enable(Dev, i, 1);
else
break;
}
/* Disable the following checks */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_set_limit_check_enable(Dev,
+ VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_set_limit_check_enable(Dev,
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_set_limit_check_enable(Dev,
+ 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);
/* Limit default values */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- (FixPoint1616_t)(18 * 65536));
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_set_limit_check_value(Dev,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ (FixPoint1616_t)(18 * 65536));
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- (FixPoint1616_t)(25 * 65536 / 100));
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_set_limit_check_value(Dev,
+ VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+ (FixPoint1616_t)(25 * 65536 / 100));
/* 0.25 * 65536 */
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- (FixPoint1616_t)(35 * 65536));
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_set_limit_check_value(Dev,
+ VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ (FixPoint1616_t)(35 * 65536));
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- (FixPoint1616_t)(0 * 65536));
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_set_limit_check_value(Dev,
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ (FixPoint1616_t)(0 * 65536));
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
PALDevDataSet(Dev, SequenceConfig, 0xFF);
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- 0xFF);
+ status = vl53l0x_write_byte(Dev, 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);
}
- if (Status == VL53L0X_ERROR_NONE)
+ if (status == VL53L0X_ERROR_NONE)
VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 0);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_check_part_used(VL53L0X_DEV Dev,
- uint8_t *Revision,
- VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+VL53L0X_Error VL53L0X::vl53l0x_check_part_used(VL53L0X_DEV dev,
+ uint8_t *revision,
+ VL53L0X_DeviceInfo_t *p_vl53l0x_device_info)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t ModuleIdInt;
- char *ProductId_tmp;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t module_id_int;
+ char *product_id_tmp;
LOG_FUNCTION_START("");
- Status = VL53L0X_get_info_from_device(Dev, 2);
-
- if (Status == VL53L0X_ERROR_NONE) {
- ModuleIdInt = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ModuleId);
-
- if (ModuleIdInt == 0) {
- *Revision = 0;
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, "");
+ status = vl53l0x_get_info_from_device(dev, 2);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ module_id_int = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, ModuleId);
+
+ if (module_id_int == 0) {
+ *revision = 0;
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->ProductId, "");
} else {
- *Revision = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, Revision);
- ProductId_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- ProductId);
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, ProductId_tmp);
+ *revision = VL53L0X_GETDEVICESPECIFICPARAMETER(dev, Revision);
+ product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
+ ProductId);
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->ProductId, product_id_tmp);
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_device_info(VL53L0X_DEV Dev,
- VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_device_info(VL53L0X_DEV dev,
+ VL53L0X_DeviceInfo_t *p_vl53l0x_device_info)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t revision_id;
- uint8_t Revision;
-
- Status = VL53L0X_check_part_used(Dev, &Revision, pVL53L0X_DeviceInfo);
-
- if (Status == VL53L0X_ERROR_NONE) {
- if (Revision == 0) {
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+ uint8_t revision;
+
+ status = vl53l0x_check_part_used(dev, &revision, p_vl53l0x_device_info);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ if (revision == 0) {
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->Name,
VL53L0X_STRING_DEVICE_INFO_NAME_TS0);
- } else if ((Revision <= 34) && (Revision != 32)) {
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+ } else if ((revision <= 34) && (revision != 32)) {
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->Name,
VL53L0X_STRING_DEVICE_INFO_NAME_TS1);
- } else if (Revision < 39) {
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+ } else if (revision < 39) {
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->Name,
VL53L0X_STRING_DEVICE_INFO_NAME_TS2);
} else {
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->Name,
VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
}
- VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Type,
+ VL53L0X_COPYSTRING(p_vl53l0x_device_info->Type,
VL53L0X_STRING_DEVICE_INFO_TYPE);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
- &pVL53L0X_DeviceInfo->ProductType);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
+ &p_vl53l0x_device_info->ProductType);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_IDENTIFICATION_REVISION_ID,
- &revision_id);
- pVL53L0X_DeviceInfo->ProductRevisionMajor = 1;
- pVL53L0X_DeviceInfo->ProductRevisionMinor =
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_byte(dev,
+ VL53L0X_REG_IDENTIFICATION_REVISION_ID,
+ &revision_id);
+ p_vl53l0x_device_info->ProductRevisionMajor = 1;
+ p_vl53l0x_device_info->ProductRevisionMinor =
(revision_id & 0xF0) >> 4;
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetDeviceInfo(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_device_info(VL53L0X_DEV Dev,
VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_get_device_info(Dev, pVL53L0X_DeviceInfo);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = wrapped_vl53l0x_get_device_info(Dev, pVL53L0X_DeviceInfo);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetInterruptMaskStatus(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_mask_status(VL53L0X_DEV Dev,
uint32_t *pInterruptMaskStatus)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t Byte;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t byte;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
- *pInterruptMaskStatus = Byte & 0x07;
-
- if (Byte & 0x18)
- Status = VL53L0X_ERROR_RANGE_ERROR;
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = vl53l0x_read_byte(Dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
+ *pInterruptMaskStatus = byte & 0x07;
+
+ if (byte & 0x18)
+ status = VL53L0X_ERROR_RANGE_ERROR;
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetMeasurementDataReady(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_get_measurement_data_ready(VL53L0X_DEV Dev,
uint8_t *pMeasurementDataReady)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t SysRangeStatusRegister;
- uint8_t InterruptConfig;
- uint32_t InterruptMask;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sys_range_status_register;
+ uint8_t interrupt_config;
+ uint32_t interrupt_mask;
LOG_FUNCTION_START("");
- InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- Pin0GpioFunctionality);
-
- if (InterruptConfig ==
+ interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ Pin0GpioFunctionality);
+
+ if (interrupt_config ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
- Status = VL53L0X_GetInterruptMaskStatus(Dev, &InterruptMask);
- if (InterruptMask ==
+ status = vl53l0x_get_interrupt_mask_status(Dev, &interrupt_mask);
+ if (interrupt_mask ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY)
*pMeasurementDataReady = 1;
else
*pMeasurementDataReady = 0;
} else {
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
- &SysRangeStatusRegister);
- if (Status == VL53L0X_ERROR_NONE) {
- if (SysRangeStatusRegister & 0x01)
+ status = vl53l0x_read_byte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
+ &sys_range_status_register);
+ if (status == VL53L0X_ERROR_NONE) {
+ if (sys_range_status_register & 0x01)
*pMeasurementDataReady = 1;
else
*pMeasurementDataReady = 0;
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_PollingDelay(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_polling_delay(VL53L0X_DEV dev)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -1825,258 +1825,258 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_measurement_poll_for_completion(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t NewDataReady = 0;
- uint32_t LoopNb;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t new_data_ready = 0;
+ uint32_t loop_nb;
LOG_FUNCTION_START("");
- LoopNb = 0;
+ loop_nb = 0;
do {
- Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDataReady);
- if (Status != 0)
+ status = vl53l0x_get_measurement_data_ready(dev, &new_data_ready);
+ if (status != 0)
break; /* the error is set */
- if (NewDataReady == 1)
+ if (new_data_ready == 1)
break; /* done note that status == 0 */
- LoopNb++;
- if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
- Status = VL53L0X_ERROR_TIME_OUT;
+ loop_nb++;
+ if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
+ status = VL53L0X_ERROR_TIME_OUT;
break;
}
- VL53L0X_PollingDelay(Dev);
+ vl53l0x_polling_delay(dev);
} while (1);
- LOG_FUNCTION_END(Status);
-
- return Status;
+ LOG_FUNCTION_END(status);
+
+ return status;
}
/* Group PAL Interrupt Functions */
-VL53L0X_Error VL53L0X::VL53L0X_ClearInterruptMask(VL53L0X_DEV Dev, uint32_t InterruptMask)
+VL53L0X_Error VL53L0X::vl53l0x_clear_interrupt_mask(VL53L0X_DEV Dev, uint32_t InterruptMask)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t LoopCount;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t loop_count;
uint8_t Byte;
LOG_FUNCTION_START("");
/* clear bit 0 range interrupt, bit 1 error interrupt */
- LoopCount = 0;
+ loop_count = 0;
do {
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
- Status |= VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
- Status |= VL53L0X_RdByte(Dev,
- VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
- LoopCount++;
+ 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);
+ loop_count++;
} while (((Byte & 0x07) != 0x00)
- && (LoopCount < 3)
- && (Status == VL53L0X_ERROR_NONE));
-
-
- if (LoopCount >= 3)
- Status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
-
- LOG_FUNCTION_END(Status);
- return Status;
+ && (loop_count < 3)
+ && (status == VL53L0X_ERROR_NONE));
+
+
+ if (loop_count >= 3)
+ status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_single_ref_calibration(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_perform_single_ref_calibration(VL53L0X_DEV dev,
uint8_t vhv_init_byte)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 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);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_ClearInterruptMask(Dev, 0);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START, 0x00);
-
- return Status;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 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);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_clear_interrupt_mask(dev, 0);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x00);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_ref_calibration_io(VL53L0X_DEV Dev, uint8_t read_not_write,
- uint8_t VhvSettings, uint8_t PhaseCal,
- uint8_t *pVhvSettings, uint8_t *pPhaseCal,
+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 Status = VL53L0X_ERROR_NONE;
- uint8_t PhaseCalint = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t phase_calint = 0;
/* Read VHV from device */
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x01);
+ status |= vl53l0x_write_byte(dev, 0x00, 0x00);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x00);
if (read_not_write) {
if (vhv_enable)
- Status |= VL53L0X_RdByte(Dev, 0xCB, pVhvSettings);
+ status |= vl53l0x_read_byte(dev, 0xCB, p_vhv_settings);
if (phase_enable)
- Status |= VL53L0X_RdByte(Dev, 0xEE, &PhaseCalint);
+ status |= vl53l0x_read_byte(dev, 0xEE, &phase_calint);
} else {
if (vhv_enable)
- Status |= VL53L0X_WrByte(Dev, 0xCB, VhvSettings);
+ status |= vl53l0x_write_byte(dev, 0xCB, vhv_settings);
if (phase_enable)
- Status |= VL53L0X_UpdateByte(Dev, 0xEE, 0x80, PhaseCal);
+ status |= vl53l0x_update_byte(dev, 0xEE, 0x80, phase_cal);
}
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
-
- *pPhaseCal = (uint8_t)(PhaseCalint&0xEF);
-
- return Status;
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x01);
+ status |= vl53l0x_write_byte(dev, 0x00, 0x01);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x00);
+
+ *p_phase_cal = (uint8_t)(phase_calint&0xEF);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_vhv_calibration(VL53L0X_DEV Dev,
- uint8_t *pVhvSettings, const uint8_t get_data_enable,
+VL53L0X_Error VL53L0X::vl53l0x_perform_vhv_calibration(VL53L0X_DEV dev,
+ uint8_t *p_vhv_settings, const uint8_t get_data_enable,
const uint8_t restore_config)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t SequenceConfig = 0;
- uint8_t VhvSettings = 0;
- uint8_t PhaseCal = 0;
- uint8_t PhaseCalInt = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sequence_config = 0;
+ uint8_t vhv_settings = 0;
+ uint8_t phase_cal = 0;
+ uint8_t phase_cal_int = 0;
/* store the value of the sequence config,
* this will be reset before the end of the function
*/
if (restore_config)
- SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+ sequence_config = PALDevDataGet(dev, SequenceConfig);
/* Run VHV */
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_perform_single_ref_calibration(Dev, 0x40);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_perform_single_ref_calibration(dev, 0x40);
/* Read VHV from device */
- if ((Status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
- Status = VL53L0X_ref_calibration_io(Dev, 1,
- VhvSettings, PhaseCal, /* Not used here */
- pVhvSettings, &PhaseCalInt,
+ 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);
} else
- *pVhvSettings = 0;
-
-
- if ((Status == VL53L0X_ERROR_NONE) && restore_config) {
+ *p_vhv_settings = 0;
+
+
+ if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- SequenceConfig);
- if (Status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ sequence_config);
+ if (status == VL53L0X_ERROR_NONE)
+ PALDevDataSet(dev, SequenceConfig, sequence_config);
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_phase_calibration(VL53L0X_DEV Dev,
- uint8_t *pPhaseCal, const uint8_t get_data_enable,
+VL53L0X_Error VL53L0X::vl53l0x_perform_phase_calibration(VL53L0X_DEV dev,
+ uint8_t *p_phase_cal, const uint8_t get_data_enable,
const uint8_t restore_config)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t SequenceConfig = 0;
- uint8_t VhvSettings = 0;
- uint8_t PhaseCal = 0;
- uint8_t VhvSettingsint;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sequence_config = 0;
+ uint8_t vhv_settings = 0;
+ uint8_t phase_cal = 0;
+ uint8_t vhv_settingsint;
/* store the value of the sequence config,
* this will be reset before the end of the function
*/
if (restore_config)
- SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+ sequence_config = PALDevDataGet(dev, SequenceConfig);
/* Run PhaseCal */
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_perform_single_ref_calibration(Dev, 0x0);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_perform_single_ref_calibration(dev, 0x0);
/* Read PhaseCal from device */
- if ((Status == VL53L0X_ERROR_NONE) && (get_data_enable == 1)) {
- Status = VL53L0X_ref_calibration_io(Dev, 1,
- VhvSettings, PhaseCal, /* Not used here */
- &VhvSettingsint, pPhaseCal,
+ 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);
} else
- *pPhaseCal = 0;
-
-
- if ((Status == VL53L0X_ERROR_NONE) && restore_config) {
+ *p_phase_cal = 0;
+
+
+ if ((status == VL53L0X_ERROR_NONE) && restore_config) {
/* restore the previous Sequence Config */
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- SequenceConfig);
- if (Status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ sequence_config);
+ if (status == VL53L0X_ERROR_NONE)
+ PALDevDataSet(dev, SequenceConfig, sequence_config);
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
- uint8_t *pVhvSettings, uint8_t *pPhaseCal, uint8_t get_data_enable)
+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 Status = VL53L0X_ERROR_NONE;
- uint8_t SequenceConfig = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sequence_config = 0;
/* store the value of the sequence config,
* this will be reset before the end of the function
*/
- SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+ sequence_config = PALDevDataGet(dev, 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, pVhvSettings, get_data_enable, 0);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_perform_phase_calibration(
- Dev, pPhaseCal, get_data_enable, 0);
-
-
- if (Status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_perform_vhv_calibration(
+ dev, 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);
+
+
+ if (status == VL53L0X_ERROR_NONE) {
/* restore the previous Sequence Config */
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- SequenceConfig);
- if (Status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ sequence_config);
+ if (status == VL53L0X_ERROR_NONE)
+ PALDevDataSet(dev, SequenceConfig, sequence_config);
}
- return Status;
+ return status;
}
-void VL53L0X::get_next_good_spad(uint8_t goodSpadArray[], uint32_t size,
- uint32_t curr, int32_t *next)
+void VL53L0X::get_next_good_spad(uint8_t good_spad_array[], uint32_t size,
+ uint32_t curr, int32_t *p_next)
{
- uint32_t startIndex;
- uint32_t fineOffset;
- uint32_t cSpadsPerByte = 8;
- uint32_t coarseIndex;
- uint32_t fineIndex;
- uint8_t dataByte;
+ uint32_t start_index;
+ uint32_t fine_offset;
+ uint32_t c_spads_per_byte = 8;
+ uint32_t coarse_index;
+ uint32_t fine_index;
+ uint8_t data_byte;
uint8_t success = 0;
/*
@@ -2087,82 +2087,82 @@
* the index of the bit within each byte.
*/
- *next = -1;
-
- startIndex = curr / cSpadsPerByte;
- fineOffset = curr % cSpadsPerByte;
-
- for (coarseIndex = startIndex; ((coarseIndex < size) && !success);
- coarseIndex++) {
- fineIndex = 0;
- dataByte = goodSpadArray[coarseIndex];
-
- if (coarseIndex == startIndex) {
+ *p_next = -1;
+
+ start_index = curr / c_spads_per_byte;
+ fine_offset = curr % c_spads_per_byte;
+
+ for (coarse_index = start_index; ((coarse_index < size) && !success);
+ coarse_index++) {
+ fine_index = 0;
+ data_byte = good_spad_array[coarse_index];
+
+ if (coarse_index == start_index) {
/* locate the bit position of the provided current
* spad bit before iterating */
- dataByte >>= fineOffset;
- fineIndex = fineOffset;
+ data_byte >>= fine_offset;
+ fine_index = fine_offset;
}
- while (fineIndex < cSpadsPerByte) {
- if ((dataByte & 0x1) == 1) {
+ while (fine_index < c_spads_per_byte) {
+ if ((data_byte & 0x1) == 1) {
success = 1;
- *next = coarseIndex * cSpadsPerByte + fineIndex;
+ *p_next = coarse_index * c_spads_per_byte + fine_index;
break;
}
- dataByte >>= 1;
- fineIndex++;
+ data_byte >>= 1;
+ fine_index++;
}
}
}
-uint8_t VL53L0X::is_aperture(uint32_t spadIndex)
+uint8_t VL53L0X::is_aperture(uint32_t spad_index)
{
/*
* This function reports if a given spad index is an aperture SPAD by
* deriving the quadrant.
*/
uint32_t quadrant;
- uint8_t isAperture = 1;
- quadrant = spadIndex >> 6;
+ uint8_t is_aperture = 1;
+ quadrant = spad_index >> 6;
if (refArrayQuadrants[quadrant] == REF_ARRAY_SPAD_0)
- isAperture = 0;
-
- return isAperture;
+ is_aperture = 0;
+
+ return is_aperture;
}
-VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spadArray[], uint32_t size,
- uint32_t spadIndex)
+VL53L0X_Error VL53L0X::enable_spad_bit(uint8_t spad_array[], uint32_t size,
+ uint32_t spad_index)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- uint32_t cSpadsPerByte = 8;
- uint32_t coarseIndex;
- uint32_t fineIndex;
-
- coarseIndex = spadIndex / cSpadsPerByte;
- fineIndex = spadIndex % cSpadsPerByte;
- if (coarseIndex >= size)
+ uint32_t c_spads_per_byte = 8;
+ uint32_t coarse_index;
+ uint32_t fine_index;
+
+ coarse_index = spad_index / c_spads_per_byte;
+ fine_index = spad_index % c_spads_per_byte;
+ if (coarse_index >= size)
status = VL53L0X_ERROR_REF_SPAD_INIT;
else
- spadArray[coarseIndex] |= (1 << fineIndex);
+ spad_array[coarse_index] |= (1 << fine_index);
return status;
}
-VL53L0X_Error VL53L0X::set_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray)
+VL53L0X_Error VL53L0X::set_ref_spad_map(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
{
- VL53L0X_Error status = VL53L0X_WriteMulti(Dev,
+ VL53L0X_Error status = vl53l0x_write_multi(dev,
VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
- refSpadArray, 6);
+ p_ref_spad_array, 6);
return status;
}
-VL53L0X_Error VL53L0X::get_ref_spad_map(VL53L0X_DEV Dev, uint8_t *refSpadArray)
+VL53L0X_Error VL53L0X::get_ref_spad_map(VL53L0X_DEV dev, uint8_t *p_ref_spad_array)
{
- VL53L0X_Error status = VL53L0X_ReadMulti(Dev,
+ VL53L0X_Error status = vl53l0x_read_multi(dev,
VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
- refSpadArray,
+ p_ref_spad_array,
6);
// VL53L0X_Error status = VL53L0X_ERROR_NONE;
// uint8_t count=0;
@@ -2172,22 +2172,22 @@
return status;
}
-VL53L0X_Error VL53L0X::enable_ref_spads(VL53L0X_DEV Dev,
- uint8_t apertureSpads,
- uint8_t goodSpadArray[],
- uint8_t spadArray[],
+VL53L0X_Error VL53L0X::enable_ref_spads(VL53L0X_DEV dev,
+ uint8_t aperture_spads,
+ uint8_t good_spad_array[],
+ uint8_t spad_array[],
uint32_t size,
uint32_t start,
uint32_t offset,
- uint32_t spadCount,
- uint32_t *lastSpad)
+ uint32_t spad_count,
+ uint32_t *p_last_spad)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint32_t index;
uint32_t i;
- int32_t nextGoodSpad = offset;
- uint32_t currentSpad;
- uint8_t checkSpadArray[6];
+ int32_t next_good_spad = offset;
+ uint32_t current_spad;
+ uint8_t check_spad_array[6];
/*
* This function takes in a spad array which may or may not have SPADS
@@ -2199,42 +2199,42 @@
* Checks are performed to ensure this.
*/
- currentSpad = offset;
- for (index = 0; index < spadCount; index++) {
- get_next_good_spad(goodSpadArray, size, currentSpad,
- &nextGoodSpad);
-
- if (nextGoodSpad == -1) {
+ current_spad = offset;
+ for (index = 0; index < spad_count; index++) {
+ get_next_good_spad(good_spad_array, size, current_spad,
+ &next_good_spad);
+
+ if (next_good_spad == -1) {
status = VL53L0X_ERROR_REF_SPAD_INIT;
break;
}
/* Confirm that the next good SPAD is non-aperture */
- if (is_aperture(start + nextGoodSpad) != apertureSpads) {
+ if (is_aperture(start + next_good_spad) != aperture_spads) {
/* if we can't get the required number of good aperture
* spads from the current quadrant then this is an error
*/
status = VL53L0X_ERROR_REF_SPAD_INIT;
break;
}
- currentSpad = (uint32_t)nextGoodSpad;
- enable_spad_bit(spadArray, size, currentSpad);
- currentSpad++;
+ current_spad = (uint32_t)next_good_spad;
+ enable_spad_bit(spad_array, size, current_spad);
+ current_spad++;
}
- *lastSpad = currentSpad;
+ *p_last_spad = current_spad;
if (status == VL53L0X_ERROR_NONE)
- status = set_ref_spad_map(Dev, spadArray);
+ status = set_ref_spad_map(dev, spad_array);
if (status == VL53L0X_ERROR_NONE) {
- status = get_ref_spad_map(Dev, checkSpadArray);
+ status = get_ref_spad_map(dev, check_spad_array);
i = 0;
/* Compare spad maps. If not equal report error. */
while (i < size) {
- if (spadArray[i] != checkSpadArray[i]) {
+ if (spad_array[i] != check_spad_array[i]) {
status = VL53L0X_ERROR_REF_SPAD_INIT;
break;
}
@@ -2244,200 +2244,200 @@
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetDeviceMode(VL53L0X_DEV Dev, VL53L0X_DeviceModes DeviceMode)
+VL53L0X_Error VL53L0X::vl53l0x_set_device_mode(VL53L0X_DEV Dev, VL53L0X_DeviceModes device_mode)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("%d", (int)DeviceMode);
- switch (DeviceMode) {
+ switch (device_mode) {
case VL53L0X_DEVICEMODE_SINGLE_RANGING:
case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
case VL53L0X_DEVICEMODE_GPIO_DRIVE:
case VL53L0X_DEVICEMODE_GPIO_OSC:
/* Supported modes */
- VL53L0X_SETPARAMETERFIELD(Dev, DeviceMode, DeviceMode);
+ VL53L0X_SETPARAMETERFIELD(Dev, DeviceMode, device_mode);
break;
default:
/* Unsupported mode */
- Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
+ status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetInterruptThresholds(VL53L0X_DEV Dev,
- VL53L0X_DeviceModes DeviceMode, FixPoint1616_t ThresholdLow,
- FixPoint1616_t ThresholdHigh)
+VL53L0X_Error VL53L0X::vl53l0x_set_interrupt_thresholds(VL53L0X_DEV dev,
+ VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
+ FixPoint1616_t threshold_high)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint16_t Threshold16;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint16_t threshold16;
LOG_FUNCTION_START("");
/* no dependency on DeviceMode for Ewok */
/* Need to divide by 2 because the FW will apply a x2 */
- Threshold16 = (uint16_t)((ThresholdLow >> 17) & 0x00fff);
- Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, Threshold16);
-
- if (Status == VL53L0X_ERROR_NONE) {
+ threshold16 = (uint16_t)((threshold_low >> 17) & 0x00fff);
+ status = vl53l0x_write_word(dev, 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)((ThresholdHigh >> 17) & 0x00fff);
- Status = VL53L0X_WrWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
- Threshold16);
+ threshold16 = (uint16_t)((threshold_high >> 17) & 0x00fff);
+ status = vl53l0x_write_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+ threshold16);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetInterruptThresholds(VL53L0X_DEV Dev,
- VL53L0X_DeviceModes DeviceMode, FixPoint1616_t *pThresholdLow,
- FixPoint1616_t *pThresholdHigh)
+VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_thresholds(VL53L0X_DEV dev,
+ VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
+ FixPoint1616_t *p_threshold_high)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint16_t Threshold16;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint16_t threshold16;
LOG_FUNCTION_START("");
/* no dependency on DeviceMode for Ewok */
- Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &Threshold16);
+ status = vl53l0x_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &threshold16);
/* Need to multiply by 2 because the FW will apply a x2 */
- *pThresholdLow = (FixPoint1616_t)((0x00fff & Threshold16) << 17);
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdWord(Dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
- &Threshold16);
+ *p_threshold_low = (FixPoint1616_t)((0x00fff & threshold16) << 17);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_word(dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
+ &threshold16);
/* Need to multiply by 2 because the FW will apply a x2 */
- *pThresholdHigh =
- (FixPoint1616_t)((0x00fff & Threshold16) << 17);
+ *p_threshold_high =
+ (FixPoint1616_t)((0x00fff & threshold16) << 17);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
- uint8_t *pTuningSettingBuffer)
+VL53L0X_Error VL53L0X::vl53l0x_load_tuning_settings(VL53L0X_DEV dev,
+ uint8_t *p_tuning_setting_buffer)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
- int Index;
+ int index;
uint8_t msb;
uint8_t lsb;
- uint8_t SelectParam;
- uint8_t NumberOfWrites;
- uint8_t Address;
- uint8_t localBuffer[4]; /* max */
- uint16_t Temp16;
+ uint8_t select_param;
+ uint8_t number_of_writes;
+ uint8_t address;
+ uint8_t local_buffer[4]; /* max */
+ uint16_t temp16;
LOG_FUNCTION_START("");
- Index = 0;
-
- while ((*(pTuningSettingBuffer + Index) != 0) &&
- (Status == VL53L0X_ERROR_NONE)) {
- NumberOfWrites = *(pTuningSettingBuffer + Index);
- Index++;
- if (NumberOfWrites == 0xFF) {
+ index = 0;
+
+ while ((*(p_tuning_setting_buffer + index) != 0) &&
+ (status == VL53L0X_ERROR_NONE)) {
+ number_of_writes = *(p_tuning_setting_buffer + index);
+ index++;
+ if (number_of_writes == 0xFF) {
/* internal parameters */
- SelectParam = *(pTuningSettingBuffer + Index);
- Index++;
- switch (SelectParam) {
+ select_param = *(p_tuning_setting_buffer + index);
+ index++;
+ switch (select_param) {
case 0: /* uint16_t SigmaEstRefArray -> 2 bytes */
- msb = *(pTuningSettingBuffer + Index);
- Index++;
- lsb = *(pTuningSettingBuffer + Index);
- Index++;
- Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(Dev, SigmaEstRefArray, Temp16);
+ msb = *(p_tuning_setting_buffer + index);
+ index++;
+ lsb = *(p_tuning_setting_buffer + index);
+ index++;
+ temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+ PALDevDataSet(dev, SigmaEstRefArray, temp16);
break;
case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
- msb = *(pTuningSettingBuffer + Index);
- Index++;
- lsb = *(pTuningSettingBuffer + Index);
- Index++;
- Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(Dev, SigmaEstEffPulseWidth,
- Temp16);
+ msb = *(p_tuning_setting_buffer + index);
+ index++;
+ lsb = *(p_tuning_setting_buffer + index);
+ index++;
+ temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+ PALDevDataSet(dev, SigmaEstEffPulseWidth,
+ temp16);
break;
case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
- msb = *(pTuningSettingBuffer + Index);
- Index++;
- lsb = *(pTuningSettingBuffer + Index);
- Index++;
- Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(Dev, SigmaEstEffAmbWidth, Temp16);
+ msb = *(p_tuning_setting_buffer + index);
+ index++;
+ lsb = *(p_tuning_setting_buffer + index);
+ index++;
+ temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+ PALDevDataSet(dev, SigmaEstEffAmbWidth, temp16);
break;
case 3: /* uint16_t targetRefRate -> 2 bytes */
- msb = *(pTuningSettingBuffer + Index);
- Index++;
- lsb = *(pTuningSettingBuffer + Index);
- Index++;
- Temp16 = VL53L0X_MAKEUINT16(lsb, msb);
- PALDevDataSet(Dev, targetRefRate, Temp16);
+ msb = *(p_tuning_setting_buffer + index);
+ index++;
+ lsb = *(p_tuning_setting_buffer + index);
+ index++;
+ temp16 = VL53L0X_MAKEUINT16(lsb, msb);
+ PALDevDataSet(dev, targetRefRate, temp16);
break;
default: /* invalid parameter */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
- } else if (NumberOfWrites <= 4) {
- Address = *(pTuningSettingBuffer + Index);
- Index++;
-
- for (i = 0; i < NumberOfWrites; i++) {
- localBuffer[i] = *(pTuningSettingBuffer +
- Index);
- Index++;
+ } else if (number_of_writes <= 4) {
+ address = *(p_tuning_setting_buffer + index);
+ index++;
+
+ for (i = 0; i < number_of_writes; i++) {
+ local_buffer[i] = *(p_tuning_setting_buffer +
+ index);
+ index++;
}
- Status = VL53L0X_WriteMulti(Dev, Address, localBuffer,
- NumberOfWrites);
+ status = vl53l0x_write_multi(dev, address, local_buffer,
+ number_of_writes);
} else {
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_CheckAndLoadInterruptSettings(VL53L0X_DEV Dev,
- uint8_t StartNotStopFlag)
+VL53L0X_Error VL53L0X::vl53l0x_check_and_load_interrupt_settings(VL53L0X_DEV Dev,
+ uint8_t start_not_stopflag)
{
- uint8_t InterruptConfig;
- FixPoint1616_t ThresholdLow;
- FixPoint1616_t ThresholdHigh;
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
-
- InterruptConfig = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- Pin0GpioFunctionality);
-
- if ((InterruptConfig ==
+ uint8_t interrupt_config;
+ FixPoint1616_t threshold_low;
+ FixPoint1616_t threshold_high;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+ interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ Pin0GpioFunctionality);
+
+ if ((interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW) ||
- (InterruptConfig ==
+ (interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH) ||
- (InterruptConfig ==
+ (interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
- Status = VL53L0X_GetInterruptThresholds(Dev,
- VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
- &ThresholdLow, &ThresholdHigh);
-
- if (((ThresholdLow > 255*65536) ||
- (ThresholdHigh > 255*65536)) &&
- (Status == VL53L0X_ERROR_NONE)) {
-
- if (StartNotStopFlag != 0) {
- Status = VL53L0X_load_tuning_settings(Dev,
+ status = vl53l0x_get_interrupt_thresholds(Dev,
+ 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);
} else {
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x04);
- Status |= VL53L0X_WrByte(Dev, 0x70, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x00);
+ 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);
}
}
@@ -2445,49 +2445,49 @@
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_StartMeasurement(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_start_measurement(VL53L0X_DEV Dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- VL53L0X_DeviceModes DeviceMode;
- uint8_t Byte;
- uint8_t StartStopByte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
- uint32_t LoopNb;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ VL53L0X_DeviceModes device_mode;
+ uint8_t byte;
+ uint8_t start_stop_byte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
+ uint32_t loop_nb;
LOG_FUNCTION_START("");
/* Get Current DeviceMode */
- VL53L0X_GetDeviceMode(Dev, &DeviceMode);
-
- Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x91, PALDevDataGet(Dev, StopVariable));
- Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
-
- switch (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);
+
+ switch (device_mode) {
case VL53L0X_DEVICEMODE_SINGLE_RANGING:
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START, 0x01);
-
- Byte = StartStopByte;
- if (Status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_byte(Dev, VL53L0X_REG_SYSRANGE_START, 0x01);
+
+ byte = start_stop_byte;
+ if (status == VL53L0X_ERROR_NONE) {
/* Wait until start bit has been cleared */
- LoopNb = 0;
+ loop_nb = 0;
do {
- if (LoopNb > 0)
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_SYSRANGE_START, &Byte);
- LoopNb = LoopNb + 1;
- } while (((Byte & StartStopByte) == StartStopByte)
- && (Status == VL53L0X_ERROR_NONE)
- && (LoopNb < VL53L0X_DEFAULT_MAX_LOOP));
-
- if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP)
- Status = VL53L0X_ERROR_TIME_OUT;
+ if (loop_nb > 0)
+ status = vl53l0x_read_byte(Dev,
+ VL53L0X_REG_SYSRANGE_START, &byte);
+ loop_nb = loop_nb + 1;
+ } while (((byte & start_stop_byte) == start_stop_byte)
+ && (status == VL53L0X_ERROR_NONE)
+ && (loop_nb < VL53L0X_DEFAULT_MAX_LOOP));
+
+ if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP)
+ status = VL53L0X_ERROR_TIME_OUT;
}
@@ -2496,13 +2496,13 @@
/* Back-to-back mode */
/* Check if need to apply interrupt settings */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSRANGE_START,
- VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK);
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_check_and_load_interrupt_settings(Dev, 1);
+
+ status = vl53l0x_write_byte(Dev,
+ 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);
}
@@ -2510,133 +2510,133 @@
case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
/* Continuous mode */
/* Check if need to apply interrupt settings */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 1);
-
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSRANGE_START,
- VL53L0X_REG_SYSRANGE_MODE_TIMED);
-
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_check_and_load_interrupt_settings(Dev, 1);
+
+ status = vl53l0x_write_byte(Dev,
+ 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);
}
break;
default:
/* Selected mode not supported */
- Status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
+ status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
/* Group PAL Measurement Functions */
-VL53L0X_Error VL53L0X::VL53L0X_PerformSingleMeasurement(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_perform_single_measurement(VL53L0X_DEV Dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- VL53L0X_DeviceModes DeviceMode;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ VL53L0X_DeviceModes device_mode;
LOG_FUNCTION_START("");
/* Get Current DeviceMode */
- Status = VL53L0X_GetDeviceMode(Dev, &DeviceMode);
+ status = vl53l0x_get_device_mode(Dev, &device_mode);
/* Start immediately to run a single ranging measurement in case of
* single ranging or single histogram */
- if (Status == VL53L0X_ERROR_NONE
- && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
- Status = VL53L0X_StartMeasurement(Dev);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_measurement_poll_for_completion(Dev);
+ if (status == VL53L0X_ERROR_NONE
+ && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
+ status = vl53l0x_start_measurement(Dev);
+
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_measurement_poll_for_completion(Dev);
/* Change PAL State in case of single ranging or single histogram */
- if (Status == VL53L0X_ERROR_NONE
- && DeviceMode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
+ if (status == VL53L0X_ERROR_NONE
+ && device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetXTalkCompensationEnable(VL53L0X_DEV Dev,
- uint8_t *pXTalkCompensationEnable)
+VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_enable(VL53L0X_DEV dev,
+ uint8_t *p_x_talk_compensation_enable)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t Temp8;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t temp8;
LOG_FUNCTION_START("");
- VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable, Temp8);
- *pXTalkCompensationEnable = Temp8;
-
- LOG_FUNCTION_END(Status);
- return Status;
+ VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationEnable, temp8);
+ *p_x_talk_compensation_enable = temp8;
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_xtalk_rate(VL53L0X_DEV Dev,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
- FixPoint1616_t *ptotal_xtalk_rate_mcps)
+VL53L0X_Error VL53L0X::vl53l0x_get_total_xtalk_rate(VL53L0X_DEV dev,
+ VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+ FixPoint1616_t *p_total_xtalk_rate_mcps)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
-
- uint8_t xtalkCompEnable;
- FixPoint1616_t totalXtalkMegaCps;
- FixPoint1616_t xtalkPerSpadMegaCps;
-
- *ptotal_xtalk_rate_mcps = 0;
-
- Status = VL53L0X_GetXTalkCompensationEnable(Dev, &xtalkCompEnable);
- if (Status == VL53L0X_ERROR_NONE) {
-
- if (xtalkCompEnable) {
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+
+ uint8_t xtalk_comp_enable;
+ FixPoint1616_t total_xtalk_mega_cps;
+ FixPoint1616_t xtalk_per_spad_mega_cps;
+
+ *p_total_xtalk_rate_mcps = 0;
+
+ status = vl53l0x_get_x_talk_compensation_enable(dev, &xtalk_comp_enable);
+ if (status == VL53L0X_ERROR_NONE) {
+
+ if (xtalk_comp_enable) {
VL53L0X_GETPARAMETERFIELD(
- Dev,
+ dev,
XTalkCompensationRateMegaCps,
- xtalkPerSpadMegaCps);
+ xtalk_per_spad_mega_cps);
/* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
- totalXtalkMegaCps =
- pRangingMeasurementData->EffectiveSpadRtnCount *
- xtalkPerSpadMegaCps;
+ total_xtalk_mega_cps =
+ p_ranging_measurement_data->EffectiveSpadRtnCount *
+ xtalk_per_spad_mega_cps;
/* FixPoint0824 >> 8 = FixPoint1616 */
- *ptotal_xtalk_rate_mcps =
- (totalXtalkMegaCps + 0x80) >> 8;
+ *p_total_xtalk_rate_mcps =
+ (total_xtalk_mega_cps + 0x80) >> 8;
}
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_total_signal_rate(VL53L0X_DEV Dev,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
- FixPoint1616_t *ptotal_signal_rate_mcps)
+VL53L0X_Error VL53L0X::vl53l0x_get_total_signal_rate(VL53L0X_DEV dev,
+ VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+ FixPoint1616_t *p_total_signal_rate_mcps)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- FixPoint1616_t totalXtalkMegaCps;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ FixPoint1616_t total_xtalk_mega_cps;
LOG_FUNCTION_START("");
- *ptotal_signal_rate_mcps =
- pRangingMeasurementData->SignalRateRtnMegaCps;
-
- Status = VL53L0X_get_total_xtalk_rate(
- Dev, pRangingMeasurementData, &totalXtalkMegaCps);
-
- if (Status == VL53L0X_ERROR_NONE)
- *ptotal_signal_rate_mcps += totalXtalkMegaCps;
-
- return Status;
+ *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);
+
+ if (status == VL53L0X_ERROR_NONE)
+ *p_total_signal_rate_mcps += total_xtalk_mega_cps;
+
+ return status;
}
/* To convert ms into register value */
-uint32_t VL53L0X::VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev,
+uint32_t VL53L0X::vl53l0x_calc_timeout_mclks(VL53L0X_DEV dev,
uint32_t timeout_period_us,
uint8_t vcsel_period_pclks)
{
@@ -2644,7 +2644,7 @@
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(dev, vcsel_period_pclks);
macro_period_ns = (macro_period_ps + 500) / 1000;
timeout_period_mclks =
@@ -2654,7 +2654,7 @@
return timeout_period_mclks;
}
-uint32_t VL53L0X::VL53L0X_isqrt(uint32_t num)
+uint32_t VL53L0X::vl53l0x_isqrt(uint32_t num)
{
/*
* Implements an integer square root
@@ -2685,154 +2685,154 @@
return res;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_dmax(
- VL53L0X_DEV Dev,
- FixPoint1616_t totalSignalRate_mcps,
- FixPoint1616_t totalCorrSignalRate_mcps,
- FixPoint1616_t pwMult,
- uint32_t sigmaEstimateP1,
- FixPoint1616_t sigmaEstimateP2,
- uint32_t peakVcselDuration_us,
- uint32_t *pdmax_mm)
+VL53L0X_Error VL53L0X::vl53l0x_calc_dmax(
+ VL53L0X_DEV dev,
+ FixPoint1616_t total_signal_rate_mcps,
+ FixPoint1616_t total_corr_signal_rate_mcps,
+ FixPoint1616_t pw_mult,
+ uint32_t sigma_estimate_p1,
+ FixPoint1616_t sigma_estimate_p2,
+ uint32_t peak_vcsel_duration_us,
+ uint32_t *pd_max_mm)
{
- const uint32_t cSigmaLimit = 18;
- const FixPoint1616_t cSignalLimit = 0x4000; /* 0.25 */
- const FixPoint1616_t cSigmaEstRef = 0x00000042; /* 0.001 */
- const uint32_t cAmbEffWidthSigmaEst_ns = 6;
- const uint32_t cAmbEffWidthDMax_ns = 7;
- uint32_t dmaxCalRange_mm;
- FixPoint1616_t dmaxCalSignalRateRtn_mcps;
- FixPoint1616_t minSignalNeeded;
- FixPoint1616_t minSignalNeeded_p1;
- FixPoint1616_t minSignalNeeded_p2;
- FixPoint1616_t minSignalNeeded_p3;
- FixPoint1616_t minSignalNeeded_p4;
- FixPoint1616_t sigmaLimitTmp;
- FixPoint1616_t sigmaEstSqTmp;
- FixPoint1616_t signalLimitTmp;
- FixPoint1616_t SignalAt0mm;
- FixPoint1616_t dmaxDark;
- FixPoint1616_t dmaxAmbient;
- FixPoint1616_t dmaxDarkTmp;
- FixPoint1616_t sigmaEstP2Tmp;
- uint32_t signalRateTemp_mcps;
-
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ const uint32_t c_sigma_limit = 18;
+ const FixPoint1616_t c_signal_limit = 0x4000; /* 0.25 */
+ const FixPoint1616_t c_sigma_est_ref = 0x00000042; /* 0.001 */
+ const uint32_t c_amb_eff_width_sigma_est_ns = 6;
+ const uint32_t c_amb_eff_width_d_max_ns = 7;
+ uint32_t dmax_cal_range_mm;
+ FixPoint1616_t dmax_cal_signal_rate_rtn_mcps;
+ FixPoint1616_t min_signal_needed;
+ FixPoint1616_t min_signal_needed_p1;
+ FixPoint1616_t min_signal_needed_p2;
+ FixPoint1616_t min_signal_needed_p3;
+ FixPoint1616_t min_signal_needed_p4;
+ FixPoint1616_t sigma_limit_tmp;
+ FixPoint1616_t sigma_est_sq_tmp;
+ FixPoint1616_t signal_limit_tmp;
+ FixPoint1616_t signal_at0_mm;
+ FixPoint1616_t dmax_dark;
+ FixPoint1616_t dmax_ambient;
+ FixPoint1616_t dmax_dark_tmp;
+ FixPoint1616_t sigma_est_p2_tmp;
+ uint32_t signal_rate_temp_mcps;
+
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- dmaxCalRange_mm =
- PALDevDataGet(Dev, DmaxCalRangeMilliMeter);
-
- dmaxCalSignalRateRtn_mcps =
- PALDevDataGet(Dev, DmaxCalSignalRateRtnMegaCps);
+ dmax_cal_range_mm =
+ PALDevDataGet(dev, DmaxCalRangeMilliMeter);
+
+ dmax_cal_signal_rate_rtn_mcps =
+ PALDevDataGet(dev, DmaxCalSignalRateRtnMegaCps);
/* uint32 * FixPoint1616 = FixPoint1616 */
- SignalAt0mm = dmaxCalRange_mm * dmaxCalSignalRateRtn_mcps;
+ signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_mcps;
/* FixPoint1616 >> 8 = FixPoint2408 */
- SignalAt0mm = (SignalAt0mm + 0x80) >> 8;
- SignalAt0mm *= dmaxCalRange_mm;
-
- minSignalNeeded_p1 = 0;
- if (totalCorrSignalRate_mcps > 0) {
+ signal_at0_mm = (signal_at0_mm + 0x80) >> 8;
+ signal_at0_mm *= dmax_cal_range_mm;
+
+ min_signal_needed_p1 = 0;
+ if (total_corr_signal_rate_mcps > 0) {
/* Shift by 10 bits to increase resolution prior to the
* division */
- signalRateTemp_mcps = totalSignalRate_mcps << 10;
+ signal_rate_temp_mcps = total_signal_rate_mcps << 10;
/* Add rounding value prior to division */
- minSignalNeeded_p1 = signalRateTemp_mcps +
- (totalCorrSignalRate_mcps/2);
+ min_signal_needed_p1 = signal_rate_temp_mcps +
+ (total_corr_signal_rate_mcps/2);
/* FixPoint0626/FixPoint1616 = FixPoint2210 */
- minSignalNeeded_p1 /= totalCorrSignalRate_mcps;
+ min_signal_needed_p1 /= total_corr_signal_rate_mcps;
/* Apply a factored version of the speed of light.
Correction to be applied at the end */
- minSignalNeeded_p1 *= 3;
+ min_signal_needed_p1 *= 3;
/* FixPoint2210 * FixPoint2210 = FixPoint1220 */
- minSignalNeeded_p1 *= minSignalNeeded_p1;
+ min_signal_needed_p1 *= min_signal_needed_p1;
/* FixPoint1220 >> 16 = FixPoint2804 */
- minSignalNeeded_p1 = (minSignalNeeded_p1 + 0x8000) >> 16;
+ min_signal_needed_p1 = (min_signal_needed_p1 + 0x8000) >> 16;
}
- minSignalNeeded_p2 = pwMult * sigmaEstimateP1;
+ min_signal_needed_p2 = pw_mult * sigma_estimate_p1;
/* FixPoint1616 >> 16 = uint32 */
- minSignalNeeded_p2 = (minSignalNeeded_p2 + 0x8000) >> 16;
+ min_signal_needed_p2 = (min_signal_needed_p2 + 0x8000) >> 16;
/* uint32 * uint32 = uint32 */
- minSignalNeeded_p2 *= minSignalNeeded_p2;
+ min_signal_needed_p2 *= min_signal_needed_p2;
/* Check sigmaEstimateP2
* If this value is too high there is not enough signal rate
* to calculate dmax value so set a suitable value to ensure
* a very small dmax.
*/
- sigmaEstP2Tmp = (sigmaEstimateP2 + 0x8000) >> 16;
- sigmaEstP2Tmp = (sigmaEstP2Tmp + cAmbEffWidthSigmaEst_ns/2)/
- cAmbEffWidthSigmaEst_ns;
- sigmaEstP2Tmp *= cAmbEffWidthDMax_ns;
-
- if (sigmaEstP2Tmp > 0xffff) {
- minSignalNeeded_p3 = 0xfff00000;
+ sigma_est_p2_tmp = (sigma_estimate_p2 + 0x8000) >> 16;
+ sigma_est_p2_tmp = (sigma_est_p2_tmp + c_amb_eff_width_sigma_est_ns/2)/
+ c_amb_eff_width_sigma_est_ns;
+ sigma_est_p2_tmp *= c_amb_eff_width_d_max_ns;
+
+ if (sigma_est_p2_tmp > 0xffff) {
+ min_signal_needed_p3 = 0xfff00000;
} else {
/* DMAX uses a different ambient width from sigma, so apply
* correction.
* Perform division before multiplication to prevent overflow.
*/
- sigmaEstimateP2 = (sigmaEstimateP2 + cAmbEffWidthSigmaEst_ns/2)/
- cAmbEffWidthSigmaEst_ns;
- sigmaEstimateP2 *= cAmbEffWidthDMax_ns;
+ sigma_estimate_p2 = (sigma_estimate_p2 + c_amb_eff_width_sigma_est_ns/2)/
+ c_amb_eff_width_sigma_est_ns;
+ sigma_estimate_p2 *= c_amb_eff_width_d_max_ns;
/* FixPoint1616 >> 16 = uint32 */
- minSignalNeeded_p3 = (sigmaEstimateP2 + 0x8000) >> 16;
-
- minSignalNeeded_p3 *= minSignalNeeded_p3;
+ min_signal_needed_p3 = (sigma_estimate_p2 + 0x8000) >> 16;
+
+ min_signal_needed_p3 *= min_signal_needed_p3;
}
/* FixPoint1814 / uint32 = FixPoint1814 */
- sigmaLimitTmp = ((cSigmaLimit << 14) + 500) / 1000;
+ sigma_limit_tmp = ((c_sigma_limit << 14) + 500) / 1000;
/* FixPoint1814 * FixPoint1814 = FixPoint3628 := FixPoint0428 */
- sigmaLimitTmp *= sigmaLimitTmp;
+ sigma_limit_tmp *= sigma_limit_tmp;
/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
- sigmaEstSqTmp = cSigmaEstRef * cSigmaEstRef;
+ sigma_est_sq_tmp = c_sigma_est_ref * c_sigma_est_ref;
/* FixPoint3232 >> 4 = FixPoint0428 */
- sigmaEstSqTmp = (sigmaEstSqTmp + 0x08) >> 4;
+ sigma_est_sq_tmp = (sigma_est_sq_tmp + 0x08) >> 4;
/* FixPoint0428 - FixPoint0428 = FixPoint0428 */
- sigmaLimitTmp -= sigmaEstSqTmp;
+ sigma_limit_tmp -= sigma_est_sq_tmp;
/* uint32_t * FixPoint0428 = FixPoint0428 */
- minSignalNeeded_p4 = 4 * 12 * sigmaLimitTmp;
+ min_signal_needed_p4 = 4 * 12 * sigma_limit_tmp;
/* FixPoint0428 >> 14 = FixPoint1814 */
- minSignalNeeded_p4 = (minSignalNeeded_p4 + 0x2000) >> 14;
+ min_signal_needed_p4 = (min_signal_needed_p4 + 0x2000) >> 14;
/* uint32 + uint32 = uint32 */
- minSignalNeeded = (minSignalNeeded_p2 + minSignalNeeded_p3);
+ min_signal_needed = (min_signal_needed_p2 + min_signal_needed_p3);
/* uint32 / uint32 = uint32 */
- minSignalNeeded += (peakVcselDuration_us/2);
- minSignalNeeded /= peakVcselDuration_us;
+ min_signal_needed += (peak_vcsel_duration_us/2);
+ min_signal_needed /= peak_vcsel_duration_us;
/* uint32 << 14 = FixPoint1814 */
- minSignalNeeded <<= 14;
+ min_signal_needed <<= 14;
/* FixPoint1814 / FixPoint1814 = uint32 */
- minSignalNeeded += (minSignalNeeded_p4/2);
- minSignalNeeded /= minSignalNeeded_p4;
+ min_signal_needed += (min_signal_needed_p4/2);
+ min_signal_needed /= min_signal_needed_p4;
/* FixPoint3200 * FixPoint2804 := FixPoint2804*/
- minSignalNeeded *= minSignalNeeded_p1;
+ min_signal_needed *= min_signal_needed_p1;
/* Apply correction by dividing by 1000000.
* This assumes 10E16 on the numerator of the equation
@@ -2841,95 +2841,95 @@
* handle the larger and smaller elements of this equation,
* i.e. speed of light and pulse widths.
*/
- minSignalNeeded = (minSignalNeeded + 500) / 1000;
- minSignalNeeded <<= 4;
-
- minSignalNeeded = (minSignalNeeded + 500) / 1000;
+ min_signal_needed = (min_signal_needed + 500) / 1000;
+ min_signal_needed <<= 4;
+
+ min_signal_needed = (min_signal_needed + 500) / 1000;
/* FixPoint1616 >> 8 = FixPoint2408 */
- signalLimitTmp = (cSignalLimit + 0x80) >> 8;
+ signal_limit_tmp = (c_signal_limit + 0x80) >> 8;
/* FixPoint2408/FixPoint2408 = uint32 */
- if (signalLimitTmp != 0)
- dmaxDarkTmp = (SignalAt0mm + (signalLimitTmp / 2))
- / signalLimitTmp;
+ if (signal_limit_tmp != 0)
+ dmax_dark_tmp = (signal_at0_mm + (signal_limit_tmp / 2))
+ / signal_limit_tmp;
else
- dmaxDarkTmp = 0;
-
- dmaxDark = VL53L0X_isqrt(dmaxDarkTmp);
+ dmax_dark_tmp = 0;
+
+ dmax_dark = vl53l0x_isqrt(dmax_dark_tmp);
/* FixPoint2408/FixPoint2408 = uint32 */
- if (minSignalNeeded != 0)
- dmaxAmbient = (SignalAt0mm + minSignalNeeded/2)
- / minSignalNeeded;
+ if (min_signal_needed != 0)
+ dmax_ambient = (signal_at0_mm + min_signal_needed/2)
+ / min_signal_needed;
else
- dmaxAmbient = 0;
-
- dmaxAmbient = VL53L0X_isqrt(dmaxAmbient);
-
- *pdmax_mm = dmaxDark;
- if (dmaxDark > dmaxAmbient)
- *pdmax_mm = dmaxAmbient;
-
- LOG_FUNCTION_END(Status);
-
- return Status;
+ dmax_ambient = 0;
+
+ dmax_ambient = vl53l0x_isqrt(dmax_ambient);
+
+ *pd_max_mm = dmax_dark;
+ if (dmax_dark > dmax_ambient)
+ *pd_max_mm = dmax_ambient;
+
+ LOG_FUNCTION_END(status);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_calc_sigma_estimate(VL53L0X_DEV Dev,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
- FixPoint1616_t *pSigmaEstimate,
- uint32_t *pDmax_mm)
+VL53L0X_Error VL53L0X::vl53l0x_calc_sigma_estimate(VL53L0X_DEV dev,
+ 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 */
- const uint32_t cPulseEffectiveWidth_centi_ns = 800;
+ const uint32_t c_pulse_effective_width_centi_ns = 800;
/* Expressed in 100ths of a ns, i.e. centi-ns */
- const uint32_t cAmbientEffectiveWidth_centi_ns = 600;
- const FixPoint1616_t cDfltFinalRangeIntegrationTimeMilliSecs = 0x00190000; /* 25ms */
- const uint32_t cVcselPulseWidth_ps = 4700; /* pico secs */
- const FixPoint1616_t cSigmaEstMax = 0x028F87AE;
- const FixPoint1616_t cSigmaEstRtnMax = 0xF000;
- const FixPoint1616_t cAmbToSignalRatioMax = 0xF0000000/
- cAmbientEffectiveWidth_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 */
+ const FixPoint1616_t c_sigma_est_max = 0x028F87AE;
+ const FixPoint1616_t c_sigma_est_rtn_max = 0xF000;
+ const FixPoint1616_t c_amb_to_signal_ratio_max = 0xF0000000/
+ c_ambient_effective_width_centi_ns;
/* Time Of Flight per mm (6.6 pico secs) */
- const FixPoint1616_t cTOF_per_mm_ps = 0x0006999A;
- const uint32_t c16BitRoundingParam = 0x00008000;
- const FixPoint1616_t cMaxXTalk_kcps = 0x00320000;
- const uint32_t cPllPeriod_ps = 1655;
-
- uint32_t vcselTotalEventsRtn;
- uint32_t finalRangeTimeoutMicroSecs;
- uint32_t preRangeTimeoutMicroSecs;
- uint32_t finalRangeIntegrationTimeMilliSecs;
- FixPoint1616_t sigmaEstimateP1;
- FixPoint1616_t sigmaEstimateP2;
- FixPoint1616_t sigmaEstimateP3;
- FixPoint1616_t deltaT_ps;
- FixPoint1616_t pwMult;
- FixPoint1616_t sigmaEstRtn;
- FixPoint1616_t sigmaEstimate;
- FixPoint1616_t xTalkCorrection;
- FixPoint1616_t ambientRate_kcps;
- FixPoint1616_t peakSignalRate_kcps;
- FixPoint1616_t xTalkCompRate_mcps;
- uint32_t xTalkCompRate_kcps;
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ const FixPoint1616_t c_tof_per_mm_ps = 0x0006999A;
+ const uint32_t c_16bit_rounding_param = 0x00008000;
+ const FixPoint1616_t c_max_x_talk_kcps = 0x00320000;
+ const uint32_t c_pll_period_ps = 1655;
+
+ uint32_t vcsel_total_events_rtn;
+ uint32_t final_range_timeout_micro_secs;
+ uint32_t pre_range_timeout_micro_secs;
+ uint32_t final_range_integration_time_milli_secs;
+ FixPoint1616_t sigma_estimate_p1;
+ FixPoint1616_t sigma_estimate_p2;
+ FixPoint1616_t sigma_estimate_p3;
+ FixPoint1616_t delta_t_ps;
+ FixPoint1616_t pw_mult;
+ FixPoint1616_t sigma_est_rtn;
+ FixPoint1616_t sigma_estimate;
+ FixPoint1616_t x_talk_correction;
+ FixPoint1616_t ambient_rate_kcps;
+ FixPoint1616_t peak_signal_rate_kcps;
+ FixPoint1616_t x_talk_comp_rate_mcps;
+ uint32_t x_talk_comp_rate_kcps;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
FixPoint1616_t diff1_mcps;
FixPoint1616_t diff2_mcps;
FixPoint1616_t sqr1;
FixPoint1616_t sqr2;
- FixPoint1616_t sqrSum;
- FixPoint1616_t sqrtResult_centi_ns;
- FixPoint1616_t sqrtResult;
- FixPoint1616_t totalSignalRate_mcps;
- FixPoint1616_t correctedSignalRate_mcps;
- FixPoint1616_t sigmaEstRef;
- uint32_t vcselWidth;
- uint32_t finalRangeMacroPCLKS;
- uint32_t preRangeMacroPCLKS;
- uint32_t peakVcselDuration_us;
- uint8_t finalRangeVcselPCLKS;
- uint8_t preRangeVcselPCLKS;
+ FixPoint1616_t sqr_sum;
+ FixPoint1616_t sqrt_result_centi_ns;
+ FixPoint1616_t sqrt_result;
+ FixPoint1616_t total_signal_rate_mcps;
+ FixPoint1616_t corrected_signal_rate_mcps;
+ FixPoint1616_t sigma_est_ref;
+ uint32_t vcsel_width;
+ uint32_t final_range_macro_pclks;
+ uint32_t pre_range_macro_pclks;
+ uint32_t peak_vcsel_duration_us;
+ uint8_t final_range_vcsel_pclks;
+ uint8_t pre_range_vcsel_pclks;
/*! \addtogroup calc_sigma_estimate
* @{
*
@@ -2938,114 +2938,114 @@
LOG_FUNCTION_START("");
- VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps,
- xTalkCompRate_mcps);
+ VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps,
+ x_talk_comp_rate_mcps);
/*
* We work in kcps rather than mcps as this helps keep within the
* confines of the 32 Fix1616 type.
*/
- ambientRate_kcps =
- (pRangingMeasurementData->AmbientRateRtnMegaCps * 1000) >> 16;
-
- correctedSignalRate_mcps =
- pRangingMeasurementData->SignalRateRtnMegaCps;
-
-
- Status = VL53L0X_get_total_signal_rate(
- Dev, pRangingMeasurementData, &totalSignalRate_mcps);
- Status = VL53L0X_get_total_xtalk_rate(
- Dev, pRangingMeasurementData, &xTalkCompRate_mcps);
+ ambient_rate_kcps =
+ (p_ranging_measurement_data->AmbientRateRtnMegaCps * 1000) >> 16;
+
+ corrected_signal_rate_mcps =
+ 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);
/* Signal rate measurement provided by device is the
* peak signal rate, not average.
*/
- peakSignalRate_kcps = (totalSignalRate_mcps * 1000);
- peakSignalRate_kcps = (peakSignalRate_kcps + 0x8000) >> 16;
-
- xTalkCompRate_kcps = xTalkCompRate_mcps * 1000;
-
- if (xTalkCompRate_kcps > cMaxXTalk_kcps)
- xTalkCompRate_kcps = cMaxXTalk_kcps;
-
- if (Status == VL53L0X_ERROR_NONE) {
+ peak_signal_rate_kcps = (total_signal_rate_mcps * 1000);
+ peak_signal_rate_kcps = (peak_signal_rate_kcps + 0x8000) >> 16;
+
+ x_talk_comp_rate_kcps = x_talk_comp_rate_mcps * 1000;
+
+ if (x_talk_comp_rate_kcps > c_max_x_talk_kcps)
+ x_talk_comp_rate_kcps = c_max_x_talk_kcps;
+
+ if (status == VL53L0X_ERROR_NONE) {
/* Calculate final range macro periods */
- finalRangeTimeoutMicroSecs = VL53L0X_GETDEVICESPECIFICPARAMETER(
- Dev, FinalRangeTimeoutMicroSecs);
-
- finalRangeVcselPCLKS = VL53L0X_GETDEVICESPECIFICPARAMETER(
- Dev, FinalRangeVcselPulsePeriod);
-
- finalRangeMacroPCLKS = VL53L0X_calc_timeout_mclks(
- Dev, finalRangeTimeoutMicroSecs, finalRangeVcselPCLKS);
+ 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);
/* Calculate pre-range macro periods */
- preRangeTimeoutMicroSecs = VL53L0X_GETDEVICESPECIFICPARAMETER(
- Dev, PreRangeTimeoutMicroSecs);
-
- preRangeVcselPCLKS = VL53L0X_GETDEVICESPECIFICPARAMETER(
- Dev, PreRangeVcselPulsePeriod);
-
- preRangeMacroPCLKS = VL53L0X_calc_timeout_mclks(
- Dev, preRangeTimeoutMicroSecs, preRangeVcselPCLKS);
-
- vcselWidth = 3;
- if (finalRangeVcselPCLKS == 8)
- vcselWidth = 2;
-
-
- peakVcselDuration_us = vcselWidth * 2048 *
- (preRangeMacroPCLKS + finalRangeMacroPCLKS);
- peakVcselDuration_us = (peakVcselDuration_us + 500)/1000;
- peakVcselDuration_us *= cPllPeriod_ps;
- peakVcselDuration_us = (peakVcselDuration_us + 500)/1000;
+ 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);
+
+ vcsel_width = 3;
+ if (final_range_vcsel_pclks == 8)
+ vcsel_width = 2;
+
+
+ peak_vcsel_duration_us = vcsel_width * 2048 *
+ (pre_range_macro_pclks + final_range_macro_pclks);
+ peak_vcsel_duration_us = (peak_vcsel_duration_us + 500)/1000;
+ peak_vcsel_duration_us *= c_pll_period_ps;
+ peak_vcsel_duration_us = (peak_vcsel_duration_us + 500)/1000;
/* Fix1616 >> 8 = Fix2408 */
- totalSignalRate_mcps = (totalSignalRate_mcps + 0x80) >> 8;
+ total_signal_rate_mcps = (total_signal_rate_mcps + 0x80) >> 8;
/* Fix2408 * uint32 = Fix2408 */
- vcselTotalEventsRtn = totalSignalRate_mcps *
- peakVcselDuration_us;
+ vcsel_total_events_rtn = total_signal_rate_mcps *
+ peak_vcsel_duration_us;
/* Fix2408 >> 8 = uint32 */
- vcselTotalEventsRtn = (vcselTotalEventsRtn + 0x80) >> 8;
+ vcsel_total_events_rtn = (vcsel_total_events_rtn + 0x80) >> 8;
/* Fix2408 << 8 = Fix1616 = */
- totalSignalRate_mcps <<= 8;
+ total_signal_rate_mcps <<= 8;
}
- if (Status != VL53L0X_ERROR_NONE) {
- LOG_FUNCTION_END(Status);
- return Status;
+ if (status != VL53L0X_ERROR_NONE) {
+ LOG_FUNCTION_END(status);
+ return status;
}
- if (peakSignalRate_kcps == 0) {
- *pSigmaEstimate = cSigmaEstMax;
- PALDevDataSet(Dev, SigmaEstimate, cSigmaEstMax);
- *pDmax_mm = 0;
+ if (peak_signal_rate_kcps == 0) {
+ *p_sigma_estimate = c_sigma_est_max;
+ PALDevDataSet(dev, SigmaEstimate, c_sigma_est_max);
+ *p_dmax_mm = 0;
} else {
- if (vcselTotalEventsRtn < 1)
- vcselTotalEventsRtn = 1;
-
- sigmaEstimateP1 = cPulseEffectiveWidth_centi_ns;
+ if (vcsel_total_events_rtn < 1)
+ vcsel_total_events_rtn = 1;
+
+ sigma_estimate_p1 = c_pulse_effective_width_centi_ns;
/* ((FixPoint1616 << 16)* uint32)/uint32 = FixPoint1616 */
- sigmaEstimateP2 = (ambientRate_kcps << 16)/peakSignalRate_kcps;
- if (sigmaEstimateP2 > cAmbToSignalRatioMax) {
+ sigma_estimate_p2 = (ambient_rate_kcps << 16)/peak_signal_rate_kcps;
+ if (sigma_estimate_p2 > c_amb_to_signal_ratio_max) {
/* Clip to prevent overflow. Will ensure safe
* max result. */
- sigmaEstimateP2 = cAmbToSignalRatioMax;
+ sigma_estimate_p2 = c_amb_to_signal_ratio_max;
}
- sigmaEstimateP2 *= cAmbientEffectiveWidth_centi_ns;
-
- sigmaEstimateP3 = 2 * VL53L0X_isqrt(vcselTotalEventsRtn * 12);
+ sigma_estimate_p2 *= c_ambient_effective_width_centi_ns;
+
+ sigma_estimate_p3 = 2 * vl53l0x_isqrt(vcsel_total_events_rtn * 12);
/* uint32 * FixPoint1616 = FixPoint1616 */
- deltaT_ps = pRangingMeasurementData->RangeMilliMeter *
- cTOF_per_mm_ps;
+ delta_t_ps = p_ranging_measurement_data->RangeMilliMeter *
+ c_tof_per_mm_ps;
/*
* vcselRate - xtalkCompRate
@@ -3054,11 +3054,11 @@
* 500 is added to ensure rounding when integer division
* truncates.
*/
- diff1_mcps = (((peakSignalRate_kcps << 16) -
- 2 * xTalkCompRate_kcps) + 500)/1000;
+ diff1_mcps = (((peak_signal_rate_kcps << 16) -
+ 2 * x_talk_comp_rate_kcps) + 500)/1000;
/* vcselRate + xtalkCompRate */
- diff2_mcps = ((peakSignalRate_kcps << 16) + 500)/1000;
+ diff2_mcps = ((peak_signal_rate_kcps << 16) + 500)/1000;
/* Shift by 8 bits to increase resolution prior to the
* division */
@@ -3067,45 +3067,45 @@
/* FixPoint0824/FixPoint1616 = FixPoint2408 */
// xTalkCorrection = abs(diff1_mcps/diff2_mcps);
// abs is causing compiler overloading isue in C++, but unsigned types. So, redundant call anyway!
- xTalkCorrection = diff1_mcps/diff2_mcps;
+ x_talk_correction = diff1_mcps/diff2_mcps;
/* FixPoint2408 << 8 = FixPoint1616 */
- xTalkCorrection <<= 8;
-
- if(pRangingMeasurementData->RangeStatus != 0) {
- pwMult = 1 << 16;
+ x_talk_correction <<= 8;
+
+ if(p_ranging_measurement_data->RangeStatus != 0) {
+ pw_mult = 1 << 16;
} else {
/* FixPoint1616/uint32 = FixPoint1616 */
- pwMult = deltaT_ps/cVcselPulseWidth_ps; /* smaller than 1.0f */
+ pw_mult = delta_t_ps/c_vcsel_pulse_width_ps; /* smaller than 1.0f */
/*
* FixPoint1616 * FixPoint1616 = FixPoint3232, however both
* values are small enough such that32 bits will not be
* exceeded.
*/
- pwMult *= ((1 << 16) - xTalkCorrection);
+ pw_mult *= ((1 << 16) - x_talk_correction);
/* (FixPoint3232 >> 16) = FixPoint1616 */
- pwMult = (pwMult + c16BitRoundingParam) >> 16;
+ pw_mult = (pw_mult + c_16bit_rounding_param) >> 16;
/* FixPoint1616 + FixPoint1616 = FixPoint1616 */
- pwMult += (1 << 16);
+ pw_mult += (1 << 16);
/*
* 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.
*/
- pwMult >>= 1;
+ pw_mult >>= 1;
/* FixPoint1715 * FixPoint1715 = FixPoint3430 */
- pwMult = pwMult * pwMult;
+ pw_mult = pw_mult * pw_mult;
/* (FixPoint3430 >> 14) = Fix1616 */
- pwMult >>= 14;
+ pw_mult >>= 14;
}
/* FixPoint1616 * uint32 = FixPoint1616 */
- sqr1 = pwMult * sigmaEstimateP1;
+ sqr1 = pw_mult * sigma_estimate_p1;
/* (FixPoint1616 >> 16) = FixPoint3200 */
sqr1 = (sqr1 + 0x8000) >> 16;
@@ -3113,7 +3113,7 @@
/* FixPoint3200 * FixPoint3200 = FixPoint6400 */
sqr1 *= sqr1;
- sqr2 = sigmaEstimateP2;
+ sqr2 = sigma_estimate_p2;
/* (FixPoint1616 >> 16) = FixPoint3200 */
sqr2 = (sqr2 + 0x8000) >> 16;
@@ -3122,110 +3122,110 @@
sqr2 *= sqr2;
/* FixPoint64000 + FixPoint6400 = FixPoint6400 */
- sqrSum = sqr1 + sqr2;
+ sqr_sum = sqr1 + sqr2;
/* SQRT(FixPoin6400) = FixPoint3200 */
- sqrtResult_centi_ns = VL53L0X_isqrt(sqrSum);
+ sqrt_result_centi_ns = vl53l0x_isqrt(sqr_sum);
/* (FixPoint3200 << 16) = FixPoint1616 */
- sqrtResult_centi_ns <<= 16;
+ sqrt_result_centi_ns <<= 16;
/*
* Note that the Speed Of Light is expressed in um per 1E-10
* seconds (2997) Therefore to get mm/ns we have to divide by
* 10000
*/
- sigmaEstRtn = (((sqrtResult_centi_ns+50)/100) /
- sigmaEstimateP3);
- sigmaEstRtn *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
+ sigma_est_rtn = (((sqrt_result_centi_ns+50)/100) /
+ sigma_estimate_p3);
+ sigma_est_rtn *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
/* Add 5000 before dividing by 10000 to ensure rounding. */
- sigmaEstRtn += 5000;
- sigmaEstRtn /= 10000;
-
- if (sigmaEstRtn > cSigmaEstRtnMax) {
+ sigma_est_rtn += 5000;
+ sigma_est_rtn /= 10000;
+
+ if (sigma_est_rtn > c_sigma_est_rtn_max) {
/* Clip to prevent overflow. Will ensure safe
* max result. */
- sigmaEstRtn = cSigmaEstRtnMax;
+ sigma_est_rtn = c_sigma_est_rtn_max;
}
- finalRangeIntegrationTimeMilliSecs =
- (finalRangeTimeoutMicroSecs + preRangeTimeoutMicroSecs + 500)/1000;
+ final_range_integration_time_milli_secs =
+ (final_range_timeout_micro_secs + pre_range_timeout_micro_secs + 500)/1000;
/* sigmaEstRef = 1mm * 25ms/final range integration time (inc pre-range)
* sqrt(FixPoint1616/int) = FixPoint2408)
*/
- sigmaEstRef =
- VL53L0X_isqrt((cDfltFinalRangeIntegrationTimeMilliSecs +
- finalRangeIntegrationTimeMilliSecs/2)/
- finalRangeIntegrationTimeMilliSecs);
+ sigma_est_ref =
+ vl53l0x_isqrt((c_dflt_final_range_integration_time_milli_secs +
+ final_range_integration_time_milli_secs/2)/
+ final_range_integration_time_milli_secs);
/* FixPoint2408 << 8 = FixPoint1616 */
- sigmaEstRef <<= 8;
- sigmaEstRef = (sigmaEstRef + 500)/1000;
+ sigma_est_ref <<= 8;
+ sigma_est_ref = (sigma_est_ref + 500)/1000;
/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
- sqr1 = sigmaEstRtn * sigmaEstRtn;
+ sqr1 = sigma_est_rtn * sigma_est_rtn;
/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
- sqr2 = sigmaEstRef * sigmaEstRef;
+ sqr2 = sigma_est_ref * sigma_est_ref;
/* sqrt(FixPoint3232) = FixPoint1616 */
- sqrtResult = VL53L0X_isqrt((sqr1 + sqr2));
+ 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 right to revert back to the FixPoint1616 format.
*/
- sigmaEstimate = 1000 * sqrtResult;
-
- if ((peakSignalRate_kcps < 1) || (vcselTotalEventsRtn < 1) ||
- (sigmaEstimate > cSigmaEstMax)) {
- sigmaEstimate = cSigmaEstMax;
+ sigma_estimate = 1000 * sqrt_result;
+
+ if ((peak_signal_rate_kcps < 1) || (vcsel_total_events_rtn < 1) ||
+ (sigma_estimate > c_sigma_est_max)) {
+ sigma_estimate = c_sigma_est_max;
}
- *pSigmaEstimate = (uint32_t)(sigmaEstimate);
- PALDevDataSet(Dev, SigmaEstimate, *pSigmaEstimate);
- Status = VL53L0X_calc_dmax(
- Dev,
- totalSignalRate_mcps,
- correctedSignalRate_mcps,
- pwMult,
- sigmaEstimateP1,
- sigmaEstimateP2,
- peakVcselDuration_us,
- pDmax_mm);
+ *p_sigma_estimate = (uint32_t)(sigma_estimate);
+ PALDevDataSet(dev, SigmaEstimate, *p_sigma_estimate);
+ status = vl53l0x_calc_dmax(
+ dev,
+ total_signal_rate_mcps,
+ corrected_signal_rate_mcps,
+ pw_mult,
+ sigma_estimate_p1,
+ sigma_estimate_p2,
+ peak_vcsel_duration_us,
+ p_dmax_mm);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_get_pal_range_status(VL53L0X_DEV Dev,
- uint8_t DeviceRangeStatus,
- FixPoint1616_t SignalRate,
- uint16_t EffectiveSpadRtnCount,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
- uint8_t *pPalRangeStatus)
+VL53L0X_Error VL53L0X::vl53l0x_get_pal_range_status(VL53L0X_DEV dev,
+ uint8_t device_range_status,
+ FixPoint1616_t signal_rate,
+ uint16_t effective_spad_rtn_count,
+ VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
+ uint8_t *p_pal_range_status)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t NoneFlag;
- uint8_t SigmaLimitflag = 0;
- uint8_t SignalRefClipflag = 0;
- uint8_t RangeIgnoreThresholdflag = 0;
- uint8_t SigmaLimitCheckEnable = 0;
- uint8_t SignalRateFinalRangeLimitCheckEnable = 0;
- uint8_t SignalRefClipLimitCheckEnable = 0;
- uint8_t RangeIgnoreThresholdLimitCheckEnable = 0;
- FixPoint1616_t SigmaEstimate;
- FixPoint1616_t SigmaLimitValue;
- FixPoint1616_t SignalRefClipValue;
- FixPoint1616_t RangeIgnoreThresholdValue;
- FixPoint1616_t SignalRatePerSpad;
- uint8_t DeviceRangeStatusInternal = 0;
- uint16_t tmpWord = 0;
- uint8_t Temp8;
- uint32_t Dmax_mm = 0;
- FixPoint1616_t LastSignalRefMcps;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t none_flag;
+ uint8_t sigma_limitflag = 0;
+ uint8_t signal_ref_clipflag = 0;
+ uint8_t range_ignore_thresholdflag = 0;
+ uint8_t sigma_limit_check_enable = 0;
+ uint8_t signal_rate_final_range_limit_check_enable = 0;
+ uint8_t signal_ref_clip_limit_check_enable = 0;
+ uint8_t range_ignore_threshold_limit_check_enable = 0;
+ FixPoint1616_t sigma_estimate;
+ FixPoint1616_t sigma_limit_value;
+ FixPoint1616_t signal_ref_clip_value;
+ FixPoint1616_t range_ignore_threshold_value;
+ FixPoint1616_t signal_rate_per_spad;
+ uint8_t device_range_status_internal = 0;
+ uint16_t tmp_word = 0;
+ uint8_t temp8;
+ uint32_t dmax_mm = 0;
+ FixPoint1616_t last_signal_ref_mcps;
LOG_FUNCTION_START("");
@@ -3238,51 +3238,51 @@
* DeviceRangeStatus, this will be added in the PalRangeStatus.
*/
- DeviceRangeStatusInternal = ((DeviceRangeStatus & 0x78) >> 3);
-
- if (DeviceRangeStatusInternal == 0 ||
- DeviceRangeStatusInternal == 5 ||
- DeviceRangeStatusInternal == 7 ||
- DeviceRangeStatusInternal == 12 ||
- DeviceRangeStatusInternal == 13 ||
- DeviceRangeStatusInternal == 14 ||
- DeviceRangeStatusInternal == 15
+ device_range_status_internal = ((device_range_status & 0x78) >> 3);
+
+ if (device_range_status_internal == 0 ||
+ device_range_status_internal == 5 ||
+ device_range_status_internal == 7 ||
+ device_range_status_internal == 12 ||
+ device_range_status_internal == 13 ||
+ device_range_status_internal == 14 ||
+ device_range_status_internal == 15
) {
- NoneFlag = 1;
+ none_flag = 1;
} else {
- NoneFlag = 0;
+ none_flag = 0;
}
/*
* 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_GetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- &SigmaLimitCheckEnable);
-
- if ((SigmaLimitCheckEnable != 0) && (Status == VL53L0X_ERROR_NONE)) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_limit_check_enable(dev,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ &sigma_limit_check_enable);
+
+ if ((sigma_limit_check_enable != 0) && (status == VL53L0X_ERROR_NONE)) {
/*
* compute the Sigma and check with limit
*/
- Status = VL53L0X_calc_sigma_estimate(
- Dev,
- pRangingMeasurementData,
- &SigmaEstimate,
- &Dmax_mm);
- if (Status == VL53L0X_ERROR_NONE)
- pRangingMeasurementData->RangeDMaxMilliMeter = Dmax_mm;
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- &SigmaLimitValue);
-
- if ((SigmaLimitValue > 0) &&
- (SigmaEstimate > SigmaLimitValue))
+ status = vl53l0x_calc_sigma_estimate(
+ dev,
+ p_ranging_measurement_data,
+ &sigma_estimate,
+ &dmax_mm);
+ if (status == VL53L0X_ERROR_NONE)
+ p_ranging_measurement_data->RangeDMaxMilliMeter = dmax_mm;
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_limit_check_value(dev,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ &sigma_limit_value);
+
+ if ((sigma_limit_value > 0) &&
+ (sigma_estimate > sigma_limit_value))
/* Limit Fail */
- SigmaLimitflag = 1;
+ sigma_limitflag = 1;
}
}
@@ -3290,37 +3290,37 @@
* 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_GetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- &SignalRefClipLimitCheckEnable);
-
- if ((SignalRefClipLimitCheckEnable != 0) &&
- (Status == VL53L0X_ERROR_NONE)) {
-
- Status = VL53L0X_GetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- &SignalRefClipValue);
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_limit_check_enable(dev,
+ 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,
+ &signal_ref_clip_value);
/* Read LastSignalRefMcps from device */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
- &tmpWord);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
-
- LastSignalRefMcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmpWord);
- PALDevDataSet(Dev, LastSignalRefMcps, LastSignalRefMcps);
-
- if ((SignalRefClipValue > 0) &&
- (LastSignalRefMcps > SignalRefClipValue)) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_read_word(dev,
+ VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ &tmp_word);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 0xFF, 0x00);
+
+ last_signal_ref_mcps = VL53L0X_FIXPOINT97TOFIXPOINT1616(tmp_word);
+ PALDevDataSet(dev, LastSignalRefMcps, last_signal_ref_mcps);
+
+ if ((signal_ref_clip_value > 0) &&
+ (last_signal_ref_mcps > signal_ref_clip_value)) {
/* Limit Fail */
- SignalRefClipflag = 1;
+ signal_ref_clipflag = 1;
}
}
@@ -3330,126 +3330,126 @@
* 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_GetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- &RangeIgnoreThresholdLimitCheckEnable);
-
- if ((RangeIgnoreThresholdLimitCheckEnable != 0) &&
- (Status == VL53L0X_ERROR_NONE)) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_limit_check_enable(dev,
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ &range_ignore_threshold_limit_check_enable);
+
+ if ((range_ignore_threshold_limit_check_enable != 0) &&
+ (status == VL53L0X_ERROR_NONE)) {
/* Compute the signal rate per spad */
- if (EffectiveSpadRtnCount == 0) {
- SignalRatePerSpad = 0;
+ if (effective_spad_rtn_count == 0) {
+ signal_rate_per_spad = 0;
} else {
- SignalRatePerSpad = (FixPoint1616_t)((256 * SignalRate)
- / EffectiveSpadRtnCount);
+ signal_rate_per_spad = (FixPoint1616_t)((256 * signal_rate)
+ / effective_spad_rtn_count);
}
- Status = VL53L0X_GetLimitCheckValue(Dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- &RangeIgnoreThresholdValue);
-
- if ((RangeIgnoreThresholdValue > 0) &&
- (SignalRatePerSpad < RangeIgnoreThresholdValue)) {
+ status = vl53l0x_get_limit_check_value(dev,
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ &range_ignore_threshold_value);
+
+ if ((range_ignore_threshold_value > 0) &&
+ (signal_rate_per_spad < range_ignore_threshold_value)) {
/* Limit Fail add 2^6 to range status */
- RangeIgnoreThresholdflag = 1;
+ range_ignore_thresholdflag = 1;
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- if (NoneFlag == 1) {
- *pPalRangeStatus = 255; /* NONE */
- } else if (DeviceRangeStatusInternal == 1 ||
- DeviceRangeStatusInternal == 2 ||
- DeviceRangeStatusInternal == 3) {
- *pPalRangeStatus = 5; /* HW fail */
- } else if (DeviceRangeStatusInternal == 6 ||
- DeviceRangeStatusInternal == 9) {
- *pPalRangeStatus = 4; /* Phase fail */
- } else if (DeviceRangeStatusInternal == 8 ||
- DeviceRangeStatusInternal == 10 ||
- SignalRefClipflag == 1) {
- *pPalRangeStatus = 3; /* Min range */
- } else if (DeviceRangeStatusInternal == 4 ||
- RangeIgnoreThresholdflag == 1) {
- *pPalRangeStatus = 2; /* Signal Fail */
- } else if (SigmaLimitflag == 1) {
- *pPalRangeStatus = 1; /* Sigma Fail */
+ if (status == VL53L0X_ERROR_NONE) {
+ if (none_flag == 1) {
+ *p_pal_range_status = 255; /* NONE */
+ } else if (device_range_status_internal == 1 ||
+ device_range_status_internal == 2 ||
+ device_range_status_internal == 3) {
+ *p_pal_range_status = 5; /* HW fail */
+ } else if (device_range_status_internal == 6 ||
+ device_range_status_internal == 9) {
+ *p_pal_range_status = 4; /* Phase fail */
+ } else if (device_range_status_internal == 8 ||
+ device_range_status_internal == 10 ||
+ signal_ref_clipflag == 1) {
+ *p_pal_range_status = 3; /* Min range */
+ } else if (device_range_status_internal == 4 ||
+ range_ignore_thresholdflag == 1) {
+ *p_pal_range_status = 2; /* Signal Fail */
+ } else if (sigma_limitflag == 1) {
+ *p_pal_range_status = 1; /* Sigma Fail */
} else {
- *pPalRangeStatus = 0; /* Range Valid */
+ *p_pal_range_status = 0; /* Range Valid */
}
}
/* DMAX only relevant during range error */
- if (*pPalRangeStatus == 0)
- pRangingMeasurementData->RangeDMaxMilliMeter = 0;
+ if (*p_pal_range_status == 0)
+ p_ranging_measurement_data->RangeDMaxMilliMeter = 0;
/* fill the Limit Check Status */
- Status = VL53L0X_GetLimitCheckEnable(Dev,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- &SignalRateFinalRangeLimitCheckEnable);
-
- if (Status == VL53L0X_ERROR_NONE) {
- if ((SigmaLimitCheckEnable == 0) || (SigmaLimitflag == 1))
- Temp8 = 1;
+ status = vl53l0x_get_limit_check_enable(dev,
+ VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
+ &signal_rate_final_range_limit_check_enable);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ if ((sigma_limit_check_enable == 0) || (sigma_limitflag == 1))
+ temp8 = 1;
else
- Temp8 = 0;
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, Temp8);
-
- if ((DeviceRangeStatusInternal == 4) ||
- (SignalRateFinalRangeLimitCheckEnable == 0))
- Temp8 = 1;
+ temp8 = 0;
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp8);
+
+ if ((device_range_status_internal == 4) ||
+ (signal_rate_final_range_limit_check_enable == 0))
+ temp8 = 1;
else
- Temp8 = 0;
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+ temp8 = 0;
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- Temp8);
-
- if ((SignalRefClipLimitCheckEnable == 0) ||
- (SignalRefClipflag == 1))
- Temp8 = 1;
+ temp8);
+
+ if ((signal_ref_clip_limit_check_enable == 0) ||
+ (signal_ref_clipflag == 1))
+ temp8 = 1;
else
- Temp8 = 0;
-
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, Temp8);
-
- if ((RangeIgnoreThresholdLimitCheckEnable == 0) ||
- (RangeIgnoreThresholdflag == 1))
- Temp8 = 1;
+ temp8 = 0;
+
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
+ VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp8);
+
+ if ((range_ignore_threshold_limit_check_enable == 0) ||
+ (range_ignore_thresholdflag == 1))
+ temp8 = 1;
else
- Temp8 = 0;
-
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksStatus,
+ temp8 = 0;
+
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksStatus,
VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- Temp8);
+ temp8);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetRangingMeasurementData(VL53L0X_DEV Dev,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
+VL53L0X_Error VL53L0X::vl53l0x_get_ranging_measurement_data(VL53L0X_DEV dev,
+ VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t DeviceRangeStatus;
- uint8_t RangeFractionalEnable;
- uint8_t PalRangeStatus;
- uint8_t XTalkCompensationEnable;
- uint16_t AmbientRate;
- FixPoint1616_t SignalRate;
- uint16_t XTalkCompensationRateMegaCps;
- uint16_t EffectiveSpadRtnCount;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t device_range_status;
+ uint8_t range_fractional_enable;
+ uint8_t pal_range_status;
+ uint8_t x_talk_compensation_enable;
+ uint16_t ambient_rate;
+ FixPoint1616_t signal_rate;
+ uint16_t x_talk_compensation_rate_mega_cps;
+ uint16_t effective_spad_rtn_count;
uint16_t tmpuint16;
- uint16_t XtalkRangeMilliMeter;
- uint16_t LinearityCorrectiveGain;
+ uint16_t xtalk_range_milli_meter;
+ uint16_t linearity_corrective_gain;
uint8_t localBuffer[12];
- VL53L0X_RangingMeasurementData_t LastRangeDataBuffer;
+ VL53L0X_RangingMeasurementData_t last_range_data_buffer;
LOG_FUNCTION_START("");
@@ -3459,90 +3459,90 @@
* start reading at 0x14 dec20
* end reading at 0x21 dec33 total 14 bytes to read
*/
- Status = VL53L0X_ReadMulti(Dev, 0x14, localBuffer, 12);
-
- if (Status == VL53L0X_ERROR_NONE) {
-
- pRangingMeasurementData->ZoneId = 0; /* Only one zone */
- pRangingMeasurementData->TimeStamp = 0; /* Not Implemented */
+ status = vl53l0x_read_multi(dev, 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]);
/* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
*(format 11.2) else no fractional
*/
- pRangingMeasurementData->MeasurementTimeUsec = 0;
-
- SignalRate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
- VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
+ p_ranging_measurement_data->MeasurementTimeUsec = 0;
+
+ signal_rate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
+ VL53L0X_MAKEUINT16(localBuffer[7], localBuffer[6]));
/* peak_signal_count_rate_rtn_mcps */
- pRangingMeasurementData->SignalRateRtnMegaCps = SignalRate;
-
- AmbientRate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
- pRangingMeasurementData->AmbientRateRtnMegaCps =
- VL53L0X_FIXPOINT97TOFIXPOINT1616(AmbientRate);
-
- EffectiveSpadRtnCount = VL53L0X_MAKEUINT16(localBuffer[3],
- localBuffer[2]);
+ p_ranging_measurement_data->SignalRateRtnMegaCps = signal_rate;
+
+ ambient_rate = VL53L0X_MAKEUINT16(localBuffer[9], localBuffer[8]);
+ p_ranging_measurement_data->AmbientRateRtnMegaCps =
+ VL53L0X_FIXPOINT97TOFIXPOINT1616(ambient_rate);
+
+ effective_spad_rtn_count = VL53L0X_MAKEUINT16(localBuffer[3],
+ localBuffer[2]);
/* EffectiveSpadRtnCount is 8.8 format */
- pRangingMeasurementData->EffectiveSpadRtnCount =
- EffectiveSpadRtnCount;
-
- DeviceRangeStatus = localBuffer[0];
+ p_ranging_measurement_data->EffectiveSpadRtnCount =
+ effective_spad_rtn_count;
+
+ device_range_status = localBuffer[0];
/* Get Linearity Corrective Gain */
- LinearityCorrectiveGain = PALDevDataGet(Dev,
- LinearityCorrectiveGain);
+ linearity_corrective_gain = PALDevDataGet(dev,
+ LinearityCorrectiveGain);
/* Get ranging configuration */
- RangeFractionalEnable = PALDevDataGet(Dev,
- RangeFractionalEnable);
-
- if (LinearityCorrectiveGain != 1000) {
-
- tmpuint16 = (uint16_t)((LinearityCorrectiveGain
+ range_fractional_enable = PALDevDataGet(dev,
+ RangeFractionalEnable);
+
+ if (linearity_corrective_gain != 1000) {
+
+ tmpuint16 = (uint16_t)((linearity_corrective_gain
* tmpuint16 + 500) / 1000);
/* Implement Xtalk */
- VL53L0X_GETPARAMETERFIELD(Dev,
+ VL53L0X_GETPARAMETERFIELD(dev,
XTalkCompensationRateMegaCps,
- XTalkCompensationRateMegaCps);
- VL53L0X_GETPARAMETERFIELD(Dev, XTalkCompensationEnable,
- XTalkCompensationEnable);
-
- if (XTalkCompensationEnable) {
-
- if ((SignalRate
- - ((XTalkCompensationRateMegaCps
- * EffectiveSpadRtnCount) >> 8))
+ x_talk_compensation_rate_mega_cps);
+ VL53L0X_GETPARAMETERFIELD(dev, XTalkCompensationEnable,
+ x_talk_compensation_enable);
+
+ if (x_talk_compensation_enable) {
+
+ if ((signal_rate
+ - ((x_talk_compensation_rate_mega_cps
+ * effective_spad_rtn_count) >> 8))
<= 0) {
- if (RangeFractionalEnable)
- XtalkRangeMilliMeter = 8888;
+ if (range_fractional_enable)
+ xtalk_range_milli_meter = 8888;
else
- XtalkRangeMilliMeter = 8888
- << 2;
+ xtalk_range_milli_meter = 8888
+ << 2;
} else {
- XtalkRangeMilliMeter =
- (tmpuint16 * SignalRate)
- / (SignalRate
- - ((XTalkCompensationRateMegaCps
- * EffectiveSpadRtnCount)
+ xtalk_range_milli_meter =
+ (tmpuint16 * signal_rate)
+ / (signal_rate
+ - ((x_talk_compensation_rate_mega_cps
+ * effective_spad_rtn_count)
>> 8));
}
- tmpuint16 = XtalkRangeMilliMeter;
+ tmpuint16 = xtalk_range_milli_meter;
}
}
- if (RangeFractionalEnable) {
- pRangingMeasurementData->RangeMilliMeter =
+ if (range_fractional_enable) {
+ p_ranging_measurement_data->RangeMilliMeter =
(uint16_t)((tmpuint16) >> 2);
- pRangingMeasurementData->RangeFractionalPart =
+ p_ranging_measurement_data->RangeFractionalPart =
(uint8_t)((tmpuint16 & 0x03) << 6);
} else {
- pRangingMeasurementData->RangeMilliMeter = tmpuint16;
- pRangingMeasurementData->RangeFractionalPart = 0;
+ p_ranging_measurement_data->RangeMilliMeter = tmpuint16;
+ p_ranging_measurement_data->RangeFractionalPart = 0;
}
/*
@@ -3551,142 +3551,142 @@
* 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, DeviceRangeStatus,
- SignalRate, EffectiveSpadRtnCount,
- pRangingMeasurementData, &PalRangeStatus);
-
- if (Status == VL53L0X_ERROR_NONE)
- pRangingMeasurementData->RangeStatus = PalRangeStatus;
+ status |= vl53l0x_get_pal_range_status(dev, 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;
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
/* Copy last read data into Dev buffer */
- LastRangeDataBuffer = PALDevDataGet(Dev, LastRangeMeasure);
-
- LastRangeDataBuffer.RangeMilliMeter =
- pRangingMeasurementData->RangeMilliMeter;
- LastRangeDataBuffer.RangeFractionalPart =
- pRangingMeasurementData->RangeFractionalPart;
- LastRangeDataBuffer.RangeDMaxMilliMeter =
- pRangingMeasurementData->RangeDMaxMilliMeter;
- LastRangeDataBuffer.MeasurementTimeUsec =
- pRangingMeasurementData->MeasurementTimeUsec;
- LastRangeDataBuffer.SignalRateRtnMegaCps =
- pRangingMeasurementData->SignalRateRtnMegaCps;
- LastRangeDataBuffer.AmbientRateRtnMegaCps =
- pRangingMeasurementData->AmbientRateRtnMegaCps;
- LastRangeDataBuffer.EffectiveSpadRtnCount =
- pRangingMeasurementData->EffectiveSpadRtnCount;
- LastRangeDataBuffer.RangeStatus =
- pRangingMeasurementData->RangeStatus;
-
- PALDevDataSet(Dev, LastRangeMeasure, LastRangeDataBuffer);
+ last_range_data_buffer = PALDevDataGet(dev, LastRangeMeasure);
+
+ last_range_data_buffer.RangeMilliMeter =
+ p_ranging_measurement_data->RangeMilliMeter;
+ last_range_data_buffer.RangeFractionalPart =
+ p_ranging_measurement_data->RangeFractionalPart;
+ last_range_data_buffer.RangeDMaxMilliMeter =
+ p_ranging_measurement_data->RangeDMaxMilliMeter;
+ last_range_data_buffer.MeasurementTimeUsec =
+ p_ranging_measurement_data->MeasurementTimeUsec;
+ last_range_data_buffer.SignalRateRtnMegaCps =
+ p_ranging_measurement_data->SignalRateRtnMegaCps;
+ last_range_data_buffer.AmbientRateRtnMegaCps =
+ p_ranging_measurement_data->AmbientRateRtnMegaCps;
+ last_range_data_buffer.EffectiveSpadRtnCount =
+ p_ranging_measurement_data->EffectiveSpadRtnCount;
+ last_range_data_buffer.RangeStatus =
+ p_ranging_measurement_data->RangeStatus;
+
+ PALDevDataSet(dev, LastRangeMeasure, last_range_data_buffer);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_PerformSingleRangingMeasurement(VL53L0X_DEV Dev,
+VL53L0X_Error VL53L0X::vl53l0x_perform_single_ranging_measurement(VL53L0X_DEV Dev,
VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
/* This function will do a complete single ranging
* Here we fix the mode! */
- Status = VL53L0X_SetDeviceMode(Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_PerformSingleMeasurement(Dev);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_GetRangingMeasurementData(Dev,
+ status = vl53l0x_set_device_mode(Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_perform_single_measurement(Dev);
+
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_ranging_measurement_data(Dev,
pRangingMeasurementData);
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_ClearInterruptMask(Dev, 0);
-
-
- LOG_FUNCTION_END(Status);
- return Status;
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_clear_interrupt_mask(Dev, 0);
+
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::perform_ref_signal_measurement(VL53L0X_DEV Dev,
- uint16_t *refSignalRate)
+VL53L0X_Error VL53L0X::perform_ref_signal_measurement(VL53L0X_DEV dev,
+ uint16_t *p_ref_signal_rate)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- VL53L0X_RangingMeasurementData_t rangingMeasurementData;
-
- uint8_t SequenceConfig = 0;
+ VL53L0X_RangingMeasurementData_t ranging_measurement_data;
+
+ uint8_t sequence_config = 0;
/* store the value of the sequence config,
* this will be reset before the end of the function
*/
- SequenceConfig = PALDevDataGet(Dev, SequenceConfig);
+ sequence_config = PALDevDataGet(dev, SequenceConfig);
/*
* This function performs a reference signal rate measurement.
*/
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_PerformSingleRangingMeasurement(Dev,
- &rangingMeasurementData);
+ status = vl53l0x_perform_single_ranging_measurement(dev,
+ &ranging_measurement_data);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_RdWord(Dev,
- VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
- refSignalRate);
+ status = vl53l0x_read_word(dev,
+ VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
+ p_ref_signal_rate);
if (status == VL53L0X_ERROR_NONE)
- status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
+ status = vl53l0x_write_byte(dev, 0xFF, 0x00);
if (status == VL53L0X_ERROR_NONE) {
/* restore the previous Sequence Config */
- status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- SequenceConfig);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ sequence_config);
if (status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, SequenceConfig);
+ PALDevDataSet(dev, SequenceConfig, sequence_config);
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
- uint32_t *refSpadCount,
- uint8_t *isApertureSpads)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_perform_ref_spad_management(VL53L0X_DEV dev,
+ uint32_t *ref_spad_count,
+ uint8_t *is_aperture_spads)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t lastSpadArray[6];
- uint8_t startSelect = 0xB4;
- uint32_t minimumSpadCount = 3;
- uint32_t maxSpadCount = 44;
- uint32_t currentSpadIndex = 0;
- uint32_t lastSpadIndex = 0;
- int32_t nextGoodSpad = 0;
- uint16_t targetRefRate = 0x0A00; /* 20 MCPS in 9:7 format */
- uint16_t peakSignalRateRef;
- uint32_t needAptSpads = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t last_spad_array[6];
+ uint8_t start_select = 0xB4;
+ uint32_t minimum_spad_count = 3;
+ uint32_t max_spad_count = 44;
+ uint32_t current_spad_index = 0;
+ uint32_t last_spad_index = 0;
+ int32_t next_good_spad = 0;
+ uint16_t target_ref_rate = 0x0A00; /* 20 MCPS in 9:7 format */
+ uint16_t peak_signal_rate_ref;
+ uint32_t need_apt_spads = 0;
uint32_t index = 0;
- uint32_t spadArraySize = 6;
- uint32_t signalRateDiff = 0;
- uint32_t lastSignalRateDiff = 0;
+ uint32_t spad_array_size = 6;
+ uint32_t signal_rate_diff = 0;
+ uint32_t last_signal_rate_diff = 0;
uint8_t complete = 0;
- uint8_t VhvSettings = 0;
- uint8_t PhaseCal = 0;
- uint32_t refSpadCount_int = 0;
- uint8_t isApertureSpads_int = 0;
+ uint8_t vhv_settings = 0;
+ uint8_t phase_cal = 0;
+ uint32_t ref_spad_count_int = 0;
+ uint8_t is_aperture_spads_int = 0;
/*
* The reference SPAD initialization procedure determines the minimum
@@ -3711,7 +3711,7 @@
*/
- targetRefRate = PALDevDataGet(Dev, targetRefRate);
+ target_ref_rate = PALDevDataGet(dev, targetRefRate);
/*
* Initialize Spad arrays.
@@ -3721,140 +3721,140 @@
* Note that there are 6 bytes. Only the first 44 bits will be used to
* represent spads.
*/
- for (index = 0; index < spadArraySize; index++)
- Dev->Data.SpadData.RefSpadEnables[index] = 0;
-
-
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
- startSelect);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0);
+ for (index = 0; index < spad_array_size; index++)
+ dev->Data.SpadData.RefSpadEnables[index] = 0;
+
+
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ 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);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 0xFF, 0x00);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ 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);
/* Perform ref calibration */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_perform_ref_calibration(Dev, &VhvSettings,
- &PhaseCal, 0);
-
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_perform_ref_calibration(dev, &vhv_settings,
+ &phase_cal, 0);
+
+ if (status == VL53L0X_ERROR_NONE) {
/* Enable Minimum NON-APERTURE Spads */
- currentSpadIndex = 0;
- lastSpadIndex = currentSpadIndex;
- needAptSpads = 0;
- Status = enable_ref_spads(Dev,
- needAptSpads,
- Dev->Data.SpadData.RefGoodSpadMap,
- Dev->Data.SpadData.RefSpadEnables,
- spadArraySize,
- startSelect,
- currentSpadIndex,
- minimumSpadCount,
- &lastSpadIndex);
+ current_spad_index = 0;
+ last_spad_index = current_spad_index;
+ need_apt_spads = 0;
+ status = enable_ref_spads(dev,
+ need_apt_spads,
+ dev->Data.SpadData.RefGoodSpadMap,
+ dev->Data.SpadData.RefSpadEnables,
+ spad_array_size,
+ start_select,
+ current_spad_index,
+ minimum_spad_count,
+ &last_spad_index);
}
- if (Status == VL53L0X_ERROR_NONE) {
- currentSpadIndex = lastSpadIndex;
-
- Status = perform_ref_signal_measurement(Dev,
- &peakSignalRateRef);
- if ((Status == VL53L0X_ERROR_NONE) &&
- (peakSignalRateRef > targetRefRate)) {
+ if (status == VL53L0X_ERROR_NONE) {
+ current_spad_index = last_spad_index;
+
+ status = perform_ref_signal_measurement(dev,
+ &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 < spadArraySize; index++)
- Dev->Data.SpadData.RefSpadEnables[index] = 0;
+ for (index = 0; index < spad_array_size; index++)
+ dev->Data.SpadData.RefSpadEnables[index] = 0;
/* Increment to the first APERTURE spad */
- while ((is_aperture(startSelect + currentSpadIndex)
- == 0) && (currentSpadIndex < maxSpadCount)) {
- currentSpadIndex++;
+ while ((is_aperture(start_select + current_spad_index)
+ == 0) && (current_spad_index < max_spad_count)) {
+ current_spad_index++;
}
- needAptSpads = 1;
-
- Status = enable_ref_spads(Dev,
- needAptSpads,
- Dev->Data.SpadData.RefGoodSpadMap,
- Dev->Data.SpadData.RefSpadEnables,
- spadArraySize,
- startSelect,
- currentSpadIndex,
- minimumSpadCount,
- &lastSpadIndex);
-
- if (Status == VL53L0X_ERROR_NONE) {
- currentSpadIndex = lastSpadIndex;
- Status = perform_ref_signal_measurement(Dev,
- &peakSignalRateRef);
-
- if ((Status == VL53L0X_ERROR_NONE) &&
- (peakSignalRateRef > targetRefRate)) {
+ need_apt_spads = 1;
+
+ status = enable_ref_spads(dev,
+ need_apt_spads,
+ dev->Data.SpadData.RefGoodSpadMap,
+ dev->Data.SpadData.RefSpadEnables,
+ spad_array_size,
+ start_select,
+ current_spad_index,
+ minimum_spad_count,
+ &last_spad_index);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ current_spad_index = last_spad_index;
+ status = perform_ref_signal_measurement(dev,
+ &peak_signal_rate_ref);
+
+ if ((status == VL53L0X_ERROR_NONE) &&
+ (peak_signal_rate_ref > target_ref_rate)) {
/* Signal rate still too high after
* setting the minimum number of
* APERTURE spads. Can do no more
* therefore set the min number of
* aperture spads as the result.
*/
- isApertureSpads_int = 1;
- refSpadCount_int = minimumSpadCount;
+ is_aperture_spads_int = 1;
+ ref_spad_count_int = minimum_spad_count;
}
}
} else {
- needAptSpads = 0;
+ need_apt_spads = 0;
}
}
- if ((Status == VL53L0X_ERROR_NONE) &&
- (peakSignalRateRef < targetRefRate)) {
+ if ((status == VL53L0X_ERROR_NONE) &&
+ (peak_signal_rate_ref < target_ref_rate)) {
/* 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.
*/
- isApertureSpads_int = needAptSpads;
- refSpadCount_int = minimumSpadCount;
-
- memcpy(lastSpadArray, Dev->Data.SpadData.RefSpadEnables,
- spadArraySize);
- lastSignalRateDiff = abs(peakSignalRateRef -
- targetRefRate);
+ is_aperture_spads_int = need_apt_spads;
+ ref_spad_count_int = minimum_spad_count;
+
+ memcpy(last_spad_array, dev->Data.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->Data.SpadData.RefGoodSpadMap,
- spadArraySize, currentSpadIndex,
- &nextGoodSpad);
-
- if (nextGoodSpad == -1) {
- Status = VL53L0X_ERROR_REF_SPAD_INIT;
+ dev->Data.SpadData.RefGoodSpadMap,
+ spad_array_size, current_spad_index,
+ &next_good_spad);
+
+ if (next_good_spad == -1) {
+ status = VL53L0X_ERROR_REF_SPAD_INIT;
break;
}
/* Cannot combine Aperture and Non-Aperture spads, so
* ensure the current spad is of the correct type.
*/
- if (is_aperture((uint32_t)startSelect + nextGoodSpad) !=
- needAptSpads) {
+ if (is_aperture((uint32_t)start_select + next_good_spad) !=
+ need_apt_spads) {
/* At this point we have enabled the maximum
* number of Aperture spads.
*/
@@ -3862,83 +3862,83 @@
break;
}
- (refSpadCount_int)++;
-
- currentSpadIndex = nextGoodSpad;
- Status = enable_spad_bit(
- Dev->Data.SpadData.RefSpadEnables,
- spadArraySize, currentSpadIndex);
-
- if (Status == VL53L0X_ERROR_NONE) {
- currentSpadIndex++;
+ (ref_spad_count_int)++;
+
+ current_spad_index = next_good_spad;
+ status = enable_spad_bit(
+ dev->Data.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->Data.SpadData.RefSpadEnables);
+ status = set_ref_spad_map(dev,
+ dev->Data.SpadData.RefSpadEnables);
}
- if (Status != VL53L0X_ERROR_NONE)
+ if (status != VL53L0X_ERROR_NONE)
break;
- Status = perform_ref_signal_measurement(Dev,
- &peakSignalRateRef);
-
- if (Status != VL53L0X_ERROR_NONE)
+ status = perform_ref_signal_measurement(dev,
+ &peak_signal_rate_ref);
+
+ if (status != VL53L0X_ERROR_NONE)
break;
- signalRateDiff = abs(peakSignalRateRef - targetRefRate);
-
- if (peakSignalRateRef > targetRefRate) {
+ signal_rate_diff = abs(peak_signal_rate_ref - target_ref_rate);
+
+ if (peak_signal_rate_ref > target_ref_rate) {
/* Select the spad map that provides the
* measurement closest to the target rate,
* either above or below it.
*/
- if (signalRateDiff > lastSignalRateDiff) {
+ if (signal_rate_diff > last_signal_rate_diff) {
/* Previous spad map produced a closer
* measurement, so choose this. */
- Status = set_ref_spad_map(Dev,
- lastSpadArray);
+ status = set_ref_spad_map(dev,
+ last_spad_array);
memcpy(
- Dev->Data.SpadData.RefSpadEnables,
- lastSpadArray, spadArraySize);
-
- (refSpadCount_int)--;
+ dev->Data.SpadData.RefSpadEnables,
+ last_spad_array, spad_array_size);
+
+ (ref_spad_count_int)--;
}
complete = 1;
} else {
/* Continue to add spads */
- lastSignalRateDiff = signalRateDiff;
- memcpy(lastSpadArray,
- Dev->Data.SpadData.RefSpadEnables,
- spadArraySize);
+ last_signal_rate_diff = signal_rate_diff;
+ memcpy(last_spad_array,
+ dev->Data.SpadData.RefSpadEnables,
+ spad_array_size);
}
} /* while */
}
- if (Status == VL53L0X_ERROR_NONE) {
- *refSpadCount = refSpadCount_int;
- *isApertureSpads = isApertureSpads_int;
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadCount, (uint8_t)(*refSpadCount));
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadType, *isApertureSpads);
+ if (status == VL53L0X_ERROR_NONE) {
+ *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);
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_reference_spads(VL53L0X_DEV Dev,
- uint32_t count, uint8_t isApertureSpads)
+VL53L0X_Error VL53L0X::vl53l0x_set_reference_spads(VL53L0X_DEV dev,
+ uint32_t count, uint8_t is_aperture_spads)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint32_t currentSpadIndex = 0;
- uint8_t startSelect = 0xB4;
- uint32_t spadArraySize = 6;
- uint32_t maxSpadCount = 44;
- uint32_t lastSpadIndex;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint32_t current_spad_index = 0;
+ uint8_t start_select = 0xB4;
+ uint32_t spad_array_size = 6;
+ uint32_t max_spad_count = 44;
+ uint32_t last_spad_index;
uint32_t index;
/*
@@ -3948,153 +3948,153 @@
* The good spad map will be applied.
*/
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
- startSelect);
-
- for (index = 0; index < spadArraySize; index++)
- Dev->Data.SpadData.RefSpadEnables[index] = 0;
-
- if (isApertureSpads) {
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ 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);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 0xFF, 0x00);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
+ start_select);
+
+ for (index = 0; index < spad_array_size; index++)
+ dev->Data.SpadData.RefSpadEnables[index] = 0;
+
+ if (is_aperture_spads) {
/* Increment to the first APERTURE spad */
- while ((is_aperture(startSelect + currentSpadIndex) == 0) &&
- (currentSpadIndex < maxSpadCount)) {
- currentSpadIndex++;
+ while ((is_aperture(start_select + current_spad_index) == 0) &&
+ (current_spad_index < max_spad_count)) {
+ current_spad_index++;
}
}
- Status = enable_ref_spads(Dev,
- isApertureSpads,
- Dev->Data.SpadData.RefGoodSpadMap,
- Dev->Data.SpadData.RefSpadEnables,
- spadArraySize,
- startSelect,
- currentSpadIndex,
+ status = enable_ref_spads(dev,
+ is_aperture_spads,
+ dev->Data.SpadData.RefGoodSpadMap,
+ dev->Data.SpadData.RefSpadEnables,
+ spad_array_size,
+ start_select,
+ current_spad_index,
count,
- &lastSpadIndex);
-
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 1);
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+ &last_spad_index);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 1);
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
ReferenceSpadCount, (uint8_t)(count));
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadType, isApertureSpads);
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ ReferenceSpadType, is_aperture_spads);
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_WaitDeviceBooted(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_wait_device_booted(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
+ VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
LOG_FUNCTION_START("");
/* not implemented on VL53L0X */
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_PerformRefCalibration(VL53L0X_DEV Dev, uint8_t *pVhvSettings,
- uint8_t *pPhaseCal)
+VL53L0X_Error VL53L0X::vl53l0x_perform_ref_calibration(VL53L0X_DEV dev, uint8_t *p_vhv_settings,
+ uint8_t *p_phase_cal)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_perform_ref_calibration(Dev, pVhvSettings,
- pPhaseCal, 1);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = vl53l0x_perform_ref_calibration(dev, p_vhv_settings,
+ p_phase_cal, 1);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_PerformRefSpadManagement(VL53L0X_DEV Dev,
- uint32_t *refSpadCount, uint8_t *isApertureSpads)
+VL53L0X_Error VL53L0X::vl53l0x_perform_ref_spad_management(VL53L0X_DEV dev,
+ uint32_t *ref_spad_count, uint8_t *is_aperture_spads)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_perform_ref_spad_management(Dev, refSpadCount,
- isApertureSpads);
-
- LOG_FUNCTION_END(Status);
-
- return Status;
+ status = wrapped_vl53l0x_perform_ref_spad_management(dev, ref_spad_count,
+ is_aperture_spads);
+
+ LOG_FUNCTION_END(status);
+
+ return status;
}
/* Group PAL Init Functions */
-VL53L0X_Error VL53L0X::VL53L0X_SetDeviceAddress(VL53L0X_DEV Dev, uint8_t DeviceAddress)
+VL53L0X_Error VL53L0X::vl53l0x_set_device_address(VL53L0X_DEV dev, uint8_t device_address)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
- DeviceAddress / 2);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
+ device_address / 2);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetGpioConfig(VL53L0X_DEV Dev, uint8_t Pin,
- VL53L0X_DeviceModes DeviceMode, VL53L0X_GpioFunctionality Functionality,
- VL53L0X_InterruptPolarity Polarity)
+VL53L0X_Error VL53L0X::vl53l0x_set_gpio_config(VL53L0X_DEV dev, uint8_t pin,
+ VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
+ VL53L0X_InterruptPolarity polarity)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t data;
LOG_FUNCTION_START("");
- if (Pin != 0) {
- Status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
- } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
- if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
+ if (pin != 0) {
+ status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
+ } else if (device_mode == VL53L0X_DEVICEMODE_GPIO_DRIVE) {
+ if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
data = 0x10;
else
data = 1;
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data);
-
- } else if (DeviceMode == VL53L0X_DEVICEMODE_GPIO_OSC) {
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0x80, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x85, 0x02);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x04);
- Status |= VL53L0X_WrByte(Dev, 0xcd, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0xcc, 0x11);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x07);
- Status |= VL53L0X_WrByte(Dev, 0xbe, 0x00);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x06);
- Status |= VL53L0X_WrByte(Dev, 0xcc, 0x09);
-
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x00);
- Status |= VL53L0X_WrByte(Dev, 0xff, 0x01);
- Status |= VL53L0X_WrByte(Dev, 0x00, 0x00);
+ status = vl53l0x_write_byte(dev,
+ 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);
} else {
- if (Status == VL53L0X_ERROR_NONE) {
- switch (Functionality) {
+ if (status == VL53L0X_ERROR_NONE) {
+ switch (functionality) {
case VL53L0X_GPIOFUNCTIONALITY_OFF:
data = 0x00;
break;
@@ -4111,52 +4111,52 @@
data = 0x04;
break;
default:
- Status =
+ status =
VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
}
}
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
-
- if (Status == VL53L0X_ERROR_NONE) {
- if (Polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ if (polarity == VL53L0X_INTERRUPTPOLARITY_LOW)
data = 0;
else
data = (uint8_t)(1 << 4);
- Status = VL53L0X_UpdateByte(Dev,
- VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
+ status = vl53l0x_update_byte(dev,
+ VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data);
}
- if (Status == VL53L0X_ERROR_NONE)
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
- Pin0GpioFunctionality, Functionality);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_ClearInterruptMask(Dev, 0);
+ if (status == VL53L0X_ERROR_NONE)
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
+ Pin0GpioFunctionality, functionality);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_clear_interrupt_mask(dev, 0);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetFractionEnable(VL53L0X_DEV Dev, uint8_t *pEnabled)
+VL53L0X_Error VL53L0X::vl53l0x_get_fraction_enable(VL53L0X_DEV dev, uint8_t *p_enabled)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, pEnabled);
-
- if (Status == VL53L0X_ERROR_NONE)
- *pEnabled = (*pEnabled & 1);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled);
+
+ if (status == VL53L0X_ERROR_NONE)
+ *p_enabled = (*p_enabled & 1);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-uint16_t VL53L0X::VL53L0X_encode_timeout(uint32_t timeout_macro_clks)
+uint16_t VL53L0X::vl53l0x_encode_timeout(uint32_t timeout_macro_clks)
{
/*!
* Encode timeout in macro periods in (LSByte * 2^MSByte) + 1 format
@@ -4182,82 +4182,82 @@
}
-VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_DEV Dev,
- VL53L0X_SequenceStepId SequenceStepId,
- uint32_t TimeOutMicroSecs)
+VL53L0X_Error VL53L0X::set_sequence_step_timeout(VL53L0X_DEV dev,
+ VL53L0X_SequenceStepId sequence_step_id,
+ uint32_t timeout_micro_secs)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t CurrentVCSELPulsePeriodPClk;
- uint8_t MsrcEncodedTimeOut;
- uint16_t PreRangeEncodedTimeOut;
- uint16_t PreRangeTimeOutMClks;
- uint16_t MsrcRangeTimeOutMClks;
- uint32_t FinalRangeTimeOutMClks;
- uint16_t FinalRangeEncodedTimeOut;
- VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
-
- if ((SequenceStepId == VL53L0X_SEQUENCESTEP_TCC) ||
- (SequenceStepId == VL53L0X_SEQUENCESTEP_DSS) ||
- (SequenceStepId == VL53L0X_SEQUENCESTEP_MSRC)) {
-
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
-
- if (Status == VL53L0X_ERROR_NONE) {
- MsrcRangeTimeOutMClks = VL53L0X_calc_timeout_mclks(Dev,
- TimeOutMicroSecs,
- (uint8_t)CurrentVCSELPulsePeriodPClk);
-
- if (MsrcRangeTimeOutMClks > 256)
- MsrcEncodedTimeOut = 255;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t current_vcsel_pulse_period_p_clk;
+ uint8_t msrc_encoded_time_out;
+ uint16_t pre_range_encoded_time_out;
+ uint16_t pre_range_time_out_m_clks;
+ uint16_t msrc_range_time_out_m_clks;
+ uint32_t final_range_time_out_m_clks;
+ uint16_t final_range_encoded_time_out;
+ VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
+
+ if ((sequence_step_id == VL53L0X_SEQUENCESTEP_TCC) ||
+ (sequence_step_id == VL53L0X_SEQUENCESTEP_DSS) ||
+ (sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC)) {
+
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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,
+ (uint8_t)current_vcsel_pulse_period_p_clk);
+
+ if (msrc_range_time_out_m_clks > 256)
+ msrc_encoded_time_out = 255;
else
- MsrcEncodedTimeOut =
- (uint8_t)MsrcRangeTimeOutMClks - 1;
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+ msrc_encoded_time_out =
+ (uint8_t)msrc_range_time_out_m_clks - 1;
+
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev,
LastEncodedTimeout,
- MsrcEncodedTimeOut);
+ msrc_encoded_time_out);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
- MsrcEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
+ msrc_encoded_time_out);
}
} else {
- if (SequenceStepId == VL53L0X_SEQUENCESTEP_PRE_RANGE) {
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
- PreRangeTimeOutMClks =
- VL53L0X_calc_timeout_mclks(Dev,
- TimeOutMicroSecs,
- (uint8_t)CurrentVCSELPulsePeriodPClk);
- PreRangeEncodedTimeOut = VL53L0X_encode_timeout(
- PreRangeTimeOutMClks);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev,
+ 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,
+ ¤t_vcsel_pulse_period_p_clk);
+ pre_range_time_out_m_clks =
+ vl53l0x_calc_timeout_mclks(dev,
+ 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,
- PreRangeEncodedTimeOut);
+ pre_range_encoded_time_out);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_WrWord(Dev,
- VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
- PreRangeEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_word(dev,
+ VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
+ pre_range_encoded_time_out);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
PreRangeTimeoutMicroSecs,
- TimeOutMicroSecs);
+ timeout_micro_secs);
}
- } else if (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
+ } else if (sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE) {
/* For the final range timeout, the pre-range timeout
* must be added. To do this both final and pre-range
@@ -4265,195 +4265,195 @@
* because they have different vcsel periods.
*/
- VL53L0X_GetSequenceStepEnables(Dev,
- &SchedulerSequenceSteps);
- PreRangeTimeOutMClks = 0;
- if (SchedulerSequenceSteps.PreRangeOn) {
+ vl53l0x_get_sequence_step_enables(dev,
+ &scheduler_sequence_steps);
+ pre_range_time_out_m_clks = 0;
+ if (scheduler_sequence_steps.PreRangeOn) {
/* Retrieve PRE-RANGE VCSEL Period */
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &CurrentVCSELPulsePeriodPClk);
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ 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_RdWord(Dev, 0x51,
- &PreRangeEncodedTimeOut);
- PreRangeTimeOutMClks =
- VL53L0X_decode_timeout(
- PreRangeEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_word(dev, 0x51,
+ &pre_range_encoded_time_out);
+ pre_range_time_out_m_clks =
+ vl53l0x_decode_timeout(
+ pre_range_encoded_time_out);
}
}
/* Calculate FINAL RANGE Timeout in Macro Periods
* (MCLKS) and add PRE-RANGE value
*/
- if (Status == VL53L0X_ERROR_NONE) {
-
- Status = VL53L0X_GetVcselPulsePeriod(Dev,
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
- &CurrentVCSELPulsePeriodPClk);
+ if (status == VL53L0X_ERROR_NONE) {
+
+ status = vl53l0x_get_vcsel_pulse_period(dev,
+ VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+ ¤t_vcsel_pulse_period_p_clk);
}
- if (Status == VL53L0X_ERROR_NONE) {
-
- FinalRangeTimeOutMClks =
- VL53L0X_calc_timeout_mclks(Dev,
- TimeOutMicroSecs,
- (uint8_t) CurrentVCSELPulsePeriodPClk);
-
- FinalRangeTimeOutMClks += PreRangeTimeOutMClks;
-
- FinalRangeEncodedTimeOut =
- VL53L0X_encode_timeout(FinalRangeTimeOutMClks);
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_WrWord(Dev, 0x71,
- FinalRangeEncodedTimeOut);
+ if (status == VL53L0X_ERROR_NONE) {
+
+ final_range_time_out_m_clks =
+ vl53l0x_calc_timeout_mclks(dev,
+ timeout_micro_secs,
+ (uint8_t) current_vcsel_pulse_period_p_clk);
+
+ final_range_time_out_m_clks += pre_range_time_out_m_clks;
+
+ final_range_encoded_time_out =
+ vl53l0x_encode_timeout(final_range_time_out_m_clks);
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_word(dev, 0x71,
+ final_range_encoded_time_out);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
FinalRangeTimeoutMicroSecs,
- TimeOutMicroSecs);
+ timeout_micro_secs);
}
}
} else
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
- uint32_t MeasurementTimingBudgetMicroSeconds)
+VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
+ uint32_t measurement_timing_budget_micro_seconds)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint32_t FinalRangeTimingBudgetMicroSeconds;
- VL53L0X_SchedulerSequenceSteps_t SchedulerSequenceSteps;
- uint32_t MsrcDccTccTimeoutMicroSeconds = 2000;
- uint32_t StartOverheadMicroSeconds = 1910;
- uint32_t EndOverheadMicroSeconds = 960;
- uint32_t MsrcOverheadMicroSeconds = 660;
- uint32_t TccOverheadMicroSeconds = 590;
- uint32_t DssOverheadMicroSeconds = 690;
- uint32_t PreRangeOverheadMicroSeconds = 660;
- uint32_t FinalRangeOverheadMicroSeconds = 550;
- uint32_t PreRangeTimeoutMicroSeconds = 0;
- uint32_t cMinTimingBudgetMicroSeconds = 20000;
- uint32_t SubTimeout = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint32_t final_range_timing_budget_micro_seconds;
+ VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
+ uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
+ uint32_t start_overhead_micro_seconds = 1910;
+ uint32_t end_overhead_micro_seconds = 960;
+ uint32_t msrc_overhead_micro_seconds = 660;
+ uint32_t tcc_overhead_micro_seconds = 590;
+ uint32_t dss_overhead_micro_seconds = 690;
+ uint32_t pre_range_overhead_micro_seconds = 660;
+ uint32_t final_range_overhead_micro_seconds = 550;
+ uint32_t pre_range_timeout_micro_seconds = 0;
+ uint32_t c_min_timing_budget_micro_seconds = 20000;
+ uint32_t sub_timeout = 0;
LOG_FUNCTION_START("");
- if (MeasurementTimingBudgetMicroSeconds
- < cMinTimingBudgetMicroSeconds) {
- Status = VL53L0X_ERROR_INVALID_PARAMS;
- return Status;
+ if (measurement_timing_budget_micro_seconds
+ < c_min_timing_budget_micro_seconds) {
+ status = VL53L0X_ERROR_INVALID_PARAMS;
+ return status;
}
- FinalRangeTimingBudgetMicroSeconds =
- MeasurementTimingBudgetMicroSeconds -
- (StartOverheadMicroSeconds + EndOverheadMicroSeconds);
-
- Status = VL53L0X_GetSequenceStepEnables(Dev, &SchedulerSequenceSteps);
-
- if (Status == VL53L0X_ERROR_NONE &&
- (SchedulerSequenceSteps.TccOn ||
- SchedulerSequenceSteps.MsrcOn ||
- SchedulerSequenceSteps.DssOn)) {
+ final_range_timing_budget_micro_seconds =
+ measurement_timing_budget_micro_seconds -
+ (start_overhead_micro_seconds + end_overhead_micro_seconds);
+
+ status = vl53l0x_get_sequence_step_enables(dev, &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,
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_MSRC,
- &MsrcDccTccTimeoutMicroSeconds);
+ &msrc_dcc_tcc_timeout_micro_seconds);
/* Subtract the TCC, MSRC and DSS timeouts if they are
* enabled. */
- if (Status != VL53L0X_ERROR_NONE)
- return Status;
+ if (status != VL53L0X_ERROR_NONE)
+ return status;
/* TCC */
- if (SchedulerSequenceSteps.TccOn) {
-
- SubTimeout = MsrcDccTccTimeoutMicroSeconds
- + TccOverheadMicroSeconds;
-
- if (SubTimeout <
- FinalRangeTimingBudgetMicroSeconds) {
- FinalRangeTimingBudgetMicroSeconds -=
- SubTimeout;
+ if (scheduler_sequence_steps.TccOn) {
+
+ sub_timeout = msrc_dcc_tcc_timeout_micro_seconds
+ + tcc_overhead_micro_seconds;
+
+ if (sub_timeout <
+ final_range_timing_budget_micro_seconds) {
+ final_range_timing_budget_micro_seconds -=
+ sub_timeout;
} else {
/* Requested timeout too big. */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
- if (Status != VL53L0X_ERROR_NONE) {
- LOG_FUNCTION_END(Status);
- return Status;
+ if (status != VL53L0X_ERROR_NONE) {
+ LOG_FUNCTION_END(status);
+ return status;
}
/* DSS */
- if (SchedulerSequenceSteps.DssOn) {
-
- SubTimeout = 2 * (MsrcDccTccTimeoutMicroSeconds +
- DssOverheadMicroSeconds);
-
- if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
- FinalRangeTimingBudgetMicroSeconds
- -= SubTimeout;
+ if (scheduler_sequence_steps.DssOn) {
+
+ sub_timeout = 2 * (msrc_dcc_tcc_timeout_micro_seconds +
+ dss_overhead_micro_seconds);
+
+ if (sub_timeout < final_range_timing_budget_micro_seconds) {
+ final_range_timing_budget_micro_seconds
+ -= sub_timeout;
} else {
/* Requested timeout too big. */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
- } else if (SchedulerSequenceSteps.MsrcOn) {
+ } else if (scheduler_sequence_steps.MsrcOn) {
/* MSRC */
- SubTimeout = MsrcDccTccTimeoutMicroSeconds +
- MsrcOverheadMicroSeconds;
-
- if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
- FinalRangeTimingBudgetMicroSeconds
- -= SubTimeout;
+ sub_timeout = msrc_dcc_tcc_timeout_micro_seconds +
+ msrc_overhead_micro_seconds;
+
+ if (sub_timeout < final_range_timing_budget_micro_seconds) {
+ final_range_timing_budget_micro_seconds
+ -= sub_timeout;
} else {
/* Requested timeout too big. */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
}
- if (Status != VL53L0X_ERROR_NONE) {
- LOG_FUNCTION_END(Status);
- return Status;
+ if (status != VL53L0X_ERROR_NONE) {
+ LOG_FUNCTION_END(status);
+ return status;
}
- if (SchedulerSequenceSteps.PreRangeOn) {
+ if (scheduler_sequence_steps.PreRangeOn) {
/* Subtract the Pre-range timeout if enabled. */
- Status = get_sequence_step_timeout(Dev,
+ status = get_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
- &PreRangeTimeoutMicroSeconds);
-
- SubTimeout = PreRangeTimeoutMicroSeconds +
- PreRangeOverheadMicroSeconds;
-
- if (SubTimeout < FinalRangeTimingBudgetMicroSeconds) {
- FinalRangeTimingBudgetMicroSeconds -= SubTimeout;
+ &pre_range_timeout_micro_seconds);
+
+ sub_timeout = pre_range_timeout_micro_seconds +
+ pre_range_overhead_micro_seconds;
+
+ if (sub_timeout < final_range_timing_budget_micro_seconds) {
+ final_range_timing_budget_micro_seconds -= sub_timeout;
} else {
/* Requested timeout too big. */
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
- if (Status == VL53L0X_ERROR_NONE &&
- SchedulerSequenceSteps.FinalRangeOn) {
-
- FinalRangeTimingBudgetMicroSeconds -=
- FinalRangeOverheadMicroSeconds;
+ if (status == VL53L0X_ERROR_NONE &&
+ scheduler_sequence_steps.FinalRangeOn) {
+
+ final_range_timing_budget_micro_seconds -=
+ final_range_overhead_micro_seconds;
/* Final Range Timeout
* Note that the final range timeout is determined by the timing
@@ -4462,476 +4462,476 @@
* will be set. Otherwise the remaining time will be applied to
* the final range.
*/
- Status = set_sequence_step_timeout(Dev,
+ status = set_sequence_step_timeout(dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
- FinalRangeTimingBudgetMicroSeconds);
-
- VL53L0X_SETPARAMETERFIELD(Dev,
+ final_range_timing_budget_micro_seconds);
+
+ VL53L0X_SETPARAMETERFIELD(dev,
MeasurementTimingBudgetMicroSeconds,
- MeasurementTimingBudgetMicroSeconds);
+ measurement_timing_budget_micro_seconds);
}
- LOG_FUNCTION_END(Status);
-
- return Status;
+ LOG_FUNCTION_END(status);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetMeasurementTimingBudgetMicroSeconds(VL53L0X_DEV Dev,
- uint32_t MeasurementTimingBudgetMicroSeconds)
+VL53L0X_Error VL53L0X::vl53l0x_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
+ uint32_t measurement_timing_budget_micro_seconds)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_set_measurement_timing_budget_micro_seconds(Dev,
- MeasurementTimingBudgetMicroSeconds);
-
- LOG_FUNCTION_END(Status);
-
- return Status;
+ status = wrapped_vl53l0x_set_measurement_timing_budget_micro_seconds(dev,
+ measurement_timing_budget_micro_seconds);
+
+ LOG_FUNCTION_END(status);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetSequenceStepEnable(VL53L0X_DEV Dev,
- VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceStepEnabled)
+VL53L0X_Error VL53L0X::vl53l0x_set_sequence_step_enable(VL53L0X_DEV dev,
+ VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t SequenceConfig = 0;
- uint8_t SequenceConfigNew = 0;
- uint32_t MeasurementTimingBudgetMicroSeconds;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t sequence_config = 0;
+ uint8_t sequence_config_new = 0;
+ uint32_t measurement_timing_budget_micro_seconds;
LOG_FUNCTION_START("");
- Status = VL53L0X_RdByte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
- &SequenceConfig);
-
- SequenceConfigNew = SequenceConfig;
-
- if (Status == VL53L0X_ERROR_NONE) {
- if (SequenceStepEnabled == 1) {
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ &sequence_config);
+
+ sequence_config_new = sequence_config;
+
+ if (status == VL53L0X_ERROR_NONE) {
+ if (sequence_step_enabled == 1) {
/* Enable requested sequence step
*/
- switch (SequenceStepId) {
+ switch (sequence_step_id) {
case VL53L0X_SEQUENCESTEP_TCC:
- SequenceConfigNew |= 0x10;
+ sequence_config_new |= 0x10;
break;
case VL53L0X_SEQUENCESTEP_DSS:
- SequenceConfigNew |= 0x28;
+ sequence_config_new |= 0x28;
break;
case VL53L0X_SEQUENCESTEP_MSRC:
- SequenceConfigNew |= 0x04;
+ sequence_config_new |= 0x04;
break;
case VL53L0X_SEQUENCESTEP_PRE_RANGE:
- SequenceConfigNew |= 0x40;
+ sequence_config_new |= 0x40;
break;
case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
- SequenceConfigNew |= 0x80;
+ sequence_config_new |= 0x80;
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
} else {
/* Disable requested sequence step
*/
- switch (SequenceStepId) {
+ switch (sequence_step_id) {
case VL53L0X_SEQUENCESTEP_TCC:
- SequenceConfigNew &= 0xef;
+ sequence_config_new &= 0xef;
break;
case VL53L0X_SEQUENCESTEP_DSS:
- SequenceConfigNew &= 0xd7;
+ sequence_config_new &= 0xd7;
break;
case VL53L0X_SEQUENCESTEP_MSRC:
- SequenceConfigNew &= 0xfb;
+ sequence_config_new &= 0xfb;
break;
case VL53L0X_SEQUENCESTEP_PRE_RANGE:
- SequenceConfigNew &= 0xbf;
+ sequence_config_new &= 0xbf;
break;
case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
- SequenceConfigNew &= 0x7f;
+ sequence_config_new &= 0x7f;
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
}
- if (SequenceConfigNew != SequenceConfig) {
+ if (sequence_config_new != sequence_config) {
/* Apply New Setting */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_WrByte(Dev,
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, SequenceConfigNew);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_byte(dev,
+ VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new);
}
- if (Status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, SequenceConfigNew);
+ if (status == VL53L0X_ERROR_NONE)
+ PALDevDataSet(dev, SequenceConfig, sequence_config_new);
/* Recalculate timing budget */
- if (Status == VL53L0X_ERROR_NONE) {
- VL53L0X_GETPARAMETERFIELD(Dev,
+ if (status == VL53L0X_ERROR_NONE) {
+ VL53L0X_GETPARAMETERFIELD(dev,
MeasurementTimingBudgetMicroSeconds,
- MeasurementTimingBudgetMicroSeconds);
-
- VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Dev,
- MeasurementTimingBudgetMicroSeconds);
+ measurement_timing_budget_micro_seconds);
+
+ vl53l0x_set_measurement_timing_budget_micro_seconds(dev,
+ measurement_timing_budget_micro_seconds);
}
}
- LOG_FUNCTION_END(Status);
-
- return Status;
+ LOG_FUNCTION_END(status);
+
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_SetLimitCheckEnable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
- uint8_t LimitCheckEnable)
+VL53L0X_Error VL53L0X::vl53l0x_set_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
+ uint8_t limit_check_enable)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- FixPoint1616_t TempFix1616 = 0;
- uint8_t LimitCheckEnableInt = 0;
- uint8_t LimitCheckDisable = 0;
- uint8_t Temp8;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ FixPoint1616_t temp_fix1616 = 0;
+ uint8_t limit_check_enable_int = 0;
+ uint8_t limit_check_disable = 0;
+ uint8_t temp8;
LOG_FUNCTION_START("");
- if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+ status = VL53L0X_ERROR_INVALID_PARAMS;
} else {
- if (LimitCheckEnable == 0) {
- TempFix1616 = 0;
- LimitCheckEnableInt = 0;
- LimitCheckDisable = 1;
+ if (limit_check_enable == 0) {
+ temp_fix1616 = 0;
+ limit_check_enable_int = 0;
+ limit_check_disable = 1;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
- LimitCheckId, TempFix1616);
- LimitCheckDisable = 0;
+ VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
+ limit_check_id, temp_fix1616);
+ limit_check_disable = 0;
/* this to be sure to have either 0 or 1 */
- LimitCheckEnableInt = 1;
+ limit_check_enable_int = 1;
}
- switch (LimitCheckId) {
+ switch (limit_check_id) {
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- LimitCheckEnableInt);
+ limit_check_enable_int);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- Status = VL53L0X_WrWord(Dev,
- VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
- VL53L0X_FIXPOINT1616TOFIXPOINT97(TempFix1616));
+ status = vl53l0x_write_word(dev,
+ VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
+ VL53L0X_FIXPOINT1616TOFIXPOINT97(temp_fix1616));
break;
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- LimitCheckEnableInt);
+ limit_check_enable_int);
break;
case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
/* internal computation: */
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- LimitCheckEnableInt);
+ limit_check_enable_int);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
- Temp8 = (uint8_t)(LimitCheckDisable << 1);
- Status = VL53L0X_UpdateByte(Dev,
- VL53L0X_REG_MSRC_CONFIG_CONTROL,
- 0xFE, Temp8);
+ temp8 = (uint8_t)(limit_check_disable << 1);
+ status = vl53l0x_update_byte(dev,
+ VL53L0X_REG_MSRC_CONFIG_CONTROL,
+ 0xFE, temp8);
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
- Temp8 = (uint8_t)(LimitCheckDisable << 4);
- Status = VL53L0X_UpdateByte(Dev,
- VL53L0X_REG_MSRC_CONFIG_CONTROL,
- 0xEF, Temp8);
+ temp8 = (uint8_t)(limit_check_disable << 4);
+ status = vl53l0x_update_byte(dev,
+ VL53L0X_REG_MSRC_CONFIG_CONTROL,
+ 0xEF, temp8);
break;
default:
- Status = VL53L0X_ERROR_INVALID_PARAMS;
+ status = VL53L0X_ERROR_INVALID_PARAMS;
}
}
- if (Status == VL53L0X_ERROR_NONE) {
- if (LimitCheckEnable == 0) {
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
- LimitCheckId, 0);
+ if (status == VL53L0X_ERROR_NONE) {
+ if (limit_check_enable == 0) {
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
+ limit_check_id, 0);
} else {
- VL53L0X_SETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
- LimitCheckId, 1);
+ VL53L0X_SETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
+ limit_check_id, 1);
}
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_StaticInit(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_static_init(VL53L0X_DEV Dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- VL53L0X_DeviceParameters_t CurrentParameters = {0};
- uint8_t *pTuningSettingBuffer;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ VL53L0X_DeviceParameters_t current_parameters = {0};
+ uint8_t *p_tuning_setting_buffer;
uint16_t tempword = 0;
uint8_t tempbyte = 0;
- uint8_t UseInternalTuningSettings = 0;
+ uint8_t use_internal_tuning_settings = 0;
uint32_t count = 0;
- uint8_t isApertureSpads = 0;
- uint32_t refSpadCount = 0;
- uint8_t ApertureSpads = 0;
- uint8_t vcselPulsePeriodPCLK;
- uint32_t seqTimeoutMicroSecs;
+ uint8_t is_aperture_spads = 0;
+ uint32_t ref_spad_count = 0;
+ uint8_t aperture_spads = 0;
+ uint8_t vcsel_pulse_period_pclk;
+ uint32_t seq_timeout_micro_secs;
LOG_FUNCTION_START("");
- Status = VL53L0X_get_info_from_device(Dev, 1);
+ status = vl53l0x_get_info_from_device(Dev, 1);
/* set the ref spad from NVM */
count = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
ReferenceSpadCount);
- ApertureSpads = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
- ReferenceSpadType);
+ aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ ReferenceSpadType);
/* NVM value invalid */
- if ((ApertureSpads > 1) ||
- ((ApertureSpads == 1) && (count > 32)) ||
- ((ApertureSpads == 0) && (count > 12)))
- Status = VL53L0X_perform_ref_spad_management(Dev, &refSpadCount,
- &isApertureSpads);
+ 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,
+ &is_aperture_spads);
else
- Status = VL53L0X_set_reference_spads(Dev, count, ApertureSpads);
+ status = vl53l0x_set_reference_spads(Dev, count, aperture_spads);
/* Initialize tuning settings buffer to prevent compiler warning. */
- pTuningSettingBuffer = DefaultTuningSettings;
-
- if (Status == VL53L0X_ERROR_NONE) {
- UseInternalTuningSettings = PALDevDataGet(Dev,
- UseInternalTuningSettings);
-
- if (UseInternalTuningSettings == 0)
- pTuningSettingBuffer = PALDevDataGet(Dev,
- pTuningSettingsPointer);
+ p_tuning_setting_buffer = DefaultTuningSettings;
+
+ if (status == VL53L0X_ERROR_NONE) {
+ use_internal_tuning_settings = PALDevDataGet(Dev,
+ UseInternalTuningSettings);
+
+ if (use_internal_tuning_settings == 0)
+ p_tuning_setting_buffer = PALDevDataGet(Dev,
+ pTuningSettingsPointer);
else
- pTuningSettingBuffer = DefaultTuningSettings;
+ p_tuning_setting_buffer = DefaultTuningSettings;
}
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_load_tuning_settings(Dev, pTuningSettingBuffer);
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_load_tuning_settings(Dev, p_tuning_setting_buffer);
/* Set interrupt config to new sample ready */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetGpioConfig(Dev, 0, 0,
- VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
- VL53L0X_INTERRUPTPOLARITY_LOW);
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_set_gpio_config(Dev, 0, 0,
+ VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
+ VL53L0X_INTERRUPTPOLARITY_LOW);
}
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status |= VL53L0X_RdWord(Dev, 0x84, &tempword);
- Status |= VL53L0X_WrByte(Dev, 0xFF, 0x00);
+ 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);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz,
VL53L0X_FIXPOINT412TOFIXPOINT1616(tempword));
}
/* After static init, some device parameters may be changed,
* so update them */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_GetDeviceParameters(Dev, &CurrentParameters);
-
-
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetFractionEnable(Dev, &tempbyte);
- if (Status == VL53L0X_ERROR_NONE)
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_get_device_parameters(Dev, ¤t_parameters);
+
+
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_fraction_enable(Dev, &tempbyte);
+ if (status == VL53L0X_ERROR_NONE)
PALDevDataSet(Dev, RangeFractionalEnable, tempbyte);
}
- if (Status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
+ if (status == VL53L0X_ERROR_NONE)
+ PALDevDataSet(Dev, CurrentParameters, current_parameters);
/* read the sequence config and save it */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_RdByte(Dev,
- VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
- if (Status == VL53L0X_ERROR_NONE)
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_read_byte(Dev,
+ VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
+ if (status == VL53L0X_ERROR_NONE)
PALDevDataSet(Dev, SequenceConfig, tempbyte);
}
/* Disable MSRC and TCC by default */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetSequenceStepEnable(Dev,
- VL53L0X_SEQUENCESTEP_TCC, 0);
-
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_SetSequenceStepEnable(Dev,
- VL53L0X_SEQUENCESTEP_MSRC, 0);
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_set_sequence_step_enable(Dev,
+ VL53L0X_SEQUENCESTEP_TCC, 0);
+
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_set_sequence_step_enable(Dev,
+ VL53L0X_SEQUENCESTEP_MSRC, 0);
/* Set PAL State to standby */
- if (Status == VL53L0X_ERROR_NONE)
+ if (status == VL53L0X_ERROR_NONE)
PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
/* Store pre-range vcsel period */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetVcselPulsePeriod(
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_vcsel_pulse_period(
Dev,
VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &vcselPulsePeriodPCLK);
+ &vcsel_pulse_period_pclk);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
Dev,
PreRangeVcselPulsePeriod,
- vcselPulsePeriodPCLK);
+ vcsel_pulse_period_pclk);
}
/* Store final-range vcsel period */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetVcselPulsePeriod(
+ if (status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_vcsel_pulse_period(
Dev,
VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
- &vcselPulsePeriodPCLK);
+ &vcsel_pulse_period_pclk);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
Dev,
FinalRangeVcselPulsePeriod,
- vcselPulsePeriodPCLK);
+ vcsel_pulse_period_pclk);
}
/* Store pre-range timeout */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = get_sequence_step_timeout(
+ if (status == VL53L0X_ERROR_NONE) {
+ status = get_sequence_step_timeout(
Dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
- &seqTimeoutMicroSecs);
+ &seq_timeout_micro_secs);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
Dev,
PreRangeTimeoutMicroSecs,
- seqTimeoutMicroSecs);
+ seq_timeout_micro_secs);
}
/* Store final-range timeout */
- if (Status == VL53L0X_ERROR_NONE) {
- Status = get_sequence_step_timeout(
+ if (status == VL53L0X_ERROR_NONE) {
+ status = get_sequence_step_timeout(
Dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
- &seqTimeoutMicroSecs);
+ &seq_timeout_micro_secs);
}
- if (Status == VL53L0X_ERROR_NONE) {
+ if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
Dev,
FinalRangeTimeoutMicroSecs,
- seqTimeoutMicroSecs);
+ seq_timeout_micro_secs);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_StopMeasurement(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_stop_measurement(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- Status = VL53L0X_WrByte(Dev, VL53L0X_REG_SYSRANGE_START,
- VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT);
-
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x91, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
-
- if (Status == VL53L0X_ERROR_NONE) {
+ status = vl53l0x_write_byte(dev, 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);
+
+ if (status == VL53L0X_ERROR_NONE) {
/* Set PAL State to Idle */
- PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
}
/* Check if need to apply interrupt settings */
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_CheckAndLoadInterruptSettings(Dev, 0);
-
- LOG_FUNCTION_END(Status);
- return Status;
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_check_and_load_interrupt_settings(dev, 0);
+
+ LOG_FUNCTION_END(status);
+ return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_GetStopCompletedStatus(VL53L0X_DEV Dev,
- uint32_t *pStopStatus)
+VL53L0X_Error VL53L0X::vl53l0x_get_stop_completed_status(VL53L0X_DEV dev,
+ uint32_t *p_stop_status)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t Byte = 0;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t byte = 0;
LOG_FUNCTION_START("");
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_RdByte(Dev, 0x04, &Byte);
-
- if (Status == VL53L0X_ERROR_NONE)
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x0);
-
- *pStopStatus = Byte;
-
- if (Byte == 0) {
- Status = VL53L0X_WrByte(Dev, 0x80, 0x01);
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x01);
- Status = VL53L0X_WrByte(Dev, 0x00, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x91,
- PALDevDataGet(Dev, StopVariable));
- Status = VL53L0X_WrByte(Dev, 0x00, 0x01);
- Status = VL53L0X_WrByte(Dev, 0xFF, 0x00);
- Status = VL53L0X_WrByte(Dev, 0x80, 0x00);
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_read_byte(dev, 0x04, &byte);
+
+ if (status == VL53L0X_ERROR_NONE)
+ status = vl53l0x_write_byte(dev, 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);
}
- LOG_FUNCTION_END(Status);
- return Status;
+ LOG_FUNCTION_END(status);
+ return status;
}
/****************** Write and read functions from I2C *************************/
-VL53L0X_Error VL53L0X::VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count)
+VL53L0X_Error VL53L0X::vl53l0x_write_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
{
int status;
- status = VL53L0X_I2CWrite(Dev->I2cDevAddr, index, pdata, (uint16_t)count);
+ status = vl53l0x_i2c_write(dev->I2cDevAddr, index, p_data, (uint16_t)count);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count)
+VL53L0X_Error VL53L0X::vl53l0x_read_multi(VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count)
{
int status;
@@ -4939,32 +4939,32 @@
status = VL53L0X_ERROR_INVALID_PARAMS;
}
- status = VL53L0X_I2CRead(Dev->I2cDevAddr, index, pdata, (uint16_t)count);
+ status = vl53l0x_i2c_read(dev->I2cDevAddr, index, p_data, (uint16_t)count);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
+VL53L0X_Error VL53L0X::vl53l0x_write_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
{
int status;
- status=VL53L0X_I2CWrite(Dev->I2cDevAddr, index, &data, 1);
+ status=vl53l0x_i2c_write(Dev->I2cDevAddr, index, &data, 1);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data)
+VL53L0X_Error VL53L0X::vl53l0x_write_word(VL53L0X_DEV dev, uint8_t index, uint16_t data)
{
int status;
uint8_t buffer[2];
buffer[0] = data >> 8;
buffer[1] = data & 0x00FF;
- status=VL53L0X_I2CWrite(Dev->I2cDevAddr, index, (uint8_t *)buffer, 2);
+ status=vl53l0x_i2c_write(dev->I2cDevAddr, index, (uint8_t *)buffer, 2);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
+VL53L0X_Error VL53L0X::vl53l0x_write_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
{
int status;
uint8_t buffer[4];
@@ -4973,16 +4973,16 @@
buffer[1] = (data >> 16) & 0xFF;
buffer[2] = (data >> 8) & 0xFF;
buffer[3] = (data >> 0) & 0xFF;
- status=VL53L0X_I2CWrite(Dev->I2cDevAddr, index, (uint8_t *)buffer, 4);
+ status=vl53l0x_i2c_write(Dev->I2cDevAddr, index, (uint8_t *)buffer, 4);
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data)
+VL53L0X_Error VL53L0X::vl53l0x_read_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t *p_data)
{
int status;
- status = VL53L0X_I2CRead(Dev->I2cDevAddr, index, data, 1);
+ status = vl53l0x_i2c_read(Dev->I2cDevAddr, index, p_data, 1);
if(status)
return -1;
@@ -4990,62 +4990,62 @@
return 0;
}
-VL53L0X_Error VL53L0X::VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data)
+VL53L0X_Error VL53L0X::vl53l0x_read_word(VL53L0X_DEV Dev, uint8_t index, uint16_t *p_data)
{
int status;
uint8_t buffer[2] = {0,0};
- status = VL53L0X_I2CRead(Dev->I2cDevAddr, index, buffer, 2);
+ status = vl53l0x_i2c_read(Dev->I2cDevAddr, index, buffer, 2);
if (!status) {
- *data = (buffer[0] << 8) + buffer[1];
+ *p_data = (buffer[0] << 8) + buffer[1];
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data)
+VL53L0X_Error VL53L0X::vl53l0x_read_dword(VL53L0X_DEV Dev, uint8_t index, uint32_t *p_data)
{
int status;
uint8_t buffer[4] = {0,0,0,0};
- status = VL53L0X_I2CRead(Dev->I2cDevAddr, index, buffer, 4);
+ status = vl53l0x_i2c_read(Dev->I2cDevAddr, index, buffer, 4);
if(!status) {
- *data = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
+ *p_data = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index, uint8_t AndData, uint8_t OrData)
+VL53L0X_Error VL53L0X::vl53l0x_update_byte(VL53L0X_DEV Dev, uint8_t index, uint8_t and_data, uint8_t or_data)
{
int status;
uint8_t buffer = 0;
/* read data direct onto buffer */
- status = VL53L0X_I2CRead(Dev->I2cDevAddr, index, &buffer,1);
+ status = vl53l0x_i2c_read(Dev->I2cDevAddr, index, &buffer,1);
if (!status) {
- buffer = (buffer & AndData) | OrData;
- status = VL53L0X_I2CWrite(Dev->I2cDevAddr, index, &buffer, (uint8_t)1);
+ buffer = (buffer & and_data) | or_data;
+ status = vl53l0x_i2c_write(Dev->I2cDevAddr, index, &buffer, (uint8_t)1);
}
return status;
}
-VL53L0X_Error VL53L0X::VL53L0X_I2CWrite(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToWrite)
+VL53L0X_Error VL53L0X::vl53l0x_i2c_write(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t* p_data, uint16_t NumByteToWrite)
{
int ret;
- ret = dev_i2c.i2c_write(pBuffer, DeviceAddr, RegisterAddr, NumByteToWrite);
+ ret = dev_i2c.i2c_write(p_data, DeviceAddr, RegisterAddr, NumByteToWrite);
if(ret)
return -1;
return 0;
}
-VL53L0X_Error VL53L0X::VL53L0X_I2CRead(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t* pBuffer, uint16_t NumByteToRead)
+VL53L0X_Error VL53L0X::vl53l0x_i2c_read(uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t* p_data, uint16_t NumByteToRead)
{
int ret;
- ret = dev_i2c.i2c_read(pBuffer, DeviceAddr, RegisterAddr, NumByteToRead);
+ ret = dev_i2c.i2c_read(p_data, DeviceAddr, RegisterAddr, NumByteToRead);
if(ret)
return -1;
@@ -5057,7 +5057,7 @@
int status = 0;
uint16_t rl_id=0;
- status = VL53L0X_RdWord(Device, VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
+ status = vl53l0x_read_word(_device, VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id);
if (rl_id == 0xEEAA)
return status;
@@ -5070,92 +5070,92 @@
}
-VL53L0X_Error VL53L0X::WaitMeasurementDataReady(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::wait_measurement_data_ready(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint8_t NewDatReady=0;
- uint32_t LoopNb;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint8_t new_dat_ready=0;
+ uint32_t loop_nb;
// Wait until it finished
// use timeout to avoid deadlock
- if (Status == VL53L0X_ERROR_NONE) {
- LoopNb = 0;
+ if (status == VL53L0X_ERROR_NONE) {
+ loop_nb = 0;
do {
- Status = VL53L0X_GetMeasurementDataReady(Dev, &NewDatReady);
- if ((NewDatReady == 0x01) || Status != VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_measurement_data_ready(dev, &new_dat_ready);
+ if ((new_dat_ready == 0x01) || status != VL53L0X_ERROR_NONE) {
break;
}
- LoopNb = LoopNb + 1;
- VL53L0X_PollingDelay(Dev);
- } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
-
- if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
- Status = VL53L0X_ERROR_TIME_OUT;
+ loop_nb = loop_nb + 1;
+ vl53l0x_polling_delay(dev);
+ } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
+
+ if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
+ status = VL53L0X_ERROR_TIME_OUT;
}
}
- return Status;
+ return status;
}
-VL53L0X_Error VL53L0X::WaitStopCompleted(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::wait_stop_completed(VL53L0X_DEV dev)
{
- VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- uint32_t StopCompleted=0;
- uint32_t LoopNb;
+ VL53L0X_Error status = VL53L0X_ERROR_NONE;
+ uint32_t stop_completed=0;
+ uint32_t loop_nb;
// Wait until it finished
// use timeout to avoid deadlock
- if (Status == VL53L0X_ERROR_NONE) {
- LoopNb = 0;
+ if (status == VL53L0X_ERROR_NONE) {
+ loop_nb = 0;
do {
- Status = VL53L0X_GetStopCompletedStatus(Dev, &StopCompleted);
- if ((StopCompleted == 0x00) || Status != VL53L0X_ERROR_NONE) {
+ status = vl53l0x_get_stop_completed_status(dev, &stop_completed);
+ if ((stop_completed == 0x00) || status != VL53L0X_ERROR_NONE) {
break;
}
- LoopNb = LoopNb + 1;
- VL53L0X_PollingDelay(Dev);
- } while (LoopNb < VL53L0X_DEFAULT_MAX_LOOP);
-
- if (LoopNb >= VL53L0X_DEFAULT_MAX_LOOP) {
- Status = VL53L0X_ERROR_TIME_OUT;
+ loop_nb = loop_nb + 1;
+ vl53l0x_polling_delay(dev);
+ } while (loop_nb < VL53L0X_DEFAULT_MAX_LOOP);
+
+ if (loop_nb >= VL53L0X_DEFAULT_MAX_LOOP) {
+ status = VL53L0X_ERROR_TIME_OUT;
}
}
- return Status;
+ return status;
}
-int VL53L0X::InitSensor(uint8_t NewAddr)
+int VL53L0X::init_sensor(uint8_t new_addr)
{
int status;
- VL53L0X_Off();
- VL53L0X_On();
+ vl53l0x_off();
+ vl53l0x_on();
// status=VL53L0X_WaitDeviceBooted(Device);
// if(status)
// printf("WaitDeviceBooted fail\n\r");
- status=IsPresent();
+ status=is_present();
if(!status) {
- status=Init(&MyDevice);
+ status=init(&_my_device);
if(status != VL53L0X_ERROR_NONE) {
printf("Failed to init VL53L0X sensor!\n\r");
return status;
}
// deduce silicon version
- status = VL53L0X_GetDeviceInfo(&MyDevice, &DeviceInfo);
-
-
- status=Prepare();
+ status = vl53l0x_get_device_info(&_my_device, &_device_info);
+
+
+ status=prepare();
if(status != VL53L0X_ERROR_NONE) {
printf("Failed to prepare VL53L0X!\n\r");
return status;
}
- if(NewAddr!=DEFAULT_DEVICE_ADDRESS) {
- status=SetDeviceAddress(NewAddr);
+ if(new_addr!=DEFAULT_DEVICE_ADDRESS) {
+ status=set_device_address(new_addr);
if(status) {
printf("Failed to change I2C address!\n\r");
return status;
@@ -5168,35 +5168,35 @@
return status;
}
-int VL53L0X::RangeMeasIntContinuousMode(void (*fptr)(void))
+int VL53L0X::range_meas_int_continuous_mode(void (*fptr)(void))
{
- int status, ClrStatus;
-
- status = VL53L0X_StopMeasurement(Device); // it is safer to do this while sensor is stopped
+ int status, clr_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_SetGpioConfig(Device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
- VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
- VL53L0X_INTERRUPTPOLARITY_HIGH);
+ status = vl53l0x_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
+ VL53L0X_INTERRUPTPOLARITY_HIGH);
if (!status) {
- AttachInterruptMeasureDetectionIRQ(fptr);
- EnableInterruptMeasureDetectionIRQ();
+ attach_interrupt_measure_detection_irq(fptr);
+ enable_interrupt_measure_detection_irq();
}
- ClrStatus=ClearInterrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS|VL53L0X_REG_RESULT_RANGE_STATUS);
- if(ClrStatus)
+ clr_status=clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS|VL53L0X_REG_RESULT_RANGE_STATUS);
+ if(clr_status)
VL53L0X_ErrLog("VL53L0X_ClearErrorInterrupt fail\r\n");
if(!status) {
- status=RangeStartContinuousMode();
+ status=range_start_continuous_mode();
}
return status;
}
-int VL53L0X::StartMeasurement(OperatingMode operating_mode, void (*fptr)(void))
+int VL53L0X::start_measurement(OperatingMode operating_mode, void (*fptr)(void))
{
int Status = VL53L0X_ERROR_NONE;
int ClrStatus;
@@ -5217,29 +5217,29 @@
return 1;
}
- Status = VL53L0X_StopMeasurement(Device); // it is safer to do this while sensor is stopped
+ 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_SetGpioConfig(Device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
- VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
- VL53L0X_INTERRUPTPOLARITY_HIGH);
+ Status = vl53l0x_set_gpio_config(_device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
+ VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
+ VL53L0X_INTERRUPTPOLARITY_HIGH);
if (Status == VL53L0X_ERROR_NONE) {
- AttachInterruptMeasureDetectionIRQ(fptr);
- EnableInterruptMeasureDetectionIRQ();
+ attach_interrupt_measure_detection_irq(fptr);
+ enable_interrupt_measure_detection_irq();
}
- ClrStatus=ClearInterrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS|VL53L0X_REG_RESULT_RANGE_STATUS);
+ ClrStatus=clear_interrupt(VL53L0X_REG_RESULT_INTERRUPT_STATUS|VL53L0X_REG_RESULT_RANGE_STATUS);
if(ClrStatus)
VL53L0X_ErrLog("VL53L0X_ClearErrorInterrupt fail\r\n");
if(Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetDeviceMode(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
+ Status = vl53l0x_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
}
if(Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_StartMeasurement(Device);
+ Status = vl53l0x_start_measurement(_device);
}
}
@@ -5247,17 +5247,17 @@
// singelshot, polled ranging
if(Status == VL53L0X_ERROR_NONE) {
// no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
- Status = VL53L0X_SetDeviceMode(Device, VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
+ Status = vl53l0x_set_device_mode(_device, VL53L0X_DEVICEMODE_SINGLE_RANGING); // Setup in single ranging mode
}
// Enable/Disable Sigma and Signal check
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckEnable(Device,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
+ Status = vl53l0x_set_limit_check_enable(_device,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckEnable(Device,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
+ Status = vl53l0x_set_limit_check_enable(_device,
+ VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1);
}
// *** from mass market cube expansion v1.1, ranging with satellites.
@@ -5291,31 +5291,31 @@
*/
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Device,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);
+ Status = vl53l0x_set_limit_check_value(_device,
+ VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetLimitCheckValue(Device,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);
+ Status = vl53l0x_set_limit_check_value(_device,
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetMeasurementTimingBudgetMicroSeconds(Device, timingBudget);
+ Status = vl53l0x_set_measurement_timing_budget_micro_seconds(_device, timingBudget);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetVcselPulsePeriod(Device,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);
+ Status = vl53l0x_set_vcsel_pulse_period(_device,
+ VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_SetVcselPulsePeriod(Device,
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);
+ Status = vl53l0x_set_vcsel_pulse_period(_device,
+ VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod);
}
if (Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_PerformRefCalibration(Device, &VhvSettings, &PhaseCal);
+ Status = vl53l0x_perform_ref_calibration(_device, &VhvSettings, &PhaseCal);
}
}
@@ -5323,12 +5323,12 @@
if (operating_mode == range_continuous_polling) {
if(Status == VL53L0X_ERROR_NONE) {
printf ("Call of VL53L0X_SetDeviceMode\n");
- Status = VL53L0X_SetDeviceMode(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
+ Status = vl53l0x_set_device_mode(_device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // Setup in continuous ranging mode
}
if(Status == VL53L0X_ERROR_NONE) {
printf ("Call of VL53L0X_StartMeasurement\n");
- Status = VL53L0X_StartMeasurement(Device);
+ Status = vl53l0x_start_measurement(_device);
}
}
@@ -5336,37 +5336,37 @@
}
-int VL53L0X::GetMeasurement(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *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_PerformSingleRangingMeasurement(Device, Data);
+ Status = vl53l0x_perform_single_ranging_measurement(_device, 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(_device);
if(Status == VL53L0X_ERROR_NONE) {
- Status = VL53L0X_GetRangingMeasurementData(Device, Data);
+ Status = vl53l0x_get_ranging_measurement_data(_device, p_data);
// Clear the interrupt
- VL53L0X_ClearInterruptMask(Device, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
- VL53L0X_PollingDelay(Device);
+ vl53l0x_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+ vl53l0x_polling_delay(_device);
}
}
if (operating_mode == range_continuous_interrupt) {
- Status = VL53L0X_GetRangingMeasurementData(Device, Data);
- VL53L0X_ClearInterruptMask(Device, VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR | VL53L0X_REG_RESULT_INTERRUPT_STATUS);
+ Status = vl53l0x_get_ranging_measurement_data(_device, p_data);
+ vl53l0x_clear_interrupt_mask(_device, VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR | VL53L0X_REG_RESULT_INTERRUPT_STATUS);
}
return Status;
}
-int VL53L0X::StopMeasurement(OperatingMode operating_mode)
+int VL53L0X::stop_measurement(OperatingMode operating_mode)
{
int status = VL53L0X_ERROR_NONE;
@@ -5379,17 +5379,17 @@
// continuous mode
if(status == VL53L0X_ERROR_NONE) {
printf ("Call of VL53L0X_StopMeasurement\n");
- status = VL53L0X_StopMeasurement(Device);
+ status = vl53l0x_stop_measurement(_device);
}
if(status == VL53L0X_ERROR_NONE) {
printf ("Wait Stop to be competed\n");
- status = WaitStopCompleted(Device);
+ status = wait_stop_completed(_device);
}
if(status == VL53L0X_ERROR_NONE)
- status = VL53L0X_ClearInterruptMask(Device,
- VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
+ status = vl53l0x_clear_interrupt_mask(_device,
+ VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY);
}
return status;
@@ -5399,8 +5399,8 @@
int VL53L0X::HandleIRQ(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data)
{
int status;
- status=GetMeasurement(operating_mode, Data);
- EnableInterruptMeasureDetectionIRQ();
+ status=get_measurement(operating_mode, Data);
+ enable_interrupt_measure_detection_irq();
return status;
}
@@ -5412,4 +5412,4 @@
-
\ No newline at end of file
+
\ No newline at end of file