amiro-lld / drivers / VL53L1X / v1 / api / core / vl53l1_api_core.c @ 4dba9195
History | View | Annotate | Download (96.276 KB)
1 |
/*
|
---|---|
2 |
* Copyright (c) 2017, STMicroelectronics - All Rights Reserved
|
3 |
*
|
4 |
* This file is part of VL53L1 Core and is dual licensed,
|
5 |
* either 'STMicroelectronics
|
6 |
* Proprietary license'
|
7 |
* or 'BSD 3-clause "New" or "Revised" License' , at your option.
|
8 |
*
|
9 |
********************************************************************************
|
10 |
*
|
11 |
* 'STMicroelectronics Proprietary license'
|
12 |
*
|
13 |
********************************************************************************
|
14 |
*
|
15 |
* License terms: STMicroelectronics Proprietary in accordance with licensing
|
16 |
* terms at www.st.com/sla0081
|
17 |
*
|
18 |
* STMicroelectronics confidential
|
19 |
* Reproduction and Communication of this document is strictly prohibited unless
|
20 |
* specifically authorized in writing by STMicroelectronics.
|
21 |
*
|
22 |
*
|
23 |
********************************************************************************
|
24 |
*
|
25 |
* Alternatively, VL53L1 Core may be distributed under the terms of
|
26 |
* 'BSD 3-clause "New" or "Revised" License', in which case the following
|
27 |
* provisions apply instead of the ones mentioned above :
|
28 |
*
|
29 |
********************************************************************************
|
30 |
*
|
31 |
* License terms: BSD 3-clause "New" or "Revised" License.
|
32 |
*
|
33 |
* Redistribution and use in source and binary forms, with or without
|
34 |
* modification, are permitted provided that the following conditions are met:
|
35 |
*
|
36 |
* 1. Redistributions of source code must retain the above copyright notice, this
|
37 |
* list of conditions and the following disclaimer.
|
38 |
*
|
39 |
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
40 |
* this list of conditions and the following disclaimer in the documentation
|
41 |
* and/or other materials provided with the distribution.
|
42 |
*
|
43 |
* 3. Neither the name of the copyright holder nor the names of its contributors
|
44 |
* may be used to endorse or promote products derived from this software
|
45 |
* without specific prior written permission.
|
46 |
*
|
47 |
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
48 |
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
49 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
50 |
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
51 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
52 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
53 |
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
54 |
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
55 |
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
56 |
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
57 |
*
|
58 |
*
|
59 |
********************************************************************************
|
60 |
*
|
61 |
*/
|
62 |
|
63 |
/**
|
64 |
* @file vl53l1_api_core.c
|
65 |
*
|
66 |
* @brief EwokPlus25 low level API function definition
|
67 |
*/
|
68 |
|
69 |
|
70 |
#include "vl53l1_ll_def.h" |
71 |
#include "vl53l1_ll_device.h" |
72 |
#include "vl53l1_platform.h" |
73 |
#include "vl53l1_register_map.h" |
74 |
#include "vl53l1_register_settings.h" |
75 |
#include "vl53l1_register_funcs.h" |
76 |
#include "vl53l1_nvm_map.h" |
77 |
#include "vl53l1_core.h" |
78 |
#include "vl53l1_wait.h" |
79 |
#include "vl53l1_api_preset_modes.h" |
80 |
#include "vl53l1_silicon_core.h" |
81 |
#include "vl53l1_api_core.h" |
82 |
#include "vl53l1_tuning_parm_defaults.h" |
83 |
|
84 |
#ifdef VL53L1_LOG_ENABLE
|
85 |
#include "vl53l1_api_debug.h" |
86 |
#endif
|
87 |
|
88 |
#define LOG_FUNCTION_START(fmt, ...) \
|
89 |
_LOG_FUNCTION_START(VL53L1_TRACE_MODULE_CORE, fmt, ##__VA_ARGS__) |
90 |
#define LOG_FUNCTION_END(status, ...) \
|
91 |
_LOG_FUNCTION_END(VL53L1_TRACE_MODULE_CORE, status, ##__VA_ARGS__) |
92 |
#define LOG_FUNCTION_END_FMT(status, fmt, ...) \
|
93 |
_LOG_FUNCTION_END_FMT(VL53L1_TRACE_MODULE_CORE, status, \ |
94 |
fmt, ##__VA_ARGS__) |
95 |
|
96 |
#define trace_print(level, ...) \
|
97 |
_LOG_TRACE_PRINT(VL53L1_TRACE_MODULE_CORE, \ |
98 |
level, VL53L1_TRACE_FUNCTION_NONE, ##__VA_ARGS__) |
99 |
|
100 |
#define VL53L1_MAX_I2C_XFER_SIZE 256 |
101 |
|
102 |
#ifdef VL53L1_DEBUG
|
103 |
VL53L1_Error VL53L1_get_version( |
104 |
VL53L1_DEV Dev, |
105 |
VL53L1_ll_version_t *pdata) |
106 |
{ |
107 |
/*
|
108 |
* respond with the #define values from version.h
|
109 |
* using memcpy(dst, src, size in bytes)
|
110 |
*/
|
111 |
|
112 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
113 |
|
114 |
VL53L1_init_version(Dev); |
115 |
|
116 |
memcpy(pdata, &(pdev->version), sizeof(VL53L1_ll_version_t));
|
117 |
|
118 |
return VL53L1_ERROR_NONE;
|
119 |
} |
120 |
|
121 |
VL53L1_Error VL53L1_get_device_firmware_version( |
122 |
VL53L1_DEV Dev, |
123 |
uint16_t *pfw_version) |
124 |
{ |
125 |
/*
|
126 |
* Read Firmware version from device
|
127 |
*/
|
128 |
|
129 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
130 |
|
131 |
LOG_FUNCTION_START("");
|
132 |
|
133 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
134 |
status = VL53L1_disable_firmware(Dev); |
135 |
|
136 |
if (status == VL53L1_ERROR_NONE)
|
137 |
status = VL53L1_RdWord( |
138 |
Dev, |
139 |
VL53L1_MCU_GENERAL_PURPOSE__GP_0, |
140 |
pfw_version); |
141 |
|
142 |
if (status == VL53L1_ERROR_NONE)
|
143 |
status = VL53L1_enable_firmware(Dev); |
144 |
|
145 |
LOG_FUNCTION_END(status); |
146 |
|
147 |
return status;
|
148 |
} |
149 |
#endif
|
150 |
|
151 |
|
152 |
VL53L1_Error VL53L1_data_init( |
153 |
VL53L1_DEV Dev, |
154 |
uint8_t read_p2p_data) |
155 |
{ |
156 |
/*
|
157 |
* Initialise pdev data structure
|
158 |
*/
|
159 |
|
160 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
161 |
VL53L1_LLDriverData_t *pdev = |
162 |
VL53L1DevStructGetLLDriverHandle(Dev); |
163 |
|
164 |
VL53L1_init_ll_driver_state( |
165 |
Dev, |
166 |
VL53L1_DEVICESTATE_UNKNOWN); |
167 |
|
168 |
pdev->wait_method = VL53L1_WAIT_METHOD_BLOCKING; |
169 |
pdev->preset_mode = VL53L1_DEVICEPRESETMODE_STANDARD_RANGING; |
170 |
pdev->measurement_mode = VL53L1_DEVICEMEASUREMENTMODE_STOP; |
171 |
|
172 |
pdev->offset_calibration_mode = |
173 |
VL53L1_OFFSETCALIBRATIONMODE__MM1_MM2__STANDARD; |
174 |
pdev->offset_correction_mode = |
175 |
VL53L1_OFFSETCORRECTIONMODE__MM1_MM2_OFFSETS; |
176 |
|
177 |
pdev->phasecal_config_timeout_us = 1000;
|
178 |
pdev->mm_config_timeout_us = 2000;
|
179 |
pdev->range_config_timeout_us = 13000;
|
180 |
pdev->inter_measurement_period_ms = 100;
|
181 |
pdev->dss_config__target_total_rate_mcps = 0x0A00;
|
182 |
pdev->debug_mode = 0x00;
|
183 |
|
184 |
/* initialise gain calibration values to tuning parameter values */
|
185 |
|
186 |
pdev->gain_cal.standard_ranging_gain_factor = |
187 |
VL53L1_TUNINGPARM_LITE_RANGING_GAIN_FACTOR_DEFAULT; |
188 |
|
189 |
/*
|
190 |
* Initialise version structure
|
191 |
*/
|
192 |
VL53L1_init_version(Dev); |
193 |
|
194 |
/*
|
195 |
* For C-API one time initialization only read device G02 registers
|
196 |
* containing data copied from NVM
|
197 |
*
|
198 |
* Contains the key NVM data e.g identification info fast oscillator
|
199 |
* freq, max trim and laser safety info
|
200 |
*/
|
201 |
|
202 |
if (read_p2p_data > 0 && status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
203 |
status = VL53L1_read_p2p_data(Dev); |
204 |
|
205 |
/* Initialise Ref SPAD Char configuration structure */
|
206 |
#ifndef VL53L1_NOCALIB
|
207 |
status = |
208 |
VL53L1_init_refspadchar_config_struct( |
209 |
&(pdev->refspadchar)); |
210 |
#endif
|
211 |
|
212 |
/* Initialise SPAD Self Check (SSC) configuration structure */
|
213 |
#ifndef VL53L1_NOCALIB
|
214 |
status = |
215 |
VL53L1_init_ssc_config_struct( |
216 |
&(pdev->ssc_cfg)); |
217 |
#endif
|
218 |
|
219 |
/* Initialise Private Xtalk configuration structure
|
220 |
* - Fill with customer NVM data to begin
|
221 |
*/
|
222 |
status = |
223 |
VL53L1_init_xtalk_config_struct( |
224 |
&(pdev->customer), |
225 |
&(pdev->xtalk_cfg)); |
226 |
|
227 |
/* Initialise Offset Calibration configuration structure
|
228 |
*/
|
229 |
#ifndef VL53L1_NOCALIB
|
230 |
status = |
231 |
VL53L1_init_offset_cal_config_struct( |
232 |
&(pdev->offsetcal_cfg)); |
233 |
#endif
|
234 |
|
235 |
/* Initialise Tuning Parameter structure
|
236 |
* - Added as part of Patch_AddingTuningParmStorage_11821
|
237 |
*/
|
238 |
status = |
239 |
VL53L1_init_tuning_parm_storage_struct( |
240 |
&(pdev->tuning_parms)); |
241 |
|
242 |
status = VL53L1_set_vhv_loopbound(Dev, |
243 |
VL53L1_TUNINGPARM_VHV_LOOPBOUND_DEFAULT); |
244 |
|
245 |
/*
|
246 |
* Initialise default settings - much happen *after*
|
247 |
* reading /setting of static_nvm_managed
|
248 |
*/
|
249 |
|
250 |
if (status == VL53L1_ERROR_NONE)
|
251 |
status = VL53L1_set_preset_mode( |
252 |
Dev, |
253 |
pdev->preset_mode, |
254 |
pdev->dss_config__target_total_rate_mcps, /* 9.7 format 20Mcps */
|
255 |
pdev->phasecal_config_timeout_us, |
256 |
pdev->mm_config_timeout_us, |
257 |
pdev->range_config_timeout_us, |
258 |
pdev->inter_measurement_period_ms); |
259 |
|
260 |
/* Initial Low Power Auto Mode data structures */
|
261 |
/* Added for Patch_LowPowerAutoMode */
|
262 |
VL53L1_low_power_auto_data_init( |
263 |
Dev |
264 |
); |
265 |
|
266 |
#ifdef VL53L1_LOG_ENABLE
|
267 |
|
268 |
/* Prints out the initial calibration data for debug */
|
269 |
|
270 |
VL53L1_print_static_nvm_managed( |
271 |
&(pdev->stat_nvm), |
272 |
"data_init():pdev->lldata.stat_nvm.",
|
273 |
VL53L1_TRACE_MODULE_DATA_INIT); |
274 |
|
275 |
VL53L1_print_customer_nvm_managed( |
276 |
&(pdev->customer), |
277 |
"data_init():pdev->lldata.customer.",
|
278 |
VL53L1_TRACE_MODULE_DATA_INIT); |
279 |
|
280 |
VL53L1_print_nvm_copy_data( |
281 |
&(pdev->nvm_copy_data), |
282 |
"data_init():pdev->lldata.nvm_copy_data.",
|
283 |
VL53L1_TRACE_MODULE_DATA_INIT); |
284 |
|
285 |
VL53L1_print_additional_offset_cal_data( |
286 |
&(pdev->add_off_cal_data), |
287 |
"data_init():pdev->lldata.add_off_cal_data.",
|
288 |
VL53L1_TRACE_MODULE_DATA_INIT); |
289 |
|
290 |
VL53L1_print_user_zone( |
291 |
&(pdev->mm_roi), |
292 |
"data_init():pdev->lldata.mm_roi.",
|
293 |
VL53L1_TRACE_MODULE_DATA_INIT); |
294 |
|
295 |
VL53L1_print_optical_centre( |
296 |
&(pdev->optical_centre), |
297 |
"data_init():pdev->lldata.optical_centre.",
|
298 |
VL53L1_TRACE_MODULE_DATA_INIT); |
299 |
|
300 |
VL53L1_print_cal_peak_rate_map( |
301 |
&(pdev->cal_peak_rate_map), |
302 |
"data_init():pdev->lldata.cal_peak_rate_map.",
|
303 |
VL53L1_TRACE_MODULE_DATA_INIT); |
304 |
|
305 |
#endif
|
306 |
|
307 |
LOG_FUNCTION_END(status); |
308 |
|
309 |
return status;
|
310 |
} |
311 |
|
312 |
|
313 |
VL53L1_Error VL53L1_read_p2p_data( |
314 |
VL53L1_DEV Dev) |
315 |
{ |
316 |
|
317 |
/*
|
318 |
* For C-API one time initialization only reads device
|
319 |
* G02 registers containing data copied from NVM
|
320 |
*
|
321 |
* Contains the key NVM data e.g identification info
|
322 |
* fast oscillator freq, max trim and laser safety info
|
323 |
*/
|
324 |
|
325 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
326 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
327 |
|
328 |
LOG_FUNCTION_START("");
|
329 |
|
330 |
if (status == VL53L1_ERROR_NONE)
|
331 |
status = VL53L1_get_static_nvm_managed( |
332 |
Dev, |
333 |
&(pdev->stat_nvm)); |
334 |
|
335 |
if (status == VL53L1_ERROR_NONE)
|
336 |
status = VL53L1_get_customer_nvm_managed( |
337 |
Dev, |
338 |
&(pdev->customer)); |
339 |
|
340 |
if (status == VL53L1_ERROR_NONE) {
|
341 |
|
342 |
status = VL53L1_get_nvm_copy_data( |
343 |
Dev, |
344 |
&(pdev->nvm_copy_data)); |
345 |
|
346 |
/* copy Return Good SPADs to buffer */
|
347 |
if (status == VL53L1_ERROR_NONE)
|
348 |
VL53L1_copy_rtn_good_spads_to_buffer( |
349 |
&(pdev->nvm_copy_data), |
350 |
&(pdev->rtn_good_spads[0]));
|
351 |
} |
352 |
|
353 |
/*
|
354 |
* read slow osc calibration value
|
355 |
* counts per ms
|
356 |
*/
|
357 |
if (status == VL53L1_ERROR_NONE)
|
358 |
status = |
359 |
VL53L1_RdWord( |
360 |
Dev, |
361 |
VL53L1_RESULT__OSC_CALIBRATE_VAL, |
362 |
&(pdev->dbg_results.result__osc_calibrate_val)); |
363 |
|
364 |
/*
|
365 |
* Check if there a sensible value for osc_measured__fast_osc__frequency
|
366 |
*/
|
367 |
|
368 |
if (pdev->stat_nvm.osc_measured__fast_osc__frequency < 0x1000) { |
369 |
trace_print( |
370 |
VL53L1_TRACE_LEVEL_WARNING, |
371 |
"\nInvalid %s value (0x%04X) - forcing to 0x%04X\n\n",
|
372 |
"pdev->stat_nvm.osc_measured__fast_osc__frequency",
|
373 |
pdev->stat_nvm.osc_measured__fast_osc__frequency, |
374 |
0xBCCC);
|
375 |
pdev->stat_nvm.osc_measured__fast_osc__frequency = 0xBCCC;
|
376 |
} |
377 |
|
378 |
/*
|
379 |
* Get MM ROI - contains optical centre as SPAD number
|
380 |
*/
|
381 |
|
382 |
if (status == VL53L1_ERROR_NONE)
|
383 |
status = |
384 |
VL53L1_get_mode_mitigation_roi( |
385 |
Dev, |
386 |
&(pdev->mm_roi)); |
387 |
|
388 |
/* catch parts where the optical centre is
|
389 |
* no programmed in to the NVM
|
390 |
*/
|
391 |
|
392 |
if (pdev->optical_centre.x_centre == 0 && |
393 |
pdev->optical_centre.y_centre == 0) {
|
394 |
pdev->optical_centre.x_centre = |
395 |
pdev->mm_roi.x_centre << 4;
|
396 |
pdev->optical_centre.y_centre = |
397 |
pdev->mm_roi.y_centre << 4;
|
398 |
} |
399 |
|
400 |
LOG_FUNCTION_END(status); |
401 |
|
402 |
return status;
|
403 |
} |
404 |
|
405 |
|
406 |
VL53L1_Error VL53L1_software_reset( |
407 |
VL53L1_DEV Dev) |
408 |
{ |
409 |
/**
|
410 |
* Sets and clears the software reset register VL53L1_SOFT_RESET.
|
411 |
* and waits for the firmware to boot
|
412 |
*/
|
413 |
|
414 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
415 |
|
416 |
LOG_FUNCTION_START("");
|
417 |
|
418 |
/* apply reset - note despite the name soft reset is active low! */
|
419 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
420 |
status = VL53L1_WrByte( |
421 |
Dev, |
422 |
VL53L1_SOFT_RESET, |
423 |
0x00);
|
424 |
|
425 |
/* wait for a while before releasing the reset */
|
426 |
if (status == VL53L1_ERROR_NONE)
|
427 |
status = |
428 |
VL53L1_WaitUs( |
429 |
Dev, |
430 |
VL53L1_SOFTWARE_RESET_DURATION_US); |
431 |
|
432 |
/* release reset */
|
433 |
if (status == VL53L1_ERROR_NONE)
|
434 |
status = VL53L1_WrByte( |
435 |
Dev, |
436 |
VL53L1_SOFT_RESET, |
437 |
0x01);
|
438 |
|
439 |
/* wait for firmware boot to complete */
|
440 |
if (status == VL53L1_ERROR_NONE)
|
441 |
status = VL53L1_wait_for_boot_completion(Dev); |
442 |
|
443 |
LOG_FUNCTION_END(status); |
444 |
|
445 |
return status;
|
446 |
} |
447 |
|
448 |
|
449 |
VL53L1_Error VL53L1_set_part_to_part_data( |
450 |
VL53L1_DEV Dev, |
451 |
VL53L1_calibration_data_t *pcal_data) |
452 |
{ |
453 |
/**
|
454 |
* Uses memcpy to copy input data to pdev->customer
|
455 |
*/
|
456 |
|
457 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
458 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
459 |
|
460 |
uint32_t tempu32; |
461 |
|
462 |
LOG_FUNCTION_START("");
|
463 |
|
464 |
if (pcal_data->struct_version !=
|
465 |
VL53L1_LL_CALIBRATION_DATA_STRUCT_VERSION) { |
466 |
status = VL53L1_ERROR_INVALID_PARAMS; |
467 |
} |
468 |
|
469 |
if (status == VL53L1_ERROR_NONE) {
|
470 |
|
471 |
/* memcpy(DEST, SRC, N) */
|
472 |
memcpy( |
473 |
&(pdev->customer), |
474 |
&(pcal_data->customer), |
475 |
sizeof(VL53L1_customer_nvm_managed_t));
|
476 |
|
477 |
/* memcpy(DEST, SRC, N) */
|
478 |
memcpy( |
479 |
&(pdev->add_off_cal_data), |
480 |
&(pcal_data->add_off_cal_data), |
481 |
sizeof(VL53L1_additional_offset_cal_data_t));
|
482 |
|
483 |
/* memcpy(DEST, SRC, N) */
|
484 |
memcpy( |
485 |
&(pdev->gain_cal), |
486 |
&(pcal_data->gain_cal), |
487 |
sizeof(VL53L1_gain_calibration_data_t));
|
488 |
|
489 |
/* memcpy(DEST, SRC, N) */
|
490 |
memcpy( |
491 |
&(pdev->cal_peak_rate_map), |
492 |
&(pcal_data->cal_peak_rate_map), |
493 |
sizeof(VL53L1_cal_peak_rate_map_t));
|
494 |
|
495 |
/*
|
496 |
* Update internal xtalk data structures
|
497 |
*/
|
498 |
|
499 |
pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps = |
500 |
pdev->customer.algo__crosstalk_compensation_plane_offset_kcps; |
501 |
pdev->xtalk_cfg.algo__crosstalk_compensation_x_plane_gradient_kcps = |
502 |
pdev->customer.algo__crosstalk_compensation_x_plane_gradient_kcps; |
503 |
pdev->xtalk_cfg.algo__crosstalk_compensation_y_plane_gradient_kcps = |
504 |
pdev->customer.algo__crosstalk_compensation_y_plane_gradient_kcps; |
505 |
|
506 |
/* Assess and update customer packet xtalk parameters */
|
507 |
|
508 |
if (pdev->xtalk_cfg.global_crosstalk_compensation_enable == 0x00) { |
509 |
pdev->customer.algo__crosstalk_compensation_plane_offset_kcps = |
510 |
0x00;
|
511 |
pdev->customer.algo__crosstalk_compensation_x_plane_gradient_kcps = |
512 |
0x00;
|
513 |
pdev->customer.algo__crosstalk_compensation_y_plane_gradient_kcps = |
514 |
0x00;
|
515 |
} else {
|
516 |
tempu32 = VL53L1_calc_crosstalk_plane_offset_with_margin( |
517 |
pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps, |
518 |
pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps); |
519 |
if (tempu32 > 0xFFFF) { /* clip to 16 bits */ |
520 |
tempu32 = 0xFFFF;
|
521 |
} |
522 |
pdev->customer.algo__crosstalk_compensation_plane_offset_kcps = |
523 |
(uint16_t)tempu32; |
524 |
} |
525 |
} |
526 |
|
527 |
LOG_FUNCTION_END(status); |
528 |
|
529 |
return status;
|
530 |
} |
531 |
|
532 |
|
533 |
VL53L1_Error VL53L1_get_part_to_part_data( |
534 |
VL53L1_DEV Dev, |
535 |
VL53L1_calibration_data_t *pcal_data) |
536 |
{ |
537 |
/**
|
538 |
* Uses memcpy to copy pdev->customer to output data
|
539 |
*/
|
540 |
|
541 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
542 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
543 |
|
544 |
LOG_FUNCTION_START("");
|
545 |
|
546 |
pcal_data->struct_version = |
547 |
VL53L1_LL_CALIBRATION_DATA_STRUCT_VERSION; |
548 |
|
549 |
/* memcpy(DEST, SRC, N) */
|
550 |
memcpy( |
551 |
&(pcal_data->customer), |
552 |
&(pdev->customer), |
553 |
sizeof(VL53L1_customer_nvm_managed_t));
|
554 |
|
555 |
/* Overwrite Struct with xtalk config parameters */
|
556 |
/* - customer struct versions are not golden copy */
|
557 |
|
558 |
if (pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps > 0xFFFF) { |
559 |
pcal_data->customer.algo__crosstalk_compensation_plane_offset_kcps = |
560 |
0xFFFF;
|
561 |
} else {
|
562 |
pcal_data->customer.algo__crosstalk_compensation_plane_offset_kcps = |
563 |
(uint16_t)pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps; |
564 |
} |
565 |
pcal_data->customer.algo__crosstalk_compensation_x_plane_gradient_kcps = |
566 |
pdev->xtalk_cfg.algo__crosstalk_compensation_x_plane_gradient_kcps; |
567 |
pcal_data->customer.algo__crosstalk_compensation_y_plane_gradient_kcps = |
568 |
pdev->xtalk_cfg.algo__crosstalk_compensation_y_plane_gradient_kcps; |
569 |
|
570 |
/* memcpy(DEST, SRC, N) */
|
571 |
memcpy( |
572 |
&(pcal_data->add_off_cal_data), |
573 |
&(pdev->add_off_cal_data), |
574 |
sizeof(VL53L1_additional_offset_cal_data_t));
|
575 |
|
576 |
/* memcpy(DEST, SRC, N) */
|
577 |
memcpy( |
578 |
&(pcal_data->optical_centre), |
579 |
&(pdev->optical_centre), |
580 |
sizeof(VL53L1_optical_centre_t));
|
581 |
|
582 |
/* memcpy(DEST, SRC, N) */
|
583 |
memcpy( |
584 |
&(pcal_data->gain_cal), |
585 |
&(pdev->gain_cal), |
586 |
sizeof(VL53L1_gain_calibration_data_t));
|
587 |
|
588 |
/* memcpy(DEST, SRC, N) */
|
589 |
memcpy( |
590 |
&(pcal_data->cal_peak_rate_map), |
591 |
&(pdev->cal_peak_rate_map), |
592 |
sizeof(VL53L1_cal_peak_rate_map_t));
|
593 |
|
594 |
LOG_FUNCTION_END(status); |
595 |
|
596 |
return status;
|
597 |
} |
598 |
|
599 |
|
600 |
VL53L1_Error VL53L1_set_inter_measurement_period_ms( |
601 |
VL53L1_DEV Dev, |
602 |
uint32_t inter_measurement_period_ms) |
603 |
{ |
604 |
/**
|
605 |
* Convenience function for setting the inter measurement period
|
606 |
*/
|
607 |
|
608 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
609 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
610 |
|
611 |
LOG_FUNCTION_START("");
|
612 |
|
613 |
if (pdev->dbg_results.result__osc_calibrate_val == 0) |
614 |
status = VL53L1_ERROR_DIVISION_BY_ZERO; |
615 |
|
616 |
if (status == VL53L1_ERROR_NONE) {
|
617 |
pdev->inter_measurement_period_ms = inter_measurement_period_ms; |
618 |
pdev->tim_cfg.system__intermeasurement_period = \ |
619 |
inter_measurement_period_ms * |
620 |
(uint32_t)pdev->dbg_results.result__osc_calibrate_val; |
621 |
} |
622 |
|
623 |
LOG_FUNCTION_END(status); |
624 |
|
625 |
return status;
|
626 |
} |
627 |
|
628 |
|
629 |
VL53L1_Error VL53L1_get_inter_measurement_period_ms( |
630 |
VL53L1_DEV Dev, |
631 |
uint32_t *pinter_measurement_period_ms) |
632 |
{ |
633 |
/**
|
634 |
* Convenience function for getting the inter measurement period
|
635 |
*/
|
636 |
|
637 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
638 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
639 |
|
640 |
LOG_FUNCTION_START("");
|
641 |
|
642 |
if (pdev->dbg_results.result__osc_calibrate_val == 0) |
643 |
status = VL53L1_ERROR_DIVISION_BY_ZERO; |
644 |
|
645 |
if (status == VL53L1_ERROR_NONE)
|
646 |
*pinter_measurement_period_ms = \ |
647 |
pdev->tim_cfg.system__intermeasurement_period / |
648 |
(uint32_t)pdev->dbg_results.result__osc_calibrate_val; |
649 |
|
650 |
|
651 |
LOG_FUNCTION_END(status); |
652 |
|
653 |
return status;
|
654 |
} |
655 |
|
656 |
|
657 |
VL53L1_Error VL53L1_set_timeouts_us( |
658 |
VL53L1_DEV Dev, |
659 |
uint32_t phasecal_config_timeout_us, |
660 |
uint32_t mm_config_timeout_us, |
661 |
uint32_t range_config_timeout_us) |
662 |
{ |
663 |
/**
|
664 |
* Convenience function for setting the MM and range
|
665 |
* timeouts
|
666 |
*/
|
667 |
|
668 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
669 |
VL53L1_LLDriverData_t *pdev = |
670 |
VL53L1DevStructGetLLDriverHandle(Dev); |
671 |
|
672 |
LOG_FUNCTION_START("");
|
673 |
|
674 |
if (pdev->stat_nvm.osc_measured__fast_osc__frequency == 0) |
675 |
status = VL53L1_ERROR_DIVISION_BY_ZERO; |
676 |
|
677 |
if (status == VL53L1_ERROR_NONE) {
|
678 |
|
679 |
pdev->phasecal_config_timeout_us = phasecal_config_timeout_us; |
680 |
pdev->mm_config_timeout_us = mm_config_timeout_us; |
681 |
pdev->range_config_timeout_us = range_config_timeout_us; |
682 |
|
683 |
status = |
684 |
VL53L1_calc_timeout_register_values( |
685 |
phasecal_config_timeout_us, |
686 |
mm_config_timeout_us, |
687 |
range_config_timeout_us, |
688 |
pdev->stat_nvm.osc_measured__fast_osc__frequency, |
689 |
&(pdev->gen_cfg), |
690 |
&(pdev->tim_cfg)); |
691 |
} |
692 |
|
693 |
LOG_FUNCTION_END(status); |
694 |
|
695 |
return status;
|
696 |
} |
697 |
|
698 |
|
699 |
VL53L1_Error VL53L1_get_timeouts_us( |
700 |
VL53L1_DEV Dev, |
701 |
uint32_t *pphasecal_config_timeout_us, |
702 |
uint32_t *pmm_config_timeout_us, |
703 |
uint32_t *prange_config_timeout_us) |
704 |
{ |
705 |
/**
|
706 |
* Convenience function for getting the MM and range
|
707 |
* timeouts
|
708 |
*/
|
709 |
|
710 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
711 |
VL53L1_LLDriverData_t *pdev = |
712 |
VL53L1DevStructGetLLDriverHandle(Dev); |
713 |
|
714 |
uint32_t macro_period_us = 0;
|
715 |
uint16_t timeout_encoded = 0;
|
716 |
|
717 |
LOG_FUNCTION_START("");
|
718 |
|
719 |
if (pdev->stat_nvm.osc_measured__fast_osc__frequency == 0) |
720 |
status = VL53L1_ERROR_DIVISION_BY_ZERO; |
721 |
|
722 |
if (status == VL53L1_ERROR_NONE) {
|
723 |
|
724 |
/* Update Macro Period for Range A VCSEL Period */
|
725 |
macro_period_us = |
726 |
VL53L1_calc_macro_period_us( |
727 |
pdev->stat_nvm.osc_measured__fast_osc__frequency, |
728 |
pdev->tim_cfg.range_config__vcsel_period_a); |
729 |
|
730 |
/* Get Phase Cal Timing A timeout */
|
731 |
|
732 |
*pphasecal_config_timeout_us = |
733 |
VL53L1_calc_timeout_us( |
734 |
(uint32_t)pdev->gen_cfg.phasecal_config__timeout_macrop, |
735 |
macro_period_us); |
736 |
|
737 |
/* Get MM Timing A timeout */
|
738 |
|
739 |
timeout_encoded = |
740 |
(uint16_t)pdev->tim_cfg.mm_config__timeout_macrop_a_hi; |
741 |
timeout_encoded = (timeout_encoded << 8) +
|
742 |
(uint16_t)pdev->tim_cfg.mm_config__timeout_macrop_a_lo; |
743 |
|
744 |
*pmm_config_timeout_us = |
745 |
VL53L1_calc_decoded_timeout_us( |
746 |
timeout_encoded, |
747 |
macro_period_us); |
748 |
|
749 |
/* Get Range Timing A timeout */
|
750 |
|
751 |
timeout_encoded = |
752 |
(uint16_t)pdev->tim_cfg.range_config__timeout_macrop_a_hi; |
753 |
timeout_encoded = (timeout_encoded << 8) +
|
754 |
(uint16_t)pdev->tim_cfg.range_config__timeout_macrop_a_lo; |
755 |
|
756 |
*prange_config_timeout_us = |
757 |
VL53L1_calc_decoded_timeout_us( |
758 |
timeout_encoded, |
759 |
macro_period_us); |
760 |
|
761 |
pdev->phasecal_config_timeout_us = *pphasecal_config_timeout_us; |
762 |
pdev->mm_config_timeout_us = *pmm_config_timeout_us; |
763 |
pdev->range_config_timeout_us = *prange_config_timeout_us; |
764 |
|
765 |
} |
766 |
|
767 |
LOG_FUNCTION_END(status); |
768 |
|
769 |
return status;
|
770 |
} |
771 |
|
772 |
|
773 |
VL53L1_Error VL53L1_set_calibration_repeat_period( |
774 |
VL53L1_DEV Dev, |
775 |
uint16_t cal_config__repeat_period) |
776 |
{ |
777 |
/**
|
778 |
* Convenience function for setting calibration repeat period
|
779 |
*/
|
780 |
|
781 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
782 |
VL53L1_LLDriverData_t *pdev = |
783 |
VL53L1DevStructGetLLDriverHandle(Dev); |
784 |
|
785 |
pdev->gen_cfg.cal_config__repeat_rate = cal_config__repeat_period; |
786 |
|
787 |
return status;
|
788 |
|
789 |
} |
790 |
|
791 |
|
792 |
VL53L1_Error VL53L1_get_calibration_repeat_period( |
793 |
VL53L1_DEV Dev, |
794 |
uint16_t *pcal_config__repeat_period) |
795 |
{ |
796 |
/**
|
797 |
* Convenience function for getting calibration repeat period
|
798 |
*/
|
799 |
|
800 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
801 |
VL53L1_LLDriverData_t *pdev = |
802 |
VL53L1DevStructGetLLDriverHandle(Dev); |
803 |
|
804 |
*pcal_config__repeat_period = pdev->gen_cfg.cal_config__repeat_rate; |
805 |
|
806 |
return status;
|
807 |
|
808 |
} |
809 |
|
810 |
|
811 |
VL53L1_Error VL53L1_set_sequence_config_bit( |
812 |
VL53L1_DEV Dev, |
813 |
VL53L1_DeviceSequenceConfig bit_id, |
814 |
uint8_t value) |
815 |
{ |
816 |
/**
|
817 |
* Convenience function for setting sequence
|
818 |
* config enable bits
|
819 |
*/
|
820 |
|
821 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
822 |
VL53L1_LLDriverData_t *pdev = |
823 |
VL53L1DevStructGetLLDriverHandle(Dev); |
824 |
|
825 |
uint8_t bit_mask = 0x01;
|
826 |
uint8_t clr_mask = 0xFF - bit_mask;
|
827 |
uint8_t bit_value = value & bit_mask; |
828 |
|
829 |
if (bit_id <= VL53L1_DEVICESEQUENCECONFIG_RANGE) {
|
830 |
|
831 |
if (bit_id > 0) { |
832 |
bit_mask = 0x01 << bit_id;
|
833 |
bit_value = bit_value << bit_id; |
834 |
clr_mask = 0xFF - bit_mask;
|
835 |
} |
836 |
|
837 |
pdev->dyn_cfg.system__sequence_config = \ |
838 |
(pdev->dyn_cfg.system__sequence_config & clr_mask) | \ |
839 |
bit_value; |
840 |
|
841 |
} else {
|
842 |
status = VL53L1_ERROR_INVALID_PARAMS; |
843 |
} |
844 |
|
845 |
return status;
|
846 |
|
847 |
} |
848 |
|
849 |
|
850 |
VL53L1_Error VL53L1_get_sequence_config_bit( |
851 |
VL53L1_DEV Dev, |
852 |
VL53L1_DeviceSequenceConfig bit_id, |
853 |
uint8_t *pvalue) |
854 |
{ |
855 |
/**
|
856 |
* Convenience function for getting sequence
|
857 |
* config enable bits
|
858 |
*/
|
859 |
|
860 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
861 |
VL53L1_LLDriverData_t *pdev = |
862 |
VL53L1DevStructGetLLDriverHandle(Dev); |
863 |
|
864 |
uint8_t bit_mask = 0x01;
|
865 |
|
866 |
if (bit_id <= VL53L1_DEVICESEQUENCECONFIG_RANGE) {
|
867 |
|
868 |
if (bit_id > 0) { |
869 |
bit_mask = 0x01 << bit_id;
|
870 |
} |
871 |
|
872 |
*pvalue = |
873 |
pdev->dyn_cfg.system__sequence_config & bit_mask; |
874 |
|
875 |
if (bit_id > 0) { |
876 |
*pvalue = *pvalue >> bit_id; |
877 |
} |
878 |
|
879 |
} else {
|
880 |
status = VL53L1_ERROR_INVALID_PARAMS; |
881 |
} |
882 |
|
883 |
return status;
|
884 |
} |
885 |
|
886 |
|
887 |
VL53L1_Error VL53L1_set_interrupt_polarity( |
888 |
VL53L1_DEV Dev, |
889 |
VL53L1_DeviceInterruptPolarity interrupt_polarity) |
890 |
{ |
891 |
/**
|
892 |
* Convenience function for setting interrupt polarity
|
893 |
*/
|
894 |
|
895 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
896 |
VL53L1_LLDriverData_t *pdev = |
897 |
VL53L1DevStructGetLLDriverHandle(Dev); |
898 |
|
899 |
pdev->stat_cfg.gpio_hv_mux__ctrl = \ |
900 |
(pdev->stat_cfg.gpio_hv_mux__ctrl & \ |
901 |
VL53L1_DEVICEINTERRUPTPOLARITY_CLEAR_MASK) | \ |
902 |
(interrupt_polarity & \ |
903 |
VL53L1_DEVICEINTERRUPTPOLARITY_BIT_MASK); |
904 |
|
905 |
return status;
|
906 |
|
907 |
} |
908 |
|
909 |
|
910 |
#ifndef VL53L1_NOCALIB
|
911 |
VL53L1_Error VL53L1_set_refspadchar_config_struct( |
912 |
VL53L1_DEV Dev, |
913 |
VL53L1_refspadchar_config_t *pdata) |
914 |
{ |
915 |
/*
|
916 |
* Allows user config of Ref SPAD Char data structure
|
917 |
*/
|
918 |
|
919 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
920 |
VL53L1_LLDriverData_t *pdev = |
921 |
VL53L1DevStructGetLLDriverHandle(Dev); |
922 |
|
923 |
LOG_FUNCTION_START("");
|
924 |
|
925 |
pdev->refspadchar.device_test_mode = pdata->device_test_mode; |
926 |
pdev->refspadchar.vcsel_period = pdata->vcsel_period; |
927 |
pdev->refspadchar.timeout_us = pdata->timeout_us; |
928 |
pdev->refspadchar.target_count_rate_mcps = |
929 |
pdata->target_count_rate_mcps; |
930 |
pdev->refspadchar.min_count_rate_limit_mcps = |
931 |
pdata->min_count_rate_limit_mcps; |
932 |
pdev->refspadchar.max_count_rate_limit_mcps = |
933 |
pdata->max_count_rate_limit_mcps; |
934 |
|
935 |
LOG_FUNCTION_END(status); |
936 |
|
937 |
return status;
|
938 |
} |
939 |
#endif
|
940 |
|
941 |
#ifndef VL53L1_NOCALIB
|
942 |
VL53L1_Error VL53L1_get_refspadchar_config_struct( |
943 |
VL53L1_DEV Dev, |
944 |
VL53L1_refspadchar_config_t *pdata) |
945 |
{ |
946 |
/*
|
947 |
* Allows user config of Ref SPAD Char data structure
|
948 |
*/
|
949 |
|
950 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
951 |
VL53L1_LLDriverData_t *pdev = |
952 |
VL53L1DevStructGetLLDriverHandle(Dev); |
953 |
|
954 |
LOG_FUNCTION_START("");
|
955 |
|
956 |
pdata->device_test_mode = pdev->refspadchar.device_test_mode; |
957 |
pdata->vcsel_period = pdev->refspadchar.vcsel_period; |
958 |
pdata->timeout_us = pdev->refspadchar.timeout_us; |
959 |
pdata->target_count_rate_mcps = pdev->refspadchar.target_count_rate_mcps; |
960 |
pdata->min_count_rate_limit_mcps = |
961 |
pdev->refspadchar.min_count_rate_limit_mcps; |
962 |
pdata->max_count_rate_limit_mcps = |
963 |
pdev->refspadchar.max_count_rate_limit_mcps; |
964 |
|
965 |
LOG_FUNCTION_END(status); |
966 |
|
967 |
return status;
|
968 |
} |
969 |
#endif
|
970 |
|
971 |
|
972 |
VL53L1_Error VL53L1_set_range_ignore_threshold( |
973 |
VL53L1_DEV Dev, |
974 |
uint8_t range_ignore_thresh_mult, |
975 |
uint16_t range_ignore_threshold_mcps) |
976 |
{ |
977 |
/**
|
978 |
* Convenience function for setting Range Ignore Threshold
|
979 |
*/
|
980 |
|
981 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
982 |
VL53L1_LLDriverData_t *pdev = |
983 |
VL53L1DevStructGetLLDriverHandle(Dev); |
984 |
|
985 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_rate_mcps = |
986 |
range_ignore_threshold_mcps; |
987 |
|
988 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult = |
989 |
range_ignore_thresh_mult; |
990 |
|
991 |
return status;
|
992 |
|
993 |
} |
994 |
|
995 |
VL53L1_Error VL53L1_get_range_ignore_threshold( |
996 |
VL53L1_DEV Dev, |
997 |
uint8_t *prange_ignore_thresh_mult, |
998 |
uint16_t *prange_ignore_threshold_mcps_internal, |
999 |
uint16_t *prange_ignore_threshold_mcps_current) |
1000 |
{ |
1001 |
/**
|
1002 |
* Convenience function for retrieving Range Ignore Threshold
|
1003 |
* - Returns both the calculated internal value
|
1004 |
* - and the value currently applied to device reg settings
|
1005 |
*
|
1006 |
* Values both in fixed point 3.13 Mcps per spad
|
1007 |
*
|
1008 |
*/
|
1009 |
|
1010 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1011 |
VL53L1_LLDriverData_t *pdev = |
1012 |
VL53L1DevStructGetLLDriverHandle(Dev); |
1013 |
|
1014 |
*prange_ignore_thresh_mult = |
1015 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult; |
1016 |
|
1017 |
*prange_ignore_threshold_mcps_current = |
1018 |
pdev->stat_cfg.algo__range_ignore_threshold_mcps; |
1019 |
|
1020 |
*prange_ignore_threshold_mcps_internal = |
1021 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_rate_mcps; |
1022 |
|
1023 |
return status;
|
1024 |
|
1025 |
} |
1026 |
|
1027 |
|
1028 |
|
1029 |
VL53L1_Error VL53L1_get_interrupt_polarity( |
1030 |
VL53L1_DEV Dev, |
1031 |
VL53L1_DeviceInterruptPolarity *pinterrupt_polarity) |
1032 |
{ |
1033 |
/**
|
1034 |
* Convenience function for getting interrupt polarity
|
1035 |
*/
|
1036 |
|
1037 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1038 |
VL53L1_LLDriverData_t *pdev = |
1039 |
VL53L1DevStructGetLLDriverHandle(Dev); |
1040 |
|
1041 |
*pinterrupt_polarity = \ |
1042 |
pdev->stat_cfg.gpio_hv_mux__ctrl & \ |
1043 |
VL53L1_DEVICEINTERRUPTPOLARITY_BIT_MASK ; |
1044 |
|
1045 |
return status;
|
1046 |
|
1047 |
} |
1048 |
|
1049 |
|
1050 |
VL53L1_Error VL53L1_set_user_zone( |
1051 |
VL53L1_DEV Dev, |
1052 |
VL53L1_user_zone_t *puser_zone) |
1053 |
{ |
1054 |
/**
|
1055 |
* Convenience function for setting the user ROI
|
1056 |
*/
|
1057 |
|
1058 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1059 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1060 |
|
1061 |
LOG_FUNCTION_START("");
|
1062 |
|
1063 |
/* convert (row,col) location into a SPAD number */
|
1064 |
VL53L1_encode_row_col( |
1065 |
puser_zone->y_centre, |
1066 |
puser_zone->x_centre, |
1067 |
&(pdev->dyn_cfg.roi_config__user_roi_centre_spad)); |
1068 |
|
1069 |
/* merge x and y sizes */
|
1070 |
VL53L1_encode_zone_size( |
1071 |
puser_zone->width, |
1072 |
puser_zone->height, |
1073 |
&(pdev->dyn_cfg.roi_config__user_roi_requested_global_xy_size)); |
1074 |
|
1075 |
/* need to add checks to ensure ROI is within array */
|
1076 |
|
1077 |
LOG_FUNCTION_END(status); |
1078 |
|
1079 |
return status;
|
1080 |
} |
1081 |
|
1082 |
|
1083 |
VL53L1_Error VL53L1_get_user_zone( |
1084 |
VL53L1_DEV Dev, |
1085 |
VL53L1_user_zone_t *puser_zone) |
1086 |
{ |
1087 |
/**
|
1088 |
* Convenience function for getting the user ROI
|
1089 |
*/
|
1090 |
|
1091 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1092 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1093 |
|
1094 |
LOG_FUNCTION_START("");
|
1095 |
|
1096 |
/* convert SPAD number into (row,col) location*/
|
1097 |
VL53L1_decode_row_col( |
1098 |
pdev->dyn_cfg.roi_config__user_roi_centre_spad, |
1099 |
&(puser_zone->y_centre), |
1100 |
&(puser_zone->x_centre)); |
1101 |
|
1102 |
/* extract x and y sizes */
|
1103 |
VL53L1_decode_zone_size( |
1104 |
pdev->dyn_cfg.roi_config__user_roi_requested_global_xy_size, |
1105 |
&(puser_zone->width), |
1106 |
&(puser_zone->height)); |
1107 |
|
1108 |
LOG_FUNCTION_END(status); |
1109 |
|
1110 |
return status;
|
1111 |
} |
1112 |
|
1113 |
|
1114 |
|
1115 |
VL53L1_Error VL53L1_get_mode_mitigation_roi( |
1116 |
VL53L1_DEV Dev, |
1117 |
VL53L1_user_zone_t *pmm_roi) |
1118 |
{ |
1119 |
/**
|
1120 |
* Convenience function for getting the mode mitigation ROI
|
1121 |
*/
|
1122 |
|
1123 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1124 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1125 |
|
1126 |
uint8_t x = 0;
|
1127 |
uint8_t y = 0;
|
1128 |
uint8_t xy_size = 0;
|
1129 |
|
1130 |
LOG_FUNCTION_START("");
|
1131 |
|
1132 |
/* convert SPAD number into (row,col) location */
|
1133 |
VL53L1_decode_row_col( |
1134 |
pdev->nvm_copy_data.roi_config__mode_roi_centre_spad, |
1135 |
&y, |
1136 |
&x); |
1137 |
|
1138 |
pmm_roi->x_centre = x; |
1139 |
pmm_roi->y_centre = y; |
1140 |
|
1141 |
/* extract x and y sizes
|
1142 |
*
|
1143 |
* Important: the sense of the device width and height is swapped
|
1144 |
* versus the API sense
|
1145 |
*
|
1146 |
* MS Nibble = height
|
1147 |
* LS Nibble = width
|
1148 |
*/
|
1149 |
xy_size = pdev->nvm_copy_data.roi_config__mode_roi_xy_size; |
1150 |
|
1151 |
pmm_roi->height = xy_size >> 4;
|
1152 |
pmm_roi->width = xy_size & 0x0F;
|
1153 |
|
1154 |
LOG_FUNCTION_END(status); |
1155 |
|
1156 |
return status;
|
1157 |
} |
1158 |
|
1159 |
VL53L1_Error VL53L1_get_preset_mode_timing_cfg( |
1160 |
VL53L1_DEV Dev, |
1161 |
VL53L1_DevicePresetModes device_preset_mode, |
1162 |
uint16_t *pdss_config__target_total_rate_mcps, |
1163 |
uint32_t *pphasecal_config_timeout_us, |
1164 |
uint32_t *pmm_config_timeout_us, |
1165 |
uint32_t *prange_config_timeout_us) |
1166 |
{ |
1167 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1168 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1169 |
|
1170 |
LOG_FUNCTION_START("");
|
1171 |
|
1172 |
|
1173 |
switch (device_preset_mode) {
|
1174 |
|
1175 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING:
|
1176 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_SHORT_RANGE:
|
1177 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_LONG_RANGE:
|
1178 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_MM1_CAL:
|
1179 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_MM2_CAL:
|
1180 |
case VL53L1_DEVICEPRESETMODE_OLT:
|
1181 |
*pdss_config__target_total_rate_mcps = |
1182 |
pdev->tuning_parms.tp_dss_target_lite_mcps; |
1183 |
*pphasecal_config_timeout_us = |
1184 |
pdev->tuning_parms.tp_phasecal_timeout_lite_us; |
1185 |
*pmm_config_timeout_us = |
1186 |
pdev->tuning_parms.tp_mm_timeout_lite_us; |
1187 |
*prange_config_timeout_us = |
1188 |
pdev->tuning_parms.tp_range_timeout_lite_us; |
1189 |
break;
|
1190 |
|
1191 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING:
|
1192 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING_SHORT_RANGE:
|
1193 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING_LONG_RANGE:
|
1194 |
case VL53L1_DEVICEPRESETMODE_SINGLESHOT_RANGING:
|
1195 |
*pdss_config__target_total_rate_mcps = |
1196 |
pdev->tuning_parms.tp_dss_target_timed_mcps; |
1197 |
*pphasecal_config_timeout_us = |
1198 |
pdev->tuning_parms.tp_phasecal_timeout_timed_us; |
1199 |
*pmm_config_timeout_us = |
1200 |
pdev->tuning_parms.tp_mm_timeout_timed_us; |
1201 |
*prange_config_timeout_us = |
1202 |
pdev->tuning_parms.tp_range_timeout_timed_us; |
1203 |
break;
|
1204 |
|
1205 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_SHORT_RANGE:
|
1206 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_MEDIUM_RANGE:
|
1207 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_LONG_RANGE:
|
1208 |
*pdss_config__target_total_rate_mcps = |
1209 |
pdev->tuning_parms.tp_dss_target_timed_mcps; |
1210 |
*pphasecal_config_timeout_us = |
1211 |
pdev->tuning_parms.tp_phasecal_timeout_timed_us; |
1212 |
*pmm_config_timeout_us = |
1213 |
pdev->tuning_parms.tp_mm_timeout_lpa_us; |
1214 |
*prange_config_timeout_us = |
1215 |
pdev->tuning_parms.tp_range_timeout_lpa_us; |
1216 |
break;
|
1217 |
|
1218 |
default:
|
1219 |
status = VL53L1_ERROR_INVALID_PARAMS; |
1220 |
break;
|
1221 |
|
1222 |
} |
1223 |
|
1224 |
LOG_FUNCTION_END(status); |
1225 |
|
1226 |
return status;
|
1227 |
} |
1228 |
|
1229 |
|
1230 |
VL53L1_Error VL53L1_set_preset_mode( |
1231 |
VL53L1_DEV Dev, |
1232 |
VL53L1_DevicePresetModes device_preset_mode, |
1233 |
uint16_t dss_config__target_total_rate_mcps, |
1234 |
uint32_t phasecal_config_timeout_us, |
1235 |
uint32_t mm_config_timeout_us, |
1236 |
uint32_t range_config_timeout_us, |
1237 |
uint32_t inter_measurement_period_ms) |
1238 |
{ |
1239 |
/**
|
1240 |
* Initializes static and dynamic data structures for
|
1241 |
* the provided preset mode
|
1242 |
*/
|
1243 |
|
1244 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1245 |
VL53L1_LLDriverData_t *pdev = |
1246 |
VL53L1DevStructGetLLDriverHandle(Dev); |
1247 |
|
1248 |
VL53L1_static_config_t *pstatic = &(pdev->stat_cfg); |
1249 |
VL53L1_general_config_t *pgeneral = &(pdev->gen_cfg); |
1250 |
VL53L1_timing_config_t *ptiming = &(pdev->tim_cfg); |
1251 |
VL53L1_dynamic_config_t *pdynamic = &(pdev->dyn_cfg); |
1252 |
VL53L1_system_control_t *psystem = &(pdev->sys_ctrl); |
1253 |
VL53L1_tuning_parm_storage_t *ptuning_parms = &(pdev->tuning_parms); |
1254 |
VL53L1_low_power_auto_data_t *plpadata = |
1255 |
&(pdev->low_power_auto_data); |
1256 |
|
1257 |
LOG_FUNCTION_START("");
|
1258 |
|
1259 |
/* save input settings */
|
1260 |
pdev->preset_mode = device_preset_mode; |
1261 |
pdev->mm_config_timeout_us = mm_config_timeout_us; |
1262 |
pdev->range_config_timeout_us = range_config_timeout_us; |
1263 |
pdev->inter_measurement_period_ms = inter_measurement_period_ms; |
1264 |
|
1265 |
/* Reset LL Driver state variables */
|
1266 |
|
1267 |
VL53L1_init_ll_driver_state( |
1268 |
Dev, |
1269 |
VL53L1_DEVICESTATE_SW_STANDBY); |
1270 |
|
1271 |
/* apply selected preset */
|
1272 |
|
1273 |
switch (device_preset_mode) {
|
1274 |
|
1275 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING:
|
1276 |
status = VL53L1_preset_mode_standard_ranging( |
1277 |
pstatic, |
1278 |
pgeneral, |
1279 |
ptiming, |
1280 |
pdynamic, |
1281 |
psystem, |
1282 |
ptuning_parms); |
1283 |
break;
|
1284 |
|
1285 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_SHORT_RANGE:
|
1286 |
status = VL53L1_preset_mode_standard_ranging_short_range( |
1287 |
pstatic, |
1288 |
pgeneral, |
1289 |
ptiming, |
1290 |
pdynamic, |
1291 |
psystem, |
1292 |
ptuning_parms); |
1293 |
break;
|
1294 |
|
1295 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_LONG_RANGE:
|
1296 |
status = VL53L1_preset_mode_standard_ranging_long_range( |
1297 |
pstatic, |
1298 |
pgeneral, |
1299 |
ptiming, |
1300 |
pdynamic, |
1301 |
psystem, |
1302 |
ptuning_parms); |
1303 |
break;
|
1304 |
|
1305 |
#ifndef VL53L1_NOCALIB
|
1306 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_MM1_CAL:
|
1307 |
status = VL53L1_preset_mode_standard_ranging_mm1_cal( |
1308 |
pstatic, |
1309 |
pgeneral, |
1310 |
ptiming, |
1311 |
pdynamic, |
1312 |
psystem, |
1313 |
ptuning_parms); |
1314 |
break;
|
1315 |
|
1316 |
case VL53L1_DEVICEPRESETMODE_STANDARD_RANGING_MM2_CAL:
|
1317 |
status = VL53L1_preset_mode_standard_ranging_mm2_cal( |
1318 |
pstatic, |
1319 |
pgeneral, |
1320 |
ptiming, |
1321 |
pdynamic, |
1322 |
psystem, |
1323 |
ptuning_parms); |
1324 |
break;
|
1325 |
#endif
|
1326 |
|
1327 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING:
|
1328 |
status = VL53L1_preset_mode_timed_ranging( |
1329 |
pstatic, |
1330 |
pgeneral, |
1331 |
ptiming, |
1332 |
pdynamic, |
1333 |
psystem, |
1334 |
ptuning_parms); |
1335 |
break;
|
1336 |
|
1337 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING_SHORT_RANGE:
|
1338 |
status = VL53L1_preset_mode_timed_ranging_short_range( |
1339 |
pstatic, |
1340 |
pgeneral, |
1341 |
ptiming, |
1342 |
pdynamic, |
1343 |
psystem, |
1344 |
ptuning_parms); |
1345 |
break;
|
1346 |
|
1347 |
case VL53L1_DEVICEPRESETMODE_TIMED_RANGING_LONG_RANGE:
|
1348 |
status = VL53L1_preset_mode_timed_ranging_long_range( |
1349 |
pstatic, |
1350 |
pgeneral, |
1351 |
ptiming, |
1352 |
pdynamic, |
1353 |
psystem, |
1354 |
ptuning_parms); |
1355 |
break;
|
1356 |
|
1357 |
case VL53L1_DEVICEPRESETMODE_OLT:
|
1358 |
status = VL53L1_preset_mode_olt( |
1359 |
pstatic, |
1360 |
pgeneral, |
1361 |
ptiming, |
1362 |
pdynamic, |
1363 |
psystem, |
1364 |
ptuning_parms); |
1365 |
break;
|
1366 |
|
1367 |
case VL53L1_DEVICEPRESETMODE_SINGLESHOT_RANGING:
|
1368 |
status = VL53L1_preset_mode_singleshot_ranging( |
1369 |
pstatic, |
1370 |
pgeneral, |
1371 |
ptiming, |
1372 |
pdynamic, |
1373 |
psystem, |
1374 |
ptuning_parms); |
1375 |
break;
|
1376 |
|
1377 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_SHORT_RANGE:
|
1378 |
status = VL53L1_preset_mode_low_power_auto_short_ranging( |
1379 |
pstatic, |
1380 |
pgeneral, |
1381 |
ptiming, |
1382 |
pdynamic, |
1383 |
psystem, |
1384 |
ptuning_parms, |
1385 |
plpadata); |
1386 |
break;
|
1387 |
|
1388 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_MEDIUM_RANGE:
|
1389 |
status = VL53L1_preset_mode_low_power_auto_ranging( |
1390 |
pstatic, |
1391 |
pgeneral, |
1392 |
ptiming, |
1393 |
pdynamic, |
1394 |
psystem, |
1395 |
ptuning_parms, |
1396 |
plpadata); |
1397 |
break;
|
1398 |
|
1399 |
case VL53L1_DEVICEPRESETMODE_LOWPOWERAUTO_LONG_RANGE:
|
1400 |
status = VL53L1_preset_mode_low_power_auto_long_ranging( |
1401 |
pstatic, |
1402 |
pgeneral, |
1403 |
ptiming, |
1404 |
pdynamic, |
1405 |
psystem, |
1406 |
ptuning_parms, |
1407 |
plpadata); |
1408 |
break;
|
1409 |
|
1410 |
default:
|
1411 |
status = VL53L1_ERROR_INVALID_PARAMS; |
1412 |
break;
|
1413 |
|
1414 |
} |
1415 |
|
1416 |
/* update DSS target */
|
1417 |
|
1418 |
if (status == VL53L1_ERROR_NONE) {
|
1419 |
|
1420 |
pstatic->dss_config__target_total_rate_mcps = |
1421 |
dss_config__target_total_rate_mcps; |
1422 |
pdev->dss_config__target_total_rate_mcps = |
1423 |
dss_config__target_total_rate_mcps; |
1424 |
|
1425 |
} |
1426 |
|
1427 |
/*
|
1428 |
* Update the register timeout values based on input
|
1429 |
* real time values and preset mode VCSEL periods
|
1430 |
*/
|
1431 |
|
1432 |
if (status == VL53L1_ERROR_NONE)
|
1433 |
status = |
1434 |
VL53L1_set_timeouts_us( |
1435 |
Dev, |
1436 |
phasecal_config_timeout_us, |
1437 |
mm_config_timeout_us, |
1438 |
range_config_timeout_us); |
1439 |
|
1440 |
if (status == VL53L1_ERROR_NONE)
|
1441 |
status = |
1442 |
VL53L1_set_inter_measurement_period_ms( |
1443 |
Dev, |
1444 |
inter_measurement_period_ms); |
1445 |
|
1446 |
LOG_FUNCTION_END(status); |
1447 |
|
1448 |
return status;
|
1449 |
} |
1450 |
|
1451 |
|
1452 |
VL53L1_Error VL53L1_enable_xtalk_compensation( |
1453 |
VL53L1_DEV Dev) |
1454 |
{ |
1455 |
/**
|
1456 |
* Currently a very simple function to copy
|
1457 |
* private xtalk parms into customer section and apply to device
|
1458 |
*
|
1459 |
*/
|
1460 |
|
1461 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1462 |
uint32_t tempu32; |
1463 |
|
1464 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1465 |
|
1466 |
LOG_FUNCTION_START("");
|
1467 |
|
1468 |
/* Fill Public customer NVM data with Xtalk parms */
|
1469 |
tempu32 = VL53L1_calc_crosstalk_plane_offset_with_margin( |
1470 |
pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps, |
1471 |
pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps); |
1472 |
if (tempu32 > 0xFFFF) { |
1473 |
tempu32 = 0xFFFF;
|
1474 |
} |
1475 |
pdev->customer.algo__crosstalk_compensation_plane_offset_kcps = |
1476 |
(uint16_t)tempu32; |
1477 |
|
1478 |
pdev->customer.algo__crosstalk_compensation_x_plane_gradient_kcps = |
1479 |
pdev->xtalk_cfg.algo__crosstalk_compensation_x_plane_gradient_kcps; |
1480 |
|
1481 |
pdev->customer.algo__crosstalk_compensation_y_plane_gradient_kcps = |
1482 |
pdev->xtalk_cfg.algo__crosstalk_compensation_y_plane_gradient_kcps; |
1483 |
|
1484 |
/* Enable Xtalk compensation */
|
1485 |
pdev->xtalk_cfg.global_crosstalk_compensation_enable = 0x01;
|
1486 |
|
1487 |
/* Update Range Ignore Threshold Xtalk Parameter */
|
1488 |
|
1489 |
if (status == VL53L1_ERROR_NONE) {
|
1490 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_rate_mcps = |
1491 |
VL53L1_calc_range_ignore_threshold( |
1492 |
pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps, |
1493 |
pdev->xtalk_cfg.algo__crosstalk_compensation_x_plane_gradient_kcps, |
1494 |
pdev->xtalk_cfg.algo__crosstalk_compensation_y_plane_gradient_kcps, |
1495 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult); |
1496 |
} |
1497 |
|
1498 |
/* Apply to device */
|
1499 |
|
1500 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
1501 |
status = |
1502 |
VL53L1_set_customer_nvm_managed( |
1503 |
Dev, |
1504 |
&(pdev->customer)); |
1505 |
|
1506 |
LOG_FUNCTION_END(status); |
1507 |
|
1508 |
return status;
|
1509 |
|
1510 |
} |
1511 |
|
1512 |
void VL53L1_get_xtalk_compensation_enable(
|
1513 |
VL53L1_DEV Dev, |
1514 |
uint8_t *pcrosstalk_compensation_enable) |
1515 |
{ |
1516 |
/**
|
1517 |
* Currently a very simple function to return
|
1518 |
*
|
1519 |
* - this flags whether xtalk compensation is enabled for all modes
|
1520 |
* or not.
|
1521 |
*
|
1522 |
* #1 - Enabled
|
1523 |
* #0 - Disabled
|
1524 |
*
|
1525 |
*/
|
1526 |
|
1527 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1528 |
|
1529 |
LOG_FUNCTION_START("");
|
1530 |
|
1531 |
/* Extract Xtalk Compensation Enable Status*/
|
1532 |
|
1533 |
*pcrosstalk_compensation_enable = |
1534 |
pdev->xtalk_cfg.global_crosstalk_compensation_enable; |
1535 |
|
1536 |
} |
1537 |
|
1538 |
|
1539 |
VL53L1_Error VL53L1_get_lite_xtalk_margin_kcps( |
1540 |
VL53L1_DEV Dev, |
1541 |
int16_t *pxtalk_margin) |
1542 |
{ |
1543 |
|
1544 |
/*
|
1545 |
* Gets the Xtalk Margin Factor in Kcps (fixed point 9.7)
|
1546 |
*/
|
1547 |
|
1548 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1549 |
|
1550 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1551 |
|
1552 |
LOG_FUNCTION_START("");
|
1553 |
|
1554 |
*pxtalk_margin = pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps; |
1555 |
|
1556 |
LOG_FUNCTION_END(status); |
1557 |
|
1558 |
return status;
|
1559 |
|
1560 |
} |
1561 |
|
1562 |
VL53L1_Error VL53L1_set_lite_xtalk_margin_kcps( |
1563 |
VL53L1_DEV Dev, |
1564 |
int16_t xtalk_margin) |
1565 |
{ |
1566 |
|
1567 |
/*
|
1568 |
* Sets the offset calibration mode
|
1569 |
*/
|
1570 |
|
1571 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1572 |
|
1573 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1574 |
|
1575 |
LOG_FUNCTION_START("");
|
1576 |
|
1577 |
pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps = xtalk_margin; |
1578 |
|
1579 |
LOG_FUNCTION_END(status); |
1580 |
|
1581 |
return status;
|
1582 |
} |
1583 |
|
1584 |
|
1585 |
VL53L1_Error VL53L1_restore_xtalk_nvm_default( |
1586 |
VL53L1_DEV Dev) |
1587 |
{ |
1588 |
|
1589 |
/*
|
1590 |
* Returns xtalk rate values to defaults as extracted from device NVM
|
1591 |
*/
|
1592 |
|
1593 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1594 |
|
1595 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1596 |
|
1597 |
LOG_FUNCTION_START("");
|
1598 |
|
1599 |
pdev->xtalk_cfg.algo__crosstalk_compensation_plane_offset_kcps = |
1600 |
pdev->xtalk_cfg.nvm_default__crosstalk_compensation_plane_offset_kcps; |
1601 |
pdev->xtalk_cfg.algo__crosstalk_compensation_x_plane_gradient_kcps = |
1602 |
pdev->xtalk_cfg.nvm_default__crosstalk_compensation_x_plane_gradient_kcps; |
1603 |
pdev->xtalk_cfg.algo__crosstalk_compensation_y_plane_gradient_kcps = |
1604 |
pdev->xtalk_cfg.nvm_default__crosstalk_compensation_y_plane_gradient_kcps; |
1605 |
|
1606 |
LOG_FUNCTION_END(status); |
1607 |
|
1608 |
return status;
|
1609 |
} |
1610 |
|
1611 |
VL53L1_Error VL53L1_disable_xtalk_compensation( |
1612 |
VL53L1_DEV Dev) |
1613 |
{ |
1614 |
/**
|
1615 |
* Currently a very simple function to clear
|
1616 |
* customer xtalk parms and apply to device
|
1617 |
*
|
1618 |
*/
|
1619 |
|
1620 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1621 |
|
1622 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1623 |
|
1624 |
LOG_FUNCTION_START("");
|
1625 |
|
1626 |
/* Fill Public customer NVM data with Xtalk parms */
|
1627 |
pdev->customer.algo__crosstalk_compensation_plane_offset_kcps = |
1628 |
0x00;
|
1629 |
|
1630 |
pdev->customer.algo__crosstalk_compensation_x_plane_gradient_kcps = |
1631 |
0x00;
|
1632 |
|
1633 |
pdev->customer.algo__crosstalk_compensation_y_plane_gradient_kcps = |
1634 |
0x00;
|
1635 |
|
1636 |
|
1637 |
/* Disable Global Xtalk comnpensation */
|
1638 |
pdev->xtalk_cfg.global_crosstalk_compensation_enable = 0x00;
|
1639 |
|
1640 |
/* Update Range Ignore Threshold Xtalk Parameter */
|
1641 |
|
1642 |
if (status == VL53L1_ERROR_NONE) {
|
1643 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_rate_mcps = |
1644 |
0x0000;
|
1645 |
} |
1646 |
|
1647 |
/* Apply to device */
|
1648 |
|
1649 |
if (status == VL53L1_ERROR_NONE) { /*lint !e774 always true*/ |
1650 |
status = |
1651 |
VL53L1_set_customer_nvm_managed( |
1652 |
Dev, |
1653 |
&(pdev->customer)); |
1654 |
} |
1655 |
LOG_FUNCTION_END(status); |
1656 |
|
1657 |
return status;
|
1658 |
|
1659 |
} |
1660 |
|
1661 |
VL53L1_Error VL53L1_get_lite_sigma_threshold( |
1662 |
VL53L1_DEV Dev, |
1663 |
uint16_t *plite_sigma) |
1664 |
{ |
1665 |
|
1666 |
/*
|
1667 |
* Gets the Sigma Threshold value for Lite Mode
|
1668 |
*
|
1669 |
* (fixed point 14.2)
|
1670 |
*/
|
1671 |
|
1672 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1673 |
|
1674 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1675 |
|
1676 |
LOG_FUNCTION_START("");
|
1677 |
|
1678 |
*plite_sigma = |
1679 |
pdev->tim_cfg.range_config__sigma_thresh; |
1680 |
|
1681 |
LOG_FUNCTION_END(status); |
1682 |
|
1683 |
return status;
|
1684 |
|
1685 |
} |
1686 |
|
1687 |
VL53L1_Error VL53L1_set_lite_sigma_threshold( |
1688 |
VL53L1_DEV Dev, |
1689 |
uint16_t lite_sigma) |
1690 |
{ |
1691 |
|
1692 |
/*
|
1693 |
* Sets the Sigma threshold value for Lite mode
|
1694 |
*
|
1695 |
* (fixed point 14.2)
|
1696 |
*/
|
1697 |
|
1698 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1699 |
|
1700 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1701 |
|
1702 |
LOG_FUNCTION_START("");
|
1703 |
|
1704 |
pdev->tim_cfg.range_config__sigma_thresh = lite_sigma; |
1705 |
|
1706 |
LOG_FUNCTION_END(status); |
1707 |
|
1708 |
return status;
|
1709 |
|
1710 |
} |
1711 |
|
1712 |
VL53L1_Error VL53L1_get_lite_min_count_rate( |
1713 |
VL53L1_DEV Dev, |
1714 |
uint16_t *plite_mincountrate) |
1715 |
{ |
1716 |
|
1717 |
/*
|
1718 |
* Gets the Min Count Rate value for Lite Mode
|
1719 |
*
|
1720 |
* (fixed point 9.7 Mcps)
|
1721 |
*/
|
1722 |
|
1723 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1724 |
|
1725 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1726 |
|
1727 |
LOG_FUNCTION_START("");
|
1728 |
|
1729 |
*plite_mincountrate = |
1730 |
pdev->tim_cfg.range_config__min_count_rate_rtn_limit_mcps; |
1731 |
|
1732 |
LOG_FUNCTION_END(status); |
1733 |
|
1734 |
return status;
|
1735 |
|
1736 |
} |
1737 |
|
1738 |
VL53L1_Error VL53L1_set_lite_min_count_rate( |
1739 |
VL53L1_DEV Dev, |
1740 |
uint16_t lite_mincountrate) |
1741 |
{ |
1742 |
|
1743 |
/*
|
1744 |
* Sets the Min COunt Rate value for Lite mode
|
1745 |
*
|
1746 |
* (fixed point 19.7Mcps)
|
1747 |
*/
|
1748 |
|
1749 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1750 |
|
1751 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1752 |
|
1753 |
LOG_FUNCTION_START("");
|
1754 |
|
1755 |
pdev->tim_cfg.range_config__min_count_rate_rtn_limit_mcps = |
1756 |
lite_mincountrate; |
1757 |
|
1758 |
LOG_FUNCTION_END(status); |
1759 |
|
1760 |
return status;
|
1761 |
|
1762 |
} |
1763 |
|
1764 |
VL53L1_Error VL53L1_get_vhv_loopbound( |
1765 |
VL53L1_DEV Dev, |
1766 |
uint8_t *pvhv_loopbound) |
1767 |
{ |
1768 |
|
1769 |
/*
|
1770 |
* Gets the VHV Loop bound parm
|
1771 |
* - extracts only bits 7:2 from internal stat nvm parm
|
1772 |
*/
|
1773 |
|
1774 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1775 |
|
1776 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1777 |
|
1778 |
LOG_FUNCTION_START("");
|
1779 |
|
1780 |
*pvhv_loopbound = pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound / 4 ;
|
1781 |
|
1782 |
LOG_FUNCTION_END(status); |
1783 |
|
1784 |
return status;
|
1785 |
|
1786 |
} |
1787 |
|
1788 |
|
1789 |
|
1790 |
VL53L1_Error VL53L1_set_vhv_loopbound( |
1791 |
VL53L1_DEV Dev, |
1792 |
uint8_t vhv_loopbound) |
1793 |
{ |
1794 |
|
1795 |
/*
|
1796 |
* Sets the VHV Loop bound parm
|
1797 |
* - sets only bits 7:2
|
1798 |
* - bits 1:0 remain unchanged
|
1799 |
* - ensure that any change here is followed by a
|
1800 |
* init_and_start_range with full i2c packet
|
1801 |
* configuration.
|
1802 |
*/
|
1803 |
|
1804 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1805 |
|
1806 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1807 |
|
1808 |
LOG_FUNCTION_START("");
|
1809 |
|
1810 |
pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound = |
1811 |
(pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound & 0x03) +
|
1812 |
(vhv_loopbound * 4);
|
1813 |
|
1814 |
LOG_FUNCTION_END(status); |
1815 |
|
1816 |
return status;
|
1817 |
|
1818 |
} |
1819 |
|
1820 |
|
1821 |
|
1822 |
VL53L1_Error VL53L1_get_vhv_config( |
1823 |
VL53L1_DEV Dev, |
1824 |
uint8_t *pvhv_init_en, |
1825 |
uint8_t *pvhv_init_value) |
1826 |
{ |
1827 |
|
1828 |
/*
|
1829 |
* Gets the VHV config init data
|
1830 |
*/
|
1831 |
|
1832 |
/*!<
|
1833 |
info: \n
|
1834 |
- msb = 7
|
1835 |
- lsb = 0
|
1836 |
- i2c_size = 1
|
1837 |
|
1838 |
fields: \n
|
1839 |
- [7] = vhv0_init_enable
|
1840 |
- [5:0] = vhv0_init_value
|
1841 |
*/
|
1842 |
|
1843 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1844 |
|
1845 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1846 |
|
1847 |
LOG_FUNCTION_START("");
|
1848 |
|
1849 |
*pvhv_init_en = (pdev->stat_nvm.vhv_config__init & 0x80) >> 7; |
1850 |
*pvhv_init_value = |
1851 |
(pdev->stat_nvm.vhv_config__init & 0x7F);
|
1852 |
|
1853 |
LOG_FUNCTION_END(status); |
1854 |
|
1855 |
return status;
|
1856 |
|
1857 |
} |
1858 |
|
1859 |
|
1860 |
|
1861 |
VL53L1_Error VL53L1_set_vhv_config( |
1862 |
VL53L1_DEV Dev, |
1863 |
uint8_t vhv_init_en, |
1864 |
uint8_t vhv_init_value) |
1865 |
{ |
1866 |
|
1867 |
/*
|
1868 |
* Sets the VHV Config init
|
1869 |
*/
|
1870 |
|
1871 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1872 |
|
1873 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1874 |
|
1875 |
LOG_FUNCTION_START("");
|
1876 |
|
1877 |
pdev->stat_nvm.vhv_config__init = |
1878 |
((vhv_init_en & 0x01) << 7) + |
1879 |
(vhv_init_value & 0x7F);
|
1880 |
|
1881 |
LOG_FUNCTION_END(status); |
1882 |
|
1883 |
return status;
|
1884 |
|
1885 |
} |
1886 |
|
1887 |
|
1888 |
|
1889 |
VL53L1_Error VL53L1_init_and_start_range( |
1890 |
VL53L1_DEV Dev, |
1891 |
uint8_t measurement_mode, |
1892 |
VL53L1_DeviceConfigLevel device_config_level) |
1893 |
{ |
1894 |
/*
|
1895 |
* Builds and sends a single I2C multiple byte transaction to
|
1896 |
* initialize the device and start a range measurement.
|
1897 |
*
|
1898 |
* The level of initialization is controlled by the
|
1899 |
* device_config_level input parameter
|
1900 |
*
|
1901 |
* system_control is always sent as the last byte of this
|
1902 |
* register group (mode_start) either triggers the range
|
1903 |
* or enables the next range
|
1904 |
*/
|
1905 |
|
1906 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
1907 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
1908 |
|
1909 |
uint8_t buffer[VL53L1_MAX_I2C_XFER_SIZE]; |
1910 |
|
1911 |
VL53L1_static_nvm_managed_t *pstatic_nvm = &(pdev->stat_nvm); |
1912 |
VL53L1_customer_nvm_managed_t *pcustomer_nvm = &(pdev->customer); |
1913 |
VL53L1_static_config_t *pstatic = &(pdev->stat_cfg); |
1914 |
VL53L1_general_config_t *pgeneral = &(pdev->gen_cfg); |
1915 |
VL53L1_timing_config_t *ptiming = &(pdev->tim_cfg); |
1916 |
VL53L1_dynamic_config_t *pdynamic = &(pdev->dyn_cfg); |
1917 |
VL53L1_system_control_t *psystem = &(pdev->sys_ctrl); |
1918 |
|
1919 |
VL53L1_ll_driver_state_t *pstate = &(pdev->ll_state); |
1920 |
|
1921 |
uint8_t *pbuffer = &buffer[0];
|
1922 |
uint16_t i = 0;
|
1923 |
uint16_t i2c_index = 0;
|
1924 |
uint16_t i2c_buffer_offset_bytes = 0;
|
1925 |
uint16_t i2c_buffer_size_bytes = 0;
|
1926 |
|
1927 |
LOG_FUNCTION_START("");
|
1928 |
|
1929 |
/* save measurement mode */
|
1930 |
pdev->measurement_mode = measurement_mode; |
1931 |
|
1932 |
/* Merge measurement mode with mode_start */
|
1933 |
|
1934 |
psystem->system__mode_start = |
1935 |
(psystem->system__mode_start & |
1936 |
VL53L1_DEVICEMEASUREMENTMODE_STOP_MASK) | |
1937 |
measurement_mode; |
1938 |
|
1939 |
/* copy in rit from xtalk config */
|
1940 |
|
1941 |
pdev->stat_cfg.algo__range_ignore_threshold_mcps = |
1942 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_rate_mcps; |
1943 |
|
1944 |
/* Start Patch_LowPowerAutoMode */
|
1945 |
|
1946 |
/* doing this ensures stop_range followed by a get_device_results does
|
1947 |
* not mess up the counters */
|
1948 |
|
1949 |
if (pdev->low_power_auto_data.low_power_auto_range_count == 0xFF) { |
1950 |
pdev->low_power_auto_data.low_power_auto_range_count = 0x0;
|
1951 |
} |
1952 |
|
1953 |
/* For Presence. Override threshold config */
|
1954 |
if ((pdev->low_power_auto_data.is_low_power_auto_mode == 1) && |
1955 |
(pdev->low_power_auto_data.low_power_auto_range_count == 0)) {
|
1956 |
/* save interrupt config */
|
1957 |
pdev->low_power_auto_data.saved_interrupt_config = |
1958 |
pdev->gen_cfg.system__interrupt_config_gpio; |
1959 |
/* set intr_new_measure_ready */
|
1960 |
pdev->gen_cfg.system__interrupt_config_gpio = 1 << 5; |
1961 |
/* check MM1/MM2 disabled? */
|
1962 |
if ((pdev->dyn_cfg.system__sequence_config & (
|
1963 |
VL53L1_SEQUENCE_MM1_EN | VL53L1_SEQUENCE_MM2_EN)) == |
1964 |
0x0) {
|
1965 |
pdev->customer.algo__part_to_part_range_offset_mm = |
1966 |
pdev->customer.mm_config__outer_offset_mm * 4;
|
1967 |
} else {
|
1968 |
pdev->customer.algo__part_to_part_range_offset_mm = 0x0;
|
1969 |
} |
1970 |
|
1971 |
/* make sure config gets written out */
|
1972 |
if (device_config_level <
|
1973 |
VL53L1_DEVICECONFIGLEVEL_CUSTOMER_ONWARDS) { |
1974 |
device_config_level = |
1975 |
VL53L1_DEVICECONFIGLEVEL_CUSTOMER_ONWARDS; |
1976 |
} |
1977 |
} |
1978 |
|
1979 |
if ((pdev->low_power_auto_data.is_low_power_auto_mode == 1) && |
1980 |
(pdev->low_power_auto_data.low_power_auto_range_count == 1)) {
|
1981 |
/* restore interrupt config */
|
1982 |
pdev->gen_cfg.system__interrupt_config_gpio = |
1983 |
pdev->low_power_auto_data.saved_interrupt_config; |
1984 |
|
1985 |
/* make sure config gets written out including VHV config */
|
1986 |
device_config_level = VL53L1_DEVICECONFIGLEVEL_FULL; |
1987 |
} |
1988 |
|
1989 |
/* End Patch_LowPowerAutoMode */
|
1990 |
|
1991 |
/*
|
1992 |
* Determine Initial I2C index
|
1993 |
*/
|
1994 |
|
1995 |
switch (device_config_level) {
|
1996 |
case VL53L1_DEVICECONFIGLEVEL_FULL:
|
1997 |
i2c_index = VL53L1_STATIC_NVM_MANAGED_I2C_INDEX; |
1998 |
break;
|
1999 |
case VL53L1_DEVICECONFIGLEVEL_CUSTOMER_ONWARDS:
|
2000 |
i2c_index = VL53L1_CUSTOMER_NVM_MANAGED_I2C_INDEX; |
2001 |
break;
|
2002 |
case VL53L1_DEVICECONFIGLEVEL_STATIC_ONWARDS:
|
2003 |
i2c_index = VL53L1_STATIC_CONFIG_I2C_INDEX; |
2004 |
break;
|
2005 |
case VL53L1_DEVICECONFIGLEVEL_GENERAL_ONWARDS:
|
2006 |
i2c_index = VL53L1_GENERAL_CONFIG_I2C_INDEX; |
2007 |
break;
|
2008 |
case VL53L1_DEVICECONFIGLEVEL_TIMING_ONWARDS:
|
2009 |
i2c_index = VL53L1_TIMING_CONFIG_I2C_INDEX; |
2010 |
break;
|
2011 |
case VL53L1_DEVICECONFIGLEVEL_DYNAMIC_ONWARDS:
|
2012 |
i2c_index = VL53L1_DYNAMIC_CONFIG_I2C_INDEX; |
2013 |
break;
|
2014 |
default:
|
2015 |
i2c_index = VL53L1_SYSTEM_CONTROL_I2C_INDEX; |
2016 |
break;
|
2017 |
} |
2018 |
|
2019 |
/* I2C Buffer size */
|
2020 |
|
2021 |
i2c_buffer_size_bytes = \ |
2022 |
(VL53L1_SYSTEM_CONTROL_I2C_INDEX + |
2023 |
VL53L1_SYSTEM_CONTROL_I2C_SIZE_BYTES) - |
2024 |
i2c_index; |
2025 |
|
2026 |
/* Initialize buffer */
|
2027 |
|
2028 |
pbuffer = &buffer[0];
|
2029 |
for (i = 0 ; i < i2c_buffer_size_bytes ; i++) { |
2030 |
*pbuffer++ = 0;
|
2031 |
} |
2032 |
|
2033 |
/* Build I2C buffer */
|
2034 |
|
2035 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_FULL &&
|
2036 |
status == VL53L1_ERROR_NONE) { |
2037 |
|
2038 |
i2c_buffer_offset_bytes = \ |
2039 |
VL53L1_STATIC_NVM_MANAGED_I2C_INDEX - i2c_index; |
2040 |
|
2041 |
status = |
2042 |
VL53L1_i2c_encode_static_nvm_managed( |
2043 |
pstatic_nvm, |
2044 |
VL53L1_STATIC_NVM_MANAGED_I2C_SIZE_BYTES, |
2045 |
&buffer[i2c_buffer_offset_bytes]); |
2046 |
} |
2047 |
|
2048 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_CUSTOMER_ONWARDS &&
|
2049 |
status == VL53L1_ERROR_NONE) { |
2050 |
|
2051 |
i2c_buffer_offset_bytes = \ |
2052 |
VL53L1_CUSTOMER_NVM_MANAGED_I2C_INDEX - i2c_index; |
2053 |
|
2054 |
status = |
2055 |
VL53L1_i2c_encode_customer_nvm_managed( |
2056 |
pcustomer_nvm, |
2057 |
VL53L1_CUSTOMER_NVM_MANAGED_I2C_SIZE_BYTES, |
2058 |
&buffer[i2c_buffer_offset_bytes]); |
2059 |
} |
2060 |
|
2061 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_STATIC_ONWARDS &&
|
2062 |
status == VL53L1_ERROR_NONE) { |
2063 |
|
2064 |
i2c_buffer_offset_bytes = \ |
2065 |
VL53L1_STATIC_CONFIG_I2C_INDEX - i2c_index; |
2066 |
|
2067 |
status = |
2068 |
VL53L1_i2c_encode_static_config( |
2069 |
pstatic, |
2070 |
VL53L1_STATIC_CONFIG_I2C_SIZE_BYTES, |
2071 |
&buffer[i2c_buffer_offset_bytes]); |
2072 |
} |
2073 |
|
2074 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_GENERAL_ONWARDS &&
|
2075 |
status == VL53L1_ERROR_NONE) { |
2076 |
|
2077 |
i2c_buffer_offset_bytes = |
2078 |
VL53L1_GENERAL_CONFIG_I2C_INDEX - i2c_index; |
2079 |
|
2080 |
status = |
2081 |
VL53L1_i2c_encode_general_config( |
2082 |
pgeneral, |
2083 |
VL53L1_GENERAL_CONFIG_I2C_SIZE_BYTES, |
2084 |
&buffer[i2c_buffer_offset_bytes]); |
2085 |
} |
2086 |
|
2087 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_TIMING_ONWARDS &&
|
2088 |
status == VL53L1_ERROR_NONE) { |
2089 |
|
2090 |
i2c_buffer_offset_bytes = \ |
2091 |
VL53L1_TIMING_CONFIG_I2C_INDEX - i2c_index; |
2092 |
|
2093 |
status = |
2094 |
VL53L1_i2c_encode_timing_config( |
2095 |
ptiming, |
2096 |
VL53L1_TIMING_CONFIG_I2C_SIZE_BYTES, |
2097 |
&buffer[i2c_buffer_offset_bytes]); |
2098 |
} |
2099 |
|
2100 |
if (device_config_level >= VL53L1_DEVICECONFIGLEVEL_DYNAMIC_ONWARDS &&
|
2101 |
status == VL53L1_ERROR_NONE) { |
2102 |
|
2103 |
i2c_buffer_offset_bytes = \ |
2104 |
VL53L1_DYNAMIC_CONFIG_I2C_INDEX - i2c_index; |
2105 |
|
2106 |
/* If in back to back mode, use GPH ID from cfg_state */
|
2107 |
if ((psystem->system__mode_start &
|
2108 |
VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK) == |
2109 |
VL53L1_DEVICEMEASUREMENTMODE_BACKTOBACK) { |
2110 |
pdynamic->system__grouped_parameter_hold_0 = pstate->cfg_gph_id | 0x01;
|
2111 |
pdynamic->system__grouped_parameter_hold_1 = pstate->cfg_gph_id | 0x01;
|
2112 |
pdynamic->system__grouped_parameter_hold = pstate->cfg_gph_id; |
2113 |
} |
2114 |
status = |
2115 |
VL53L1_i2c_encode_dynamic_config( |
2116 |
pdynamic, |
2117 |
VL53L1_DYNAMIC_CONFIG_I2C_SIZE_BYTES, |
2118 |
&buffer[i2c_buffer_offset_bytes]); |
2119 |
} |
2120 |
|
2121 |
if (status == VL53L1_ERROR_NONE) {
|
2122 |
|
2123 |
i2c_buffer_offset_bytes = \ |
2124 |
VL53L1_SYSTEM_CONTROL_I2C_INDEX - i2c_index; |
2125 |
|
2126 |
status = |
2127 |
VL53L1_i2c_encode_system_control( |
2128 |
psystem, |
2129 |
VL53L1_SYSTEM_CONTROL_I2C_SIZE_BYTES, |
2130 |
&buffer[i2c_buffer_offset_bytes]); |
2131 |
} |
2132 |
|
2133 |
/* Send I2C Buffer */
|
2134 |
|
2135 |
if (status == VL53L1_ERROR_NONE) {
|
2136 |
status = |
2137 |
VL53L1_WriteMulti( |
2138 |
Dev, |
2139 |
i2c_index, |
2140 |
buffer, |
2141 |
(uint32_t)i2c_buffer_size_bytes); |
2142 |
} |
2143 |
|
2144 |
/*
|
2145 |
* Update LL Driver State
|
2146 |
*/
|
2147 |
if (status == VL53L1_ERROR_NONE)
|
2148 |
status = VL53L1_update_ll_driver_rd_state(Dev); |
2149 |
|
2150 |
if (status == VL53L1_ERROR_NONE)
|
2151 |
status = VL53L1_update_ll_driver_cfg_state(Dev); |
2152 |
|
2153 |
LOG_FUNCTION_END(status); |
2154 |
|
2155 |
return status;
|
2156 |
} |
2157 |
|
2158 |
|
2159 |
VL53L1_Error VL53L1_stop_range( |
2160 |
VL53L1_DEV Dev) |
2161 |
{ |
2162 |
/*
|
2163 |
* Stops any in process range using the ABORT command
|
2164 |
* Also clears all of the measurement mode bits
|
2165 |
*/
|
2166 |
|
2167 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2168 |
|
2169 |
VL53L1_LLDriverData_t *pdev = |
2170 |
VL53L1DevStructGetLLDriverHandle(Dev); |
2171 |
|
2172 |
/* Merge ABORT mode with mode_start */
|
2173 |
|
2174 |
pdev->sys_ctrl.system__mode_start = |
2175 |
(pdev->sys_ctrl.system__mode_start & VL53L1_DEVICEMEASUREMENTMODE_STOP_MASK) | |
2176 |
VL53L1_DEVICEMEASUREMENTMODE_ABORT; |
2177 |
|
2178 |
status = VL53L1_set_system_control( |
2179 |
Dev, |
2180 |
&pdev->sys_ctrl); |
2181 |
|
2182 |
/* Abort bit is auto clear so clear register group structure to match */
|
2183 |
pdev->sys_ctrl.system__mode_start = |
2184 |
(pdev->sys_ctrl.system__mode_start & VL53L1_DEVICEMEASUREMENTMODE_STOP_MASK); |
2185 |
|
2186 |
/* reset zone dynamic info */
|
2187 |
VL53L1_init_ll_driver_state( |
2188 |
Dev, |
2189 |
VL53L1_DEVICESTATE_SW_STANDBY); |
2190 |
|
2191 |
/* reset low power auto */
|
2192 |
if (pdev->low_power_auto_data.is_low_power_auto_mode == 1) |
2193 |
VL53L1_low_power_auto_data_stop_range(Dev); |
2194 |
|
2195 |
return status;
|
2196 |
} |
2197 |
|
2198 |
|
2199 |
VL53L1_Error VL53L1_get_measurement_results( |
2200 |
VL53L1_DEV Dev, |
2201 |
VL53L1_DeviceResultsLevel device_results_level) |
2202 |
{ |
2203 |
/*
|
2204 |
* Read via a single I2C multiple byte transaction all
|
2205 |
* of the requested device measurement data results
|
2206 |
*/
|
2207 |
|
2208 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2209 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2210 |
|
2211 |
uint8_t buffer[VL53L1_MAX_I2C_XFER_SIZE]; |
2212 |
|
2213 |
VL53L1_system_results_t *psystem_results = &(pdev->sys_results); |
2214 |
VL53L1_core_results_t *pcore_results = &(pdev->core_results); |
2215 |
VL53L1_debug_results_t *pdebug_results = &(pdev->dbg_results); |
2216 |
|
2217 |
uint16_t i2c_index = VL53L1_SYSTEM_RESULTS_I2C_INDEX; |
2218 |
uint16_t i2c_buffer_offset_bytes = 0;
|
2219 |
uint16_t i2c_buffer_size_bytes = 0;
|
2220 |
|
2221 |
LOG_FUNCTION_START("");
|
2222 |
|
2223 |
/* Determine multi byte read transaction size */
|
2224 |
|
2225 |
switch (device_results_level) {
|
2226 |
case VL53L1_DEVICERESULTSLEVEL_FULL:
|
2227 |
i2c_buffer_size_bytes = |
2228 |
(VL53L1_DEBUG_RESULTS_I2C_INDEX + |
2229 |
VL53L1_DEBUG_RESULTS_I2C_SIZE_BYTES) - |
2230 |
i2c_index; |
2231 |
break;
|
2232 |
case VL53L1_DEVICERESULTSLEVEL_UPTO_CORE:
|
2233 |
i2c_buffer_size_bytes = |
2234 |
(VL53L1_CORE_RESULTS_I2C_INDEX + |
2235 |
VL53L1_CORE_RESULTS_I2C_SIZE_BYTES) - |
2236 |
i2c_index; |
2237 |
break;
|
2238 |
default:
|
2239 |
i2c_buffer_size_bytes = |
2240 |
VL53L1_SYSTEM_RESULTS_I2C_SIZE_BYTES; |
2241 |
break;
|
2242 |
} |
2243 |
|
2244 |
/* Read Result Data */
|
2245 |
|
2246 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
2247 |
status = |
2248 |
VL53L1_ReadMulti( |
2249 |
Dev, |
2250 |
i2c_index, |
2251 |
buffer, |
2252 |
(uint32_t)i2c_buffer_size_bytes); |
2253 |
|
2254 |
/* Decode I2C buffer */
|
2255 |
|
2256 |
if (device_results_level >= VL53L1_DEVICERESULTSLEVEL_FULL &&
|
2257 |
status == VL53L1_ERROR_NONE) { |
2258 |
|
2259 |
i2c_buffer_offset_bytes = |
2260 |
VL53L1_DEBUG_RESULTS_I2C_INDEX - i2c_index; |
2261 |
|
2262 |
status = |
2263 |
VL53L1_i2c_decode_debug_results( |
2264 |
VL53L1_DEBUG_RESULTS_I2C_SIZE_BYTES, |
2265 |
&buffer[i2c_buffer_offset_bytes], |
2266 |
pdebug_results); |
2267 |
} |
2268 |
|
2269 |
if (device_results_level >= VL53L1_DEVICERESULTSLEVEL_UPTO_CORE &&
|
2270 |
status == VL53L1_ERROR_NONE) { |
2271 |
|
2272 |
i2c_buffer_offset_bytes = |
2273 |
VL53L1_CORE_RESULTS_I2C_INDEX - i2c_index; |
2274 |
|
2275 |
status = |
2276 |
VL53L1_i2c_decode_core_results( |
2277 |
VL53L1_CORE_RESULTS_I2C_SIZE_BYTES, |
2278 |
&buffer[i2c_buffer_offset_bytes], |
2279 |
pcore_results); |
2280 |
} |
2281 |
|
2282 |
if (status == VL53L1_ERROR_NONE) {
|
2283 |
|
2284 |
i2c_buffer_offset_bytes = 0;
|
2285 |
status = |
2286 |
VL53L1_i2c_decode_system_results( |
2287 |
VL53L1_SYSTEM_RESULTS_I2C_SIZE_BYTES, |
2288 |
&buffer[i2c_buffer_offset_bytes], |
2289 |
psystem_results); |
2290 |
} |
2291 |
|
2292 |
LOG_FUNCTION_END(status); |
2293 |
|
2294 |
return status;
|
2295 |
} |
2296 |
|
2297 |
|
2298 |
VL53L1_Error VL53L1_get_device_results( |
2299 |
VL53L1_DEV Dev, |
2300 |
VL53L1_DeviceResultsLevel device_results_level, |
2301 |
VL53L1_range_results_t *prange_results) |
2302 |
{ |
2303 |
/*
|
2304 |
* Wrapper function using the functions below
|
2305 |
*
|
2306 |
* VL53L1_get_measurement_results()
|
2307 |
* VL53L1_init_and_start_range()
|
2308 |
* VL53L1_copy_sys_and_core_results_to_range_results()
|
2309 |
*
|
2310 |
* The input measurement mode controls what happens next ...
|
2311 |
*/
|
2312 |
|
2313 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2314 |
|
2315 |
VL53L1_LLDriverData_t *pdev = |
2316 |
VL53L1DevStructGetLLDriverHandle(Dev); |
2317 |
VL53L1_LLDriverResults_t *pres = |
2318 |
VL53L1DevStructGetLLResultsHandle(Dev); |
2319 |
|
2320 |
VL53L1_range_results_t *presults = &(pres->range_results); |
2321 |
|
2322 |
LOG_FUNCTION_START("");
|
2323 |
|
2324 |
/* Get device results */
|
2325 |
|
2326 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
2327 |
status = VL53L1_get_measurement_results( |
2328 |
Dev, |
2329 |
device_results_level); |
2330 |
|
2331 |
if (status == VL53L1_ERROR_NONE)
|
2332 |
VL53L1_copy_sys_and_core_results_to_range_results( |
2333 |
(int32_t)pdev->gain_cal.standard_ranging_gain_factor, |
2334 |
&(pdev->sys_results), |
2335 |
&(pdev->core_results), |
2336 |
presults); |
2337 |
|
2338 |
/* Start Patch_LowPowerAutoMode */
|
2339 |
/* process results from first range of low power auto */
|
2340 |
if (pdev->low_power_auto_data.is_low_power_auto_mode == 1) { |
2341 |
/* change to manual calibrations. Only needed on the
|
2342 |
* first range out */
|
2343 |
if ((status == VL53L1_ERROR_NONE) &&
|
2344 |
(pdev->low_power_auto_data.low_power_auto_range_count == 0)) {
|
2345 |
status = VL53L1_low_power_auto_setup_manual_calibration( |
2346 |
Dev); |
2347 |
pdev->low_power_auto_data.low_power_auto_range_count = 1;
|
2348 |
} else if ((status == VL53L1_ERROR_NONE) && |
2349 |
(pdev->low_power_auto_data.low_power_auto_range_count == 1)) {
|
2350 |
pdev->low_power_auto_data.low_power_auto_range_count = 2;
|
2351 |
} |
2352 |
|
2353 |
/* perform DSS calculation. This can be performed every range */
|
2354 |
if ((pdev->low_power_auto_data.low_power_auto_range_count != 0xFF) && |
2355 |
(status == VL53L1_ERROR_NONE)) { |
2356 |
status = VL53L1_low_power_auto_update_DSS( |
2357 |
Dev); |
2358 |
} |
2359 |
|
2360 |
} |
2361 |
/* End Patch_LowPowerAutoMode */
|
2362 |
|
2363 |
/* copy current state into results */
|
2364 |
|
2365 |
presults->cfg_device_state = pdev->ll_state.cfg_device_state; |
2366 |
presults->rd_device_state = pdev->ll_state.rd_device_state; |
2367 |
|
2368 |
/* copy internal structure to supplied output pointer */
|
2369 |
|
2370 |
memcpy( |
2371 |
prange_results, |
2372 |
presults, |
2373 |
sizeof(VL53L1_range_results_t));
|
2374 |
|
2375 |
/*
|
2376 |
* Check LL driver and Device are in Sync
|
2377 |
* If not an error is raised
|
2378 |
*/
|
2379 |
|
2380 |
if (status == VL53L1_ERROR_NONE)
|
2381 |
status = VL53L1_check_ll_driver_rd_state(Dev); |
2382 |
|
2383 |
#ifdef VL53L1_LOG_ENABLE
|
2384 |
if (status == VL53L1_ERROR_NONE)
|
2385 |
VL53L1_print_range_results( |
2386 |
presults, |
2387 |
"get_device_results():pdev->llresults.range_results.",
|
2388 |
VL53L1_TRACE_MODULE_RANGE_RESULTS_DATA); |
2389 |
#endif
|
2390 |
|
2391 |
LOG_FUNCTION_END(status); |
2392 |
|
2393 |
return status;
|
2394 |
} |
2395 |
|
2396 |
|
2397 |
VL53L1_Error VL53L1_clear_interrupt_and_enable_next_range( |
2398 |
VL53L1_DEV Dev, |
2399 |
uint8_t measurement_mode) |
2400 |
{ |
2401 |
|
2402 |
/*
|
2403 |
* Enable next range by sending handshake which
|
2404 |
* clears the interrupt
|
2405 |
*/
|
2406 |
|
2407 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2408 |
|
2409 |
LOG_FUNCTION_START("");
|
2410 |
|
2411 |
/* Dynamic Management */
|
2412 |
/* Current results analysis and generate next settings */
|
2413 |
|
2414 |
|
2415 |
/* Dynamic GPH Management */
|
2416 |
/* Setup GPH absorption point and config values for next measurement */
|
2417 |
|
2418 |
/* Update GPH registers, clear interrupt and set measurement mode */
|
2419 |
|
2420 |
if (status == VL53L1_ERROR_NONE) /*lint !e774 always true*/ |
2421 |
status = VL53L1_init_and_start_range( |
2422 |
Dev, |
2423 |
measurement_mode, |
2424 |
VL53L1_DEVICECONFIGLEVEL_GENERAL_ONWARDS); |
2425 |
|
2426 |
LOG_FUNCTION_END(status); |
2427 |
|
2428 |
return status;
|
2429 |
} |
2430 |
|
2431 |
|
2432 |
void VL53L1_copy_sys_and_core_results_to_range_results(
|
2433 |
int32_t gain_factor, |
2434 |
VL53L1_system_results_t *psys, |
2435 |
VL53L1_core_results_t *pcore, |
2436 |
VL53L1_range_results_t *presults) |
2437 |
{ |
2438 |
uint8_t i = 0;
|
2439 |
|
2440 |
VL53L1_range_data_t *pdata; |
2441 |
int32_t range_mm = 0;
|
2442 |
uint32_t tmpu32 = 0;
|
2443 |
|
2444 |
LOG_FUNCTION_START("");
|
2445 |
|
2446 |
/* copy results */
|
2447 |
|
2448 |
presults->stream_count = psys->result__stream_count; |
2449 |
|
2450 |
pdata = &(presults->data[0]);
|
2451 |
|
2452 |
for (i = 0 ; i < 2 ; i++) { |
2453 |
|
2454 |
pdata->range_id = i; |
2455 |
pdata->time_stamp = 0;
|
2456 |
|
2457 |
if ((psys->result__stream_count == 0) && |
2458 |
((psys->result__range_status & VL53L1_RANGE_STATUS__RANGE_STATUS_MASK) == |
2459 |
VL53L1_DEVICEERROR_RANGECOMPLETE)) { |
2460 |
pdata->range_status = VL53L1_DEVICEERROR_RANGECOMPLETE_NO_WRAP_CHECK; |
2461 |
} else {
|
2462 |
pdata->range_status = |
2463 |
psys->result__range_status & VL53L1_RANGE_STATUS__RANGE_STATUS_MASK; |
2464 |
} |
2465 |
|
2466 |
switch (i) {
|
2467 |
|
2468 |
case 0: |
2469 |
|
2470 |
if (psys->result__report_status == VL53L1_DEVICEREPORTSTATUS_MM1)
|
2471 |
pdata->actual_effective_spads = |
2472 |
psys->result__mm_inner_actual_effective_spads_sd0; |
2473 |
else if (psys->result__report_status == VL53L1_DEVICEREPORTSTATUS_MM2) |
2474 |
pdata->actual_effective_spads = |
2475 |
psys->result__mm_outer_actual_effective_spads_sd0; |
2476 |
else
|
2477 |
pdata->actual_effective_spads = |
2478 |
psys->result__dss_actual_effective_spads_sd0; |
2479 |
|
2480 |
pdata->peak_signal_count_rate_mcps = |
2481 |
psys->result__peak_signal_count_rate_crosstalk_corrected_mcps_sd0; |
2482 |
pdata->avg_signal_count_rate_mcps = |
2483 |
psys->result__avg_signal_count_rate_mcps_sd0; |
2484 |
pdata->ambient_count_rate_mcps = |
2485 |
psys->result__ambient_count_rate_mcps_sd0; |
2486 |
|
2487 |
/* Start Patch_SigmaEstimateAccuracyImprovement */
|
2488 |
|
2489 |
/* shift up sigma estimate to 7 bit fractional and clip to 9 bit int */
|
2490 |
tmpu32 = ((uint32_t)psys->result__sigma_sd0 << 5);
|
2491 |
if (tmpu32 > 0xFFFF) { |
2492 |
tmpu32 = 0xFFFF;
|
2493 |
} |
2494 |
pdata->sigma_mm = (uint16_t)tmpu32; |
2495 |
|
2496 |
/* End Patch_SigmaEstimateAccuracyImprovement */
|
2497 |
|
2498 |
pdata->median_phase = |
2499 |
psys->result__phase_sd0; |
2500 |
|
2501 |
range_mm = |
2502 |
(int32_t)psys->result__final_crosstalk_corrected_range_mm_sd0; |
2503 |
|
2504 |
/* apply correction gain */
|
2505 |
range_mm *= gain_factor; |
2506 |
range_mm += 0x0400;
|
2507 |
range_mm /= 0x0800;
|
2508 |
|
2509 |
pdata->median_range_mm = (int16_t)range_mm; |
2510 |
|
2511 |
pdata->ranging_total_events = |
2512 |
pcore->result_core__ranging_total_events_sd0; |
2513 |
pdata->signal_total_events = |
2514 |
pcore->result_core__signal_total_events_sd0; |
2515 |
pdata->total_periods_elapsed = |
2516 |
pcore->result_core__total_periods_elapsed_sd0; |
2517 |
pdata->ambient_window_events = |
2518 |
pcore->result_core__ambient_window_events_sd0; |
2519 |
|
2520 |
break;
|
2521 |
case 1: |
2522 |
|
2523 |
pdata->actual_effective_spads = |
2524 |
psys->result__dss_actual_effective_spads_sd1; |
2525 |
pdata->peak_signal_count_rate_mcps = |
2526 |
psys->result__peak_signal_count_rate_mcps_sd1; |
2527 |
pdata->avg_signal_count_rate_mcps = |
2528 |
0xFFFF;
|
2529 |
pdata->ambient_count_rate_mcps = |
2530 |
psys->result__ambient_count_rate_mcps_sd1; |
2531 |
|
2532 |
/* Start Patch_SigmaEstimateAccuracyImprovement */
|
2533 |
|
2534 |
/* shift up sigma estimate to 7 bit fractional and clip to 9 bit int */
|
2535 |
tmpu32 = ((uint32_t)psys->result__sigma_sd1 << 5);
|
2536 |
if (tmpu32 > 0xFFFF) { |
2537 |
tmpu32 = 0xFFFF;
|
2538 |
} |
2539 |
pdata->sigma_mm = (uint16_t)tmpu32; |
2540 |
|
2541 |
/* End Patch_SigmaEstimateAccuracyImprovement */
|
2542 |
|
2543 |
pdata->median_phase = |
2544 |
psys->result__phase_sd1; |
2545 |
|
2546 |
range_mm = |
2547 |
(int32_t)psys->result__final_crosstalk_corrected_range_mm_sd1; |
2548 |
|
2549 |
/* apply correction gain */
|
2550 |
range_mm *= gain_factor; |
2551 |
range_mm += 0x0400;
|
2552 |
range_mm /= 0x0800;
|
2553 |
|
2554 |
pdata->median_range_mm = (int16_t)range_mm; |
2555 |
|
2556 |
pdata->ranging_total_events = |
2557 |
pcore->result_core__ranging_total_events_sd1; |
2558 |
pdata->signal_total_events = |
2559 |
pcore->result_core__signal_total_events_sd1; |
2560 |
pdata->total_periods_elapsed = |
2561 |
pcore->result_core__total_periods_elapsed_sd1; |
2562 |
pdata->ambient_window_events = |
2563 |
pcore->result_core__ambient_window_events_sd1; |
2564 |
|
2565 |
break;
|
2566 |
} |
2567 |
|
2568 |
pdata++; |
2569 |
} |
2570 |
|
2571 |
/* Update Global Device Status for results
|
2572 |
* - Default to no update
|
2573 |
*/
|
2574 |
|
2575 |
presults->device_status = VL53L1_DEVICEERROR_NOUPDATE; |
2576 |
|
2577 |
/* Check range status
|
2578 |
* - If device error condition, update device status
|
2579 |
* - Remove device status from range status output this should
|
2580 |
* only contain information relating to range data
|
2581 |
*/
|
2582 |
|
2583 |
switch (psys->result__range_status &
|
2584 |
VL53L1_RANGE_STATUS__RANGE_STATUS_MASK) { |
2585 |
|
2586 |
case VL53L1_DEVICEERROR_VCSELCONTINUITYTESTFAILURE:
|
2587 |
case VL53L1_DEVICEERROR_VCSELWATCHDOGTESTFAILURE:
|
2588 |
case VL53L1_DEVICEERROR_NOVHVVALUEFOUND:
|
2589 |
case VL53L1_DEVICEERROR_USERROICLIP:
|
2590 |
case VL53L1_DEVICEERROR_MULTCLIPFAIL:
|
2591 |
|
2592 |
presults->device_status = (psys->result__range_status & |
2593 |
VL53L1_RANGE_STATUS__RANGE_STATUS_MASK); |
2594 |
|
2595 |
presults->data[0].range_status = VL53L1_DEVICEERROR_NOUPDATE;
|
2596 |
break;
|
2597 |
|
2598 |
} |
2599 |
|
2600 |
LOG_FUNCTION_END(0);
|
2601 |
} |
2602 |
|
2603 |
/*
|
2604 |
* Configure the GPIO interrupt config, from the given input
|
2605 |
*/
|
2606 |
|
2607 |
VL53L1_Error VL53L1_set_GPIO_interrupt_config( |
2608 |
VL53L1_DEV Dev, |
2609 |
VL53L1_GPIO_Interrupt_Mode intr_mode_distance, |
2610 |
VL53L1_GPIO_Interrupt_Mode intr_mode_rate, |
2611 |
uint8_t intr_new_measure_ready, |
2612 |
uint8_t intr_no_target, |
2613 |
uint8_t intr_combined_mode, |
2614 |
uint16_t thresh_distance_high, |
2615 |
uint16_t thresh_distance_low, |
2616 |
uint16_t thresh_rate_high, |
2617 |
uint16_t thresh_rate_low |
2618 |
) |
2619 |
{ |
2620 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2621 |
|
2622 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2623 |
VL53L1_GPIO_interrupt_config_t *pintconf = &(pdev->gpio_interrupt_config); |
2624 |
|
2625 |
LOG_FUNCTION_START("");
|
2626 |
|
2627 |
/* update local data structure */
|
2628 |
pintconf->intr_mode_distance = intr_mode_distance; |
2629 |
pintconf->intr_mode_rate = intr_mode_rate; |
2630 |
pintconf->intr_new_measure_ready = intr_new_measure_ready; |
2631 |
pintconf->intr_no_target = intr_no_target; |
2632 |
pintconf->intr_combined_mode = intr_combined_mode; |
2633 |
pintconf->threshold_distance_high = thresh_distance_high; |
2634 |
pintconf->threshold_distance_low = thresh_distance_low; |
2635 |
pintconf->threshold_rate_high = thresh_rate_high; |
2636 |
pintconf->threshold_rate_low = thresh_rate_low; |
2637 |
|
2638 |
/* encoded interrupt config */
|
2639 |
pdev->gen_cfg.system__interrupt_config_gpio = |
2640 |
VL53L1_encode_GPIO_interrupt_config(pintconf); |
2641 |
|
2642 |
|
2643 |
/* set thresholds */
|
2644 |
status = VL53L1_set_GPIO_thresholds_from_struct( |
2645 |
Dev, |
2646 |
pintconf); |
2647 |
|
2648 |
LOG_FUNCTION_END(status); |
2649 |
return status;
|
2650 |
} |
2651 |
|
2652 |
/*
|
2653 |
* Configure the GPIO interrupt config, from the given structure
|
2654 |
*/
|
2655 |
|
2656 |
VL53L1_Error VL53L1_set_GPIO_interrupt_config_struct( |
2657 |
VL53L1_DEV Dev, |
2658 |
VL53L1_GPIO_interrupt_config_t intconf) |
2659 |
{ |
2660 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2661 |
|
2662 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2663 |
VL53L1_GPIO_interrupt_config_t *pintconf = &(pdev->gpio_interrupt_config); |
2664 |
|
2665 |
LOG_FUNCTION_START("");
|
2666 |
|
2667 |
/* using memcpy(dst, src, size in bytes) */
|
2668 |
memcpy(pintconf, &(intconf), sizeof(VL53L1_GPIO_interrupt_config_t));
|
2669 |
|
2670 |
/* encoded interrupt config */
|
2671 |
pdev->gen_cfg.system__interrupt_config_gpio = |
2672 |
VL53L1_encode_GPIO_interrupt_config(pintconf); |
2673 |
|
2674 |
/* set thresholds */
|
2675 |
status = VL53L1_set_GPIO_thresholds_from_struct( |
2676 |
Dev, |
2677 |
pintconf); |
2678 |
|
2679 |
LOG_FUNCTION_END(status); |
2680 |
return status;
|
2681 |
} |
2682 |
|
2683 |
/*
|
2684 |
* Retrieve GPIO interrupt config structure
|
2685 |
*/
|
2686 |
|
2687 |
VL53L1_Error VL53L1_get_GPIO_interrupt_config( |
2688 |
VL53L1_DEV Dev, |
2689 |
VL53L1_GPIO_interrupt_config_t *pintconf) |
2690 |
{ |
2691 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2692 |
|
2693 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2694 |
|
2695 |
LOG_FUNCTION_START("");
|
2696 |
|
2697 |
/*
|
2698 |
* Decode the system__interrupt_config_gpio register
|
2699 |
* This makes sure the structure is in line with the register
|
2700 |
*/
|
2701 |
pdev->gpio_interrupt_config = VL53L1_decode_GPIO_interrupt_config( |
2702 |
pdev->gen_cfg.system__interrupt_config_gpio); |
2703 |
|
2704 |
/*
|
2705 |
* Readout the system thresholds
|
2706 |
*/
|
2707 |
pdev->gpio_interrupt_config.threshold_distance_high = |
2708 |
pdev->dyn_cfg.system__thresh_high; |
2709 |
pdev->gpio_interrupt_config.threshold_distance_low = |
2710 |
pdev->dyn_cfg.system__thresh_low; |
2711 |
|
2712 |
pdev->gpio_interrupt_config.threshold_rate_high = |
2713 |
pdev->gen_cfg.system__thresh_rate_high; |
2714 |
pdev->gpio_interrupt_config.threshold_rate_low = |
2715 |
pdev->gen_cfg.system__thresh_rate_low; |
2716 |
|
2717 |
if (pintconf == &(pdev->gpio_interrupt_config)) {
|
2718 |
/* Cowardly refusing to copy the same memory locations */
|
2719 |
} else {
|
2720 |
|
2721 |
/* using memcpy(dst, src, size in bytes) */
|
2722 |
memcpy(pintconf, &(pdev->gpio_interrupt_config), |
2723 |
sizeof(VL53L1_GPIO_interrupt_config_t));
|
2724 |
} |
2725 |
|
2726 |
LOG_FUNCTION_END(status); |
2727 |
return status;
|
2728 |
} |
2729 |
|
2730 |
VL53L1_Error VL53L1_set_offset_calibration_mode( |
2731 |
VL53L1_DEV Dev, |
2732 |
VL53L1_OffsetCalibrationMode offset_cal_mode) |
2733 |
{ |
2734 |
|
2735 |
/*
|
2736 |
* Sets the offset calibration mode
|
2737 |
*/
|
2738 |
|
2739 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2740 |
|
2741 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2742 |
|
2743 |
LOG_FUNCTION_START("");
|
2744 |
|
2745 |
pdev->offset_calibration_mode = offset_cal_mode; |
2746 |
|
2747 |
LOG_FUNCTION_END(status); |
2748 |
|
2749 |
return status;
|
2750 |
} |
2751 |
|
2752 |
|
2753 |
VL53L1_Error VL53L1_get_offset_calibration_mode( |
2754 |
VL53L1_DEV Dev, |
2755 |
VL53L1_OffsetCalibrationMode *poffset_cal_mode) |
2756 |
{ |
2757 |
|
2758 |
/*
|
2759 |
* Gets the offset calibration mode
|
2760 |
*/
|
2761 |
|
2762 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2763 |
|
2764 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2765 |
|
2766 |
LOG_FUNCTION_START("");
|
2767 |
|
2768 |
*poffset_cal_mode = pdev->offset_calibration_mode; |
2769 |
|
2770 |
LOG_FUNCTION_END(status); |
2771 |
|
2772 |
return status;
|
2773 |
} |
2774 |
|
2775 |
|
2776 |
VL53L1_Error VL53L1_set_offset_correction_mode( |
2777 |
VL53L1_DEV Dev, |
2778 |
VL53L1_OffsetCorrectionMode offset_cor_mode) |
2779 |
{ |
2780 |
|
2781 |
/*
|
2782 |
* Sets the offset correction mode
|
2783 |
*/
|
2784 |
|
2785 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2786 |
|
2787 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2788 |
|
2789 |
LOG_FUNCTION_START("");
|
2790 |
|
2791 |
pdev->offset_correction_mode = offset_cor_mode; |
2792 |
|
2793 |
LOG_FUNCTION_END(status); |
2794 |
|
2795 |
return status;
|
2796 |
} |
2797 |
|
2798 |
|
2799 |
VL53L1_Error VL53L1_get_offset_correction_mode( |
2800 |
VL53L1_DEV Dev, |
2801 |
VL53L1_OffsetCorrectionMode *poffset_cor_mode) |
2802 |
{ |
2803 |
|
2804 |
/*
|
2805 |
* Gets the offset correction mode
|
2806 |
*/
|
2807 |
|
2808 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2809 |
|
2810 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2811 |
|
2812 |
LOG_FUNCTION_START("");
|
2813 |
|
2814 |
*poffset_cor_mode = pdev->offset_correction_mode; |
2815 |
|
2816 |
LOG_FUNCTION_END(status); |
2817 |
|
2818 |
return status;
|
2819 |
} |
2820 |
|
2821 |
|
2822 |
/* Start Patch_AddedTuningParms_11761 */
|
2823 |
#ifdef VL53L1_DEBUG
|
2824 |
VL53L1_Error VL53L1_get_tuning_debug_data( |
2825 |
VL53L1_DEV Dev, |
2826 |
VL53L1_tuning_parameters_t *ptun_data) |
2827 |
{ |
2828 |
/*
|
2829 |
* Helper function to extract all tuning parm values
|
2830 |
*/
|
2831 |
|
2832 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
2833 |
|
2834 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
2835 |
|
2836 |
LOG_FUNCTION_START("");
|
2837 |
|
2838 |
ptun_data->vl53l1_tuningparm_version = |
2839 |
pdev->tuning_parms.tp_tuning_parm_version; |
2840 |
|
2841 |
ptun_data->vl53l1_tuningparm_key_table_version = |
2842 |
pdev->tuning_parms.tp_tuning_parm_key_table_version; |
2843 |
|
2844 |
|
2845 |
ptun_data->vl53l1_tuningparm_lld_version = |
2846 |
pdev->tuning_parms.tp_tuning_parm_lld_version; |
2847 |
|
2848 |
ptun_data->vl53l1_tuningparm_lite_min_clip_mm = |
2849 |
pdev->tuning_parms.tp_lite_min_clip; |
2850 |
|
2851 |
ptun_data->vl53l1_tuningparm_lite_long_sigma_thresh_mm = |
2852 |
pdev->tuning_parms.tp_lite_long_sigma_thresh_mm; |
2853 |
|
2854 |
ptun_data->vl53l1_tuningparm_lite_med_sigma_thresh_mm = |
2855 |
pdev->tuning_parms.tp_lite_med_sigma_thresh_mm; |
2856 |
|
2857 |
ptun_data->vl53l1_tuningparm_lite_short_sigma_thresh_mm = |
2858 |
pdev->tuning_parms.tp_lite_short_sigma_thresh_mm; |
2859 |
|
2860 |
ptun_data->vl53l1_tuningparm_lite_long_min_count_rate_rtn_mcps = |
2861 |
pdev->tuning_parms.tp_lite_long_min_count_rate_rtn_mcps; |
2862 |
|
2863 |
ptun_data->vl53l1_tuningparm_lite_med_min_count_rate_rtn_mcps = |
2864 |
pdev->tuning_parms.tp_lite_med_min_count_rate_rtn_mcps; |
2865 |
|
2866 |
ptun_data->vl53l1_tuningparm_lite_short_min_count_rate_rtn_mcps = |
2867 |
pdev->tuning_parms.tp_lite_short_min_count_rate_rtn_mcps; |
2868 |
|
2869 |
ptun_data->vl53l1_tuningparm_lite_sigma_est_pulse_width = |
2870 |
pdev->tuning_parms.tp_lite_sigma_est_pulse_width_ns; |
2871 |
|
2872 |
ptun_data->vl53l1_tuningparm_lite_sigma_est_amb_width_ns = |
2873 |
pdev->tuning_parms.tp_lite_sigma_est_amb_width_ns; |
2874 |
|
2875 |
ptun_data->vl53l1_tuningparm_lite_sigma_ref_mm = |
2876 |
pdev->tuning_parms.tp_lite_sigma_ref_mm; |
2877 |
|
2878 |
ptun_data->vl53l1_tuningparm_lite_rit_mult = |
2879 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult; |
2880 |
|
2881 |
ptun_data->vl53l1_tuningparm_lite_seed_config = |
2882 |
pdev->tuning_parms.tp_lite_seed_cfg ; |
2883 |
|
2884 |
ptun_data->vl53l1_tuningparm_lite_quantifier = |
2885 |
pdev->tuning_parms.tp_lite_quantifier; |
2886 |
|
2887 |
ptun_data->vl53l1_tuningparm_lite_first_order_select = |
2888 |
pdev->tuning_parms.tp_lite_first_order_select; |
2889 |
|
2890 |
ptun_data->vl53l1_tuningparm_lite_xtalk_margin_kcps = |
2891 |
pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps; |
2892 |
|
2893 |
ptun_data->vl53l1_tuningparm_initial_phase_rtn_lite_long_range = |
2894 |
pdev->tuning_parms.tp_init_phase_rtn_lite_long; |
2895 |
|
2896 |
ptun_data->vl53l1_tuningparm_initial_phase_rtn_lite_med_range = |
2897 |
pdev->tuning_parms.tp_init_phase_rtn_lite_med; |
2898 |
|
2899 |
ptun_data->vl53l1_tuningparm_initial_phase_rtn_lite_short_range = |
2900 |
pdev->tuning_parms.tp_init_phase_rtn_lite_short; |
2901 |
|
2902 |
ptun_data->vl53l1_tuningparm_initial_phase_ref_lite_long_range = |
2903 |
pdev->tuning_parms.tp_init_phase_ref_lite_long; |
2904 |
|
2905 |
ptun_data->vl53l1_tuningparm_initial_phase_ref_lite_med_range = |
2906 |
pdev->tuning_parms.tp_init_phase_ref_lite_med; |
2907 |
|
2908 |
ptun_data->vl53l1_tuningparm_initial_phase_ref_lite_short_range = |
2909 |
pdev->tuning_parms.tp_init_phase_ref_lite_short; |
2910 |
|
2911 |
ptun_data->vl53l1_tuningparm_timed_seed_config = |
2912 |
pdev->tuning_parms.tp_timed_seed_cfg; |
2913 |
|
2914 |
ptun_data->vl53l1_tuningparm_vhv_loopbound = |
2915 |
pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound; |
2916 |
|
2917 |
ptun_data->vl53l1_tuningparm_refspadchar_device_test_mode = |
2918 |
pdev->refspadchar.device_test_mode; |
2919 |
|
2920 |
ptun_data->vl53l1_tuningparm_refspadchar_vcsel_period = |
2921 |
pdev->refspadchar.vcsel_period; |
2922 |
|
2923 |
ptun_data->vl53l1_tuningparm_refspadchar_phasecal_timeout_us = |
2924 |
pdev->refspadchar.timeout_us; |
2925 |
|
2926 |
ptun_data->vl53l1_tuningparm_refspadchar_target_count_rate_mcps = |
2927 |
pdev->refspadchar.target_count_rate_mcps; |
2928 |
|
2929 |
ptun_data->vl53l1_tuningparm_refspadchar_min_countrate_limit_mcps = |
2930 |
pdev->refspadchar.min_count_rate_limit_mcps; |
2931 |
|
2932 |
ptun_data->vl53l1_tuningparm_refspadchar_max_countrate_limit_mcps = |
2933 |
pdev->refspadchar.max_count_rate_limit_mcps; |
2934 |
|
2935 |
ptun_data->vl53l1_tuningparm_offset_cal_dss_rate_mcps = |
2936 |
pdev->offsetcal_cfg.dss_config__target_total_rate_mcps; |
2937 |
|
2938 |
ptun_data->vl53l1_tuningparm_offset_cal_phasecal_timeout_us = |
2939 |
pdev->offsetcal_cfg.phasecal_config_timeout_us; |
2940 |
|
2941 |
ptun_data->vl53l1_tuningparm_offset_cal_mm_timeout_us = |
2942 |
pdev->offsetcal_cfg.mm_config_timeout_us; |
2943 |
|
2944 |
ptun_data->vl53l1_tuningparm_offset_cal_range_timeout_us = |
2945 |
pdev->offsetcal_cfg.range_config_timeout_us; |
2946 |
|
2947 |
ptun_data->vl53l1_tuningparm_offset_cal_pre_samples = |
2948 |
pdev->offsetcal_cfg.pre_num_of_samples; |
2949 |
|
2950 |
ptun_data->vl53l1_tuningparm_offset_cal_mm1_samples = |
2951 |
pdev->offsetcal_cfg.mm1_num_of_samples; |
2952 |
|
2953 |
ptun_data->vl53l1_tuningparm_offset_cal_mm2_samples = |
2954 |
pdev->offsetcal_cfg.mm2_num_of_samples; |
2955 |
|
2956 |
ptun_data->vl53l1_tuningparm_spadmap_vcsel_period = |
2957 |
pdev->ssc_cfg.vcsel_period; |
2958 |
|
2959 |
ptun_data->vl53l1_tuningparm_spadmap_vcsel_start = |
2960 |
pdev->ssc_cfg.vcsel_start; |
2961 |
|
2962 |
ptun_data->vl53l1_tuningparm_spadmap_rate_limit_mcps = |
2963 |
pdev->ssc_cfg.rate_limit_mcps; |
2964 |
|
2965 |
ptun_data->vl53l1_tuningparm_lite_dss_config_target_total_rate_mcps = |
2966 |
pdev->tuning_parms.tp_dss_target_lite_mcps; |
2967 |
|
2968 |
ptun_data->vl53l1_tuningparm_timed_dss_config_target_total_rate_mcps = |
2969 |
pdev->tuning_parms.tp_dss_target_timed_mcps; |
2970 |
|
2971 |
ptun_data->vl53l1_tuningparm_lite_phasecal_config_timeout_us = |
2972 |
pdev->tuning_parms.tp_phasecal_timeout_lite_us; |
2973 |
|
2974 |
ptun_data->vl53l1_tuningparm_timed_phasecal_config_timeout_us = |
2975 |
pdev->tuning_parms.tp_phasecal_timeout_timed_us; |
2976 |
|
2977 |
ptun_data->vl53l1_tuningparm_lite_mm_config_timeout_us = |
2978 |
pdev->tuning_parms.tp_mm_timeout_lite_us; |
2979 |
|
2980 |
ptun_data->vl53l1_tuningparm_timed_mm_config_timeout_us = |
2981 |
pdev->tuning_parms.tp_mm_timeout_timed_us; |
2982 |
|
2983 |
ptun_data->vl53l1_tuningparm_lite_range_config_timeout_us = |
2984 |
pdev->tuning_parms.tp_range_timeout_lite_us; |
2985 |
|
2986 |
ptun_data->vl53l1_tuningparm_timed_range_config_timeout_us = |
2987 |
pdev->tuning_parms.tp_range_timeout_timed_us; |
2988 |
|
2989 |
ptun_data->vl53l1_tuningparm_lowpowerauto_vhv_loop_bound = |
2990 |
pdev->low_power_auto_data.vhv_loop_bound; |
2991 |
|
2992 |
ptun_data->vl53l1_tuningparm_lowpowerauto_mm_config_timeout_us = |
2993 |
pdev->tuning_parms.tp_mm_timeout_lpa_us; |
2994 |
|
2995 |
ptun_data->vl53l1_tuningparm_lowpowerauto_range_config_timeout_us = |
2996 |
pdev->tuning_parms.tp_range_timeout_lpa_us; |
2997 |
|
2998 |
LOG_FUNCTION_END(status); |
2999 |
|
3000 |
return status;
|
3001 |
} |
3002 |
#endif
|
3003 |
|
3004 |
VL53L1_Error VL53L1_get_tuning_parm( |
3005 |
VL53L1_DEV Dev, |
3006 |
VL53L1_TuningParms tuning_parm_key, |
3007 |
int32_t *ptuning_parm_value) |
3008 |
{ |
3009 |
|
3010 |
/*
|
3011 |
* Gets the requested tuning parm value
|
3012 |
* - Large case statement for returns
|
3013 |
* - if key does not match, INVALID parm error returned
|
3014 |
*/
|
3015 |
|
3016 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
3017 |
|
3018 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
3019 |
|
3020 |
LOG_FUNCTION_START("");
|
3021 |
|
3022 |
switch (tuning_parm_key) {
|
3023 |
|
3024 |
case VL53L1_TUNINGPARM_VERSION:
|
3025 |
*ptuning_parm_value = |
3026 |
(int32_t)pdev->tuning_parms.tp_tuning_parm_version; |
3027 |
break;
|
3028 |
case VL53L1_TUNINGPARM_KEY_TABLE_VERSION:
|
3029 |
*ptuning_parm_value = |
3030 |
(int32_t)pdev->tuning_parms.tp_tuning_parm_key_table_version; |
3031 |
break;
|
3032 |
case VL53L1_TUNINGPARM_LLD_VERSION:
|
3033 |
*ptuning_parm_value = |
3034 |
(int32_t)pdev->tuning_parms.tp_tuning_parm_lld_version; |
3035 |
break;
|
3036 |
case VL53L1_TUNINGPARM_CONSISTENCY_LITE_PHASE_TOLERANCE:
|
3037 |
*ptuning_parm_value = |
3038 |
(int32_t)pdev->tuning_parms.tp_consistency_lite_phase_tolerance; |
3039 |
break;
|
3040 |
case VL53L1_TUNINGPARM_PHASECAL_TARGET:
|
3041 |
*ptuning_parm_value = |
3042 |
(int32_t)pdev->tuning_parms.tp_phasecal_target; |
3043 |
break;
|
3044 |
case VL53L1_TUNINGPARM_LITE_CAL_REPEAT_RATE:
|
3045 |
*ptuning_parm_value = |
3046 |
(int32_t)pdev->tuning_parms.tp_cal_repeat_rate; |
3047 |
break;
|
3048 |
case VL53L1_TUNINGPARM_LITE_RANGING_GAIN_FACTOR:
|
3049 |
*ptuning_parm_value = |
3050 |
(int32_t)pdev->gain_cal.standard_ranging_gain_factor; |
3051 |
break;
|
3052 |
case VL53L1_TUNINGPARM_LITE_MIN_CLIP_MM:
|
3053 |
*ptuning_parm_value = |
3054 |
(int32_t)pdev->tuning_parms.tp_lite_min_clip; |
3055 |
break;
|
3056 |
case VL53L1_TUNINGPARM_LITE_LONG_SIGMA_THRESH_MM:
|
3057 |
*ptuning_parm_value = |
3058 |
(int32_t)pdev->tuning_parms.tp_lite_long_sigma_thresh_mm; |
3059 |
break;
|
3060 |
case VL53L1_TUNINGPARM_LITE_MED_SIGMA_THRESH_MM:
|
3061 |
*ptuning_parm_value = |
3062 |
(int32_t)pdev->tuning_parms.tp_lite_med_sigma_thresh_mm; |
3063 |
break;
|
3064 |
case VL53L1_TUNINGPARM_LITE_SHORT_SIGMA_THRESH_MM:
|
3065 |
*ptuning_parm_value = |
3066 |
(int32_t)pdev->tuning_parms.tp_lite_short_sigma_thresh_mm; |
3067 |
break;
|
3068 |
case VL53L1_TUNINGPARM_LITE_LONG_MIN_COUNT_RATE_RTN_MCPS:
|
3069 |
*ptuning_parm_value = |
3070 |
(int32_t)pdev->tuning_parms.tp_lite_long_min_count_rate_rtn_mcps; |
3071 |
break;
|
3072 |
case VL53L1_TUNINGPARM_LITE_MED_MIN_COUNT_RATE_RTN_MCPS:
|
3073 |
*ptuning_parm_value = |
3074 |
(int32_t)pdev->tuning_parms.tp_lite_med_min_count_rate_rtn_mcps; |
3075 |
break;
|
3076 |
case VL53L1_TUNINGPARM_LITE_SHORT_MIN_COUNT_RATE_RTN_MCPS:
|
3077 |
*ptuning_parm_value = |
3078 |
(int32_t)pdev->tuning_parms.tp_lite_short_min_count_rate_rtn_mcps; |
3079 |
break;
|
3080 |
case VL53L1_TUNINGPARM_LITE_SIGMA_EST_PULSE_WIDTH:
|
3081 |
*ptuning_parm_value = |
3082 |
(int32_t)pdev->tuning_parms.tp_lite_sigma_est_pulse_width_ns; |
3083 |
break;
|
3084 |
case VL53L1_TUNINGPARM_LITE_SIGMA_EST_AMB_WIDTH_NS:
|
3085 |
*ptuning_parm_value = |
3086 |
(int32_t)pdev->tuning_parms.tp_lite_sigma_est_amb_width_ns; |
3087 |
break;
|
3088 |
case VL53L1_TUNINGPARM_LITE_SIGMA_REF_MM:
|
3089 |
*ptuning_parm_value = |
3090 |
(int32_t)pdev->tuning_parms.tp_lite_sigma_ref_mm; |
3091 |
break;
|
3092 |
case VL53L1_TUNINGPARM_LITE_RIT_MULT:
|
3093 |
*ptuning_parm_value = |
3094 |
(int32_t)pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult; |
3095 |
break;
|
3096 |
case VL53L1_TUNINGPARM_LITE_SEED_CONFIG:
|
3097 |
*ptuning_parm_value = |
3098 |
(int32_t)pdev->tuning_parms.tp_lite_seed_cfg ; |
3099 |
break;
|
3100 |
case VL53L1_TUNINGPARM_LITE_QUANTIFIER:
|
3101 |
*ptuning_parm_value = |
3102 |
(int32_t)pdev->tuning_parms.tp_lite_quantifier; |
3103 |
break;
|
3104 |
case VL53L1_TUNINGPARM_LITE_FIRST_ORDER_SELECT:
|
3105 |
*ptuning_parm_value = |
3106 |
(int32_t)pdev->tuning_parms.tp_lite_first_order_select; |
3107 |
break;
|
3108 |
case VL53L1_TUNINGPARM_LITE_XTALK_MARGIN_KCPS:
|
3109 |
*ptuning_parm_value = |
3110 |
(int32_t)pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps; |
3111 |
break;
|
3112 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_LONG_RANGE:
|
3113 |
*ptuning_parm_value = |
3114 |
(int32_t)pdev->tuning_parms.tp_init_phase_rtn_lite_long; |
3115 |
break;
|
3116 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_MED_RANGE:
|
3117 |
*ptuning_parm_value = |
3118 |
(int32_t)pdev->tuning_parms.tp_init_phase_rtn_lite_med; |
3119 |
break;
|
3120 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_SHORT_RANGE:
|
3121 |
*ptuning_parm_value = |
3122 |
(int32_t)pdev->tuning_parms.tp_init_phase_rtn_lite_short; |
3123 |
break;
|
3124 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_LONG_RANGE:
|
3125 |
*ptuning_parm_value = |
3126 |
(int32_t)pdev->tuning_parms.tp_init_phase_ref_lite_long; |
3127 |
break;
|
3128 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_MED_RANGE:
|
3129 |
*ptuning_parm_value = |
3130 |
(int32_t)pdev->tuning_parms.tp_init_phase_ref_lite_med; |
3131 |
break;
|
3132 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_SHORT_RANGE:
|
3133 |
*ptuning_parm_value = |
3134 |
(int32_t)pdev->tuning_parms.tp_init_phase_ref_lite_short; |
3135 |
break;
|
3136 |
case VL53L1_TUNINGPARM_TIMED_SEED_CONFIG:
|
3137 |
*ptuning_parm_value = |
3138 |
(int32_t)pdev->tuning_parms.tp_timed_seed_cfg; |
3139 |
break;
|
3140 |
case VL53L1_TUNINGPARM_VHV_LOOPBOUND:
|
3141 |
*ptuning_parm_value = |
3142 |
(int32_t)pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound; |
3143 |
break;
|
3144 |
case VL53L1_TUNINGPARM_REFSPADCHAR_DEVICE_TEST_MODE:
|
3145 |
*ptuning_parm_value = |
3146 |
(int32_t)pdev->refspadchar.device_test_mode; |
3147 |
break;
|
3148 |
case VL53L1_TUNINGPARM_REFSPADCHAR_VCSEL_PERIOD:
|
3149 |
*ptuning_parm_value = |
3150 |
(int32_t)pdev->refspadchar.vcsel_period; |
3151 |
break;
|
3152 |
case VL53L1_TUNINGPARM_REFSPADCHAR_PHASECAL_TIMEOUT_US:
|
3153 |
*ptuning_parm_value = |
3154 |
(int32_t)pdev->refspadchar.timeout_us; |
3155 |
break;
|
3156 |
case VL53L1_TUNINGPARM_REFSPADCHAR_TARGET_COUNT_RATE_MCPS:
|
3157 |
*ptuning_parm_value = |
3158 |
(int32_t)pdev->refspadchar.target_count_rate_mcps; |
3159 |
break;
|
3160 |
case VL53L1_TUNINGPARM_REFSPADCHAR_MIN_COUNTRATE_LIMIT_MCPS:
|
3161 |
*ptuning_parm_value = |
3162 |
(int32_t)pdev->refspadchar.min_count_rate_limit_mcps; |
3163 |
break;
|
3164 |
case VL53L1_TUNINGPARM_REFSPADCHAR_MAX_COUNTRATE_LIMIT_MCPS:
|
3165 |
*ptuning_parm_value = |
3166 |
(int32_t)pdev->refspadchar.max_count_rate_limit_mcps; |
3167 |
break;
|
3168 |
case VL53L1_TUNINGPARM_OFFSET_CAL_DSS_RATE_MCPS:
|
3169 |
*ptuning_parm_value = |
3170 |
(int32_t)pdev->offsetcal_cfg.dss_config__target_total_rate_mcps;; |
3171 |
break;
|
3172 |
case VL53L1_TUNINGPARM_OFFSET_CAL_PHASECAL_TIMEOUT_US:
|
3173 |
*ptuning_parm_value = |
3174 |
(int32_t)pdev->offsetcal_cfg.phasecal_config_timeout_us; |
3175 |
break;
|
3176 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM_TIMEOUT_US:
|
3177 |
*ptuning_parm_value = |
3178 |
(int32_t)pdev->offsetcal_cfg.mm_config_timeout_us; |
3179 |
break;
|
3180 |
case VL53L1_TUNINGPARM_OFFSET_CAL_RANGE_TIMEOUT_US:
|
3181 |
*ptuning_parm_value = |
3182 |
(int32_t)pdev->offsetcal_cfg.range_config_timeout_us; |
3183 |
break;
|
3184 |
case VL53L1_TUNINGPARM_OFFSET_CAL_PRE_SAMPLES:
|
3185 |
*ptuning_parm_value = |
3186 |
(int32_t)pdev->offsetcal_cfg.pre_num_of_samples; |
3187 |
break;
|
3188 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM1_SAMPLES:
|
3189 |
*ptuning_parm_value = |
3190 |
(int32_t)pdev->offsetcal_cfg.mm1_num_of_samples; |
3191 |
break;
|
3192 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM2_SAMPLES:
|
3193 |
*ptuning_parm_value = |
3194 |
(int32_t)pdev->offsetcal_cfg.mm2_num_of_samples; |
3195 |
break;
|
3196 |
case VL53L1_TUNINGPARM_SPADMAP_VCSEL_PERIOD:
|
3197 |
*ptuning_parm_value = |
3198 |
(int32_t)pdev->ssc_cfg.vcsel_period; |
3199 |
break;
|
3200 |
case VL53L1_TUNINGPARM_SPADMAP_VCSEL_START:
|
3201 |
*ptuning_parm_value = |
3202 |
(int32_t)pdev->ssc_cfg.vcsel_start; |
3203 |
break;
|
3204 |
case VL53L1_TUNINGPARM_SPADMAP_RATE_LIMIT_MCPS:
|
3205 |
*ptuning_parm_value = |
3206 |
(int32_t)pdev->ssc_cfg.rate_limit_mcps; |
3207 |
break;
|
3208 |
case VL53L1_TUNINGPARM_LITE_DSS_CONFIG_TARGET_TOTAL_RATE_MCPS:
|
3209 |
*ptuning_parm_value = |
3210 |
(int32_t)pdev->tuning_parms.tp_dss_target_lite_mcps; |
3211 |
break;
|
3212 |
case VL53L1_TUNINGPARM_TIMED_DSS_CONFIG_TARGET_TOTAL_RATE_MCPS:
|
3213 |
*ptuning_parm_value = |
3214 |
(int32_t)pdev->tuning_parms.tp_dss_target_timed_mcps; |
3215 |
break;
|
3216 |
case VL53L1_TUNINGPARM_LITE_PHASECAL_CONFIG_TIMEOUT_US:
|
3217 |
*ptuning_parm_value = |
3218 |
(int32_t)pdev->tuning_parms.tp_phasecal_timeout_lite_us; |
3219 |
break;
|
3220 |
case VL53L1_TUNINGPARM_TIMED_PHASECAL_CONFIG_TIMEOUT_US:
|
3221 |
*ptuning_parm_value = |
3222 |
(int32_t)pdev->tuning_parms.tp_phasecal_timeout_timed_us; |
3223 |
break;
|
3224 |
case VL53L1_TUNINGPARM_LITE_MM_CONFIG_TIMEOUT_US:
|
3225 |
*ptuning_parm_value = |
3226 |
(int32_t)pdev->tuning_parms.tp_mm_timeout_lite_us; |
3227 |
break;
|
3228 |
case VL53L1_TUNINGPARM_TIMED_MM_CONFIG_TIMEOUT_US:
|
3229 |
*ptuning_parm_value = |
3230 |
(int32_t)pdev->tuning_parms.tp_mm_timeout_timed_us; |
3231 |
break;
|
3232 |
case VL53L1_TUNINGPARM_LITE_RANGE_CONFIG_TIMEOUT_US:
|
3233 |
*ptuning_parm_value = |
3234 |
(int32_t)pdev->tuning_parms.tp_range_timeout_lite_us; |
3235 |
break;
|
3236 |
case VL53L1_TUNINGPARM_TIMED_RANGE_CONFIG_TIMEOUT_US:
|
3237 |
*ptuning_parm_value = |
3238 |
(int32_t)pdev->tuning_parms.tp_range_timeout_timed_us; |
3239 |
break;
|
3240 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_VHV_LOOP_BOUND:
|
3241 |
*ptuning_parm_value = |
3242 |
(int32_t)pdev->low_power_auto_data.vhv_loop_bound; |
3243 |
break;
|
3244 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_MM_CONFIG_TIMEOUT_US:
|
3245 |
*ptuning_parm_value = |
3246 |
(int32_t)pdev->tuning_parms.tp_mm_timeout_lpa_us; |
3247 |
break;
|
3248 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_RANGE_CONFIG_TIMEOUT_US:
|
3249 |
*ptuning_parm_value = |
3250 |
(int32_t)pdev->tuning_parms.tp_range_timeout_lpa_us; |
3251 |
break;
|
3252 |
|
3253 |
|
3254 |
default:
|
3255 |
*ptuning_parm_value = 0x7FFFFFFF;
|
3256 |
status = VL53L1_ERROR_INVALID_PARAMS; |
3257 |
break;
|
3258 |
|
3259 |
} |
3260 |
|
3261 |
LOG_FUNCTION_END(status); |
3262 |
|
3263 |
return status;
|
3264 |
} |
3265 |
|
3266 |
VL53L1_Error VL53L1_set_tuning_parm( |
3267 |
VL53L1_DEV Dev, |
3268 |
VL53L1_TuningParms tuning_parm_key, |
3269 |
int32_t tuning_parm_value) |
3270 |
{ |
3271 |
|
3272 |
/*
|
3273 |
* Sets the requested tuning parm value
|
3274 |
* - Large case statement for set value
|
3275 |
* - if key does not match, INVALID parm error returned
|
3276 |
*/
|
3277 |
|
3278 |
VL53L1_Error status = VL53L1_ERROR_NONE; |
3279 |
|
3280 |
VL53L1_LLDriverData_t *pdev = VL53L1DevStructGetLLDriverHandle(Dev); |
3281 |
|
3282 |
LOG_FUNCTION_START("");
|
3283 |
|
3284 |
switch (tuning_parm_key) {
|
3285 |
|
3286 |
case VL53L1_TUNINGPARM_VERSION:
|
3287 |
pdev->tuning_parms.tp_tuning_parm_version = |
3288 |
(uint16_t)tuning_parm_value; |
3289 |
break;
|
3290 |
case VL53L1_TUNINGPARM_KEY_TABLE_VERSION:
|
3291 |
pdev->tuning_parms.tp_tuning_parm_key_table_version = |
3292 |
(uint16_t)tuning_parm_value; |
3293 |
|
3294 |
/* Perform Key Table Check
|
3295 |
*
|
3296 |
* - If does not match default, key table
|
3297 |
* format does not match tuning file,
|
3298 |
* error should be thrown
|
3299 |
*
|
3300 |
*/
|
3301 |
|
3302 |
if ((uint16_t)tuning_parm_value
|
3303 |
!= VL53L1_TUNINGPARM_KEY_TABLE_VERSION_DEFAULT) { |
3304 |
status = VL53L1_ERROR_TUNING_PARM_KEY_MISMATCH; |
3305 |
} |
3306 |
break;
|
3307 |
case VL53L1_TUNINGPARM_LLD_VERSION:
|
3308 |
pdev->tuning_parms.tp_tuning_parm_lld_version = |
3309 |
(uint16_t)tuning_parm_value; |
3310 |
break;
|
3311 |
case VL53L1_TUNINGPARM_CONSISTENCY_LITE_PHASE_TOLERANCE:
|
3312 |
pdev->tuning_parms.tp_consistency_lite_phase_tolerance = |
3313 |
(uint8_t)tuning_parm_value; |
3314 |
break;
|
3315 |
case VL53L1_TUNINGPARM_PHASECAL_TARGET:
|
3316 |
pdev->tuning_parms.tp_phasecal_target = |
3317 |
(uint8_t)tuning_parm_value; |
3318 |
break;
|
3319 |
case VL53L1_TUNINGPARM_LITE_CAL_REPEAT_RATE:
|
3320 |
pdev->tuning_parms.tp_cal_repeat_rate = |
3321 |
(uint16_t)tuning_parm_value; |
3322 |
break;
|
3323 |
case VL53L1_TUNINGPARM_LITE_RANGING_GAIN_FACTOR:
|
3324 |
pdev->gain_cal.standard_ranging_gain_factor = |
3325 |
(uint16_t)tuning_parm_value; |
3326 |
break;
|
3327 |
case VL53L1_TUNINGPARM_LITE_MIN_CLIP_MM:
|
3328 |
pdev->tuning_parms.tp_lite_min_clip = |
3329 |
(uint8_t)tuning_parm_value; |
3330 |
break;
|
3331 |
case VL53L1_TUNINGPARM_LITE_LONG_SIGMA_THRESH_MM:
|
3332 |
pdev->tuning_parms.tp_lite_long_sigma_thresh_mm = |
3333 |
(uint16_t)tuning_parm_value; |
3334 |
break;
|
3335 |
case VL53L1_TUNINGPARM_LITE_MED_SIGMA_THRESH_MM:
|
3336 |
pdev->tuning_parms.tp_lite_med_sigma_thresh_mm = |
3337 |
(uint16_t)tuning_parm_value; |
3338 |
break;
|
3339 |
case VL53L1_TUNINGPARM_LITE_SHORT_SIGMA_THRESH_MM:
|
3340 |
pdev->tuning_parms.tp_lite_short_sigma_thresh_mm = |
3341 |
(uint16_t)tuning_parm_value; |
3342 |
break;
|
3343 |
case VL53L1_TUNINGPARM_LITE_LONG_MIN_COUNT_RATE_RTN_MCPS:
|
3344 |
pdev->tuning_parms.tp_lite_long_min_count_rate_rtn_mcps = |
3345 |
(uint16_t)tuning_parm_value; |
3346 |
break;
|
3347 |
case VL53L1_TUNINGPARM_LITE_MED_MIN_COUNT_RATE_RTN_MCPS:
|
3348 |
pdev->tuning_parms.tp_lite_med_min_count_rate_rtn_mcps = |
3349 |
(uint16_t)tuning_parm_value; |
3350 |
break;
|
3351 |
case VL53L1_TUNINGPARM_LITE_SHORT_MIN_COUNT_RATE_RTN_MCPS:
|
3352 |
pdev->tuning_parms.tp_lite_short_min_count_rate_rtn_mcps = |
3353 |
(uint16_t)tuning_parm_value; |
3354 |
break;
|
3355 |
case VL53L1_TUNINGPARM_LITE_SIGMA_EST_PULSE_WIDTH:
|
3356 |
pdev->tuning_parms.tp_lite_sigma_est_pulse_width_ns = |
3357 |
(uint8_t)tuning_parm_value; |
3358 |
break;
|
3359 |
case VL53L1_TUNINGPARM_LITE_SIGMA_EST_AMB_WIDTH_NS:
|
3360 |
pdev->tuning_parms.tp_lite_sigma_est_amb_width_ns = |
3361 |
(uint8_t)tuning_parm_value; |
3362 |
break;
|
3363 |
case VL53L1_TUNINGPARM_LITE_SIGMA_REF_MM:
|
3364 |
pdev->tuning_parms.tp_lite_sigma_ref_mm = |
3365 |
(uint8_t)tuning_parm_value; |
3366 |
break;
|
3367 |
case VL53L1_TUNINGPARM_LITE_RIT_MULT:
|
3368 |
pdev->xtalk_cfg.crosstalk_range_ignore_threshold_mult = |
3369 |
(uint8_t)tuning_parm_value; |
3370 |
break;
|
3371 |
case VL53L1_TUNINGPARM_LITE_SEED_CONFIG:
|
3372 |
pdev->tuning_parms.tp_lite_seed_cfg = |
3373 |
(uint8_t)tuning_parm_value; |
3374 |
break;
|
3375 |
case VL53L1_TUNINGPARM_LITE_QUANTIFIER:
|
3376 |
pdev->tuning_parms.tp_lite_quantifier = |
3377 |
(uint8_t)tuning_parm_value; |
3378 |
break;
|
3379 |
case VL53L1_TUNINGPARM_LITE_FIRST_ORDER_SELECT:
|
3380 |
pdev->tuning_parms.tp_lite_first_order_select = |
3381 |
(uint8_t)tuning_parm_value; |
3382 |
break;
|
3383 |
case VL53L1_TUNINGPARM_LITE_XTALK_MARGIN_KCPS:
|
3384 |
pdev->xtalk_cfg.lite_mode_crosstalk_margin_kcps = |
3385 |
(int16_t)tuning_parm_value; |
3386 |
break;
|
3387 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_LONG_RANGE:
|
3388 |
pdev->tuning_parms.tp_init_phase_rtn_lite_long = |
3389 |
(uint8_t)tuning_parm_value; |
3390 |
break;
|
3391 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_MED_RANGE:
|
3392 |
pdev->tuning_parms.tp_init_phase_rtn_lite_med = |
3393 |
(uint8_t)tuning_parm_value; |
3394 |
break;
|
3395 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_RTN_LITE_SHORT_RANGE:
|
3396 |
pdev->tuning_parms.tp_init_phase_rtn_lite_short = |
3397 |
(uint8_t)tuning_parm_value; |
3398 |
break;
|
3399 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_LONG_RANGE:
|
3400 |
pdev->tuning_parms.tp_init_phase_ref_lite_long = |
3401 |
(uint8_t)tuning_parm_value; |
3402 |
break;
|
3403 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_MED_RANGE:
|
3404 |
pdev->tuning_parms.tp_init_phase_ref_lite_med = |
3405 |
(uint8_t)tuning_parm_value; |
3406 |
break;
|
3407 |
case VL53L1_TUNINGPARM_INITIAL_PHASE_REF_LITE_SHORT_RANGE:
|
3408 |
pdev->tuning_parms.tp_init_phase_ref_lite_short = |
3409 |
(uint8_t)tuning_parm_value; |
3410 |
break;
|
3411 |
case VL53L1_TUNINGPARM_TIMED_SEED_CONFIG:
|
3412 |
pdev->tuning_parms.tp_timed_seed_cfg = |
3413 |
(uint8_t)tuning_parm_value; |
3414 |
break;
|
3415 |
case VL53L1_TUNINGPARM_VHV_LOOPBOUND:
|
3416 |
pdev->stat_nvm.vhv_config__timeout_macrop_loop_bound = |
3417 |
(uint8_t)tuning_parm_value; |
3418 |
break;
|
3419 |
case VL53L1_TUNINGPARM_REFSPADCHAR_DEVICE_TEST_MODE:
|
3420 |
pdev->refspadchar.device_test_mode = |
3421 |
(uint8_t)tuning_parm_value; |
3422 |
break;
|
3423 |
case VL53L1_TUNINGPARM_REFSPADCHAR_VCSEL_PERIOD:
|
3424 |
pdev->refspadchar.vcsel_period = |
3425 |
(uint8_t)tuning_parm_value; |
3426 |
break;
|
3427 |
case VL53L1_TUNINGPARM_REFSPADCHAR_PHASECAL_TIMEOUT_US:
|
3428 |
pdev->refspadchar.timeout_us = |
3429 |
(uint32_t)tuning_parm_value; |
3430 |
break;
|
3431 |
case VL53L1_TUNINGPARM_REFSPADCHAR_TARGET_COUNT_RATE_MCPS:
|
3432 |
pdev->refspadchar.target_count_rate_mcps = |
3433 |
(uint16_t)tuning_parm_value; |
3434 |
break;
|
3435 |
case VL53L1_TUNINGPARM_REFSPADCHAR_MIN_COUNTRATE_LIMIT_MCPS:
|
3436 |
pdev->refspadchar.min_count_rate_limit_mcps = |
3437 |
(uint16_t)tuning_parm_value; |
3438 |
break;
|
3439 |
case VL53L1_TUNINGPARM_REFSPADCHAR_MAX_COUNTRATE_LIMIT_MCPS:
|
3440 |
pdev->refspadchar.max_count_rate_limit_mcps = |
3441 |
(uint16_t)tuning_parm_value; |
3442 |
break;
|
3443 |
case VL53L1_TUNINGPARM_OFFSET_CAL_DSS_RATE_MCPS:
|
3444 |
pdev->offsetcal_cfg.dss_config__target_total_rate_mcps = |
3445 |
(uint16_t)tuning_parm_value; |
3446 |
break;
|
3447 |
case VL53L1_TUNINGPARM_OFFSET_CAL_PHASECAL_TIMEOUT_US:
|
3448 |
pdev->offsetcal_cfg.phasecal_config_timeout_us = |
3449 |
(uint32_t)tuning_parm_value; |
3450 |
break;
|
3451 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM_TIMEOUT_US:
|
3452 |
pdev->offsetcal_cfg.mm_config_timeout_us = |
3453 |
(uint32_t)tuning_parm_value; |
3454 |
break;
|
3455 |
case VL53L1_TUNINGPARM_OFFSET_CAL_RANGE_TIMEOUT_US:
|
3456 |
pdev->offsetcal_cfg.range_config_timeout_us = |
3457 |
(uint32_t)tuning_parm_value; |
3458 |
break;
|
3459 |
case VL53L1_TUNINGPARM_OFFSET_CAL_PRE_SAMPLES:
|
3460 |
pdev->offsetcal_cfg.pre_num_of_samples = |
3461 |
(uint8_t)tuning_parm_value; |
3462 |
break;
|
3463 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM1_SAMPLES:
|
3464 |
pdev->offsetcal_cfg.mm1_num_of_samples = |
3465 |
(uint8_t)tuning_parm_value; |
3466 |
break;
|
3467 |
case VL53L1_TUNINGPARM_OFFSET_CAL_MM2_SAMPLES:
|
3468 |
pdev->offsetcal_cfg.mm2_num_of_samples = |
3469 |
(uint8_t)tuning_parm_value; |
3470 |
break;
|
3471 |
case VL53L1_TUNINGPARM_SPADMAP_VCSEL_PERIOD:
|
3472 |
pdev->ssc_cfg.vcsel_period = |
3473 |
(uint8_t)tuning_parm_value; |
3474 |
break;
|
3475 |
case VL53L1_TUNINGPARM_SPADMAP_VCSEL_START:
|
3476 |
pdev->ssc_cfg.vcsel_start = |
3477 |
(uint8_t)tuning_parm_value; |
3478 |
break;
|
3479 |
case VL53L1_TUNINGPARM_SPADMAP_RATE_LIMIT_MCPS:
|
3480 |
pdev->ssc_cfg.rate_limit_mcps = |
3481 |
(uint16_t)tuning_parm_value; |
3482 |
break;
|
3483 |
case VL53L1_TUNINGPARM_LITE_DSS_CONFIG_TARGET_TOTAL_RATE_MCPS:
|
3484 |
pdev->tuning_parms.tp_dss_target_lite_mcps = |
3485 |
(uint16_t)tuning_parm_value; |
3486 |
break;
|
3487 |
case VL53L1_TUNINGPARM_TIMED_DSS_CONFIG_TARGET_TOTAL_RATE_MCPS:
|
3488 |
pdev->tuning_parms.tp_dss_target_timed_mcps = |
3489 |
(uint16_t)tuning_parm_value; |
3490 |
break;
|
3491 |
case VL53L1_TUNINGPARM_LITE_PHASECAL_CONFIG_TIMEOUT_US:
|
3492 |
pdev->tuning_parms.tp_phasecal_timeout_lite_us = |
3493 |
(uint32_t)tuning_parm_value; |
3494 |
break;
|
3495 |
case VL53L1_TUNINGPARM_TIMED_PHASECAL_CONFIG_TIMEOUT_US:
|
3496 |
pdev->tuning_parms.tp_phasecal_timeout_timed_us = |
3497 |
(uint32_t)tuning_parm_value; |
3498 |
break;
|
3499 |
case VL53L1_TUNINGPARM_LITE_MM_CONFIG_TIMEOUT_US:
|
3500 |
pdev->tuning_parms.tp_mm_timeout_lite_us = |
3501 |
(uint32_t)tuning_parm_value; |
3502 |
break;
|
3503 |
case VL53L1_TUNINGPARM_TIMED_MM_CONFIG_TIMEOUT_US:
|
3504 |
pdev->tuning_parms.tp_mm_timeout_timed_us = |
3505 |
(uint32_t)tuning_parm_value; |
3506 |
break;
|
3507 |
case VL53L1_TUNINGPARM_LITE_RANGE_CONFIG_TIMEOUT_US:
|
3508 |
pdev->tuning_parms.tp_range_timeout_lite_us = |
3509 |
(uint32_t)tuning_parm_value; |
3510 |
break;
|
3511 |
case VL53L1_TUNINGPARM_TIMED_RANGE_CONFIG_TIMEOUT_US:
|
3512 |
pdev->tuning_parms.tp_range_timeout_timed_us = |
3513 |
(uint32_t)tuning_parm_value; |
3514 |
break;
|
3515 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_VHV_LOOP_BOUND:
|
3516 |
pdev->low_power_auto_data.vhv_loop_bound = |
3517 |
(uint8_t)tuning_parm_value; |
3518 |
break;
|
3519 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_MM_CONFIG_TIMEOUT_US:
|
3520 |
pdev->tuning_parms.tp_mm_timeout_lpa_us = |
3521 |
(uint32_t)tuning_parm_value; |
3522 |
break;
|
3523 |
case VL53L1_TUNINGPARM_LOWPOWERAUTO_RANGE_CONFIG_TIMEOUT_US:
|
3524 |
pdev->tuning_parms.tp_range_timeout_lpa_us = |
3525 |
(uint32_t)tuning_parm_value; |
3526 |
break;
|
3527 |
|
3528 |
|
3529 |
default:
|
3530 |
status = VL53L1_ERROR_INVALID_PARAMS; |
3531 |
break;
|
3532 |
|
3533 |
} |
3534 |
|
3535 |
LOG_FUNCTION_END(status); |
3536 |
|
3537 |
return status;
|
3538 |
} |
3539 |
|
3540 |
/* End Patch_AddedTuningParms_11761 */
|