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:
- 17:1b842521063a
- Parent:
- 16:98ce55ddbb1a
- Child:
- 20:cf211a3b3d9e
--- a/Components/VL53L0X/vl53l0x_class.cpp Thu Jun 22 09:55:10 2017 +0000
+++ b/Components/VL53L0X/vl53l0x_class.cpp Thu Jun 22 10:20:57 2017 +0000
@@ -410,14 +410,14 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
- int32_t *pOffsetCalibrationDataMicroMeter)
+VL53L0X_Error VL53L0X::vl53l0x_get_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
+ int32_t *p_offset_calibration_data_micro_meter)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- status = wrapped_vl53l0x_get_offset_calibration_data_micro_meter(Dev,
- pOffsetCalibrationDataMicroMeter);
+ status = wrapped_vl53l0x_get_offset_calibration_data_micro_meter(dev,
+ p_offset_calibration_data_micro_meter);
LOG_FUNCTION_END(status);
return status;
@@ -460,14 +460,14 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
- int32_t OffsetCalibrationDataMicroMeter)
+VL53L0X_Error VL53L0X::vl53l0x_set_offset_calibration_data_micro_meter(VL53L0X_DEV dev,
+ int32_t offset_calibration_data_micro_meter)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- status = wrapped_vl53l0x_set_offset_calibration_data_micro_meter(Dev,
- OffsetCalibrationDataMicroMeter);
+ status = wrapped_vl53l0x_set_offset_calibration_data_micro_meter(dev,
+ offset_calibration_data_micro_meter);
LOG_FUNCTION_END(status);
return status;
@@ -486,7 +486,7 @@
/* Read back current device offset */
if (status == VL53L0X_ERROR_NONE) {
status = vl53l0x_get_offset_calibration_data_micro_meter(dev,
- ¤t_offset_micro_meters);
+ ¤t_offset_micro_meters);
}
/* Apply Offset Adjustment derived from 400mm measurements */
@@ -501,7 +501,7 @@
Part2PartOffsetAdjustmentNVMMicroMeter);
status = vl53l0x_set_offset_calibration_data_micro_meter(dev,
- corrected_offset_micro_meters);
+ corrected_offset_micro_meters);
/* store current, adjusted offset */
if (status == VL53L0X_ERROR_NONE) {
@@ -513,20 +513,20 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_device_mode(VL53L0X_DEV Dev,
- VL53L0X_DeviceModes *pDeviceMode)
+VL53L0X_Error VL53L0X::vl53l0x_get_device_mode(VL53L0X_DEV dev,
+ VL53L0X_DeviceModes *p_device_mode)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- VL53L0X_GETPARAMETERFIELD(Dev, DeviceMode, *pDeviceMode);
+ VL53L0X_GETPARAMETERFIELD(dev, DeviceMode, *p_device_mode);
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_inter_measurement_period_milli_seconds(VL53L0X_DEV Dev,
- uint32_t *pInterMeasurementPeriodMilliSeconds)
+VL53L0X_Error VL53L0X::vl53l0x_get_inter_measurement_period_milli_seconds(VL53L0X_DEV dev,
+ uint32_t *p_inter_measurement_period_milli_seconds)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t osc_calibrate_val;
@@ -534,31 +534,31 @@
LOG_FUNCTION_START("");
- status = vl53l0x_read_word(Dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
+ status = vl53l0x_read_word(dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
&osc_calibrate_val);
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_read_dword(Dev,
+ status = vl53l0x_read_dword(dev,
VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
&im_period_milli_seconds);
}
if (status == VL53L0X_ERROR_NONE) {
if (osc_calibrate_val != 0) {
- *pInterMeasurementPeriodMilliSeconds =
+ *p_inter_measurement_period_milli_seconds =
im_period_milli_seconds / osc_calibrate_val;
}
- VL53L0X_SETPARAMETERFIELD(Dev,
+ VL53L0X_SETPARAMETERFIELD(dev,
InterMeasurementPeriodMilliSeconds,
- *pInterMeasurementPeriodMilliSeconds);
+ *p_inter_measurement_period_milli_seconds);
}
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_rate_mega_cps(VL53L0X_DEV Dev,
- FixPoint1616_t *pXTalkCompensationRateMegaCps)
+VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_rate_mega_cps(VL53L0X_DEV dev,
+ FixPoint1616_t *p_xtalk_compensation_rate_mega_cps)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint16_t value;
@@ -566,22 +566,22 @@
LOG_FUNCTION_START("");
- status = vl53l0x_read_word(Dev,
+ 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,
+ VL53L0X_GETPARAMETERFIELD(dev,
XTalkCompensationRateMegaCps, temp_fix1616);
- *pXTalkCompensationRateMegaCps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+ *p_xtalk_compensation_rate_mega_cps = temp_fix1616;
+ VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
0);
} else {
temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616(value);
- *pXTalkCompensationRateMegaCps = temp_fix1616;
- VL53L0X_SETPARAMETERFIELD(Dev,
+ *p_xtalk_compensation_rate_mega_cps = temp_fix1616;
+ VL53L0X_SETPARAMETERFIELD(dev,
XTalkCompensationRateMegaCps, temp_fix1616);
- VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationEnable,
+ VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationEnable,
1);
}
}
@@ -590,8 +590,8 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_value(VL53L0X_DEV Dev, uint16_t LimitCheckId,
- FixPoint1616_t *pLimitCheckValue)
+VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_value(VL53L0X_DEV dev, uint16_t limit_check_id,
+ FixPoint1616_t *p_limit_check_value)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t enable_zero_value = 0;
@@ -600,17 +600,17 @@
LOG_FUNCTION_START("");
- switch (LimitCheckId) {
+ switch (limit_check_id) {
case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+ VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616);
enable_zero_value = 0;
break;
case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
- status = vl53l0x_read_word(Dev,
+ status = vl53l0x_read_word(dev,
VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
&temp16);
if (status == VL53L0X_ERROR_NONE)
@@ -622,21 +622,21 @@
case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
/* internal computation: */
- VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksValue,
+ VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
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_GETARRAYPARAMETERFIELD(dev, LimitChecksValue,
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_read_word(Dev,
+ status = vl53l0x_read_word(dev,
VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
&temp16);
if (status == VL53L0X_ERROR_NONE)
@@ -657,22 +657,22 @@
if (temp_fix1616 == 0) {
/* disabled: return value from memory */
- VL53L0X_GETARRAYPARAMETERFIELD(Dev,
- LimitChecksValue, LimitCheckId,
+ VL53L0X_GETARRAYPARAMETERFIELD(dev,
+ LimitChecksValue, limit_check_id,
temp_fix1616);
- *pLimitCheckValue = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(Dev,
- LimitChecksEnable, LimitCheckId, 0);
+ *p_limit_check_value = temp_fix1616;
+ VL53L0X_SETARRAYPARAMETERFIELD(dev,
+ LimitChecksEnable, limit_check_id, 0);
} else {
- *pLimitCheckValue = temp_fix1616;
- VL53L0X_SETARRAYPARAMETERFIELD(Dev,
- LimitChecksValue, LimitCheckId,
+ *p_limit_check_value = temp_fix1616;
+ VL53L0X_SETARRAYPARAMETERFIELD(dev,
+ LimitChecksValue, limit_check_id,
temp_fix1616);
- VL53L0X_SETARRAYPARAMETERFIELD(Dev,
- LimitChecksEnable, LimitCheckId, 1);
+ VL53L0X_SETARRAYPARAMETERFIELD(dev,
+ LimitChecksEnable, limit_check_id, 1);
}
} else {
- *pLimitCheckValue = temp_fix1616;
+ *p_limit_check_value = temp_fix1616;
}
}
@@ -681,75 +681,75 @@
}
-VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_enable(VL53L0X_DEV Dev, uint16_t LimitCheckId,
- uint8_t *pLimitCheckEnable)
+VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_enable(VL53L0X_DEV dev, uint16_t limit_check_id,
+ uint8_t *p_limit_check_enable)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t temp8;
LOG_FUNCTION_START("");
- if (LimitCheckId >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
+ if (limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS) {
status = VL53L0X_ERROR_INVALID_PARAMS;
- *pLimitCheckEnable = 0;
+ *p_limit_check_enable = 0;
} else {
- VL53L0X_GETARRAYPARAMETERFIELD(Dev, LimitChecksEnable,
- LimitCheckId, temp8);
- *pLimitCheckEnable = temp8;
+ VL53L0X_GETARRAYPARAMETERFIELD(dev, LimitChecksEnable,
+ limit_check_id, temp8);
+ *p_limit_check_enable = temp8;
}
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_wrap_around_check_enable(VL53L0X_DEV Dev,
- uint8_t *pWrapAroundCheckEnable)
+VL53L0X_Error VL53L0X::vl53l0x_get_wrap_around_check_enable(VL53L0X_DEV dev,
+ uint8_t *p_wrap_around_check_enable)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t data;
LOG_FUNCTION_START("");
- status = vl53l0x_read_byte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data);
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(Dev, SequenceConfig, data);
+ PALDevDataSet(dev, SequenceConfig, data);
if (data & (0x01 << 7))
- *pWrapAroundCheckEnable = 0x01;
+ *p_wrap_around_check_enable = 0x01;
else
- *pWrapAroundCheckEnable = 0x00;
+ *p_wrap_around_check_enable = 0x00;
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETPARAMETERFIELD(Dev, WrapAroundCheckEnable,
- *pWrapAroundCheckEnable);
+ VL53L0X_SETPARAMETERFIELD(dev, WrapAroundCheckEnable,
+ *p_wrap_around_check_enable);
}
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_DEV Dev,
- VL53L0X_SequenceStepId SequenceStepId, uint8_t SequenceConfig,
- uint8_t *pSequenceStepEnabled)
+VL53L0X_Error VL53L0X::sequence_step_enabled(VL53L0X_DEV dev,
+ VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
+ uint8_t *p_sequence_step_enabled)
{
VL53L0X_Error Status = VL53L0X_ERROR_NONE;
- *pSequenceStepEnabled = 0;
+ *p_sequence_step_enabled = 0;
LOG_FUNCTION_START("");
- switch (SequenceStepId) {
+ switch (sequence_step_id) {
case VL53L0X_SEQUENCESTEP_TCC:
- *pSequenceStepEnabled = (SequenceConfig & 0x10) >> 4;
+ *p_sequence_step_enabled = (sequence_config & 0x10) >> 4;
break;
case VL53L0X_SEQUENCESTEP_DSS:
- *pSequenceStepEnabled = (SequenceConfig & 0x08) >> 3;
+ *p_sequence_step_enabled = (sequence_config & 0x08) >> 3;
break;
case VL53L0X_SEQUENCESTEP_MSRC:
- *pSequenceStepEnabled = (SequenceConfig & 0x04) >> 2;
+ *p_sequence_step_enabled = (sequence_config & 0x04) >> 2;
break;
case VL53L0X_SEQUENCESTEP_PRE_RANGE:
- *pSequenceStepEnabled = (SequenceConfig & 0x40) >> 6;
+ *p_sequence_step_enabled = (sequence_config & 0x40) >> 6;
break;
case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
- *pSequenceStepEnabled = (SequenceConfig & 0x80) >> 7;
+ *p_sequence_step_enabled = (sequence_config & 0x80) >> 7;
break;
default:
Status = VL53L0X_ERROR_INVALID_PARAMS;
@@ -759,40 +759,40 @@
return Status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_enables(VL53L0X_DEV Dev,
- VL53L0X_SchedulerSequenceSteps_t *pSchedulerSequenceSteps)
+VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_enables(VL53L0X_DEV dev,
+ VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sequence_config = 0;
LOG_FUNCTION_START("");
- status = vl53l0x_read_byte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
&sequence_config);
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(Dev,
+ status = sequence_step_enabled(dev,
VL53L0X_SEQUENCESTEP_TCC, sequence_config,
- &pSchedulerSequenceSteps->TccOn);
+ &p_scheduler_sequence_steps->TccOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(Dev,
+ status = sequence_step_enabled(dev,
VL53L0X_SEQUENCESTEP_DSS, sequence_config,
- &pSchedulerSequenceSteps->DssOn);
+ &p_scheduler_sequence_steps->DssOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(Dev,
+ status = sequence_step_enabled(dev,
VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
- &pSchedulerSequenceSteps->MsrcOn);
+ &p_scheduler_sequence_steps->MsrcOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(Dev,
+ status = sequence_step_enabled(dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
- &pSchedulerSequenceSteps->PreRangeOn);
+ &p_scheduler_sequence_steps->PreRangeOn);
}
if (status == VL53L0X_ERROR_NONE) {
- status = sequence_step_enabled(Dev,
+ status = sequence_step_enabled(dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
- &pSchedulerSequenceSteps->FinalRangeOn);
+ &p_scheduler_sequence_steps->FinalRangeOn);
}
LOG_FUNCTION_END(status);
@@ -1118,14 +1118,14 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_vcsel_pulse_period(VL53L0X_DEV Dev,
- VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK)
+VL53L0X_Error VL53L0X::vl53l0x_get_vcsel_pulse_period(VL53L0X_DEV dev,
+ VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- status = wrapped_vl53l0x_get_vcsel_pulse_period(Dev, VcselPeriodType,
- pVCSELPulsePeriodPCLK);
+ status = wrapped_vl53l0x_get_vcsel_pulse_period(dev, vcsel_period_type,
+ p_vcsel_pulse_period_pclk);
LOG_FUNCTION_END(status);
return status;
@@ -1381,45 +1381,45 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
- uint32_t *pMeasurementTimingBudgetMicroSeconds)
+VL53L0X_Error VL53L0X::vl53l0x_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV dev,
+ uint32_t *p_measurement_timing_budget_micro_seconds)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- status = wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds(Dev,
- pMeasurementTimingBudgetMicroSeconds);
+ status = wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds(dev,
+ p_measurement_timing_budget_micro_seconds);
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_device_parameters(VL53L0X_DEV Dev,
- VL53L0X_DeviceParameters_t *pDeviceParameters)
+VL53L0X_Error VL53L0X::vl53l0x_get_device_parameters(VL53L0X_DEV dev,
+ VL53L0X_DeviceParameters_t *p_device_parameters)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
int i;
LOG_FUNCTION_START("");
- status = vl53l0x_get_device_mode(Dev, &(pDeviceParameters->DeviceMode));
+ status = vl53l0x_get_device_mode(dev, &(p_device_parameters->DeviceMode));
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_get_inter_measurement_period_milli_seconds(Dev,
- &(pDeviceParameters->InterMeasurementPeriodMilliSeconds));
+ status = vl53l0x_get_inter_measurement_period_milli_seconds(dev,
+ &(p_device_parameters->InterMeasurementPeriodMilliSeconds));
if (status == VL53L0X_ERROR_NONE)
- pDeviceParameters->XTalkCompensationEnable = 0;
+ p_device_parameters->XTalkCompensationEnable = 0;
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_get_x_talk_compensation_rate_mega_cps(Dev,
- &(pDeviceParameters->XTalkCompensationRateMegaCps));
+ status = vl53l0x_get_x_talk_compensation_rate_mega_cps(dev,
+ &(p_device_parameters->XTalkCompensationRateMegaCps));
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_get_offset_calibration_data_micro_meter(Dev,
- &(pDeviceParameters->RangeOffsetMicroMeters));
+ status = vl53l0x_get_offset_calibration_data_micro_meter(dev,
+ &(p_device_parameters->RangeOffsetMicroMeters));
if (status == VL53L0X_ERROR_NONE) {
@@ -1429,14 +1429,14 @@
* flags
*/
if (status == VL53L0X_ERROR_NONE) {
- status |= vl53l0x_get_limit_check_value(Dev, i,
- &(pDeviceParameters->LimitChecksValue[i]));
+ status |= vl53l0x_get_limit_check_value(dev, i,
+ &(p_device_parameters->LimitChecksValue[i]));
} else {
break;
}
if (status == VL53L0X_ERROR_NONE) {
- status |= vl53l0x_get_limit_check_enable(Dev, i,
- &(pDeviceParameters->LimitChecksEnable[i]));
+ status |= vl53l0x_get_limit_check_enable(dev, i,
+ &(p_device_parameters->LimitChecksEnable[i]));
} else {
break;
}
@@ -1444,14 +1444,14 @@
}
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_get_wrap_around_check_enable(Dev,
- &(pDeviceParameters->WrapAroundCheckEnable));
+ status = vl53l0x_get_wrap_around_check_enable(dev,
+ &(p_device_parameters->WrapAroundCheckEnable));
}
/* Need to be done at the end as it uses VCSELPulsePeriod */
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_get_measurement_timing_budget_micro_seconds(Dev,
- &(pDeviceParameters->MeasurementTimingBudgetMicroSeconds));
+ status = vl53l0x_get_measurement_timing_budget_micro_seconds(dev,
+ &(p_device_parameters->MeasurementTimingBudgetMicroSeconds));
}
LOG_FUNCTION_END(status);
@@ -1535,7 +1535,7 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_data_init(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_data_init(VL53L0X_DEV dev)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t CurrentParameters;
@@ -1555,9 +1555,9 @@
/* Set I2C standard mode */
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_write_byte(Dev, 0x88, 0x00);
-
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, ReadDataFromDeviceDone, 0);
+ status = vl53l0x_write_byte(dev, 0x88, 0x00);
+
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev, ReadDataFromDeviceDone, 0);
#ifdef USE_IQC_STATION
if (Status == VL53L0X_ERROR_NONE)
@@ -1565,51 +1565,51 @@
#endif
/* Default value is 1000 for Linearity Corrective Gain */
- PALDevDataSet(Dev, LinearityCorrectiveGain, 1000);
+ PALDevDataSet(dev, LinearityCorrectiveGain, 1000);
/* Dmax default Parameter */
- PALDevDataSet(Dev, DmaxCalRangeMilliMeter, 400);
- PALDevDataSet(Dev, DmaxCalSignalRateRtnMegaCps,
+ PALDevDataSet(dev, DmaxCalRangeMilliMeter, 400);
+ PALDevDataSet(dev, DmaxCalSignalRateRtnMegaCps,
(FixPoint1616_t)((0x00016B85))); /* 1.42 No Cover Glass*/
/* Set Default static parameters
*set first temporary values 9.44MHz * 65536 = 618660 */
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz, 618660);
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev, OscFrequencyMHz, 618660);
/* Set Default XTalkCompensationRateMegaCps to 0 */
- VL53L0X_SETPARAMETERFIELD(Dev, XTalkCompensationRateMegaCps, 0);
+ VL53L0X_SETPARAMETERFIELD(dev, XTalkCompensationRateMegaCps, 0);
/* Get default parameters */
- status = vl53l0x_get_device_parameters(Dev, &CurrentParameters);
+ 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;
- PALDevDataSet(Dev, CurrentParameters, CurrentParameters);
+ PALDevDataSet(dev, CurrentParameters, CurrentParameters);
}
/* Sigma estimator variable */
- PALDevDataSet(Dev, SigmaEstRefArray, 100);
- PALDevDataSet(Dev, SigmaEstEffPulseWidth, 900);
- PALDevDataSet(Dev, SigmaEstEffAmbWidth, 500);
- PALDevDataSet(Dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
+ PALDevDataSet(dev, SigmaEstRefArray, 100);
+ PALDevDataSet(dev, SigmaEstEffPulseWidth, 900);
+ PALDevDataSet(dev, SigmaEstEffAmbWidth, 500);
+ PALDevDataSet(dev, targetRefRate, 0x0A00); /* 20 MCPS in 9:7 format */
/* Use internal default settings */
- PALDevDataSet(Dev, UseInternalTuningSettings, 1);
-
- status |= vl53l0x_write_byte(Dev, 0x80, 0x01);
- status |= vl53l0x_write_byte(Dev, 0xFF, 0x01);
- status |= vl53l0x_write_byte(Dev, 0x00, 0x00);
- status |= vl53l0x_read_byte(Dev, 0x91, &StopVariable);
- PALDevDataSet(Dev, StopVariable, StopVariable);
- status |= vl53l0x_write_byte(Dev, 0x00, 0x01);
- status |= vl53l0x_write_byte(Dev, 0xFF, 0x00);
- status |= vl53l0x_write_byte(Dev, 0x80, 0x00);
+ PALDevDataSet(dev, UseInternalTuningSettings, 1);
+
+ status |= vl53l0x_write_byte(dev, 0x80, 0x01);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x01);
+ status |= vl53l0x_write_byte(dev, 0x00, 0x00);
+ status |= vl53l0x_read_byte(dev, 0x91, &StopVariable);
+ PALDevDataSet(dev, StopVariable, StopVariable);
+ status |= vl53l0x_write_byte(dev, 0x00, 0x01);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x00);
+ status |= vl53l0x_write_byte(dev, 0x80, 0x00);
/* Enable all check */
for (i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++) {
if (status == VL53L0X_ERROR_NONE)
- status |= vl53l0x_set_limit_check_enable(Dev, i, 1);
+ status |= vl53l0x_set_limit_check_enable(dev, i, 1);
else
break;
@@ -1617,59 +1617,59 @@
/* Disable the following checks */
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_set_limit_check_enable(Dev,
+ 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,
+ 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,
+ 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,
+ status = vl53l0x_set_limit_check_enable(dev,
VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0);
/* Limit default values */
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_set_limit_check_value(Dev,
+ status = vl53l0x_set_limit_check_value(dev,
VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
(FixPoint1616_t)(18 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_set_limit_check_value(Dev,
+ 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_set_limit_check_value(Dev,
+ status = vl53l0x_set_limit_check_value(dev,
VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
(FixPoint1616_t)(35 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_set_limit_check_value(Dev,
+ status = vl53l0x_set_limit_check_value(dev,
VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
(FixPoint1616_t)(0 * 65536));
}
if (status == VL53L0X_ERROR_NONE) {
- PALDevDataSet(Dev, SequenceConfig, 0xFF);
- status = vl53l0x_write_byte(Dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
+ PALDevDataSet(dev, SequenceConfig, 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);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_WAIT_STATICINIT);
}
if (status == VL53L0X_ERROR_NONE)
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, RefSpadsInitialised, 0);
+ VL53L0X_SETDEVICESPECIFICPARAMETER(dev, RefSpadsInitialised, 0);
LOG_FUNCTION_END(status);
@@ -1752,27 +1752,27 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_device_info(VL53L0X_DEV Dev,
- VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+VL53L0X_Error VL53L0X::vl53l0x_get_device_info(VL53L0X_DEV dev,
+ VL53L0X_DeviceInfo_t *p_vl53l0x_device_info)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
LOG_FUNCTION_START("");
- status = wrapped_vl53l0x_get_device_info(Dev, pVL53L0X_DeviceInfo);
+ status = wrapped_vl53l0x_get_device_info(dev, p_vl53l0x_device_info);
LOG_FUNCTION_END(status);
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_mask_status(VL53L0X_DEV Dev,
- uint32_t *pInterruptMaskStatus)
+VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_mask_status(VL53L0X_DEV dev,
+ uint32_t *p_interrupt_mask_status)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t byte;
LOG_FUNCTION_START("");
- status = vl53l0x_read_byte(Dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
- *pInterruptMaskStatus = byte & 0x07;
+ status = vl53l0x_read_byte(dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
+ *p_interrupt_mask_status = byte & 0x07;
if (byte & 0x18)
status = VL53L0X_ERROR_RANGE_ERROR;
@@ -1781,8 +1781,8 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_get_measurement_data_ready(VL53L0X_DEV Dev,
- uint8_t *pMeasurementDataReady)
+VL53L0X_Error VL53L0X::vl53l0x_get_measurement_data_ready(VL53L0X_DEV dev,
+ uint8_t *p_measurement_data_ready)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t sys_range_status_register;
@@ -1790,25 +1790,25 @@
uint32_t interrupt_mask;
LOG_FUNCTION_START("");
- interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
Pin0GpioFunctionality);
if (interrupt_config ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY) {
- status = vl53l0x_get_interrupt_mask_status(Dev, &interrupt_mask);
+ status = vl53l0x_get_interrupt_mask_status(dev, &interrupt_mask);
if (interrupt_mask ==
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY)
- *pMeasurementDataReady = 1;
+ *p_measurement_data_ready = 1;
else
- *pMeasurementDataReady = 0;
+ *p_measurement_data_ready = 0;
} else {
- status = vl53l0x_read_byte(Dev, VL53L0X_REG_RESULT_RANGE_STATUS,
+ 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;
+ *p_measurement_data_ready = 1;
else
- *pMeasurementDataReady = 0;
+ *p_measurement_data_ready = 0;
}
}
@@ -1858,24 +1858,24 @@
}
/* Group PAL Interrupt Functions */
-VL53L0X_Error VL53L0X::vl53l0x_clear_interrupt_mask(VL53L0X_DEV Dev, uint32_t InterruptMask)
+VL53L0X_Error VL53L0X::vl53l0x_clear_interrupt_mask(VL53L0X_DEV dev, uint32_t interrupt_mask)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
uint8_t loop_count;
- uint8_t Byte;
+ uint8_t byte;
LOG_FUNCTION_START("");
/* clear bit 0 range interrupt, bit 1 error interrupt */
loop_count = 0;
do {
- status = vl53l0x_write_byte(Dev,
+ status = vl53l0x_write_byte(dev,
VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01);
- status |= vl53l0x_write_byte(Dev,
+ status |= vl53l0x_write_byte(dev,
VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00);
- status |= vl53l0x_read_byte(Dev,
- VL53L0X_REG_RESULT_INTERRUPT_STATUS, &Byte);
+ status |= vl53l0x_read_byte(dev,
+ VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte);
loop_count++;
- } while (((Byte & 0x07) != 0x00)
+ } while (((byte & 0x07) != 0x00)
&& (loop_count < 3)
&& (status == VL53L0X_ERROR_NONE));
@@ -2244,7 +2244,7 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_set_device_mode(VL53L0X_DEV Dev, VL53L0X_DeviceModes device_mode)
+VL53L0X_Error VL53L0X::vl53l0x_set_device_mode(VL53L0X_DEV dev, VL53L0X_DeviceModes device_mode)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -2257,7 +2257,7 @@
case VL53L0X_DEVICEMODE_GPIO_DRIVE:
case VL53L0X_DEVICEMODE_GPIO_OSC:
/* Supported modes */
- VL53L0X_SETPARAMETERFIELD(Dev, DeviceMode, device_mode);
+ VL53L0X_SETPARAMETERFIELD(dev, DeviceMode, device_mode);
break;
default:
/* Unsupported mode */
@@ -2404,15 +2404,15 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_check_and_load_interrupt_settings(VL53L0X_DEV Dev,
- uint8_t start_not_stopflag)
+VL53L0X_Error VL53L0X::vl53l0x_check_and_load_interrupt_settings(VL53L0X_DEV dev,
+ uint8_t start_not_stopflag)
{
uint8_t interrupt_config;
FixPoint1616_t threshold_low;
FixPoint1616_t threshold_high;
VL53L0X_Error status = VL53L0X_ERROR_NONE;
- interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
Pin0GpioFunctionality);
if ((interrupt_config ==
@@ -2422,7 +2422,7 @@
(interrupt_config ==
VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT)) {
- status = vl53l0x_get_interrupt_thresholds(Dev,
+ status = vl53l0x_get_interrupt_thresholds(dev,
VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
&threshold_low, &threshold_high);
@@ -2431,13 +2431,13 @@
(status == VL53L0X_ERROR_NONE)) {
if (start_not_stopflag != 0) {
- status = vl53l0x_load_tuning_settings(Dev,
+ status = vl53l0x_load_tuning_settings(dev,
InterruptThresholdSettings);
} else {
- status |= vl53l0x_write_byte(Dev, 0xFF, 0x04);
- status |= vl53l0x_write_byte(Dev, 0x70, 0x00);
- status |= vl53l0x_write_byte(Dev, 0xFF, 0x00);
- status |= vl53l0x_write_byte(Dev, 0x80, 0x00);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x04);
+ status |= vl53l0x_write_byte(dev, 0x70, 0x00);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x00);
+ status |= vl53l0x_write_byte(dev, 0x80, 0x00);
}
}
@@ -2449,7 +2449,7 @@
}
-VL53L0X_Error VL53L0X::vl53l0x_start_measurement(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_start_measurement(VL53L0X_DEV dev)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
@@ -2459,19 +2459,19 @@
LOG_FUNCTION_START("");
/* Get Current DeviceMode */
- vl53l0x_get_device_mode(Dev, &device_mode);
-
- status = vl53l0x_write_byte(Dev, 0x80, 0x01);
- status = vl53l0x_write_byte(Dev, 0xFF, 0x01);
- status = vl53l0x_write_byte(Dev, 0x00, 0x00);
- status = vl53l0x_write_byte(Dev, 0x91, PALDevDataGet(Dev, StopVariable));
- status = vl53l0x_write_byte(Dev, 0x00, 0x01);
- status = vl53l0x_write_byte(Dev, 0xFF, 0x00);
- status = vl53l0x_write_byte(Dev, 0x80, 0x00);
+ vl53l0x_get_device_mode(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_write_byte(Dev, VL53L0X_REG_SYSRANGE_START, 0x01);
+ status = vl53l0x_write_byte(dev, VL53L0X_REG_SYSRANGE_START, 0x01);
byte = start_stop_byte;
if (status == VL53L0X_ERROR_NONE) {
@@ -2479,7 +2479,7 @@
loop_nb = 0;
do {
if (loop_nb > 0)
- status = vl53l0x_read_byte(Dev,
+ status = vl53l0x_read_byte(dev,
VL53L0X_REG_SYSRANGE_START, &byte);
loop_nb = loop_nb + 1;
} while (((byte & start_stop_byte) == start_stop_byte)
@@ -2497,29 +2497,29 @@
/* Check if need to apply interrupt settings */
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_check_and_load_interrupt_settings(Dev, 1);
-
- status = vl53l0x_write_byte(Dev,
+ 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);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_RUNNING);
}
break;
case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
/* Continuous mode */
/* Check if need to apply interrupt settings */
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_check_and_load_interrupt_settings(Dev, 1);
-
- status = vl53l0x_write_byte(Dev,
+ 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);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_RUNNING);
}
break;
default:
@@ -2533,7 +2533,7 @@
}
/* Group PAL Measurement Functions */
-VL53L0X_Error VL53L0X::vl53l0x_perform_single_measurement(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_perform_single_measurement(VL53L0X_DEV dev)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceModes device_mode;
@@ -2541,23 +2541,23 @@
LOG_FUNCTION_START("");
/* Get Current DeviceMode */
- status = vl53l0x_get_device_mode(Dev, &device_mode);
+ 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
&& device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
- status = vl53l0x_start_measurement(Dev);
+ status = vl53l0x_start_measurement(dev);
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_measurement_poll_for_completion(Dev);
+ status = vl53l0x_measurement_poll_for_completion(dev);
/* Change PAL State in case of single ranging or single histogram */
if (status == VL53L0X_ERROR_NONE
&& device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING)
- PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
LOG_FUNCTION_END(status);
@@ -3259,8 +3259,8 @@
*/
if (status == VL53L0X_ERROR_NONE)
status = vl53l0x_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
- &sigma_limit_check_enable);
+ VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
+ &sigma_limit_check_enable);
if ((sigma_limit_check_enable != 0) && (status == VL53L0X_ERROR_NONE)) {
/*
@@ -3292,8 +3292,8 @@
*/
if (status == VL53L0X_ERROR_NONE)
status = vl53l0x_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
- &signal_ref_clip_limit_check_enable);
+ VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
+ &signal_ref_clip_limit_check_enable);
if ((signal_ref_clip_limit_check_enable != 0) &&
(status == VL53L0X_ERROR_NONE)) {
@@ -3332,8 +3332,8 @@
*/
if (status == VL53L0X_ERROR_NONE)
status = vl53l0x_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
- &range_ignore_threshold_limit_check_enable);
+ VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
+ &range_ignore_threshold_limit_check_enable);
if ((range_ignore_threshold_limit_check_enable != 0) &&
(status == VL53L0X_ERROR_NONE)) {
@@ -3388,8 +3388,8 @@
/* fill the Limit Check Status */
status = vl53l0x_get_limit_check_enable(dev,
- VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
- &signal_rate_final_range_limit_check_enable);
+ 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))
@@ -3588,8 +3588,8 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_perform_single_ranging_measurement(VL53L0X_DEV Dev,
- VL53L0X_RangingMeasurementData_t *pRangingMeasurementData)
+VL53L0X_Error VL53L0X::vl53l0x_perform_single_ranging_measurement(VL53L0X_DEV dev,
+ VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
@@ -3597,19 +3597,19 @@
/* This function will do a complete single ranging
* Here we fix the mode! */
- status = vl53l0x_set_device_mode(Dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
+ status = vl53l0x_set_device_mode(dev, VL53L0X_DEVICEMODE_SINGLE_RANGING);
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_perform_single_measurement(Dev);
+ status = vl53l0x_perform_single_measurement(dev);
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_get_ranging_measurement_data(Dev,
- pRangingMeasurementData);
+ status = vl53l0x_get_ranging_measurement_data(dev,
+ p_ranging_measurement_data);
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_clear_interrupt_mask(Dev, 0);
+ status = vl53l0x_clear_interrupt_mask(dev, 0);
LOG_FUNCTION_END(status);
@@ -3639,7 +3639,7 @@
if (status == VL53L0X_ERROR_NONE)
status = vl53l0x_perform_single_ranging_measurement(dev,
- &ranging_measurement_data);
+ &ranging_measurement_data);
if (status == VL53L0X_ERROR_NONE)
status = vl53l0x_write_byte(dev, 0xFF, 0x01);
@@ -4682,7 +4682,7 @@
return status;
}
-VL53L0X_Error VL53L0X::vl53l0x_static_init(VL53L0X_DEV Dev)
+VL53L0X_Error VL53L0X::vl53l0x_static_init(VL53L0X_DEV dev)
{
VL53L0X_Error status = VL53L0X_ERROR_NONE;
VL53L0X_DeviceParameters_t current_parameters = {0};
@@ -4699,33 +4699,33 @@
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,
+ count = (uint32_t)VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
ReferenceSpadCount);
- aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+ aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER(dev,
ReferenceSpadType);
/* NVM value invalid */
if ((aperture_spads > 1) ||
((aperture_spads == 1) && (count > 32)) ||
((aperture_spads == 0) && (count > 12)))
- status = wrapped_vl53l0x_perform_ref_spad_management(Dev, &ref_spad_count,
+ status = wrapped_vl53l0x_perform_ref_spad_management(dev, &ref_spad_count,
&is_aperture_spads);
else
- status = vl53l0x_set_reference_spads(Dev, count, aperture_spads);
+ status = vl53l0x_set_reference_spads(dev, count, aperture_spads);
/* Initialize tuning settings buffer to prevent compiler warning. */
p_tuning_setting_buffer = DefaultTuningSettings;
if (status == VL53L0X_ERROR_NONE) {
- use_internal_tuning_settings = PALDevDataGet(Dev,
+ use_internal_tuning_settings = PALDevDataGet(dev,
UseInternalTuningSettings);
if (use_internal_tuning_settings == 0)
- p_tuning_setting_buffer = PALDevDataGet(Dev,
+ p_tuning_setting_buffer = PALDevDataGet(dev,
pTuningSettingsPointer);
else
p_tuning_setting_buffer = DefaultTuningSettings;
@@ -4733,81 +4733,81 @@
}
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_load_tuning_settings(Dev, p_tuning_setting_buffer);
+ status = vl53l0x_load_tuning_settings(dev, p_tuning_setting_buffer);
/* Set interrupt config to new sample ready */
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_set_gpio_config(Dev, 0, 0,
+ status = vl53l0x_set_gpio_config(dev, 0, 0,
VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
VL53L0X_INTERRUPTPOLARITY_LOW);
}
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_write_byte(Dev, 0xFF, 0x01);
- status |= vl53l0x_read_word(Dev, 0x84, &tempword);
- status |= vl53l0x_write_byte(Dev, 0xFF, 0x00);
+ status = vl53l0x_write_byte(dev, 0xFF, 0x01);
+ status |= vl53l0x_read_word(dev, 0x84, &tempword);
+ status |= vl53l0x_write_byte(dev, 0xFF, 0x00);
}
if (status == VL53L0X_ERROR_NONE) {
- VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, OscFrequencyMHz,
+ 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_get_device_parameters(Dev, ¤t_parameters);
+ status = vl53l0x_get_device_parameters(dev, ¤t_parameters);
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_get_fraction_enable(Dev, &tempbyte);
+ status = vl53l0x_get_fraction_enable(dev, &tempbyte);
if (status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, RangeFractionalEnable, tempbyte);
+ PALDevDataSet(dev, RangeFractionalEnable, tempbyte);
}
if (status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, CurrentParameters, current_parameters);
+ PALDevDataSet(dev, CurrentParameters, current_parameters);
/* read the sequence config and save it */
if (status == VL53L0X_ERROR_NONE) {
- status = vl53l0x_read_byte(Dev,
+ status = vl53l0x_read_byte(dev,
VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte);
if (status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, SequenceConfig, tempbyte);
+ PALDevDataSet(dev, SequenceConfig, tempbyte);
}
/* Disable MSRC and TCC by default */
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_set_sequence_step_enable(Dev,
+ status = vl53l0x_set_sequence_step_enable(dev,
VL53L0X_SEQUENCESTEP_TCC, 0);
if (status == VL53L0X_ERROR_NONE)
- status = vl53l0x_set_sequence_step_enable(Dev,
+ status = vl53l0x_set_sequence_step_enable(dev,
VL53L0X_SEQUENCESTEP_MSRC, 0);
/* Set PAL State to standby */
if (status == VL53L0X_ERROR_NONE)
- PALDevDataSet(Dev, PalState, VL53L0X_STATE_IDLE);
+ PALDevDataSet(dev, PalState, VL53L0X_STATE_IDLE);
/* Store pre-range vcsel period */
if (status == VL53L0X_ERROR_NONE) {
status = vl53l0x_get_vcsel_pulse_period(
- Dev,
- VL53L0X_VCSEL_PERIOD_PRE_RANGE,
- &vcsel_pulse_period_pclk);
+ dev,
+ VL53L0X_VCSEL_PERIOD_PRE_RANGE,
+ &vcsel_pulse_period_pclk);
}
if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
PreRangeVcselPulsePeriod,
vcsel_pulse_period_pclk);
}
@@ -4815,14 +4815,14 @@
/* Store final-range vcsel period */
if (status == VL53L0X_ERROR_NONE) {
status = vl53l0x_get_vcsel_pulse_period(
- Dev,
- VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
- &vcsel_pulse_period_pclk);
+ dev,
+ VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
+ &vcsel_pulse_period_pclk);
}
if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
FinalRangeVcselPulsePeriod,
vcsel_pulse_period_pclk);
}
@@ -4830,14 +4830,14 @@
/* Store pre-range timeout */
if (status == VL53L0X_ERROR_NONE) {
status = get_sequence_step_timeout(
- Dev,
+ dev,
VL53L0X_SEQUENCESTEP_PRE_RANGE,
&seq_timeout_micro_secs);
}
if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
PreRangeTimeoutMicroSecs,
seq_timeout_micro_secs);
}
@@ -4845,14 +4845,14 @@
/* Store final-range timeout */
if (status == VL53L0X_ERROR_NONE) {
status = get_sequence_step_timeout(
- Dev,
+ dev,
VL53L0X_SEQUENCESTEP_FINAL_RANGE,
&seq_timeout_micro_secs);
}
if (status == VL53L0X_ERROR_NONE) {
VL53L0X_SETDEVICESPECIFICPARAMETER(
- Dev,
+ dev,
FinalRangeTimeoutMicroSecs,
seq_timeout_micro_secs);
}
@@ -5064,11 +5064,6 @@
return -1;
}
-int VL53L0X::ReadID(uint8_t *id)
-{
- return read_id(id);
-}
-
VL53L0X_Error VL53L0X::wait_measurement_data_ready(VL53L0X_DEV dev)
{
@@ -5396,10 +5391,10 @@
}
-int VL53L0X::HandleIRQ(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *Data)
+int VL53L0X::handle_irq(OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data)
{
int status;
- status=get_measurement(operating_mode, Data);
+ status = get_measurement(operating_mode, data);
enable_interrupt_measure_detection_irq();
return status;
}