mirror of
https://github.com/ArduPilot/ardupilot
synced 2025-01-03 06:28:27 -04:00
AP_RangeFinder: implement VL53L0X rangefinder
This commit is contained in:
Andrew Tridgell
Francisco Ferreira
parent
758414cfe5
commit
b29db0aa5b
783
libraries/AP_RangeFinder/AP_RangeFinder_VL53L0X.cpp
Normal file
783
libraries/AP_RangeFinder/AP_RangeFinder_VL53L0X.cpp
Normal file
@ -0,0 +1,783 @@
|
||||
/*
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
/*
|
||||
driver for ST VL53L0X lidar
|
||||
|
||||
Many thanks to Pololu, https://github.com/pololu/vl53l0x-arduino and
|
||||
the ST example code
|
||||
*/
|
||||
#include "AP_RangeFinder_VL53L0X.h"
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include <AP_HAL/AP_HAL.h>
|
||||
#include <AP_HAL/utility/sparse-endian.h>
|
||||
#include <stdio.h>
|
||||
|
||||
extern const AP_HAL::HAL& hal;
|
||||
|
||||
enum regAddr
|
||||
{
|
||||
SYSRANGE_START = 0x00,
|
||||
|
||||
SYSTEM_THRESH_HIGH = 0x0C,
|
||||
SYSTEM_THRESH_LOW = 0x0E,
|
||||
|
||||
SYSTEM_SEQUENCE_CONFIG = 0x01,
|
||||
SYSTEM_RANGE_CONFIG = 0x09,
|
||||
SYSTEM_INTERMEASUREMENT_PERIOD = 0x04,
|
||||
|
||||
SYSTEM_INTERRUPT_CONFIG_GPIO = 0x0A,
|
||||
|
||||
GPIO_HV_MUX_ACTIVE_HIGH = 0x84,
|
||||
|
||||
SYSTEM_INTERRUPT_CLEAR = 0x0B,
|
||||
|
||||
RESULT_INTERRUPT_STATUS = 0x13,
|
||||
RESULT_RANGE_STATUS = 0x14,
|
||||
|
||||
RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN = 0xBC,
|
||||
RESULT_CORE_RANGING_TOTAL_EVENTS_RTN = 0xC0,
|
||||
RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF = 0xD0,
|
||||
RESULT_CORE_RANGING_TOTAL_EVENTS_REF = 0xD4,
|
||||
RESULT_PEAK_SIGNAL_RATE_REF = 0xB6,
|
||||
|
||||
ALGO_PART_TO_PART_RANGE_OFFSET_MM = 0x28,
|
||||
|
||||
I2C_SLAVE_DEVICE_ADDRESS = 0x8A,
|
||||
|
||||
MSRC_CONFIG_CONTROL = 0x60,
|
||||
|
||||
PRE_RANGE_CONFIG_MIN_SNR = 0x27,
|
||||
PRE_RANGE_CONFIG_VALID_PHASE_LOW = 0x56,
|
||||
PRE_RANGE_CONFIG_VALID_PHASE_HIGH = 0x57,
|
||||
PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT = 0x64,
|
||||
|
||||
FINAL_RANGE_CONFIG_MIN_SNR = 0x67,
|
||||
FINAL_RANGE_CONFIG_VALID_PHASE_LOW = 0x47,
|
||||
FINAL_RANGE_CONFIG_VALID_PHASE_HIGH = 0x48,
|
||||
FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT = 0x44,
|
||||
|
||||
PRE_RANGE_CONFIG_SIGMA_THRESH_HI = 0x61,
|
||||
PRE_RANGE_CONFIG_SIGMA_THRESH_LO = 0x62,
|
||||
|
||||
PRE_RANGE_CONFIG_VCSEL_PERIOD = 0x50,
|
||||
PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI = 0x51,
|
||||
PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO = 0x52,
|
||||
|
||||
SYSTEM_HISTOGRAM_BIN = 0x81,
|
||||
HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT = 0x33,
|
||||
HISTOGRAM_CONFIG_READOUT_CTRL = 0x55,
|
||||
|
||||
FINAL_RANGE_CONFIG_VCSEL_PERIOD = 0x70,
|
||||
FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI = 0x71,
|
||||
FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO = 0x72,
|
||||
CROSSTALK_COMPENSATION_PEAK_RATE_MCPS = 0x20,
|
||||
|
||||
MSRC_CONFIG_TIMEOUT_MACROP = 0x46,
|
||||
|
||||
SOFT_RESET_GO2_SOFT_RESET_N = 0xBF,
|
||||
IDENTIFICATION_MODEL_ID = 0xC0,
|
||||
IDENTIFICATION_REVISION_ID = 0xC2,
|
||||
|
||||
OSC_CALIBRATE_VAL = 0xF8,
|
||||
|
||||
GLOBAL_CONFIG_VCSEL_WIDTH = 0x32,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_0 = 0xB0,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_1 = 0xB1,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_2 = 0xB2,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_3 = 0xB3,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_4 = 0xB4,
|
||||
GLOBAL_CONFIG_SPAD_ENABLES_REF_5 = 0xB5,
|
||||
|
||||
GLOBAL_CONFIG_REF_EN_START_SELECT = 0xB6,
|
||||
DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD = 0x4E,
|
||||
DYNAMIC_SPAD_REF_EN_START_OFFSET = 0x4F,
|
||||
POWER_MANAGEMENT_GO1_POWER_FORCE = 0x80,
|
||||
|
||||
VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV = 0x89,
|
||||
|
||||
ALGO_PHASECAL_LIM = 0x30,
|
||||
ALGO_PHASECAL_CONFIG_TIMEOUT = 0x30,
|
||||
};
|
||||
|
||||
// tuning register settings
|
||||
const AP_RangeFinder_VL53L0X::RegData AP_RangeFinder_VL53L0X::tuning_data[] =
|
||||
{
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x00, 0x00 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x09, 0x00 },
|
||||
{ 0x10, 0x00 },
|
||||
{ 0x11, 0x00 },
|
||||
|
||||
{ 0x24, 0x01 },
|
||||
{ 0x25, 0xFF },
|
||||
{ 0x75, 0x00 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x4E, 0x2C },
|
||||
{ 0x48, 0x00 },
|
||||
{ 0x30, 0x20 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x30, 0x09 },
|
||||
{ 0x54, 0x00 },
|
||||
{ 0x31, 0x04 },
|
||||
{ 0x32, 0x03 },
|
||||
{ 0x40, 0x83 },
|
||||
{ 0x46, 0x25 },
|
||||
{ 0x60, 0x00 },
|
||||
{ 0x27, 0x00 },
|
||||
{ 0x50, 0x06 },
|
||||
{ 0x51, 0x00 },
|
||||
{ 0x52, 0x96 },
|
||||
{ 0x56, 0x08 },
|
||||
{ 0x57, 0x30 },
|
||||
{ 0x61, 0x00 },
|
||||
{ 0x62, 0x00 },
|
||||
{ 0x64, 0x00 },
|
||||
{ 0x65, 0x00 },
|
||||
{ 0x66, 0xA0 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x22, 0x32 },
|
||||
{ 0x47, 0x14 },
|
||||
{ 0x49, 0xFF },
|
||||
{ 0x4A, 0x00 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x7A, 0x0A },
|
||||
{ 0x7B, 0x00 },
|
||||
{ 0x78, 0x21 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x23, 0x34 },
|
||||
{ 0x42, 0x00 },
|
||||
{ 0x44, 0xFF },
|
||||
{ 0x45, 0x26 },
|
||||
{ 0x46, 0x05 },
|
||||
{ 0x40, 0x40 },
|
||||
{ 0x0E, 0x06 },
|
||||
{ 0x20, 0x1A },
|
||||
{ 0x43, 0x40 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x34, 0x03 },
|
||||
{ 0x35, 0x44 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x31, 0x04 },
|
||||
{ 0x4B, 0x09 },
|
||||
{ 0x4C, 0x05 },
|
||||
{ 0x4D, 0x04 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x44, 0x00 },
|
||||
{ 0x45, 0x20 },
|
||||
{ 0x47, 0x08 },
|
||||
{ 0x48, 0x28 },
|
||||
{ 0x67, 0x00 },
|
||||
{ 0x70, 0x04 },
|
||||
{ 0x71, 0x01 },
|
||||
{ 0x72, 0xFE },
|
||||
{ 0x76, 0x00 },
|
||||
{ 0x77, 0x00 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x0D, 0x01 },
|
||||
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x80, 0x01 },
|
||||
{ 0x01, 0xF8 },
|
||||
|
||||
{ 0xFF, 0x01 },
|
||||
{ 0x8E, 0x01 },
|
||||
{ 0x00, 0x01 },
|
||||
{ 0xFF, 0x00 },
|
||||
{ 0x80, 0x00 },
|
||||
};
|
||||
|
||||
/*
|
||||
The constructor also initializes the rangefinder. Note that this
|
||||
constructor is not called until detect() returns true, so we
|
||||
already know that we should setup the rangefinder
|
||||
*/
|
||||
AP_RangeFinder_VL53L0X::AP_RangeFinder_VL53L0X(RangeFinder &_ranger, uint8_t instance, RangeFinder::RangeFinder_State &_state, AP_HAL::OwnPtr<AP_HAL::I2CDevice> _dev)
|
||||
: AP_RangeFinder_Backend(_ranger, instance, _state)
|
||||
, dev(std::move(_dev)) {}
|
||||
|
||||
|
||||
/*
|
||||
detect if a VL53L0X rangefinder is connected. We'll detect by
|
||||
trying to take a reading on I2C. If we get a result the sensor is
|
||||
there.
|
||||
*/
|
||||
AP_RangeFinder_Backend *AP_RangeFinder_VL53L0X::detect(RangeFinder &_ranger, uint8_t instance, RangeFinder::RangeFinder_State &_state, AP_HAL::OwnPtr<AP_HAL::I2CDevice> dev)
|
||||
{
|
||||
AP_RangeFinder_VL53L0X *sensor
|
||||
= new AP_RangeFinder_VL53L0X(_ranger, instance, _state, std::move(dev));
|
||||
|
||||
if (!sensor) {
|
||||
delete sensor;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
if (sensor->dev->get_semaphore()->take(0)) {
|
||||
if (!sensor->check_id()) {
|
||||
sensor->dev->get_semaphore()->give();
|
||||
delete sensor;
|
||||
return nullptr;
|
||||
}
|
||||
sensor->dev->get_semaphore()->give();
|
||||
}
|
||||
|
||||
sensor->init();
|
||||
|
||||
return sensor;
|
||||
}
|
||||
|
||||
// check sensor ID registers
|
||||
bool AP_RangeFinder_VL53L0X::check_id(void)
|
||||
{
|
||||
uint8_t v1, v2;
|
||||
if (!dev->read_registers(0xC0, &v1, 1) ||
|
||||
!dev->read_registers(0xC1, &v2, 1) ||
|
||||
v1 != 0xEE ||
|
||||
v2 != 0xAA) {
|
||||
return false;
|
||||
}
|
||||
printf("Detected VL53L0X on bus 0x%x\n", dev->get_bus_id());
|
||||
return true;
|
||||
}
|
||||
|
||||
// Get reference SPAD (single photon avalanche diode) count and type
|
||||
// based on VL53L0X_get_info_from_device(),
|
||||
// but only gets reference SPAD count and type
|
||||
bool AP_RangeFinder_VL53L0X::get_SPAD_info(uint8_t * count, bool *type_is_aperture)
|
||||
{
|
||||
uint8_t tmp;
|
||||
|
||||
write_register(0x80, 0x01);
|
||||
write_register(0xFF, 0x01);
|
||||
write_register(0x00, 0x00);
|
||||
|
||||
write_register(0xFF, 0x06);
|
||||
write_register(0x83, read_register(0x83) | 0x04);
|
||||
write_register(0xFF, 0x07);
|
||||
write_register(0x81, 0x01);
|
||||
|
||||
write_register(0x80, 0x01);
|
||||
|
||||
write_register(0x94, 0x6b);
|
||||
write_register(0x83, 0x00);
|
||||
|
||||
uint8_t tries = 50;
|
||||
while (read_register(0x83) == 0x00) {
|
||||
tries--;
|
||||
if (tries == 0) {
|
||||
return false;
|
||||
}
|
||||
hal.scheduler->delay(1);
|
||||
}
|
||||
write_register(0x83, 0x01);
|
||||
tmp = read_register(0x92);
|
||||
|
||||
*count = tmp & 0x7f;
|
||||
*type_is_aperture = (tmp >> 7) & 0x01;
|
||||
|
||||
write_register(0x81, 0x00);
|
||||
write_register(0xFF, 0x06);
|
||||
write_register(0x83, read_register(0x83) & ~0x04);
|
||||
write_register(0xFF, 0x01);
|
||||
write_register(0x00, 0x01);
|
||||
|
||||
write_register(0xFF, 0x00);
|
||||
write_register(0x80, 0x00);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Get sequence step enables
|
||||
// based on VL53L0X_GetSequenceStepEnables()
|
||||
void AP_RangeFinder_VL53L0X::getSequenceStepEnables(SequenceStepEnables * enables)
|
||||
{
|
||||
uint8_t sequence_config = read_register(SYSTEM_SEQUENCE_CONFIG);
|
||||
|
||||
enables->tcc = (sequence_config >> 4) & 0x1;
|
||||
enables->dss = (sequence_config >> 3) & 0x1;
|
||||
enables->msrc = (sequence_config >> 2) & 0x1;
|
||||
enables->pre_range = (sequence_config >> 6) & 0x1;
|
||||
enables->final_range = (sequence_config >> 7) & 0x1;
|
||||
}
|
||||
|
||||
// Get the VCSEL pulse period in PCLKs for the given period type.
|
||||
// based on VL53L0X_get_vcsel_pulse_period()
|
||||
uint8_t AP_RangeFinder_VL53L0X::getVcselPulsePeriod(vcselPeriodType type)
|
||||
{
|
||||
#define decodeVcselPeriod(reg_val) (((reg_val) + 1) << 1)
|
||||
if (type == VcselPeriodPreRange) {
|
||||
return decodeVcselPeriod(read_register(PRE_RANGE_CONFIG_VCSEL_PERIOD));
|
||||
} else if (type == VcselPeriodFinalRange) {
|
||||
return decodeVcselPeriod(read_register(FINAL_RANGE_CONFIG_VCSEL_PERIOD));
|
||||
}
|
||||
return 255;
|
||||
}
|
||||
|
||||
// Convert sequence step timeout from MCLKs to microseconds with given VCSEL period in PCLKs
|
||||
// based on VL53L0X_calc_timeout_us()
|
||||
uint32_t AP_RangeFinder_VL53L0X::timeoutMclksToMicroseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks)
|
||||
{
|
||||
#define calcMacroPeriod(vcsel_period_pclks) ((((uint32_t)2304 * (vcsel_period_pclks) * 1655) + 500) / 1000)
|
||||
uint32_t macro_period_ns = calcMacroPeriod(vcsel_period_pclks);
|
||||
|
||||
return ((timeout_period_mclks * macro_period_ns) + (macro_period_ns / 2)) / 1000;
|
||||
}
|
||||
|
||||
// Decode sequence step timeout in MCLKs from register value
|
||||
// based on VL53L0X_decode_timeout()
|
||||
// Note: the original function returned a uint32_t, but the return value is
|
||||
// always stored in a uint16_t.
|
||||
uint16_t AP_RangeFinder_VL53L0X::decodeTimeout(uint16_t reg_val)
|
||||
{
|
||||
// format: "(LSByte * 2^MSByte) + 1"
|
||||
return (uint16_t)((reg_val & 0x00FF) <<
|
||||
(uint16_t)((reg_val & 0xFF00) >> 8)) + 1;
|
||||
}
|
||||
|
||||
// Get sequence step timeouts
|
||||
// based on get_sequence_step_timeout(),
|
||||
// but gets all timeouts instead of just the requested one, and also stores
|
||||
// intermediate values
|
||||
void AP_RangeFinder_VL53L0X::getSequenceStepTimeouts(SequenceStepEnables const * enables, SequenceStepTimeouts * timeouts)
|
||||
{
|
||||
timeouts->pre_range_vcsel_period_pclks = getVcselPulsePeriod(VcselPeriodPreRange);
|
||||
|
||||
timeouts->msrc_dss_tcc_mclks = read_register(MSRC_CONFIG_TIMEOUT_MACROP) + 1;
|
||||
timeouts->msrc_dss_tcc_us =
|
||||
timeoutMclksToMicroseconds(timeouts->msrc_dss_tcc_mclks,
|
||||
timeouts->pre_range_vcsel_period_pclks);
|
||||
|
||||
timeouts->pre_range_mclks =
|
||||
decodeTimeout(read_register16(PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI));
|
||||
timeouts->pre_range_us =
|
||||
timeoutMclksToMicroseconds(timeouts->pre_range_mclks,
|
||||
timeouts->pre_range_vcsel_period_pclks);
|
||||
|
||||
timeouts->final_range_vcsel_period_pclks = getVcselPulsePeriod(VcselPeriodFinalRange);
|
||||
|
||||
timeouts->final_range_mclks =
|
||||
decodeTimeout(read_register16(FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI));
|
||||
|
||||
if (enables->pre_range) {
|
||||
timeouts->final_range_mclks -= timeouts->pre_range_mclks;
|
||||
}
|
||||
|
||||
timeouts->final_range_us =
|
||||
timeoutMclksToMicroseconds(timeouts->final_range_mclks,
|
||||
timeouts->final_range_vcsel_period_pclks);
|
||||
}
|
||||
|
||||
|
||||
// Get the measurement timing budget in microseconds
|
||||
// based on VL53L0X_get_measurement_timing_budget_micro_seconds()
|
||||
// in us
|
||||
uint32_t AP_RangeFinder_VL53L0X::getMeasurementTimingBudget(void)
|
||||
{
|
||||
SequenceStepEnables enables;
|
||||
SequenceStepTimeouts timeouts;
|
||||
|
||||
uint16_t const StartOverhead = 1910; // note that this is different than the value in set_
|
||||
uint16_t const EndOverhead = 960;
|
||||
uint16_t const MsrcOverhead = 660;
|
||||
uint16_t const TccOverhead = 590;
|
||||
uint16_t const DssOverhead = 690;
|
||||
uint16_t const PreRangeOverhead = 660;
|
||||
uint16_t const FinalRangeOverhead = 550;
|
||||
|
||||
// "Start and end overhead times always present"
|
||||
uint32_t budget_us = StartOverhead + EndOverhead;
|
||||
|
||||
getSequenceStepEnables(&enables);
|
||||
getSequenceStepTimeouts(&enables, &timeouts);
|
||||
|
||||
if (enables.tcc) {
|
||||
budget_us += (timeouts.msrc_dss_tcc_us + TccOverhead);
|
||||
}
|
||||
|
||||
if (enables.dss) {
|
||||
budget_us += 2 * (timeouts.msrc_dss_tcc_us + DssOverhead);
|
||||
} else if (enables.msrc) {
|
||||
budget_us += (timeouts.msrc_dss_tcc_us + MsrcOverhead);
|
||||
}
|
||||
|
||||
if (enables.pre_range) {
|
||||
budget_us += (timeouts.pre_range_us + PreRangeOverhead);
|
||||
}
|
||||
|
||||
if (enables.final_range) {
|
||||
budget_us += (timeouts.final_range_us + FinalRangeOverhead);
|
||||
}
|
||||
|
||||
measurement_timing_budget_us = budget_us; // store for internal reuse
|
||||
return budget_us;
|
||||
}
|
||||
|
||||
// Convert sequence step timeout from microseconds to MCLKs with given VCSEL period in PCLKs
|
||||
// based on VL53L0X_calc_timeout_mclks()
|
||||
uint32_t AP_RangeFinder_VL53L0X::timeoutMicrosecondsToMclks(uint32_t timeout_period_us, uint8_t vcsel_period_pclks)
|
||||
{
|
||||
uint32_t macro_period_ns = calcMacroPeriod(vcsel_period_pclks);
|
||||
|
||||
return (((timeout_period_us * 1000) + (macro_period_ns / 2)) / macro_period_ns);
|
||||
}
|
||||
|
||||
// Encode sequence step timeout register value from timeout in MCLKs
|
||||
// based on VL53L0X_encode_timeout()
|
||||
// Note: the original function took a uint16_t, but the argument passed to it
|
||||
// is always a uint16_t.
|
||||
uint16_t AP_RangeFinder_VL53L0X::encodeTimeout(uint16_t timeout_mclks)
|
||||
{
|
||||
// format: "(LSByte * 2^MSByte) + 1"
|
||||
|
||||
uint32_t ls_byte = 0;
|
||||
uint16_t ms_byte = 0;
|
||||
|
||||
if (timeout_mclks > 0) {
|
||||
ls_byte = timeout_mclks - 1;
|
||||
|
||||
while ((ls_byte & 0xFFFFFF00) > 0) {
|
||||
ls_byte >>= 1;
|
||||
ms_byte++;
|
||||
}
|
||||
|
||||
return (ms_byte << 8) | (ls_byte & 0xFF);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Set the measurement timing budget in microseconds, which is the time allowed
|
||||
// for one measurement; the ST API and this library take care of splitting the
|
||||
// timing budget among the sub-steps in the ranging sequence. A longer timing
|
||||
// budget allows for more accurate measurements. Increasing the budget by a
|
||||
// factor of N decreases the range measurement standard deviation by a factor of
|
||||
// sqrt(N). Defaults to about 33 milliseconds; the minimum is 20 ms.
|
||||
// based on VL53L0X_set_measurement_timing_budget_micro_seconds()
|
||||
bool AP_RangeFinder_VL53L0X::setMeasurementTimingBudget(uint32_t budget_us)
|
||||
{
|
||||
SequenceStepEnables enables;
|
||||
SequenceStepTimeouts timeouts;
|
||||
|
||||
uint16_t const StartOverhead = 1320; // note that this is different than the value in get_
|
||||
uint16_t const EndOverhead = 960;
|
||||
uint16_t const MsrcOverhead = 660;
|
||||
uint16_t const TccOverhead = 590;
|
||||
uint16_t const DssOverhead = 690;
|
||||
uint16_t const PreRangeOverhead = 660;
|
||||
uint16_t const FinalRangeOverhead = 550;
|
||||
|
||||
uint32_t const MinTimingBudget = 20000;
|
||||
|
||||
if (budget_us < MinTimingBudget) { return false; }
|
||||
|
||||
uint32_t used_budget_us = StartOverhead + EndOverhead;
|
||||
|
||||
getSequenceStepEnables(&enables);
|
||||
getSequenceStepTimeouts(&enables, &timeouts);
|
||||
|
||||
if (enables.tcc) {
|
||||
used_budget_us += (timeouts.msrc_dss_tcc_us + TccOverhead);
|
||||
}
|
||||
|
||||
if (enables.dss) {
|
||||
used_budget_us += 2 * (timeouts.msrc_dss_tcc_us + DssOverhead);
|
||||
} else if (enables.msrc) {
|
||||
used_budget_us += (timeouts.msrc_dss_tcc_us + MsrcOverhead);
|
||||
}
|
||||
|
||||
if (enables.pre_range) {
|
||||
used_budget_us += (timeouts.pre_range_us + PreRangeOverhead);
|
||||
}
|
||||
|
||||
if (enables.final_range) {
|
||||
used_budget_us += FinalRangeOverhead;
|
||||
|
||||
// "Note that the final range timeout is determined by the timing
|
||||
// budget and the sum of all other timeouts within the sequence.
|
||||
// If there is no room for the final range timeout, then an error
|
||||
// will be set. Otherwise the remaining time will be applied to
|
||||
// the final range."
|
||||
|
||||
if (used_budget_us > budget_us) {
|
||||
// "Requested timeout too big."
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t final_range_timeout_us = budget_us - used_budget_us;
|
||||
|
||||
// set_sequence_step_timeout() begin
|
||||
// (SequenceStepId == VL53L0X_SEQUENCESTEP_FINAL_RANGE)
|
||||
|
||||
// "For the final range timeout, the pre-range timeout
|
||||
// must be added. To do this both final and pre-range
|
||||
// timeouts must be expressed in macro periods MClks
|
||||
// because they have different vcsel periods."
|
||||
|
||||
uint16_t final_range_timeout_mclks =
|
||||
timeoutMicrosecondsToMclks(final_range_timeout_us,
|
||||
timeouts.final_range_vcsel_period_pclks);
|
||||
|
||||
if (enables.pre_range) {
|
||||
final_range_timeout_mclks += timeouts.pre_range_mclks;
|
||||
}
|
||||
|
||||
write_register16(FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
|
||||
encodeTimeout(final_range_timeout_mclks));
|
||||
|
||||
// set_sequence_step_timeout() end
|
||||
measurement_timing_budget_us = budget_us; // store for internal reuse
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void AP_RangeFinder_VL53L0X::init()
|
||||
{
|
||||
// setup for 2.8V operation
|
||||
write_register(VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
|
||||
read_register(VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV) | 0x01);
|
||||
|
||||
// "Set I2C standard mode"
|
||||
write_register(0x88, 0x00);
|
||||
|
||||
write_register(0x80, 0x01);
|
||||
write_register(0xFF, 0x01);
|
||||
write_register(0x00, 0x00);
|
||||
stop_variable = read_register(0x91);
|
||||
write_register(0x00, 0x01);
|
||||
write_register(0xFF, 0x00);
|
||||
write_register(0x80, 0x00);
|
||||
|
||||
// disable SIGNAL_RATE_MSRC (bit 1) and SIGNAL_RATE_PRE_RANGE (bit 4) limit checks
|
||||
write_register(MSRC_CONFIG_CONTROL, read_register(MSRC_CONFIG_CONTROL) | 0x12);
|
||||
|
||||
// set final range signal rate limit to 0.25 MCPS (million counts per second)
|
||||
write_register16(FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT, uint16_t(0.25 * (1 << 7)));
|
||||
|
||||
write_register(SYSTEM_SEQUENCE_CONFIG, 0xFF);
|
||||
|
||||
uint8_t spad_count;
|
||||
bool spad_type_is_aperture;
|
||||
if (!get_SPAD_info(&spad_count, &spad_type_is_aperture)) {
|
||||
printf("Failed to get SPAD info\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// The SPAD map (RefGoodSpadMap) is read by VL53L0X_get_info_from_device() in
|
||||
// the API, but the same data seems to be more easily readable from
|
||||
// GLOBAL_CONFIG_SPAD_ENABLES_REF_0 through _6, so read it from there
|
||||
uint8_t ref_spad_map[6];
|
||||
if (!dev->read_registers(GLOBAL_CONFIG_SPAD_ENABLES_REF_0, ref_spad_map, 6)) {
|
||||
printf("Failed to read SPAD map\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// -- VL53L0X_set_reference_spads() begin (assume NVM values are valid)
|
||||
write_register(0xFF, 0x01);
|
||||
write_register(DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00);
|
||||
write_register(DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C);
|
||||
write_register(0xFF, 0x00);
|
||||
write_register(GLOBAL_CONFIG_REF_EN_START_SELECT, 0xB4);
|
||||
|
||||
uint8_t first_spad_to_enable = spad_type_is_aperture ? 12 : 0; // 12 is the first aperture spad
|
||||
uint8_t spads_enabled = 0;
|
||||
|
||||
for (uint8_t i = 0; i < 48; i++) {
|
||||
if (i < first_spad_to_enable || spads_enabled == spad_count) {
|
||||
// This bit is lower than the first one that should be enabled, or
|
||||
// (reference_spad_count) bits have already been enabled, so zero this bit
|
||||
ref_spad_map[i / 8] &= ~(1 << (i % 8));
|
||||
} else if ((ref_spad_map[i / 8] >> (i % 8)) & 0x1) {
|
||||
spads_enabled++;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t reg_spad_map[7] = { GLOBAL_CONFIG_SPAD_ENABLES_REF_0, };
|
||||
memcpy(®_spad_map[1], ref_spad_map, 6);
|
||||
dev->transfer(reg_spad_map, 7, nullptr, 0);
|
||||
|
||||
for (uint16_t i=0; i<ARRAY_SIZE(tuning_data); i++) {
|
||||
write_register(tuning_data[i].reg, tuning_data[i].value);
|
||||
}
|
||||
|
||||
write_register(SYSTEM_INTERRUPT_CONFIG_GPIO, 0x04);
|
||||
write_register(GPIO_HV_MUX_ACTIVE_HIGH, read_register(GPIO_HV_MUX_ACTIVE_HIGH) & ~0x10); // active low
|
||||
write_register(SYSTEM_INTERRUPT_CLEAR, 0x01);
|
||||
|
||||
// -- VL53L0X_SetGpioConfig() end
|
||||
|
||||
measurement_timing_budget_us = getMeasurementTimingBudget();
|
||||
|
||||
// "Disable MSRC and TCC by default"
|
||||
// MSRC = Minimum Signal Rate Check
|
||||
// TCC = Target CentreCheck
|
||||
// -- VL53L0X_SetSequenceStepEnable() begin
|
||||
|
||||
write_register(SYSTEM_SEQUENCE_CONFIG, 0xE8);
|
||||
|
||||
// -- VL53L0X_SetSequenceStepEnable() end
|
||||
|
||||
// "Recalculate timing budget"
|
||||
setMeasurementTimingBudget(measurement_timing_budget_us);
|
||||
|
||||
// VL53L0X_StaticInit() end
|
||||
|
||||
// VL53L0X_PerformRefCalibration() begin (VL53L0X_perform_ref_calibration())
|
||||
|
||||
// -- VL53L0X_perform_vhv_calibration() begin
|
||||
|
||||
write_register(SYSTEM_SEQUENCE_CONFIG, 0x01);
|
||||
if (!performSingleRefCalibration(0x40)) {
|
||||
printf("Failed SingleRefCalibration1\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// -- VL53L0X_perform_vhv_calibration() end
|
||||
|
||||
// -- VL53L0X_perform_phase_calibration() begin
|
||||
|
||||
write_register(SYSTEM_SEQUENCE_CONFIG, 0x02);
|
||||
if (!performSingleRefCalibration(0x00)) {
|
||||
printf("Failed SingleRefCalibration2\n");
|
||||
return;
|
||||
}
|
||||
|
||||
// -- VL53L0X_perform_phase_calibration() end
|
||||
|
||||
// "restore the previous Sequence Config"
|
||||
write_register(SYSTEM_SEQUENCE_CONFIG, 0xE8);
|
||||
|
||||
start_continuous();
|
||||
|
||||
// call timer() every 33ms. We expect new data to be available every 33ms
|
||||
dev->register_periodic_callback(33000,
|
||||
FUNCTOR_BIND_MEMBER(&AP_RangeFinder_VL53L0X::timer, void));
|
||||
}
|
||||
|
||||
|
||||
// based on VL53L0X_perform_single_ref_calibration()
|
||||
bool AP_RangeFinder_VL53L0X::performSingleRefCalibration(uint8_t vhv_init_byte)
|
||||
{
|
||||
write_register(SYSRANGE_START, 0x01 | vhv_init_byte); // VL53L0X_REG_SYSRANGE_MODE_START_STOP
|
||||
|
||||
uint8_t tries = 200;
|
||||
while ((read_register(RESULT_INTERRUPT_STATUS) & 0x07) == 0) {
|
||||
if (tries-- == 0) {
|
||||
return false;
|
||||
}
|
||||
hal.scheduler->delay(1);
|
||||
}
|
||||
|
||||
write_register(SYSTEM_INTERRUPT_CLEAR, 0x01);
|
||||
|
||||
write_register(SYSRANGE_START, 0x00);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// Start continuous ranging measurements
|
||||
void AP_RangeFinder_VL53L0X::start_continuous(void)
|
||||
{
|
||||
write_register(0x80, 0x01);
|
||||
write_register(0xFF, 0x01);
|
||||
write_register(0x00, 0x00);
|
||||
write_register(0x91, stop_variable);
|
||||
write_register(0x00, 0x01);
|
||||
write_register(0xFF, 0x00);
|
||||
write_register(0x80, 0x00);
|
||||
|
||||
// continuous back-to-back mode
|
||||
write_register(SYSRANGE_START, 0x02); // VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK
|
||||
|
||||
start_ms = AP_HAL::millis();
|
||||
}
|
||||
|
||||
// read - return last value measured by sensor
|
||||
bool AP_RangeFinder_VL53L0X::get_reading(uint16_t &reading_mm)
|
||||
{
|
||||
if ((read_register(RESULT_INTERRUPT_STATUS) & 0x07) == 0) {
|
||||
if (AP_HAL::millis() - start_ms > 200) {
|
||||
start_continuous();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// assumptions: Linearity Corrective Gain is 1000 (default);
|
||||
// fractional ranging is not enabled
|
||||
reading_mm = read_register16(RESULT_RANGE_STATUS + 10);
|
||||
write_register(SYSTEM_INTERRUPT_CLEAR, 0x01);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void AP_RangeFinder_VL53L0X::write_register16(uint8_t reg, uint16_t value)
|
||||
{
|
||||
uint8_t b[3] = { reg, uint8_t(value>>8), uint8_t(value) };
|
||||
dev->transfer(b, 3, nullptr, 0);
|
||||
}
|
||||
|
||||
void AP_RangeFinder_VL53L0X::write_register(uint8_t reg, uint8_t value)
|
||||
{
|
||||
dev->write_register(reg, value);
|
||||
}
|
||||
|
||||
uint8_t AP_RangeFinder_VL53L0X::read_register(uint8_t reg)
|
||||
{
|
||||
uint8_t v = 0;
|
||||
dev->read_registers(reg, &v, 1);
|
||||
return v;
|
||||
}
|
||||
|
||||
uint16_t AP_RangeFinder_VL53L0X::read_register16(uint8_t reg)
|
||||
{
|
||||
uint16_t v = 0;
|
||||
dev->transfer(®, 1, (uint8_t *)&v, 2);
|
||||
return be16toh(v);
|
||||
}
|
||||
|
||||
/*
|
||||
update the state of the sensor
|
||||
*/
|
||||
void AP_RangeFinder_VL53L0X::update(void)
|
||||
{
|
||||
if (counter > 0) {
|
||||
state.distance_cm = sum_mm / (10*counter);
|
||||
sum_mm = 0;
|
||||
counter = 0;
|
||||
update_status();
|
||||
} else {
|
||||
set_status(RangeFinder::RangeFinder_NoData);
|
||||
}
|
||||
}
|
||||
|
||||
void AP_RangeFinder_VL53L0X::timer(void)
|
||||
{
|
||||
uint16_t range_mm;
|
||||
if (get_reading(range_mm) && range_mm < 8000) {
|
||||
sum_mm += range_mm;
|
||||
counter++;
|
||||
}
|
||||
}
|
||||
76
libraries/AP_RangeFinder/AP_RangeFinder_VL53L0X.h
Normal file
76
libraries/AP_RangeFinder/AP_RangeFinder_VL53L0X.h
Normal file
@ -0,0 +1,76 @@
|
||||
#pragma once
|
||||
|
||||
#include "RangeFinder.h"
|
||||
#include "RangeFinder_Backend.h"
|
||||
#include <AP_HAL/I2CDevice.h>
|
||||
|
||||
class AP_RangeFinder_VL53L0X : public AP_RangeFinder_Backend
|
||||
{
|
||||
|
||||
public:
|
||||
// static detection function
|
||||
static AP_RangeFinder_Backend *detect(RangeFinder &ranger, uint8_t instance, RangeFinder::RangeFinder_State &_state, AP_HAL::OwnPtr<AP_HAL::I2CDevice> dev);
|
||||
|
||||
// update state
|
||||
void update(void);
|
||||
|
||||
private:
|
||||
// constructor
|
||||
AP_RangeFinder_VL53L0X(RangeFinder &ranger, uint8_t instance, RangeFinder::RangeFinder_State &_state, AP_HAL::OwnPtr<AP_HAL::I2CDevice> dev);
|
||||
|
||||
void init();
|
||||
void timer();
|
||||
|
||||
// check sensor ID
|
||||
bool check_id(void);
|
||||
|
||||
// get a reading
|
||||
bool get_reading(uint16_t &reading_cm);
|
||||
AP_HAL::OwnPtr<AP_HAL::I2CDevice> dev;
|
||||
|
||||
uint8_t read_register(uint8_t reg);
|
||||
uint16_t read_register16(uint8_t reg);
|
||||
|
||||
void write_register(uint8_t reg, uint8_t value);
|
||||
void write_register16(uint8_t reg, uint16_t value);
|
||||
|
||||
struct SequenceStepEnables {
|
||||
bool tcc:1, msrc:1, dss:1, pre_range:1, final_range:1;
|
||||
};
|
||||
|
||||
struct SequenceStepTimeouts {
|
||||
uint16_t pre_range_vcsel_period_pclks, final_range_vcsel_period_pclks;
|
||||
|
||||
uint16_t msrc_dss_tcc_mclks, pre_range_mclks, final_range_mclks;
|
||||
uint32_t msrc_dss_tcc_us, pre_range_us, final_range_us;
|
||||
};
|
||||
|
||||
struct RegData {
|
||||
uint8_t reg;
|
||||
uint8_t value;
|
||||
};
|
||||
|
||||
static const RegData tuning_data[];
|
||||
|
||||
enum vcselPeriodType { VcselPeriodPreRange, VcselPeriodFinalRange };
|
||||
|
||||
bool get_SPAD_info(uint8_t * count, bool *type_is_aperture);
|
||||
void getSequenceStepEnables(SequenceStepEnables * enables);
|
||||
uint32_t getMeasurementTimingBudget(void);
|
||||
void getSequenceStepTimeouts(SequenceStepEnables const * enables, SequenceStepTimeouts * timeouts);
|
||||
uint8_t getVcselPulsePeriod(vcselPeriodType type);
|
||||
uint32_t timeoutMclksToMicroseconds(uint16_t timeout_period_mclks, uint8_t vcsel_period_pclks);
|
||||
uint16_t decodeTimeout(uint16_t reg_val);
|
||||
bool setMeasurementTimingBudget(uint32_t budget_us);
|
||||
uint32_t timeoutMicrosecondsToMclks(uint32_t timeout_period_us, uint8_t vcsel_period_pclks);
|
||||
uint16_t encodeTimeout(uint16_t timeout_mclks);
|
||||
bool performSingleRefCalibration(uint8_t vhv_init_byte);
|
||||
void start_continuous(void);
|
||||
|
||||
uint8_t stop_variable;
|
||||
uint32_t measurement_timing_budget_us;
|
||||
uint32_t start_ms;
|
||||
|
||||
uint32_t sum_mm;
|
||||
uint32_t counter;
|
||||
};
|
||||
@ -27,6 +27,7 @@
|
||||
#include "AP_RangeFinder_LeddarOne.h"
|
||||
#include "AP_RangeFinder_uLanding.h"
|
||||
#include "AP_RangeFinder_trone.h"
|
||||
#include "AP_RangeFinder_VL53L0X.h"
|
||||
#include <AP_BoardConfig/AP_BoardConfig.h>
|
||||
|
||||
extern const AP_HAL::HAL &hal;
|
||||
@ -36,7 +37,7 @@ const AP_Param::GroupInfo RangeFinder::var_info[] = {
|
||||
// @Param: _TYPE
|
||||
// @DisplayName: Rangefinder type
|
||||
// @Description: What type of rangefinder device that is connected
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C,16:VL53L0X
|
||||
// @User: Standard
|
||||
AP_GROUPINFO("_TYPE", 0, RangeFinder, _type[0], 0),
|
||||
|
||||
@ -163,7 +164,7 @@ const AP_Param::GroupInfo RangeFinder::var_info[] = {
|
||||
// @Param: 2_TYPE
|
||||
// @DisplayName: Second Rangefinder type
|
||||
// @Description: What type of rangefinder device that is connected
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C,16:VL53L0X
|
||||
// @User: Advanced
|
||||
AP_GROUPINFO("2_TYPE", 12, RangeFinder, _type[1], 0),
|
||||
|
||||
@ -284,7 +285,7 @@ const AP_Param::GroupInfo RangeFinder::var_info[] = {
|
||||
// @Param: 3_TYPE
|
||||
// @DisplayName: Third Rangefinder type
|
||||
// @Description: What type of rangefinder device that is connected
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C,16:VL53L0X
|
||||
// @User: Advanced
|
||||
AP_GROUPINFO("3_TYPE", 25, RangeFinder, _type[2], 0),
|
||||
|
||||
@ -405,7 +406,7 @@ const AP_Param::GroupInfo RangeFinder::var_info[] = {
|
||||
// @Param: 4_TYPE
|
||||
// @DisplayName: Fourth Rangefinder type
|
||||
// @Description: What type of rangefinder device that is connected
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C
|
||||
// @Values: 0:None,1:Analog,2:MaxbotixI2C,3:LidarLiteV2-I2C,5:PX4-PWM,6:BBB-PRU,7:LightWareI2C,8:LightWareSerial,9:Bebop,10:MAVLink,11:uLanding,12:LeddarOne,13:MaxbotixSerial,14:TrOneI2C,15:LidarLiteV3-I2C,16:VL53L0X
|
||||
// @User: Advanced
|
||||
AP_GROUPINFO("4_TYPE", 37, RangeFinder, _type[3], 0),
|
||||
|
||||
@ -630,6 +631,13 @@ void RangeFinder::detect_instance(uint8_t instance)
|
||||
_add_backend(AP_RangeFinder_trone::detect(1, *this, instance, state[instance]));
|
||||
}
|
||||
break;
|
||||
case RangeFinder_TYPE_VL53L0X:
|
||||
if (!_add_backend(AP_RangeFinder_VL53L0X::detect(*this, instance, state[instance],
|
||||
hal.i2c_mgr->get_device(1, 0x29)))) {
|
||||
_add_backend(AP_RangeFinder_VL53L0X::detect(*this, instance, state[instance],
|
||||
hal.i2c_mgr->get_device(0, 0x29)));
|
||||
}
|
||||
break;
|
||||
#if CONFIG_HAL_BOARD == HAL_BOARD_PX4 || CONFIG_HAL_BOARD == HAL_BOARD_VRBRAIN
|
||||
case RangeFinder_TYPE_PX4_PWM:
|
||||
if (AP_RangeFinder_PX4_PWM::detect(*this, instance)) {
|
||||
|
||||
@ -53,6 +53,7 @@ public:
|
||||
RangeFinder_TYPE_MBSER = 13,
|
||||
RangeFinder_TYPE_TRONE = 14,
|
||||
RangeFinder_TYPE_PLI2CV3= 15,
|
||||
RangeFinder_TYPE_VL53L0X = 16
|
||||
};
|
||||
|
||||
enum RangeFinder_Function {
|
||||
|
||||
Loading…
Reference in New Issue
Block a user