X_NUCLEO_53L0A1_mbed_sdk - Updates to follow mbed SDK coding style guideline…

ST Expansion SW Team » Code » X_NUCLEO_53L0A1_mbed_sdk

ST Expansion SW Team / X_NUCLEO_53L0A1_mbed_sdk

Updates to follow mbed SDK coding style guidelines.

Dependencies: ST_INTERFACES X_NUCLEO_COMMON

Dependents: 53L0A1_Satellites_with_Interrupts_OS5 Display_53L0A1_OS5

Fork of X_NUCLEO_53L0A1 by ST

Components/VL53L0X/vl53l0x_class.cpp@21:627b65069e6d, 2017-06-28 (annotated)

Committer:: JerrySzczurak
Date:: Wed Jun 28 12:23:03 2017 +0000
Revision:: 21:627b65069e6d
Parent:: 20:cf211a3b3d9e

Cosmetic changes to v53l0x class; wrWord and rdWord calls changed to write_word and read_word

Who changed what in which revision?

User	Revision	Line number	New contents of line
johnAlexander	0:c523920bcc09	1	/**
johnAlexander	0:c523920bcc09	2	******************************************************************************
johnAlexander	0:c523920bcc09	3	* @file vl53l0x_class.cpp
johnAlexander	0:c523920bcc09	4	* @author IMG
johnAlexander	0:c523920bcc09	5	* @version V0.0.1
johnAlexander	0:c523920bcc09	6	* @date 28-June-2016
johnAlexander	0:c523920bcc09	7	* @brief Implementation file for the VL53L0X driver class
johnAlexander	0:c523920bcc09	8	******************************************************************************
johnAlexander	0:c523920bcc09	9	* @attention
johnAlexander	0:c523920bcc09	10	*
johnAlexander	0:c523920bcc09	11	* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
johnAlexander	0:c523920bcc09	12	*
johnAlexander	0:c523920bcc09	13	* Redistribution and use in source and binary forms, with or without modification,
johnAlexander	0:c523920bcc09	14	* are permitted provided that the following conditions are met:
johnAlexander	0:c523920bcc09	15	* 1. Redistributions of source code must retain the above copyright notice,
johnAlexander	0:c523920bcc09	16	* this list of conditions and the following disclaimer.
johnAlexander	0:c523920bcc09	17	* 2. Redistributions in binary form must reproduce the above copyright notice,
johnAlexander	0:c523920bcc09	18	* this list of conditions and the following disclaimer in the documentation
johnAlexander	0:c523920bcc09	19	* and/or other materials provided with the distribution.
johnAlexander	0:c523920bcc09	20	* 3. Neither the name of STMicroelectronics nor the names of its contributors
johnAlexander	0:c523920bcc09	21	* may be used to endorse or promote products derived from this software
johnAlexander	0:c523920bcc09	22	* without specific prior written permission.
johnAlexander	0:c523920bcc09	23	*
johnAlexander	0:c523920bcc09	24	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
johnAlexander	0:c523920bcc09	25	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
johnAlexander	0:c523920bcc09	26	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
johnAlexander	0:c523920bcc09	27	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
johnAlexander	0:c523920bcc09	28	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
johnAlexander	0:c523920bcc09	29	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
johnAlexander	0:c523920bcc09	30	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
johnAlexander	0:c523920bcc09	31	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
johnAlexander	0:c523920bcc09	32	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
johnAlexander	0:c523920bcc09	33	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
johnAlexander	0:c523920bcc09	34	*
johnAlexander	0:c523920bcc09	35	******************************************************************************
johnAlexander	0:c523920bcc09	36	*/
johnAlexander	15:932d8b4e52c9	37
johnAlexander	0:c523920bcc09	38	/* Includes */
johnAlexander	0:c523920bcc09	39	#include <stdlib.h>
johnAlexander	0:c523920bcc09	40
johnAlexander	0:c523920bcc09	41	#include "vl53l0x_class.h"
johnAlexander	0:c523920bcc09	42
johnAlexander	0:c523920bcc09	43	//#include "vl53l0x_api_core.h"
johnAlexander	0:c523920bcc09	44	//#include "vl53l0x_api_calibration.h"
johnAlexander	0:c523920bcc09	45	//#include "vl53l0x_api_strings.h"
johnAlexander	0:c523920bcc09	46	#include "vl53l0x_interrupt_threshold_settings.h"
johnAlexander	0:c523920bcc09	47	#include "vl53l0x_tuning.h"
johnAlexander	0:c523920bcc09	48	#include "vl53l0x_types.h"
johnAlexander	0:c523920bcc09	49
johnAlexander	0:c523920bcc09	50
johnAlexander	0:c523920bcc09	51	/**************** define for i2c configuration *****************************/
johnAlexander	15:932d8b4e52c9	52
johnAlexander	0:c523920bcc09	53	#define TEMP_BUF_SIZE 64
johnAlexander	0:c523920bcc09	54
johnAlexander	0:c523920bcc09	55	/** Maximum buffer size to be used in i2c */
johnAlexander	0:c523920bcc09	56	#define VL53L0X_MAX_I2C_XFER_SIZE 64 /* Maximum buffer size to be used in i2c */
johnAlexander	0:c523920bcc09	57	#define VL53L0X_I2C_USER_VAR /* none but could be for a flag var to get/pass to mutex interruptible return flags and try again */
johnAlexander	15:932d8b4e52c9	58
johnAlexander	0:c523920bcc09	59
johnAlexander	0:c523920bcc09	60	#define LOG_FUNCTION_START(fmt, ...) \
johnAlexander	0:c523920bcc09	61	_LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
johnAlexander	0:c523920bcc09	62	#define LOG_FUNCTION_END(status, ...) \
johnAlexander	0:c523920bcc09	63	_LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
johnAlexander	0:c523920bcc09	64	#define LOG_FUNCTION_END_FMT(status, fmt, ...) \
johnAlexander	0:c523920bcc09	65	_LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)
johnAlexander	0:c523920bcc09	66
johnAlexander	0:c523920bcc09	67	#ifdef VL53L0X_LOG_ENABLE
johnAlexander	0:c523920bcc09	68	#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_API, \
johnAlexander	0:c523920bcc09	69	level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
johnAlexander	0:c523920bcc09	70	#endif
johnAlexander	0:c523920bcc09	71
johnAlexander	0:c523920bcc09	72	#define REF_ARRAY_SPAD_0 0
johnAlexander	0:c523920bcc09	73	#define REF_ARRAY_SPAD_5 5
johnAlexander	0:c523920bcc09	74	#define REF_ARRAY_SPAD_10 10
johnAlexander	0:c523920bcc09	75
johnAlexander	0:c523920bcc09	76	uint32_t refArrayQuadrants[4] = {REF_ARRAY_SPAD_10, REF_ARRAY_SPAD_5,
johnAlexander	15:932d8b4e52c9	77	REF_ARRAY_SPAD_0, REF_ARRAY_SPAD_5
johnAlexander	15:932d8b4e52c9	78	};
johnAlexander	0:c523920bcc09	79
johnAlexander	0:c523920bcc09	80
johnAlexander	0:c523920bcc09	81
johnAlexander	0:c523920bcc09	82
JerrySzczurak	20:cf211a3b3d9e	83	VL53L0X_Error VL53L0X::vl53l0x_device_read_strobe( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	84	{
johnAlexander	16:98ce55ddbb1a	85	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	86	uint8_t strobe;
johnAlexander	16:98ce55ddbb1a	87	uint32_t loop_nb;
JerrySzczurak	20:cf211a3b3d9e	88	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	89
JerrySzczurak	20:cf211a3b3d9e	90	status \|= vl53l0x_write_byte( dev, 0x83, 0x00 );
johnAlexander	15:932d8b4e52c9	91
johnAlexander	15:932d8b4e52c9	92	/* polling
johnAlexander	15:932d8b4e52c9	93	* use timeout to avoid deadlock*/
JerrySzczurak	20:cf211a3b3d9e	94	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	95	loop_nb = 0;
johnAlexander	15:932d8b4e52c9	96	do {
JerrySzczurak	20:cf211a3b3d9e	97	status = vl53l0x_read_byte( dev, 0x83, &strobe );
JerrySzczurak	20:cf211a3b3d9e	98	if ( ( strobe != 0x00 ) \|\| status != VL53L0X_ERROR_NONE )
johnAlexander	15:932d8b4e52c9	99	break;
johnAlexander	15:932d8b4e52c9	100
johnAlexander	16:98ce55ddbb1a	101	loop_nb = loop_nb + 1;
JerrySzczurak	20:cf211a3b3d9e	102	} while ( loop_nb < VL53L0X_DEFAULT_MAX_LOOP );
JerrySzczurak	20:cf211a3b3d9e	103
JerrySzczurak	20:cf211a3b3d9e	104	if ( loop_nb >= VL53L0X_DEFAULT_MAX_LOOP )
johnAlexander	16:98ce55ddbb1a	105	status = VL53L0X_ERROR_TIME_OUT;
johnAlexander	15:932d8b4e52c9	106
johnAlexander	15:932d8b4e52c9	107	}
johnAlexander	15:932d8b4e52c9	108
JerrySzczurak	20:cf211a3b3d9e	109	status \|= vl53l0x_write_byte( dev, 0x83, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	110
JerrySzczurak	20:cf211a3b3d9e	111	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	112	return status;
JerrySzczurak	20:cf211a3b3d9e	113
JerrySzczurak	20:cf211a3b3d9e	114	}
JerrySzczurak	20:cf211a3b3d9e	115
JerrySzczurak	20:cf211a3b3d9e	116	VL53L0X_Error VL53L0X::vl53l0x_get_info_from_device( VL53L0X_DEV dev, uint8_t option )
johnAlexander	0:c523920bcc09	117	{
johnAlexander	0:c523920bcc09	118
johnAlexander	16:98ce55ddbb1a	119	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	120	uint8_t byte;
johnAlexander	16:98ce55ddbb1a	121	uint32_t tmp_dword;
johnAlexander	16:98ce55ddbb1a	122	uint8_t module_id;
johnAlexander	16:98ce55ddbb1a	123	uint8_t revision;
johnAlexander	16:98ce55ddbb1a	124	uint8_t reference_spad_count = 0;
johnAlexander	16:98ce55ddbb1a	125	uint8_t reference_spad_type = 0;
johnAlexander	16:98ce55ddbb1a	126	uint32_t part_uid_upper = 0;
johnAlexander	16:98ce55ddbb1a	127	uint32_t part_uid_lower = 0;
johnAlexander	16:98ce55ddbb1a	128	uint32_t offset_fixed1104_mm = 0;
johnAlexander	16:98ce55ddbb1a	129	int16_t offset_micro_meters = 0;
johnAlexander	16:98ce55ddbb1a	130	uint32_t dist_meas_tgt_fixed1104_mm = 400 << 4;
johnAlexander	16:98ce55ddbb1a	131	uint32_t dist_meas_fixed1104_400_mm = 0;
johnAlexander	16:98ce55ddbb1a	132	uint32_t signal_rate_meas_fixed1104_400_mm = 0;
johnAlexander	16:98ce55ddbb1a	133	char product_id[19];
johnAlexander	16:98ce55ddbb1a	134	char *product_id_tmp;
johnAlexander	16:98ce55ddbb1a	135	uint8_t read_data_from_device_done;
johnAlexander	16:98ce55ddbb1a	136	FixPoint1616_t signal_rate_meas_fixed400_mm_fix = 0;
johnAlexander	16:98ce55ddbb1a	137	uint8_t nvm_ref_good_spad_map[VL53L0X_REF_SPAD_BUFFER_SIZE];
johnAlexander	15:932d8b4e52c9	138	int i;
johnAlexander	15:932d8b4e52c9	139
johnAlexander	15:932d8b4e52c9	140
JerrySzczurak	20:cf211a3b3d9e	141	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	142
JerrySzczurak	20:cf211a3b3d9e	143	read_data_from_device_done = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	144	ReadDataFromDeviceDone );
johnAlexander	15:932d8b4e52c9	145
johnAlexander	15:932d8b4e52c9	146	/* This access is done only once after that a GetDeviceInfo or
johnAlexander	15:932d8b4e52c9	147	* datainit is done*/
JerrySzczurak	20:cf211a3b3d9e	148	if ( read_data_from_device_done != 7 ) {
JerrySzczurak	20:cf211a3b3d9e	149
JerrySzczurak	20:cf211a3b3d9e	150	status \|= vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	151	status \|= vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	152	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	153
JerrySzczurak	20:cf211a3b3d9e	154	status \|= vl53l0x_write_byte( dev, 0xFF, 0x06 );
JerrySzczurak	20:cf211a3b3d9e	155	status \|= vl53l0x_read_byte( dev, 0x83, &byte );
JerrySzczurak	20:cf211a3b3d9e	156	status \|= vl53l0x_write_byte( dev, 0x83, byte \| 4 );
JerrySzczurak	20:cf211a3b3d9e	157	status \|= vl53l0x_write_byte( dev, 0xFF, 0x07 );
JerrySzczurak	20:cf211a3b3d9e	158	status \|= vl53l0x_write_byte( dev, 0x81, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	159
JerrySzczurak	20:cf211a3b3d9e	160	status \|= vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	161
JerrySzczurak	20:cf211a3b3d9e	162	status \|= vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	163
JerrySzczurak	20:cf211a3b3d9e	164	if ( ( ( option & 1 ) == 1 ) &&
JerrySzczurak	20:cf211a3b3d9e	165	( ( read_data_from_device_done & 1 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	166	status \|= vl53l0x_write_byte( dev, 0x94, 0x6b );
JerrySzczurak	20:cf211a3b3d9e	167	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	168	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	169
JerrySzczurak	20:cf211a3b3d9e	170	reference_spad_count = ( uint8_t )( ( tmp_dword >> 8 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	171	reference_spad_type = ( uint8_t )( ( tmp_dword >> 15 ) & 0x01 );
JerrySzczurak	20:cf211a3b3d9e	172
JerrySzczurak	20:cf211a3b3d9e	173	status \|= vl53l0x_write_byte( dev, 0x94, 0x24 );
JerrySzczurak	20:cf211a3b3d9e	174	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	175	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	176
JerrySzczurak	20:cf211a3b3d9e	177
JerrySzczurak	20:cf211a3b3d9e	178	nvm_ref_good_spad_map[0] = ( uint8_t )( ( tmp_dword >> 24 )
JerrySzczurak	20:cf211a3b3d9e	179	& 0xff );
JerrySzczurak	20:cf211a3b3d9e	180	nvm_ref_good_spad_map[1] = ( uint8_t )( ( tmp_dword >> 16 )
JerrySzczurak	20:cf211a3b3d9e	181	& 0xff );
JerrySzczurak	20:cf211a3b3d9e	182	nvm_ref_good_spad_map[2] = ( uint8_t )( ( tmp_dword >> 8 )
JerrySzczurak	20:cf211a3b3d9e	183	& 0xff );
JerrySzczurak	20:cf211a3b3d9e	184	nvm_ref_good_spad_map[3] = ( uint8_t )( tmp_dword & 0xff );
JerrySzczurak	20:cf211a3b3d9e	185
JerrySzczurak	20:cf211a3b3d9e	186	status \|= vl53l0x_write_byte( dev, 0x94, 0x25 );
JerrySzczurak	20:cf211a3b3d9e	187	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	188	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	189
JerrySzczurak	20:cf211a3b3d9e	190	nvm_ref_good_spad_map[4] = ( uint8_t )( ( tmp_dword >> 24 )
JerrySzczurak	20:cf211a3b3d9e	191	& 0xff );
JerrySzczurak	20:cf211a3b3d9e	192	nvm_ref_good_spad_map[5] = ( uint8_t )( ( tmp_dword >> 16 )
JerrySzczurak	20:cf211a3b3d9e	193	& 0xff );
johnAlexander	15:932d8b4e52c9	194	}
johnAlexander	15:932d8b4e52c9	195
JerrySzczurak	20:cf211a3b3d9e	196	if ( ( ( option & 2 ) == 2 ) &&
JerrySzczurak	20:cf211a3b3d9e	197	( ( read_data_from_device_done & 2 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	198
JerrySzczurak	20:cf211a3b3d9e	199	status \|= vl53l0x_write_byte( dev, 0x94, 0x02 );
JerrySzczurak	20:cf211a3b3d9e	200	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	201	status \|= vl53l0x_read_byte( dev, 0x90, &module_id );
JerrySzczurak	20:cf211a3b3d9e	202
JerrySzczurak	20:cf211a3b3d9e	203	status \|= vl53l0x_write_byte( dev, 0x94, 0x7B );
JerrySzczurak	20:cf211a3b3d9e	204	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	205	status \|= vl53l0x_read_byte( dev, 0x90, &revision );
JerrySzczurak	20:cf211a3b3d9e	206
JerrySzczurak	20:cf211a3b3d9e	207	status \|= vl53l0x_write_byte( dev, 0x94, 0x77 );
JerrySzczurak	20:cf211a3b3d9e	208	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	209	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	210
JerrySzczurak	20:cf211a3b3d9e	211	product_id[0] = ( char )( ( tmp_dword >> 25 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	212	product_id[1] = ( char )( ( tmp_dword >> 18 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	213	product_id[2] = ( char )( ( tmp_dword >> 11 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	214	product_id[3] = ( char )( ( tmp_dword >> 4 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	215
JerrySzczurak	20:cf211a3b3d9e	216	byte = ( uint8_t )( ( tmp_dword & 0x00f ) << 3 );
JerrySzczurak	20:cf211a3b3d9e	217
JerrySzczurak	20:cf211a3b3d9e	218	status \|= vl53l0x_write_byte( dev, 0x94, 0x78 );
JerrySzczurak	20:cf211a3b3d9e	219	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	220	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	221
JerrySzczurak	20:cf211a3b3d9e	222	product_id[4] = ( char )( byte +
JerrySzczurak	20:cf211a3b3d9e	223	( ( tmp_dword >> 29 ) & 0x07f ) );
JerrySzczurak	20:cf211a3b3d9e	224	product_id[5] = ( char )( ( tmp_dword >> 22 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	225	product_id[6] = ( char )( ( tmp_dword >> 15 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	226	product_id[7] = ( char )( ( tmp_dword >> 8 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	227	product_id[8] = ( char )( ( tmp_dword >> 1 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	228
JerrySzczurak	20:cf211a3b3d9e	229	byte = ( uint8_t )( ( tmp_dword & 0x001 ) << 6 );
JerrySzczurak	20:cf211a3b3d9e	230
JerrySzczurak	20:cf211a3b3d9e	231	status \|= vl53l0x_write_byte( dev, 0x94, 0x79 );
JerrySzczurak	20:cf211a3b3d9e	232
JerrySzczurak	20:cf211a3b3d9e	233	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	234
JerrySzczurak	20:cf211a3b3d9e	235	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	236
JerrySzczurak	20:cf211a3b3d9e	237	product_id[9] = ( char )( byte +
JerrySzczurak	20:cf211a3b3d9e	238	( ( tmp_dword >> 26 ) & 0x07f ) );
JerrySzczurak	20:cf211a3b3d9e	239	product_id[10] = ( char )( ( tmp_dword >> 19 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	240	product_id[11] = ( char )( ( tmp_dword >> 12 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	241	product_id[12] = ( char )( ( tmp_dword >> 5 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	242
JerrySzczurak	20:cf211a3b3d9e	243	byte = ( uint8_t )( ( tmp_dword & 0x01f ) << 2 );
JerrySzczurak	20:cf211a3b3d9e	244
JerrySzczurak	20:cf211a3b3d9e	245	status \|= vl53l0x_write_byte( dev, 0x94, 0x7A );
JerrySzczurak	20:cf211a3b3d9e	246
JerrySzczurak	20:cf211a3b3d9e	247	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	248
JerrySzczurak	20:cf211a3b3d9e	249	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	250
JerrySzczurak	20:cf211a3b3d9e	251	product_id[13] = ( char )( byte +
JerrySzczurak	20:cf211a3b3d9e	252	( ( tmp_dword >> 30 ) & 0x07f ) );
JerrySzczurak	20:cf211a3b3d9e	253	product_id[14] = ( char )( ( tmp_dword >> 23 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	254	product_id[15] = ( char )( ( tmp_dword >> 16 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	255	product_id[16] = ( char )( ( tmp_dword >> 9 ) & 0x07f );
JerrySzczurak	20:cf211a3b3d9e	256	product_id[17] = ( char )( ( tmp_dword >> 2 ) & 0x07f );
johnAlexander	16:98ce55ddbb1a	257	product_id[18] = '\0';
johnAlexander	15:932d8b4e52c9	258
johnAlexander	15:932d8b4e52c9	259	}
johnAlexander	15:932d8b4e52c9	260
JerrySzczurak	20:cf211a3b3d9e	261	if ( ( ( option & 4 ) == 4 ) &&
JerrySzczurak	20:cf211a3b3d9e	262	( ( read_data_from_device_done & 4 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	263
JerrySzczurak	20:cf211a3b3d9e	264	status \|= vl53l0x_write_byte( dev, 0x94, 0x7B );
JerrySzczurak	20:cf211a3b3d9e	265	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	266	status \|= vl53l0x_read_dword( dev, 0x90, &part_uid_upper );
JerrySzczurak	20:cf211a3b3d9e	267
JerrySzczurak	20:cf211a3b3d9e	268	status \|= vl53l0x_write_byte( dev, 0x94, 0x7C );
JerrySzczurak	20:cf211a3b3d9e	269	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	270	status \|= vl53l0x_read_dword( dev, 0x90, &part_uid_lower );
JerrySzczurak	20:cf211a3b3d9e	271
JerrySzczurak	20:cf211a3b3d9e	272	status \|= vl53l0x_write_byte( dev, 0x94, 0x73 );
JerrySzczurak	20:cf211a3b3d9e	273	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	274	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	275
JerrySzczurak	20:cf211a3b3d9e	276	signal_rate_meas_fixed1104_400_mm = ( tmp_dword &
JerrySzczurak	20:cf211a3b3d9e	277	0x0000000ff ) << 8;
JerrySzczurak	20:cf211a3b3d9e	278
JerrySzczurak	20:cf211a3b3d9e	279	status \|= vl53l0x_write_byte( dev, 0x94, 0x74 );
JerrySzczurak	20:cf211a3b3d9e	280	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	281	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	282
JerrySzczurak	20:cf211a3b3d9e	283	signal_rate_meas_fixed1104_400_mm \|= ( ( tmp_dword &
JerrySzczurak	20:cf211a3b3d9e	284	0xff000000 ) >> 24 );
JerrySzczurak	20:cf211a3b3d9e	285
JerrySzczurak	20:cf211a3b3d9e	286	status \|= vl53l0x_write_byte( dev, 0x94, 0x75 );
JerrySzczurak	20:cf211a3b3d9e	287	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	288	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	289
JerrySzczurak	20:cf211a3b3d9e	290	dist_meas_fixed1104_400_mm = ( tmp_dword & 0x0000000ff )
johnAlexander	16:98ce55ddbb1a	291	<< 8;
johnAlexander	16:98ce55ddbb1a	292
JerrySzczurak	20:cf211a3b3d9e	293	status \|= vl53l0x_write_byte( dev, 0x94, 0x76 );
JerrySzczurak	20:cf211a3b3d9e	294	status \|= vl53l0x_device_read_strobe( dev );
JerrySzczurak	20:cf211a3b3d9e	295	status \|= vl53l0x_read_dword( dev, 0x90, &tmp_dword );
JerrySzczurak	20:cf211a3b3d9e	296
JerrySzczurak	20:cf211a3b3d9e	297	dist_meas_fixed1104_400_mm \|= ( ( tmp_dword & 0xff000000 )
JerrySzczurak	20:cf211a3b3d9e	298	>> 24 );
johnAlexander	15:932d8b4e52c9	299	}
johnAlexander	15:932d8b4e52c9	300
JerrySzczurak	20:cf211a3b3d9e	301	status \|= vl53l0x_write_byte( dev, 0x81, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	302	status \|= vl53l0x_write_byte( dev, 0xFF, 0x06 );
JerrySzczurak	20:cf211a3b3d9e	303	status \|= vl53l0x_read_byte( dev, 0x83, &byte );
JerrySzczurak	20:cf211a3b3d9e	304	status \|= vl53l0x_write_byte( dev, 0x83, byte & 0xfb );
JerrySzczurak	20:cf211a3b3d9e	305	status \|= vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	306	status \|= vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	307
JerrySzczurak	20:cf211a3b3d9e	308	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	309	status \|= vl53l0x_write_byte( dev, 0x80, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	310	}
JerrySzczurak	20:cf211a3b3d9e	311
JerrySzczurak	20:cf211a3b3d9e	312	if ( ( status == VL53L0X_ERROR_NONE ) &&
JerrySzczurak	20:cf211a3b3d9e	313	( read_data_from_device_done != 7 ) ) {
johnAlexander	15:932d8b4e52c9	314	/* Assign to variable if status is ok */
JerrySzczurak	20:cf211a3b3d9e	315	if ( ( ( option & 1 ) == 1 ) &&
JerrySzczurak	20:cf211a3b3d9e	316	( ( read_data_from_device_done & 1 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	317	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	318	ReferenceSpadCount, reference_spad_count );
JerrySzczurak	20:cf211a3b3d9e	319
JerrySzczurak	20:cf211a3b3d9e	320	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	321	ReferenceSpadType, reference_spad_type );
JerrySzczurak	20:cf211a3b3d9e	322
JerrySzczurak	20:cf211a3b3d9e	323	for ( i = 0; i < VL53L0X_REF_SPAD_BUFFER_SIZE; i++ ) {
johnAlexander	16:98ce55ddbb1a	324	dev->Data.SpadData.RefGoodSpadMap[i] =
johnAlexander	16:98ce55ddbb1a	325	nvm_ref_good_spad_map[i];
johnAlexander	15:932d8b4e52c9	326	}
johnAlexander	15:932d8b4e52c9	327	}
johnAlexander	15:932d8b4e52c9	328
JerrySzczurak	20:cf211a3b3d9e	329	if ( ( ( option & 2 ) == 2 ) &&
JerrySzczurak	20:cf211a3b3d9e	330	( ( read_data_from_device_done & 2 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	331	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	332	ModuleId, module_id );
JerrySzczurak	20:cf211a3b3d9e	333
JerrySzczurak	20:cf211a3b3d9e	334	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	335	Revision, revision );
JerrySzczurak	20:cf211a3b3d9e	336
JerrySzczurak	20:cf211a3b3d9e	337	product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	338	ProductId );
JerrySzczurak	20:cf211a3b3d9e	339	VL53L0X_COPYSTRING( product_id_tmp, product_id );
johnAlexander	15:932d8b4e52c9	340
johnAlexander	15:932d8b4e52c9	341	}
johnAlexander	15:932d8b4e52c9	342
JerrySzczurak	20:cf211a3b3d9e	343	if ( ( ( option & 4 ) == 4 ) &&
JerrySzczurak	20:cf211a3b3d9e	344	( ( read_data_from_device_done & 4 ) == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	345	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	346	PartUIDUpper, part_uid_upper );
JerrySzczurak	20:cf211a3b3d9e	347
JerrySzczurak	20:cf211a3b3d9e	348	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	349	PartUIDLower, part_uid_lower );
johnAlexander	16:98ce55ddbb1a	350
johnAlexander	16:98ce55ddbb1a	351	signal_rate_meas_fixed400_mm_fix =
johnAlexander	15:932d8b4e52c9	352	VL53L0X_FIXPOINT97TOFIXPOINT1616(
JerrySzczurak	20:cf211a3b3d9e	353	signal_rate_meas_fixed1104_400_mm );
JerrySzczurak	20:cf211a3b3d9e	354
JerrySzczurak	20:cf211a3b3d9e	355	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	356	SignalRateMeasFixed400mm,
JerrySzczurak	20:cf211a3b3d9e	357	signal_rate_meas_fixed400_mm_fix );
johnAlexander	16:98ce55ddbb1a	358
johnAlexander	16:98ce55ddbb1a	359	offset_micro_meters = 0;
JerrySzczurak	20:cf211a3b3d9e	360	if ( dist_meas_fixed1104_400_mm != 0 ) {
johnAlexander	16:98ce55ddbb1a	361	offset_fixed1104_mm =
johnAlexander	16:98ce55ddbb1a	362	dist_meas_fixed1104_400_mm -
johnAlexander	16:98ce55ddbb1a	363	dist_meas_tgt_fixed1104_mm;
JerrySzczurak	20:cf211a3b3d9e	364	offset_micro_meters = ( offset_fixed1104_mm
JerrySzczurak	20:cf211a3b3d9e	365	* 1000 ) >> 4;
johnAlexander	16:98ce55ddbb1a	366	offset_micro_meters *= -1;
johnAlexander	15:932d8b4e52c9	367	}
johnAlexander	15:932d8b4e52c9	368
JerrySzczurak	20:cf211a3b3d9e	369	PALDevDataSet( dev,
JerrySzczurak	20:cf211a3b3d9e	370	Part2PartOffsetAdjustmentNVMMicroMeter,
JerrySzczurak	20:cf211a3b3d9e	371	offset_micro_meters );
johnAlexander	15:932d8b4e52c9	372	}
JerrySzczurak	20:cf211a3b3d9e	373	byte = ( uint8_t )( read_data_from_device_done \| option );
JerrySzczurak	20:cf211a3b3d9e	374	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, ReadDataFromDeviceDone,
JerrySzczurak	20:cf211a3b3d9e	375	byte );
JerrySzczurak	20:cf211a3b3d9e	376	}
JerrySzczurak	20:cf211a3b3d9e	377
JerrySzczurak	20:cf211a3b3d9e	378	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	379	return status;
JerrySzczurak	20:cf211a3b3d9e	380	}
JerrySzczurak	20:cf211a3b3d9e	381
JerrySzczurak	20:cf211a3b3d9e	382	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_offset_calibration_data_micro_meter( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	383	int32_t *p_offset_calibration_data_micro_meter )
johnAlexander	0:c523920bcc09	384	{
johnAlexander	16:98ce55ddbb1a	385	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	386	uint16_t range_offset_register;
johnAlexander	16:98ce55ddbb1a	387	int16_t c_max_offset = 2047;
johnAlexander	16:98ce55ddbb1a	388	int16_t c_offset_range = 4096;
johnAlexander	15:932d8b4e52c9	389
johnAlexander	15:932d8b4e52c9	390	/* Note that offset has 10.2 format */
johnAlexander	15:932d8b4e52c9	391
JerrySzczurak	20:cf211a3b3d9e	392	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	393	VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
JerrySzczurak	20:cf211a3b3d9e	394	&range_offset_register );
JerrySzczurak	20:cf211a3b3d9e	395
JerrySzczurak	20:cf211a3b3d9e	396	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	397	range_offset_register = ( range_offset_register & 0x0fff );
johnAlexander	15:932d8b4e52c9	398
johnAlexander	15:932d8b4e52c9	399	/* Apply 12 bit 2's compliment conversion */
JerrySzczurak	20:cf211a3b3d9e	400	if ( range_offset_register > c_max_offset )
johnAlexander	16:98ce55ddbb1a	401	*p_offset_calibration_data_micro_meter =
JerrySzczurak	20:cf211a3b3d9e	402	( int16_t )( range_offset_register - c_offset_range )
johnAlexander	15:932d8b4e52c9	403	* 250;
johnAlexander	15:932d8b4e52c9	404	else
johnAlexander	16:98ce55ddbb1a	405	*p_offset_calibration_data_micro_meter =
JerrySzczurak	20:cf211a3b3d9e	406	( int16_t )range_offset_register * 250;
JerrySzczurak	20:cf211a3b3d9e	407
JerrySzczurak	20:cf211a3b3d9e	408	}
JerrySzczurak	20:cf211a3b3d9e	409
JerrySzczurak	20:cf211a3b3d9e	410	return status;
JerrySzczurak	20:cf211a3b3d9e	411	}
JerrySzczurak	20:cf211a3b3d9e	412
JerrySzczurak	20:cf211a3b3d9e	413	VL53L0X_Error VL53L0X::vl53l0x_get_offset_calibration_data_micro_meter( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	414	int32_t *p_offset_calibration_data_micro_meter )
johnAlexander	0:c523920bcc09	415	{
johnAlexander	16:98ce55ddbb1a	416	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	417	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	418
JerrySzczurak	20:cf211a3b3d9e	419	status = wrapped_vl53l0x_get_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	420	p_offset_calibration_data_micro_meter );
JerrySzczurak	20:cf211a3b3d9e	421
JerrySzczurak	20:cf211a3b3d9e	422	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	423	return status;
JerrySzczurak	20:cf211a3b3d9e	424	}
JerrySzczurak	20:cf211a3b3d9e	425
JerrySzczurak	20:cf211a3b3d9e	426	VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_offset_calibration_data_micro_meter( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	427	int32_t offset_calibration_data_micro_meter )
johnAlexander	0:c523920bcc09	428	{
johnAlexander	16:98ce55ddbb1a	429	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	430	int32_t c_max_offset_micro_meter = 511000;
johnAlexander	16:98ce55ddbb1a	431	int32_t c_min_offset_micro_meter = -512000;
johnAlexander	16:98ce55ddbb1a	432	int16_t c_offset_range = 4096;
johnAlexander	16:98ce55ddbb1a	433	uint32_t encoded_offset_val;
johnAlexander	15:932d8b4e52c9	434
JerrySzczurak	20:cf211a3b3d9e	435	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	436
JerrySzczurak	20:cf211a3b3d9e	437	if ( offset_calibration_data_micro_meter > c_max_offset_micro_meter )
johnAlexander	16:98ce55ddbb1a	438	offset_calibration_data_micro_meter = c_max_offset_micro_meter;
JerrySzczurak	20:cf211a3b3d9e	439	else if ( offset_calibration_data_micro_meter < c_min_offset_micro_meter )
johnAlexander	16:98ce55ddbb1a	440	offset_calibration_data_micro_meter = c_min_offset_micro_meter;
johnAlexander	15:932d8b4e52c9	441
johnAlexander	15:932d8b4e52c9	442	/* The offset register is 10.2 format and units are mm
johnAlexander	15:932d8b4e52c9	443	* therefore conversion is applied by a division of
johnAlexander	15:932d8b4e52c9	444	* 250.
johnAlexander	15:932d8b4e52c9	445	*/
JerrySzczurak	20:cf211a3b3d9e	446	if ( offset_calibration_data_micro_meter >= 0 ) {
johnAlexander	16:98ce55ddbb1a	447	encoded_offset_val =
JerrySzczurak	20:cf211a3b3d9e	448	offset_calibration_data_micro_meter / 250;
johnAlexander	15:932d8b4e52c9	449	} else {
johnAlexander	16:98ce55ddbb1a	450	encoded_offset_val =
johnAlexander	16:98ce55ddbb1a	451	c_offset_range +
JerrySzczurak	20:cf211a3b3d9e	452	offset_calibration_data_micro_meter / 250;
JerrySzczurak	20:cf211a3b3d9e	453	}
JerrySzczurak	20:cf211a3b3d9e	454
JerrySzczurak	20:cf211a3b3d9e	455	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	456	VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM,
JerrySzczurak	20:cf211a3b3d9e	457	encoded_offset_val );
JerrySzczurak	20:cf211a3b3d9e	458
JerrySzczurak	20:cf211a3b3d9e	459	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	460	return status;
JerrySzczurak	20:cf211a3b3d9e	461	}
JerrySzczurak	20:cf211a3b3d9e	462
JerrySzczurak	20:cf211a3b3d9e	463	VL53L0X_Error VL53L0X::vl53l0x_set_offset_calibration_data_micro_meter( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	464	int32_t offset_calibration_data_micro_meter )
johnAlexander	0:c523920bcc09	465	{
johnAlexander	16:98ce55ddbb1a	466	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	467	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	468
JerrySzczurak	20:cf211a3b3d9e	469	status = wrapped_vl53l0x_set_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	470	offset_calibration_data_micro_meter );
JerrySzczurak	20:cf211a3b3d9e	471
JerrySzczurak	20:cf211a3b3d9e	472	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	473	return status;
JerrySzczurak	20:cf211a3b3d9e	474	}
JerrySzczurak	20:cf211a3b3d9e	475
JerrySzczurak	20:cf211a3b3d9e	476	VL53L0X_Error VL53L0X::vl53l0x_apply_offset_adjustment( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	477	{
johnAlexander	16:98ce55ddbb1a	478	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	479	int32_t corrected_offset_micro_meters;
johnAlexander	16:98ce55ddbb1a	480	int32_t current_offset_micro_meters;
johnAlexander	15:932d8b4e52c9	481
johnAlexander	15:932d8b4e52c9	482	/* if we run on this function we can read all the NVM info
johnAlexander	15:932d8b4e52c9	483	* used by the API */
JerrySzczurak	20:cf211a3b3d9e	484	status = vl53l0x_get_info_from_device( dev, 7 );
johnAlexander	15:932d8b4e52c9	485
johnAlexander	15:932d8b4e52c9	486	/* Read back current device offset */
JerrySzczurak	20:cf211a3b3d9e	487	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	488	status = vl53l0x_get_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	489	&current_offset_micro_meters );
johnAlexander	15:932d8b4e52c9	490	}
johnAlexander	15:932d8b4e52c9	491
johnAlexander	15:932d8b4e52c9	492	/* Apply Offset Adjustment derived from 400mm measurements */
JerrySzczurak	20:cf211a3b3d9e	493	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	494
johnAlexander	15:932d8b4e52c9	495	/* Store initial device offset */
JerrySzczurak	20:cf211a3b3d9e	496	PALDevDataSet( dev, Part2PartOffsetNVMMicroMeter,
JerrySzczurak	20:cf211a3b3d9e	497	current_offset_micro_meters );
johnAlexander	16:98ce55ddbb1a	498
johnAlexander	16:98ce55ddbb1a	499	corrected_offset_micro_meters = current_offset_micro_meters +
JerrySzczurak	20:cf211a3b3d9e	500	( int32_t )PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	501	Part2PartOffsetAdjustmentNVMMicroMeter );
JerrySzczurak	20:cf211a3b3d9e	502
JerrySzczurak	20:cf211a3b3d9e	503	status = vl53l0x_set_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	504	corrected_offset_micro_meters );
johnAlexander	15:932d8b4e52c9	505
johnAlexander	15:932d8b4e52c9	506	/* store current, adjusted offset */
JerrySzczurak	20:cf211a3b3d9e	507	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	508	VL53L0X_SETPARAMETERFIELD( dev, RangeOffsetMicroMeters,
JerrySzczurak	20:cf211a3b3d9e	509	corrected_offset_micro_meters );
johnAlexander	15:932d8b4e52c9	510	}
johnAlexander	15:932d8b4e52c9	511	}
johnAlexander	15:932d8b4e52c9	512
johnAlexander	16:98ce55ddbb1a	513	return status;
johnAlexander	0:c523920bcc09	514	}
johnAlexander	0:c523920bcc09	515
JerrySzczurak	20:cf211a3b3d9e	516	VL53L0X_Error VL53L0X::vl53l0x_get_device_mode( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	517	VL53L0X_DeviceModes *p_device_mode )
johnAlexander	0:c523920bcc09	518	{
johnAlexander	16:98ce55ddbb1a	519	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	520	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	521
JerrySzczurak	20:cf211a3b3d9e	522	VL53L0X_GETPARAMETERFIELD( dev, DeviceMode, *p_device_mode );
JerrySzczurak	20:cf211a3b3d9e	523
JerrySzczurak	20:cf211a3b3d9e	524	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	525	return status;
JerrySzczurak	20:cf211a3b3d9e	526	}
JerrySzczurak	20:cf211a3b3d9e	527
JerrySzczurak	20:cf211a3b3d9e	528	VL53L0X_Error VL53L0X::vl53l0x_get_inter_measurement_period_milli_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	529	uint32_t *p_inter_measurement_period_milli_seconds )
johnAlexander	0:c523920bcc09	530	{
johnAlexander	16:98ce55ddbb1a	531	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	532	uint16_t osc_calibrate_val;
johnAlexander	16:98ce55ddbb1a	533	uint32_t im_period_milli_seconds;
johnAlexander	15:932d8b4e52c9	534
JerrySzczurak	20:cf211a3b3d9e	535	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	536
JerrySzczurak	20:cf211a3b3d9e	537	status = vl53l0x_read_word( dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
JerrySzczurak	20:cf211a3b3d9e	538	&osc_calibrate_val );
JerrySzczurak	20:cf211a3b3d9e	539
JerrySzczurak	20:cf211a3b3d9e	540	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	541	status = vl53l0x_read_dword( dev,
JerrySzczurak	20:cf211a3b3d9e	542	VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	543	&im_period_milli_seconds );
JerrySzczurak	20:cf211a3b3d9e	544	}
JerrySzczurak	20:cf211a3b3d9e	545
JerrySzczurak	20:cf211a3b3d9e	546	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	547	if ( osc_calibrate_val != 0 ) {
johnAlexander	17:1b842521063a	548	*p_inter_measurement_period_milli_seconds =
johnAlexander	16:98ce55ddbb1a	549	im_period_milli_seconds / osc_calibrate_val;
johnAlexander	15:932d8b4e52c9	550	}
JerrySzczurak	20:cf211a3b3d9e	551	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	552	InterMeasurementPeriodMilliSeconds,
JerrySzczurak	20:cf211a3b3d9e	553	*p_inter_measurement_period_milli_seconds );
JerrySzczurak	20:cf211a3b3d9e	554	}
JerrySzczurak	20:cf211a3b3d9e	555
JerrySzczurak	20:cf211a3b3d9e	556	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	557	return status;
JerrySzczurak	20:cf211a3b3d9e	558	}
JerrySzczurak	20:cf211a3b3d9e	559
JerrySzczurak	20:cf211a3b3d9e	560	VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_rate_mega_cps( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	561	FixPoint1616_t *p_xtalk_compensation_rate_mega_cps )
johnAlexander	0:c523920bcc09	562	{
johnAlexander	16:98ce55ddbb1a	563	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	564	uint16_t value;
johnAlexander	16:98ce55ddbb1a	565	FixPoint1616_t temp_fix1616;
johnAlexander	15:932d8b4e52c9	566
JerrySzczurak	20:cf211a3b3d9e	567	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	568
JerrySzczurak	20:cf211a3b3d9e	569	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	570	VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, ( uint16_t * )&value );
JerrySzczurak	20:cf211a3b3d9e	571	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	572	if ( value == 0 ) {
johnAlexander	15:932d8b4e52c9	573	/* the Xtalk is disabled return value from memory */
JerrySzczurak	20:cf211a3b3d9e	574	VL53L0X_GETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	575	XTalkCompensationRateMegaCps, temp_fix1616 );
johnAlexander	17:1b842521063a	576	*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
JerrySzczurak	20:cf211a3b3d9e	577	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationEnable,
JerrySzczurak	20:cf211a3b3d9e	578	0 );
johnAlexander	15:932d8b4e52c9	579	} else {
JerrySzczurak	20:cf211a3b3d9e	580	temp_fix1616 = VL53L0X_FIXPOINT313TOFIXPOINT1616( value );
johnAlexander	17:1b842521063a	581	*p_xtalk_compensation_rate_mega_cps = temp_fix1616;
JerrySzczurak	20:cf211a3b3d9e	582	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	583	XTalkCompensationRateMegaCps, temp_fix1616 );
JerrySzczurak	20:cf211a3b3d9e	584	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationEnable,
JerrySzczurak	20:cf211a3b3d9e	585	1 );
johnAlexander	15:932d8b4e52c9	586	}
johnAlexander	15:932d8b4e52c9	587	}
johnAlexander	15:932d8b4e52c9	588
JerrySzczurak	20:cf211a3b3d9e	589	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	590	return status;
JerrySzczurak	20:cf211a3b3d9e	591	}
JerrySzczurak	20:cf211a3b3d9e	592
JerrySzczurak	20:cf211a3b3d9e	593	VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_value( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	594	FixPoint1616_t *p_limit_check_value )
johnAlexander	0:c523920bcc09	595	{
johnAlexander	16:98ce55ddbb1a	596	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	597	uint8_t enable_zero_value = 0;
johnAlexander	16:98ce55ddbb1a	598	uint16_t temp16;
johnAlexander	16:98ce55ddbb1a	599	FixPoint1616_t temp_fix1616;
johnAlexander	15:932d8b4e52c9	600
JerrySzczurak	20:cf211a3b3d9e	601	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	602
JerrySzczurak	20:cf211a3b3d9e	603	switch ( limit_check_id ) {
johnAlexander	15:932d8b4e52c9	604
johnAlexander	15:932d8b4e52c9	605	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander	15:932d8b4e52c9	606	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	607	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	608	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp_fix1616 );
johnAlexander	16:98ce55ddbb1a	609	enable_zero_value = 0;
johnAlexander	15:932d8b4e52c9	610	break;
johnAlexander	15:932d8b4e52c9	611
johnAlexander	15:932d8b4e52c9	612	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	613	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	614	VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
JerrySzczurak	20:cf211a3b3d9e	615	&temp16 );
JerrySzczurak	20:cf211a3b3d9e	616	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	617	temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616( temp16 );
johnAlexander	16:98ce55ddbb1a	618
johnAlexander	16:98ce55ddbb1a	619
johnAlexander	16:98ce55ddbb1a	620	enable_zero_value = 1;
johnAlexander	15:932d8b4e52c9	621	break;
johnAlexander	15:932d8b4e52c9	622
johnAlexander	15:932d8b4e52c9	623	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander	15:932d8b4e52c9	624	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	625	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	626	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp_fix1616 );
johnAlexander	16:98ce55ddbb1a	627	enable_zero_value = 0;
johnAlexander	15:932d8b4e52c9	628	break;
johnAlexander	15:932d8b4e52c9	629
johnAlexander	15:932d8b4e52c9	630	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander	15:932d8b4e52c9	631	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	632	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	633	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, temp_fix1616 );
johnAlexander	16:98ce55ddbb1a	634	enable_zero_value = 0;
johnAlexander	15:932d8b4e52c9	635	break;
johnAlexander	15:932d8b4e52c9	636
johnAlexander	15:932d8b4e52c9	637	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander	15:932d8b4e52c9	638	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	639	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	640	VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
JerrySzczurak	20:cf211a3b3d9e	641	&temp16 );
JerrySzczurak	20:cf211a3b3d9e	642	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	643	temp_fix1616 = VL53L0X_FIXPOINT97TOFIXPOINT1616( temp16 );
johnAlexander	16:98ce55ddbb1a	644
johnAlexander	16:98ce55ddbb1a	645
johnAlexander	16:98ce55ddbb1a	646	enable_zero_value = 0;
johnAlexander	15:932d8b4e52c9	647	break;
johnAlexander	15:932d8b4e52c9	648
johnAlexander	15:932d8b4e52c9	649	default:
johnAlexander	16:98ce55ddbb1a	650	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	651
johnAlexander	15:932d8b4e52c9	652	}
johnAlexander	15:932d8b4e52c9	653
JerrySzczurak	20:cf211a3b3d9e	654	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	655
JerrySzczurak	20:cf211a3b3d9e	656	if ( enable_zero_value == 1 ) {
JerrySzczurak	20:cf211a3b3d9e	657
JerrySzczurak	20:cf211a3b3d9e	658	if ( temp_fix1616 == 0 ) {
johnAlexander	15:932d8b4e52c9	659	/* disabled: return value from memory */
JerrySzczurak	20:cf211a3b3d9e	660	VL53L0X_GETARRAYPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	661	LimitChecksValue, limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	662	temp_fix1616 );
johnAlexander	17:1b842521063a	663	*p_limit_check_value = temp_fix1616;
JerrySzczurak	20:cf211a3b3d9e	664	VL53L0X_SETARRAYPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	665	LimitChecksEnable, limit_check_id, 0 );
johnAlexander	15:932d8b4e52c9	666	} else {
johnAlexander	17:1b842521063a	667	*p_limit_check_value = temp_fix1616;
JerrySzczurak	20:cf211a3b3d9e	668	VL53L0X_SETARRAYPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	669	LimitChecksValue, limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	670	temp_fix1616 );
JerrySzczurak	20:cf211a3b3d9e	671	VL53L0X_SETARRAYPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	672	LimitChecksEnable, limit_check_id, 1 );
johnAlexander	15:932d8b4e52c9	673	}
johnAlexander	15:932d8b4e52c9	674	} else {
johnAlexander	17:1b842521063a	675	*p_limit_check_value = temp_fix1616;
johnAlexander	15:932d8b4e52c9	676	}
johnAlexander	15:932d8b4e52c9	677	}
johnAlexander	15:932d8b4e52c9	678
JerrySzczurak	20:cf211a3b3d9e	679	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	680	return status;
JerrySzczurak	20:cf211a3b3d9e	681
JerrySzczurak	20:cf211a3b3d9e	682	}
JerrySzczurak	20:cf211a3b3d9e	683
JerrySzczurak	20:cf211a3b3d9e	684	VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_enable( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	685	uint8_t *p_limit_check_enable )
johnAlexander	0:c523920bcc09	686	{
johnAlexander	16:98ce55ddbb1a	687	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	688	uint8_t temp8;
johnAlexander	15:932d8b4e52c9	689
JerrySzczurak	20:cf211a3b3d9e	690	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	691
JerrySzczurak	20:cf211a3b3d9e	692	if ( limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS ) {
johnAlexander	16:98ce55ddbb1a	693	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	17:1b842521063a	694	*p_limit_check_enable = 0;
johnAlexander	15:932d8b4e52c9	695	} else {
JerrySzczurak	20:cf211a3b3d9e	696	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	697	limit_check_id, temp8 );
johnAlexander	17:1b842521063a	698	*p_limit_check_enable = temp8;
johnAlexander	15:932d8b4e52c9	699	}
johnAlexander	15:932d8b4e52c9	700
JerrySzczurak	20:cf211a3b3d9e	701	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	702	return status;
JerrySzczurak	20:cf211a3b3d9e	703	}
JerrySzczurak	20:cf211a3b3d9e	704
JerrySzczurak	20:cf211a3b3d9e	705	VL53L0X_Error VL53L0X::vl53l0x_get_wrap_around_check_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	706	uint8_t *p_wrap_around_check_enable )
johnAlexander	0:c523920bcc09	707	{
johnAlexander	16:98ce55ddbb1a	708	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	709	uint8_t data;
johnAlexander	15:932d8b4e52c9	710
JerrySzczurak	20:cf211a3b3d9e	711	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	712
JerrySzczurak	20:cf211a3b3d9e	713	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data );
JerrySzczurak	20:cf211a3b3d9e	714	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	715	PALDevDataSet( dev, SequenceConfig, data );
JerrySzczurak	20:cf211a3b3d9e	716	if ( data & ( 0x01 << 7 ) )
johnAlexander	17:1b842521063a	717	*p_wrap_around_check_enable = 0x01;
johnAlexander	15:932d8b4e52c9	718	else
johnAlexander	17:1b842521063a	719	*p_wrap_around_check_enable = 0x00;
johnAlexander	15:932d8b4e52c9	720	}
JerrySzczurak	20:cf211a3b3d9e	721	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	722	VL53L0X_SETPARAMETERFIELD( dev, WrapAroundCheckEnable,
JerrySzczurak	20:cf211a3b3d9e	723	*p_wrap_around_check_enable );
JerrySzczurak	20:cf211a3b3d9e	724	}
JerrySzczurak	20:cf211a3b3d9e	725
JerrySzczurak	20:cf211a3b3d9e	726	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	727	return status;
JerrySzczurak	20:cf211a3b3d9e	728	}
JerrySzczurak	20:cf211a3b3d9e	729
JerrySzczurak	20:cf211a3b3d9e	730	VL53L0X_Error VL53L0X::sequence_step_enabled( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	731	VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_config,
JerrySzczurak	20:cf211a3b3d9e	732	uint8_t *p_sequence_step_enabled )
johnAlexander	0:c523920bcc09	733	{
johnAlexander	15:932d8b4e52c9	734	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
johnAlexander	17:1b842521063a	735	*p_sequence_step_enabled = 0;
JerrySzczurak	20:cf211a3b3d9e	736	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	737
JerrySzczurak	20:cf211a3b3d9e	738	switch ( sequence_step_id ) {
johnAlexander	15:932d8b4e52c9	739	case VL53L0X_SEQUENCESTEP_TCC:
JerrySzczurak	20:cf211a3b3d9e	740	*p_sequence_step_enabled = ( sequence_config & 0x10 ) >> 4;
johnAlexander	15:932d8b4e52c9	741	break;
johnAlexander	15:932d8b4e52c9	742	case VL53L0X_SEQUENCESTEP_DSS:
JerrySzczurak	20:cf211a3b3d9e	743	*p_sequence_step_enabled = ( sequence_config & 0x08 ) >> 3;
johnAlexander	15:932d8b4e52c9	744	break;
johnAlexander	15:932d8b4e52c9	745	case VL53L0X_SEQUENCESTEP_MSRC:
JerrySzczurak	20:cf211a3b3d9e	746	*p_sequence_step_enabled = ( sequence_config & 0x04 ) >> 2;
johnAlexander	15:932d8b4e52c9	747	break;
johnAlexander	15:932d8b4e52c9	748	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	749	*p_sequence_step_enabled = ( sequence_config & 0x40 ) >> 6;
johnAlexander	15:932d8b4e52c9	750	break;
johnAlexander	15:932d8b4e52c9	751	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	752	*p_sequence_step_enabled = ( sequence_config & 0x80 ) >> 7;
johnAlexander	15:932d8b4e52c9	753	break;
johnAlexander	15:932d8b4e52c9	754	default:
johnAlexander	15:932d8b4e52c9	755	Status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	756	}
johnAlexander	15:932d8b4e52c9	757
JerrySzczurak	20:cf211a3b3d9e	758	LOG_FUNCTION_END( status );
johnAlexander	15:932d8b4e52c9	759	return Status;
johnAlexander	0:c523920bcc09	760	}
johnAlexander	0:c523920bcc09	761
JerrySzczurak	20:cf211a3b3d9e	762	VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_enables( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	763	VL53L0X_SchedulerSequenceSteps_t *p_scheduler_sequence_steps )
johnAlexander	0:c523920bcc09	764	{
johnAlexander	16:98ce55ddbb1a	765	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	766	uint8_t sequence_config = 0;
JerrySzczurak	20:cf211a3b3d9e	767	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	768
JerrySzczurak	20:cf211a3b3d9e	769	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	770	&sequence_config );
JerrySzczurak	20:cf211a3b3d9e	771
JerrySzczurak	20:cf211a3b3d9e	772	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	773	status = sequence_step_enabled( dev,
JerrySzczurak	20:cf211a3b3d9e	774	VL53L0X_SEQUENCESTEP_TCC, sequence_config,
JerrySzczurak	20:cf211a3b3d9e	775	&p_scheduler_sequence_steps->TccOn );
JerrySzczurak	20:cf211a3b3d9e	776	}
JerrySzczurak	20:cf211a3b3d9e	777	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	778	status = sequence_step_enabled( dev,
JerrySzczurak	20:cf211a3b3d9e	779	VL53L0X_SEQUENCESTEP_DSS, sequence_config,
JerrySzczurak	20:cf211a3b3d9e	780	&p_scheduler_sequence_steps->DssOn );
JerrySzczurak	20:cf211a3b3d9e	781	}
JerrySzczurak	20:cf211a3b3d9e	782	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	783	status = sequence_step_enabled( dev,
JerrySzczurak	20:cf211a3b3d9e	784	VL53L0X_SEQUENCESTEP_MSRC, sequence_config,
JerrySzczurak	20:cf211a3b3d9e	785	&p_scheduler_sequence_steps->MsrcOn );
JerrySzczurak	20:cf211a3b3d9e	786	}
JerrySzczurak	20:cf211a3b3d9e	787	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	788	status = sequence_step_enabled( dev,
JerrySzczurak	20:cf211a3b3d9e	789	VL53L0X_SEQUENCESTEP_PRE_RANGE, sequence_config,
JerrySzczurak	20:cf211a3b3d9e	790	&p_scheduler_sequence_steps->PreRangeOn );
JerrySzczurak	20:cf211a3b3d9e	791	}
JerrySzczurak	20:cf211a3b3d9e	792	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	793	status = sequence_step_enabled( dev,
JerrySzczurak	20:cf211a3b3d9e	794	VL53L0X_SEQUENCESTEP_FINAL_RANGE, sequence_config,
JerrySzczurak	20:cf211a3b3d9e	795	&p_scheduler_sequence_steps->FinalRangeOn );
JerrySzczurak	20:cf211a3b3d9e	796	}
JerrySzczurak	20:cf211a3b3d9e	797
JerrySzczurak	20:cf211a3b3d9e	798	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	799	return status;
JerrySzczurak	20:cf211a3b3d9e	800	}
JerrySzczurak	20:cf211a3b3d9e	801
JerrySzczurak	20:cf211a3b3d9e	802	uint8_t VL53L0X::vl53l0x_decode_vcsel_period( uint8_t vcsel_period_reg )
johnAlexander	0:c523920bcc09	803	{
johnAlexander	15:932d8b4e52c9	804	/*!
johnAlexander	15:932d8b4e52c9	805	* Converts the encoded VCSEL period register value into the real
johnAlexander	15:932d8b4e52c9	806	* period in PLL clocks
johnAlexander	15:932d8b4e52c9	807	*/
johnAlexander	15:932d8b4e52c9	808
johnAlexander	15:932d8b4e52c9	809	uint8_t vcsel_period_pclks = 0;
johnAlexander	15:932d8b4e52c9	810
JerrySzczurak	20:cf211a3b3d9e	811	vcsel_period_pclks = ( vcsel_period_reg + 1 ) << 1;
johnAlexander	15:932d8b4e52c9	812
johnAlexander	15:932d8b4e52c9	813	return vcsel_period_pclks;
johnAlexander	0:c523920bcc09	814	}
johnAlexander	0:c523920bcc09	815
JerrySzczurak	20:cf211a3b3d9e	816	uint8_t VL53L0X::lv53l0x_encode_vcsel_period( uint8_t vcsel_period_pclks )
johnAlexander	0:c523920bcc09	817	{
johnAlexander	15:932d8b4e52c9	818	/*!
johnAlexander	15:932d8b4e52c9	819	* Converts the encoded VCSEL period register value into the real period
johnAlexander	15:932d8b4e52c9	820	* in PLL clocks
johnAlexander	15:932d8b4e52c9	821	*/
johnAlexander	15:932d8b4e52c9	822
johnAlexander	15:932d8b4e52c9	823	uint8_t vcsel_period_reg = 0;
johnAlexander	15:932d8b4e52c9	824
JerrySzczurak	20:cf211a3b3d9e	825	vcsel_period_reg = ( vcsel_period_pclks >> 1 ) - 1;
johnAlexander	15:932d8b4e52c9	826
johnAlexander	15:932d8b4e52c9	827	return vcsel_period_reg;
johnAlexander	0:c523920bcc09	828	}
johnAlexander	0:c523920bcc09	829
johnAlexander	0:c523920bcc09	830
JerrySzczurak	20:cf211a3b3d9e	831	VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_vcsel_pulse_period( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	832	VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period_pclk )
johnAlexander	0:c523920bcc09	833	{
johnAlexander	16:98ce55ddbb1a	834	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	835	uint8_t vcsel_period_reg;
johnAlexander	16:98ce55ddbb1a	836	uint8_t min_pre_vcsel_period_pclk = 12;
johnAlexander	16:98ce55ddbb1a	837	uint8_t max_pre_vcsel_period_pclk = 18;
johnAlexander	16:98ce55ddbb1a	838	uint8_t min_final_vcsel_period_pclk = 8;
johnAlexander	16:98ce55ddbb1a	839	uint8_t max_final_vcsel_period_pclk = 14;
johnAlexander	16:98ce55ddbb1a	840	uint32_t measurement_timing_budget_micro_seconds;
johnAlexander	16:98ce55ddbb1a	841	uint32_t final_range_timeout_micro_seconds;
johnAlexander	16:98ce55ddbb1a	842	uint32_t pre_range_timeout_micro_seconds;
johnAlexander	16:98ce55ddbb1a	843	uint32_t msrc_timeout_micro_seconds;
johnAlexander	16:98ce55ddbb1a	844	uint8_t phase_cal_int = 0;
johnAlexander	15:932d8b4e52c9	845
johnAlexander	15:932d8b4e52c9	846	/* Check if valid clock period requested */
johnAlexander	15:932d8b4e52c9	847
JerrySzczurak	20:cf211a3b3d9e	848	if ( ( vcsel_pulse_period_pclk % 2 ) != 0 ) {
johnAlexander	15:932d8b4e52c9	849	/* Value must be an even number */
johnAlexander	16:98ce55ddbb1a	850	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	851	} else if ( vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE &&
JerrySzczurak	20:cf211a3b3d9e	852	( vcsel_pulse_period_pclk < min_pre_vcsel_period_pclk \|\|
JerrySzczurak	20:cf211a3b3d9e	853	vcsel_pulse_period_pclk > max_pre_vcsel_period_pclk ) ) {
johnAlexander	16:98ce55ddbb1a	854	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	855	} else if ( vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE &&
JerrySzczurak	20:cf211a3b3d9e	856	( vcsel_pulse_period_pclk < min_final_vcsel_period_pclk \|\|
JerrySzczurak	20:cf211a3b3d9e	857	vcsel_pulse_period_pclk > max_final_vcsel_period_pclk ) ) {
johnAlexander	16:98ce55ddbb1a	858
johnAlexander	16:98ce55ddbb1a	859	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	860	}
johnAlexander	15:932d8b4e52c9	861
johnAlexander	15:932d8b4e52c9	862	/* Apply specific settings for the requested clock period */
johnAlexander	15:932d8b4e52c9	863
JerrySzczurak	20:cf211a3b3d9e	864	if ( status != VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	865	return status;
johnAlexander	16:98ce55ddbb1a	866
johnAlexander	16:98ce55ddbb1a	867
JerrySzczurak	20:cf211a3b3d9e	868	if ( vcsel_period_type == VL53L0X_VCSEL_PERIOD_PRE_RANGE ) {
johnAlexander	15:932d8b4e52c9	869
johnAlexander	15:932d8b4e52c9	870	/* Set phase check limits */
JerrySzczurak	20:cf211a3b3d9e	871	if ( vcsel_pulse_period_pclk == 12 ) {
JerrySzczurak	20:cf211a3b3d9e	872
JerrySzczurak	20:cf211a3b3d9e	873	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	874	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	875	0x18 );
JerrySzczurak	20:cf211a3b3d9e	876	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	877	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	878	0x08 );
JerrySzczurak	20:cf211a3b3d9e	879	} else if ( vcsel_pulse_period_pclk == 14 ) {
JerrySzczurak	20:cf211a3b3d9e	880
JerrySzczurak	20:cf211a3b3d9e	881	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	882	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	883	0x30 );
JerrySzczurak	20:cf211a3b3d9e	884	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	885	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	886	0x08 );
JerrySzczurak	20:cf211a3b3d9e	887	} else if ( vcsel_pulse_period_pclk == 16 ) {
JerrySzczurak	20:cf211a3b3d9e	888
JerrySzczurak	20:cf211a3b3d9e	889	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	890	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	891	0x40 );
JerrySzczurak	20:cf211a3b3d9e	892	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	893	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	894	0x08 );
JerrySzczurak	20:cf211a3b3d9e	895	} else if ( vcsel_pulse_period_pclk == 18 ) {
JerrySzczurak	20:cf211a3b3d9e	896
JerrySzczurak	20:cf211a3b3d9e	897	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	898	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	899	0x50 );
JerrySzczurak	20:cf211a3b3d9e	900	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	901	VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	902	0x08 );
johnAlexander	15:932d8b4e52c9	903	}
JerrySzczurak	20:cf211a3b3d9e	904	} else if ( vcsel_period_type == VL53L0X_VCSEL_PERIOD_FINAL_RANGE ) {
JerrySzczurak	20:cf211a3b3d9e	905
JerrySzczurak	20:cf211a3b3d9e	906	if ( vcsel_pulse_period_pclk == 8 ) {
JerrySzczurak	20:cf211a3b3d9e	907
JerrySzczurak	20:cf211a3b3d9e	908	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	909	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	910	0x10 );
JerrySzczurak	20:cf211a3b3d9e	911	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	912	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	913	0x08 );
JerrySzczurak	20:cf211a3b3d9e	914
JerrySzczurak	20:cf211a3b3d9e	915	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	916	VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x02 );
JerrySzczurak	20:cf211a3b3d9e	917	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	918	VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x0C );
JerrySzczurak	20:cf211a3b3d9e	919
JerrySzczurak	20:cf211a3b3d9e	920	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	921	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	922	VL53L0X_REG_ALGO_PHASECAL_LIM,
JerrySzczurak	20:cf211a3b3d9e	923	0x30 );
JerrySzczurak	20:cf211a3b3d9e	924	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	925	} else if ( vcsel_pulse_period_pclk == 10 ) {
JerrySzczurak	20:cf211a3b3d9e	926
JerrySzczurak	20:cf211a3b3d9e	927	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	928	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	929	0x28 );
JerrySzczurak	20:cf211a3b3d9e	930	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	931	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	932	0x08 );
JerrySzczurak	20:cf211a3b3d9e	933
JerrySzczurak	20:cf211a3b3d9e	934	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	935	VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03 );
JerrySzczurak	20:cf211a3b3d9e	936	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	937	VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x09 );
JerrySzczurak	20:cf211a3b3d9e	938
JerrySzczurak	20:cf211a3b3d9e	939	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	940	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	941	VL53L0X_REG_ALGO_PHASECAL_LIM,
JerrySzczurak	20:cf211a3b3d9e	942	0x20 );
JerrySzczurak	20:cf211a3b3d9e	943	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	944	} else if ( vcsel_pulse_period_pclk == 12 ) {
JerrySzczurak	20:cf211a3b3d9e	945
JerrySzczurak	20:cf211a3b3d9e	946	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	947	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	948	0x38 );
JerrySzczurak	20:cf211a3b3d9e	949	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	950	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	951	0x08 );
JerrySzczurak	20:cf211a3b3d9e	952
JerrySzczurak	20:cf211a3b3d9e	953	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	954	VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03 );
JerrySzczurak	20:cf211a3b3d9e	955	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	956	VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x08 );
JerrySzczurak	20:cf211a3b3d9e	957
JerrySzczurak	20:cf211a3b3d9e	958	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	959	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	960	VL53L0X_REG_ALGO_PHASECAL_LIM,
JerrySzczurak	20:cf211a3b3d9e	961	0x20 );
JerrySzczurak	20:cf211a3b3d9e	962	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	963	} else if ( vcsel_pulse_period_pclk == 14 ) {
JerrySzczurak	20:cf211a3b3d9e	964
JerrySzczurak	20:cf211a3b3d9e	965	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	966	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	967	0x048 );
JerrySzczurak	20:cf211a3b3d9e	968	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	969	VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW,
JerrySzczurak	20:cf211a3b3d9e	970	0x08 );
JerrySzczurak	20:cf211a3b3d9e	971
JerrySzczurak	20:cf211a3b3d9e	972	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	973	VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH, 0x03 );
JerrySzczurak	20:cf211a3b3d9e	974	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	975	VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT, 0x07 );
JerrySzczurak	20:cf211a3b3d9e	976
JerrySzczurak	20:cf211a3b3d9e	977	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	978	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	979	VL53L0X_REG_ALGO_PHASECAL_LIM,
JerrySzczurak	20:cf211a3b3d9e	980	0x20 );
JerrySzczurak	20:cf211a3b3d9e	981	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
johnAlexander	15:932d8b4e52c9	982	}
johnAlexander	15:932d8b4e52c9	983	}
johnAlexander	15:932d8b4e52c9	984
johnAlexander	15:932d8b4e52c9	985
johnAlexander	15:932d8b4e52c9	986	/* Re-calculate and apply timeouts, in macro periods */
johnAlexander	15:932d8b4e52c9	987
JerrySzczurak	20:cf211a3b3d9e	988	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	989	vcsel_period_reg = lv53l0x_encode_vcsel_period( ( uint8_t )
JerrySzczurak	20:cf211a3b3d9e	990	vcsel_pulse_period_pclk );
johnAlexander	15:932d8b4e52c9	991
johnAlexander	15:932d8b4e52c9	992	/* When the VCSEL period for the pre or final range is changed,
johnAlexander	15:932d8b4e52c9	993	* the corresponding timeout must be read from the device using
johnAlexander	15:932d8b4e52c9	994	* the current VCSEL period, then the new VCSEL period can be
johnAlexander	15:932d8b4e52c9	995	* applied. The timeout then must be written back to the device
johnAlexander	15:932d8b4e52c9	996	* using the new VCSEL period.
johnAlexander	15:932d8b4e52c9	997	*
johnAlexander	15:932d8b4e52c9	998	* For the MSRC timeout, the same applies - this timeout being
johnAlexander	15:932d8b4e52c9	999	* dependant on the pre-range vcsel period.
johnAlexander	15:932d8b4e52c9	1000	*/
JerrySzczurak	20:cf211a3b3d9e	1001	switch ( vcsel_period_type ) {
johnAlexander	15:932d8b4e52c9	1002	case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	1003	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1004	VL53L0X_SEQUENCESTEP_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1005	&pre_range_timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1006
JerrySzczurak	20:cf211a3b3d9e	1007	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1008	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1009	VL53L0X_SEQUENCESTEP_MSRC,
JerrySzczurak	20:cf211a3b3d9e	1010	&msrc_timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1011
JerrySzczurak	20:cf211a3b3d9e	1012	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1013	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1014	VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	1015	vcsel_period_reg );
JerrySzczurak	20:cf211a3b3d9e	1016
JerrySzczurak	20:cf211a3b3d9e	1017
JerrySzczurak	20:cf211a3b3d9e	1018	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1019	status = set_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1020	VL53L0X_SEQUENCESTEP_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1021	pre_range_timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1022
JerrySzczurak	20:cf211a3b3d9e	1023
JerrySzczurak	20:cf211a3b3d9e	1024	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1025	status = set_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1026	VL53L0X_SEQUENCESTEP_MSRC,
JerrySzczurak	20:cf211a3b3d9e	1027	msrc_timeout_micro_seconds );
johnAlexander	15:932d8b4e52c9	1028
johnAlexander	15:932d8b4e52c9	1029	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	16:98ce55ddbb1a	1030	dev,
johnAlexander	15:932d8b4e52c9	1031	PreRangeVcselPulsePeriod,
JerrySzczurak	20:cf211a3b3d9e	1032	vcsel_pulse_period_pclk );
johnAlexander	15:932d8b4e52c9	1033	break;
johnAlexander	15:932d8b4e52c9	1034	case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	1035	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1036	VL53L0X_SEQUENCESTEP_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1037	&final_range_timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1038
JerrySzczurak	20:cf211a3b3d9e	1039	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1040	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1041	VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	1042	vcsel_period_reg );
JerrySzczurak	20:cf211a3b3d9e	1043
JerrySzczurak	20:cf211a3b3d9e	1044
JerrySzczurak	20:cf211a3b3d9e	1045	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1046	status = set_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1047	VL53L0X_SEQUENCESTEP_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1048	final_range_timeout_micro_seconds );
johnAlexander	15:932d8b4e52c9	1049
johnAlexander	15:932d8b4e52c9	1050	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	16:98ce55ddbb1a	1051	dev,
johnAlexander	15:932d8b4e52c9	1052	FinalRangeVcselPulsePeriod,
JerrySzczurak	20:cf211a3b3d9e	1053	vcsel_pulse_period_pclk );
johnAlexander	15:932d8b4e52c9	1054	break;
johnAlexander	15:932d8b4e52c9	1055	default:
johnAlexander	16:98ce55ddbb1a	1056	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	1057	}
johnAlexander	15:932d8b4e52c9	1058	}
johnAlexander	15:932d8b4e52c9	1059
johnAlexander	15:932d8b4e52c9	1060	/* Finally, the timing budget must be re-applied */
JerrySzczurak	20:cf211a3b3d9e	1061	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1062	VL53L0X_GETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	1063	MeasurementTimingBudgetMicroSeconds,
JerrySzczurak	20:cf211a3b3d9e	1064	measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1065
JerrySzczurak	20:cf211a3b3d9e	1066	status = vl53l0x_set_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	1067	measurement_timing_budget_micro_seconds );
johnAlexander	15:932d8b4e52c9	1068	}
johnAlexander	15:932d8b4e52c9	1069
johnAlexander	15:932d8b4e52c9	1070	/* Perform the phase calibration. This is needed after changing on
johnAlexander	15:932d8b4e52c9	1071	* vcsel period.
johnAlexander	15:932d8b4e52c9	1072	* get_data_enable = 0, restore_config = 1 */
JerrySzczurak	20:cf211a3b3d9e	1073	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	1074	status = vl53l0x_perform_phase_calibration(
JerrySzczurak	20:cf211a3b3d9e	1075	dev, &phase_cal_int, 0, 1 );
JerrySzczurak	20:cf211a3b3d9e	1076
JerrySzczurak	20:cf211a3b3d9e	1077	return status;
JerrySzczurak	20:cf211a3b3d9e	1078	}
JerrySzczurak	20:cf211a3b3d9e	1079
JerrySzczurak	20:cf211a3b3d9e	1080	VL53L0X_Error VL53L0X::vl53l0x_set_vcsel_pulse_period( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1081	VL53L0X_VcselPeriod vcsel_period_type, uint8_t vcsel_pulse_period )
johnAlexander	16:98ce55ddbb1a	1082	{
johnAlexander	16:98ce55ddbb1a	1083	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	1084	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1085
JerrySzczurak	20:cf211a3b3d9e	1086	status = wrapped_vl53l0x_set_vcsel_pulse_period( dev, vcsel_period_type,
JerrySzczurak	20:cf211a3b3d9e	1087	vcsel_pulse_period );
JerrySzczurak	20:cf211a3b3d9e	1088
JerrySzczurak	20:cf211a3b3d9e	1089	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1090	return status;
JerrySzczurak	20:cf211a3b3d9e	1091	}
JerrySzczurak	20:cf211a3b3d9e	1092
JerrySzczurak	20:cf211a3b3d9e	1093	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_vcsel_pulse_period( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1094	VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk )
johnAlexander	0:c523920bcc09	1095	{
johnAlexander	16:98ce55ddbb1a	1096	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1097	uint8_t vcsel_period_reg;
johnAlexander	16:98ce55ddbb1a	1098
JerrySzczurak	20:cf211a3b3d9e	1099	switch ( vcsel_period_type ) {
johnAlexander	16:98ce55ddbb1a	1100	case VL53L0X_VCSEL_PERIOD_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	1101	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1102	VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	1103	&vcsel_period_reg );
johnAlexander	16:98ce55ddbb1a	1104	break;
johnAlexander	16:98ce55ddbb1a	1105	case VL53L0X_VCSEL_PERIOD_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	1106	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1107	VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	1108	&vcsel_period_reg );
johnAlexander	16:98ce55ddbb1a	1109	break;
johnAlexander	16:98ce55ddbb1a	1110	default:
johnAlexander	16:98ce55ddbb1a	1111	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	16:98ce55ddbb1a	1112	}
johnAlexander	16:98ce55ddbb1a	1113
JerrySzczurak	20:cf211a3b3d9e	1114	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	1115	*p_vcsel_pulse_period_pclk =
JerrySzczurak	20:cf211a3b3d9e	1116	vl53l0x_decode_vcsel_period( vcsel_period_reg );
JerrySzczurak	20:cf211a3b3d9e	1117
JerrySzczurak	20:cf211a3b3d9e	1118	return status;
JerrySzczurak	20:cf211a3b3d9e	1119	}
JerrySzczurak	20:cf211a3b3d9e	1120
JerrySzczurak	20:cf211a3b3d9e	1121	VL53L0X_Error VL53L0X::vl53l0x_get_vcsel_pulse_period( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1122	VL53L0X_VcselPeriod vcsel_period_type, uint8_t *p_vcsel_pulse_period_pclk )
johnAlexander	0:c523920bcc09	1123	{
johnAlexander	16:98ce55ddbb1a	1124	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	1125	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1126
JerrySzczurak	20:cf211a3b3d9e	1127	status = wrapped_vl53l0x_get_vcsel_pulse_period( dev, vcsel_period_type,
JerrySzczurak	20:cf211a3b3d9e	1128	p_vcsel_pulse_period_pclk );
JerrySzczurak	20:cf211a3b3d9e	1129
JerrySzczurak	20:cf211a3b3d9e	1130	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1131	return status;
JerrySzczurak	20:cf211a3b3d9e	1132	}
JerrySzczurak	20:cf211a3b3d9e	1133
JerrySzczurak	20:cf211a3b3d9e	1134	uint32_t VL53L0X::vl53l0x_decode_timeout( uint16_t encoded_timeout )
johnAlexander	0:c523920bcc09	1135	{
johnAlexander	15:932d8b4e52c9	1136	/*!
johnAlexander	15:932d8b4e52c9	1137	* Decode 16-bit timeout register value - format (LSByte * 2^MSByte) + 1
johnAlexander	15:932d8b4e52c9	1138	*/
johnAlexander	15:932d8b4e52c9	1139
johnAlexander	15:932d8b4e52c9	1140	uint32_t timeout_macro_clks = 0;
johnAlexander	15:932d8b4e52c9	1141
JerrySzczurak	20:cf211a3b3d9e	1142	timeout_macro_clks = ( ( uint32_t ) ( encoded_timeout & 0x00FF )
JerrySzczurak	20:cf211a3b3d9e	1143	<< ( uint32_t ) ( ( encoded_timeout & 0xFF00 ) >> 8 ) ) + 1;
johnAlexander	15:932d8b4e52c9	1144
johnAlexander	15:932d8b4e52c9	1145	return timeout_macro_clks;
johnAlexander	0:c523920bcc09	1146	}
johnAlexander	0:c523920bcc09	1147
JerrySzczurak	20:cf211a3b3d9e	1148	uint32_t VL53L0X::vl53l0x_calc_macro_period_ps( VL53L0X_DEV dev, uint8_t vcsel_period_pclks )
johnAlexander	0:c523920bcc09	1149	{
johnAlexander	16:98ce55ddbb1a	1150	uint64_t pll_period_ps;
johnAlexander	15:932d8b4e52c9	1151	uint32_t macro_period_vclks;
johnAlexander	15:932d8b4e52c9	1152	uint32_t macro_period_ps;
johnAlexander	15:932d8b4e52c9	1153
JerrySzczurak	20:cf211a3b3d9e	1154	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	1155
johnAlexander	15:932d8b4e52c9	1156	/* The above calculation will produce rounding errors,
johnAlexander	15:932d8b4e52c9	1157	therefore set fixed value
johnAlexander	15:932d8b4e52c9	1158	*/
johnAlexander	16:98ce55ddbb1a	1159	pll_period_ps = 1655;
johnAlexander	15:932d8b4e52c9	1160
johnAlexander	15:932d8b4e52c9	1161	macro_period_vclks = 2304;
JerrySzczurak	20:cf211a3b3d9e	1162	macro_period_ps = ( uint32_t )( macro_period_vclks
JerrySzczurak	20:cf211a3b3d9e	1163	* vcsel_period_pclks * pll_period_ps );
JerrySzczurak	20:cf211a3b3d9e	1164
JerrySzczurak	20:cf211a3b3d9e	1165	LOG_FUNCTION_END( "" );
johnAlexander	15:932d8b4e52c9	1166	return macro_period_ps;
johnAlexander	0:c523920bcc09	1167	}
johnAlexander	0:c523920bcc09	1168
johnAlexander	0:c523920bcc09	1169	/* To convert register value into us */
JerrySzczurak	20:cf211a3b3d9e	1170	uint32_t VL53L0X::vl53l0x_calc_timeout_us( VL53L0X_DEV dev,
johnAlexander	15:932d8b4e52c9	1171	uint16_t timeout_period_mclks,
JerrySzczurak	20:cf211a3b3d9e	1172	uint8_t vcsel_period_pclks )
johnAlexander	0:c523920bcc09	1173	{
johnAlexander	15:932d8b4e52c9	1174	uint32_t macro_period_ps;
johnAlexander	15:932d8b4e52c9	1175	uint32_t macro_period_ns;
johnAlexander	15:932d8b4e52c9	1176	uint32_t actual_timeout_period_us = 0;
johnAlexander	15:932d8b4e52c9	1177
JerrySzczurak	20:cf211a3b3d9e	1178	macro_period_ps = vl53l0x_calc_macro_period_ps( dev, vcsel_period_pclks );
JerrySzczurak	20:cf211a3b3d9e	1179	macro_period_ns = ( macro_period_ps + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	1180
johnAlexander	15:932d8b4e52c9	1181	actual_timeout_period_us =
JerrySzczurak	20:cf211a3b3d9e	1182	( ( timeout_period_mclks * macro_period_ns ) + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	1183
johnAlexander	15:932d8b4e52c9	1184	return actual_timeout_period_us;
johnAlexander	0:c523920bcc09	1185	}
johnAlexander	0:c523920bcc09	1186
JerrySzczurak	20:cf211a3b3d9e	1187	VL53L0X_Error VL53L0X::get_sequence_step_timeout( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	1188	VL53L0X_SequenceStepId sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	1189	uint32_t *p_time_out_micro_secs )
johnAlexander	0:c523920bcc09	1190	{
johnAlexander	16:98ce55ddbb1a	1191	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1192	uint8_t current_vcsel_pulse_period_p_clk;
johnAlexander	16:98ce55ddbb1a	1193	uint8_t encoded_time_out_byte = 0;
johnAlexander	16:98ce55ddbb1a	1194	uint32_t timeout_micro_seconds = 0;
johnAlexander	16:98ce55ddbb1a	1195	uint16_t pre_range_encoded_time_out = 0;
johnAlexander	16:98ce55ddbb1a	1196	uint16_t msrc_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	1197	uint16_t pre_range_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	1198	uint16_t final_range_time_out_m_clks = 0;
johnAlexander	16:98ce55ddbb1a	1199	uint16_t final_range_encoded_time_out;
johnAlexander	16:98ce55ddbb1a	1200	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander	16:98ce55ddbb1a	1201
JerrySzczurak	20:cf211a3b3d9e	1202	if ( ( sequence_step_id == VL53L0X_SEQUENCESTEP_TCC ) \|\|
JerrySzczurak	20:cf211a3b3d9e	1203	( sequence_step_id == VL53L0X_SEQUENCESTEP_DSS ) \|\|
JerrySzczurak	20:cf211a3b3d9e	1204	( sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC ) ) {
JerrySzczurak	20:cf211a3b3d9e	1205
JerrySzczurak	20:cf211a3b3d9e	1206	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	1207	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1208	&current_vcsel_pulse_period_p_clk );
JerrySzczurak	20:cf211a3b3d9e	1209	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1210	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1211	VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
JerrySzczurak	20:cf211a3b3d9e	1212	&encoded_time_out_byte );
johnAlexander	15:932d8b4e52c9	1213	}
JerrySzczurak	20:cf211a3b3d9e	1214	msrc_time_out_m_clks = vl53l0x_decode_timeout( encoded_time_out_byte );
JerrySzczurak	20:cf211a3b3d9e	1215
JerrySzczurak	20:cf211a3b3d9e	1216	timeout_micro_seconds = vl53l0x_calc_timeout_us( dev,
johnAlexander	16:98ce55ddbb1a	1217	msrc_time_out_m_clks,
JerrySzczurak	20:cf211a3b3d9e	1218	current_vcsel_pulse_period_p_clk );
JerrySzczurak	20:cf211a3b3d9e	1219	} else if ( sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE ) {
johnAlexander	15:932d8b4e52c9	1220	/* Retrieve PRE-RANGE VCSEL Period */
JerrySzczurak	20:cf211a3b3d9e	1221	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	1222	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1223	&current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	1224
johnAlexander	15:932d8b4e52c9	1225	/* Retrieve PRE-RANGE Timeout in Macro periods (MCLKS) */
JerrySzczurak	20:cf211a3b3d9e	1226	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	1227
johnAlexander	15:932d8b4e52c9	1228	/* Retrieve PRE-RANGE VCSEL Period */
JerrySzczurak	20:cf211a3b3d9e	1229	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	1230	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1231	&current_vcsel_pulse_period_p_clk );
JerrySzczurak	20:cf211a3b3d9e	1232
JerrySzczurak	20:cf211a3b3d9e	1233	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1234	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	1235	VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
JerrySzczurak	20:cf211a3b3d9e	1236	&pre_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	1237	}
johnAlexander	15:932d8b4e52c9	1238
johnAlexander	16:98ce55ddbb1a	1239	pre_range_time_out_m_clks = vl53l0x_decode_timeout(
JerrySzczurak	20:cf211a3b3d9e	1240	pre_range_encoded_time_out );
JerrySzczurak	20:cf211a3b3d9e	1241
JerrySzczurak	20:cf211a3b3d9e	1242	timeout_micro_seconds = vl53l0x_calc_timeout_us( dev,
johnAlexander	16:98ce55ddbb1a	1243	pre_range_time_out_m_clks,
JerrySzczurak	20:cf211a3b3d9e	1244	current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	1245	}
JerrySzczurak	20:cf211a3b3d9e	1246	} else if ( sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE ) {
JerrySzczurak	20:cf211a3b3d9e	1247
JerrySzczurak	20:cf211a3b3d9e	1248	vl53l0x_get_sequence_step_enables( dev, &scheduler_sequence_steps );
johnAlexander	16:98ce55ddbb1a	1249	pre_range_time_out_m_clks = 0;
johnAlexander	16:98ce55ddbb1a	1250
JerrySzczurak	20:cf211a3b3d9e	1251	if ( scheduler_sequence_steps.PreRangeOn ) {
johnAlexander	15:932d8b4e52c9	1252	/* Retrieve PRE-RANGE VCSEL Period */
JerrySzczurak	20:cf211a3b3d9e	1253	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	1254	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1255	&current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	1256
johnAlexander	15:932d8b4e52c9	1257	/* Retrieve PRE-RANGE Timeout in Macro periods
johnAlexander	15:932d8b4e52c9	1258	* (MCLKS) */
JerrySzczurak	20:cf211a3b3d9e	1259	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1260	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	1261	VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
JerrySzczurak	20:cf211a3b3d9e	1262	&pre_range_encoded_time_out );
johnAlexander	16:98ce55ddbb1a	1263	pre_range_time_out_m_clks = vl53l0x_decode_timeout(
JerrySzczurak	20:cf211a3b3d9e	1264	pre_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	1265	}
johnAlexander	15:932d8b4e52c9	1266	}
johnAlexander	15:932d8b4e52c9	1267
JerrySzczurak	20:cf211a3b3d9e	1268	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	1269	/* Retrieve FINAL-RANGE VCSEL Period */
JerrySzczurak	20:cf211a3b3d9e	1270	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	1271	VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1272	&current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	1273	}
johnAlexander	15:932d8b4e52c9	1274
johnAlexander	15:932d8b4e52c9	1275	/* Retrieve FINAL-RANGE Timeout in Macro periods (MCLKS) */
JerrySzczurak	20:cf211a3b3d9e	1276	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1277	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	1278	VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI,
JerrySzczurak	20:cf211a3b3d9e	1279	&final_range_encoded_time_out );
johnAlexander	16:98ce55ddbb1a	1280	final_range_time_out_m_clks = vl53l0x_decode_timeout(
JerrySzczurak	20:cf211a3b3d9e	1281	final_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	1282	}
johnAlexander	15:932d8b4e52c9	1283
johnAlexander	16:98ce55ddbb1a	1284	final_range_time_out_m_clks -= pre_range_time_out_m_clks;
JerrySzczurak	20:cf211a3b3d9e	1285	timeout_micro_seconds = vl53l0x_calc_timeout_us( dev,
johnAlexander	16:98ce55ddbb1a	1286	final_range_time_out_m_clks,
JerrySzczurak	20:cf211a3b3d9e	1287	current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	1288	}
johnAlexander	15:932d8b4e52c9	1289
johnAlexander	16:98ce55ddbb1a	1290	*p_time_out_micro_secs = timeout_micro_seconds;
johnAlexander	16:98ce55ddbb1a	1291
johnAlexander	16:98ce55ddbb1a	1292	return status;
johnAlexander	0:c523920bcc09	1293	}
johnAlexander	0:c523920bcc09	1294
JerrySzczurak	20:cf211a3b3d9e	1295	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1296	uint32_t *p_measurement_timing_budget_micro_seconds )
johnAlexander	0:c523920bcc09	1297	{
johnAlexander	16:98ce55ddbb1a	1298	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1299	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander	16:98ce55ddbb1a	1300	uint32_t final_range_timeout_micro_seconds;
johnAlexander	16:98ce55ddbb1a	1301	uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
johnAlexander	16:98ce55ddbb1a	1302	uint32_t start_overhead_micro_seconds = 1910;
johnAlexander	16:98ce55ddbb1a	1303	uint32_t end_overhead_micro_seconds = 960;
johnAlexander	16:98ce55ddbb1a	1304	uint32_t msrc_overhead_micro_seconds = 660;
johnAlexander	16:98ce55ddbb1a	1305	uint32_t tcc_overhead_micro_seconds = 590;
johnAlexander	16:98ce55ddbb1a	1306	uint32_t dss_overhead_micro_seconds = 690;
johnAlexander	16:98ce55ddbb1a	1307	uint32_t pre_range_overhead_micro_seconds = 660;
johnAlexander	16:98ce55ddbb1a	1308	uint32_t final_range_overhead_micro_seconds = 550;
johnAlexander	16:98ce55ddbb1a	1309	uint32_t pre_range_timeout_micro_seconds = 0;
johnAlexander	15:932d8b4e52c9	1310
JerrySzczurak	20:cf211a3b3d9e	1311	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	1312
johnAlexander	15:932d8b4e52c9	1313	/* Start and end overhead times always present */
johnAlexander	16:98ce55ddbb1a	1314	*p_measurement_timing_budget_micro_seconds
johnAlexander	16:98ce55ddbb1a	1315	= start_overhead_micro_seconds + end_overhead_micro_seconds;
johnAlexander	16:98ce55ddbb1a	1316
JerrySzczurak	20:cf211a3b3d9e	1317	status = vl53l0x_get_sequence_step_enables( dev, &scheduler_sequence_steps );
JerrySzczurak	20:cf211a3b3d9e	1318
JerrySzczurak	20:cf211a3b3d9e	1319	if ( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1320	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	1321	return status;
johnAlexander	15:932d8b4e52c9	1322	}
johnAlexander	15:932d8b4e52c9	1323
johnAlexander	15:932d8b4e52c9	1324
JerrySzczurak	20:cf211a3b3d9e	1325	if ( scheduler_sequence_steps.TccOn \|\|
johnAlexander	16:98ce55ddbb1a	1326	scheduler_sequence_steps.MsrcOn \|\|
JerrySzczurak	20:cf211a3b3d9e	1327	scheduler_sequence_steps.DssOn ) {
JerrySzczurak	20:cf211a3b3d9e	1328
JerrySzczurak	20:cf211a3b3d9e	1329	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1330	VL53L0X_SEQUENCESTEP_MSRC,
JerrySzczurak	20:cf211a3b3d9e	1331	&msrc_dcc_tcc_timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1332
JerrySzczurak	20:cf211a3b3d9e	1333	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1334	if ( scheduler_sequence_steps.TccOn ) {
johnAlexander	16:98ce55ddbb1a	1335	*p_measurement_timing_budget_micro_seconds +=
johnAlexander	16:98ce55ddbb1a	1336	msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander	16:98ce55ddbb1a	1337	tcc_overhead_micro_seconds;
johnAlexander	15:932d8b4e52c9	1338	}
johnAlexander	15:932d8b4e52c9	1339
JerrySzczurak	20:cf211a3b3d9e	1340	if ( scheduler_sequence_steps.DssOn ) {
johnAlexander	16:98ce55ddbb1a	1341	*p_measurement_timing_budget_micro_seconds +=
JerrySzczurak	20:cf211a3b3d9e	1342	2 * ( msrc_dcc_tcc_timeout_micro_seconds +
JerrySzczurak	20:cf211a3b3d9e	1343	dss_overhead_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1344	} else if ( scheduler_sequence_steps.MsrcOn ) {
johnAlexander	16:98ce55ddbb1a	1345	*p_measurement_timing_budget_micro_seconds +=
johnAlexander	16:98ce55ddbb1a	1346	msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander	16:98ce55ddbb1a	1347	msrc_overhead_micro_seconds;
johnAlexander	15:932d8b4e52c9	1348	}
johnAlexander	15:932d8b4e52c9	1349	}
johnAlexander	15:932d8b4e52c9	1350	}
johnAlexander	15:932d8b4e52c9	1351
JerrySzczurak	20:cf211a3b3d9e	1352	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1353	if ( scheduler_sequence_steps.PreRangeOn ) {
JerrySzczurak	20:cf211a3b3d9e	1354	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1355	VL53L0X_SEQUENCESTEP_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1356	&pre_range_timeout_micro_seconds );
johnAlexander	16:98ce55ddbb1a	1357	*p_measurement_timing_budget_micro_seconds +=
johnAlexander	16:98ce55ddbb1a	1358	pre_range_timeout_micro_seconds +
johnAlexander	16:98ce55ddbb1a	1359	pre_range_overhead_micro_seconds;
johnAlexander	15:932d8b4e52c9	1360	}
johnAlexander	15:932d8b4e52c9	1361	}
johnAlexander	15:932d8b4e52c9	1362
JerrySzczurak	20:cf211a3b3d9e	1363	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1364	if ( scheduler_sequence_steps.FinalRangeOn ) {
JerrySzczurak	20:cf211a3b3d9e	1365	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	1366	VL53L0X_SEQUENCESTEP_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1367	&final_range_timeout_micro_seconds );
johnAlexander	16:98ce55ddbb1a	1368	*p_measurement_timing_budget_micro_seconds +=
JerrySzczurak	20:cf211a3b3d9e	1369	( final_range_timeout_micro_seconds +
JerrySzczurak	20:cf211a3b3d9e	1370	final_range_overhead_micro_seconds );
johnAlexander	15:932d8b4e52c9	1371	}
johnAlexander	15:932d8b4e52c9	1372	}
johnAlexander	15:932d8b4e52c9	1373
JerrySzczurak	20:cf211a3b3d9e	1374	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1375	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	1376	MeasurementTimingBudgetMicroSeconds,
JerrySzczurak	20:cf211a3b3d9e	1377	*p_measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1378	}
JerrySzczurak	20:cf211a3b3d9e	1379
JerrySzczurak	20:cf211a3b3d9e	1380	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1381	return status;
JerrySzczurak	20:cf211a3b3d9e	1382	}
JerrySzczurak	20:cf211a3b3d9e	1383
JerrySzczurak	20:cf211a3b3d9e	1384	VL53L0X_Error VL53L0X::vl53l0x_get_measurement_timing_budget_micro_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1385	uint32_t *p_measurement_timing_budget_micro_seconds )
johnAlexander	0:c523920bcc09	1386	{
johnAlexander	16:98ce55ddbb1a	1387	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	1388	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1389
JerrySzczurak	20:cf211a3b3d9e	1390	status = wrapped_vl53l0x_get_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	1391	p_measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	1392
JerrySzczurak	20:cf211a3b3d9e	1393	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1394	return status;
JerrySzczurak	20:cf211a3b3d9e	1395	}
JerrySzczurak	20:cf211a3b3d9e	1396
JerrySzczurak	20:cf211a3b3d9e	1397	VL53L0X_Error VL53L0X::vl53l0x_get_device_parameters( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1398	VL53L0X_DeviceParameters_t *p_device_parameters )
johnAlexander	0:c523920bcc09	1399	{
johnAlexander	16:98ce55ddbb1a	1400	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	1401	int i;
johnAlexander	15:932d8b4e52c9	1402
JerrySzczurak	20:cf211a3b3d9e	1403	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1404
JerrySzczurak	20:cf211a3b3d9e	1405	status = vl53l0x_get_device_mode( dev, &( p_device_parameters->DeviceMode ) );
JerrySzczurak	20:cf211a3b3d9e	1406
JerrySzczurak	20:cf211a3b3d9e	1407	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1408	status = vl53l0x_get_inter_measurement_period_milli_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	1409	&( p_device_parameters->InterMeasurementPeriodMilliSeconds ) );
JerrySzczurak	20:cf211a3b3d9e	1410
JerrySzczurak	20:cf211a3b3d9e	1411
JerrySzczurak	20:cf211a3b3d9e	1412	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	17:1b842521063a	1413	p_device_parameters->XTalkCompensationEnable = 0;
johnAlexander	15:932d8b4e52c9	1414
JerrySzczurak	20:cf211a3b3d9e	1415	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1416	status = vl53l0x_get_x_talk_compensation_rate_mega_cps( dev,
JerrySzczurak	20:cf211a3b3d9e	1417	&( p_device_parameters->XTalkCompensationRateMegaCps ) );
JerrySzczurak	20:cf211a3b3d9e	1418
JerrySzczurak	20:cf211a3b3d9e	1419
JerrySzczurak	20:cf211a3b3d9e	1420	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1421	status = vl53l0x_get_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	1422	&( p_device_parameters->RangeOffsetMicroMeters ) );
JerrySzczurak	20:cf211a3b3d9e	1423
JerrySzczurak	20:cf211a3b3d9e	1424
JerrySzczurak	20:cf211a3b3d9e	1425	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1426	for ( i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++ ) {
johnAlexander	15:932d8b4e52c9	1427	/* get first the values, then the enables.
johnAlexander	15:932d8b4e52c9	1428	* VL53L0X_GetLimitCheckValue will modify the enable
johnAlexander	15:932d8b4e52c9	1429	* flags
johnAlexander	15:932d8b4e52c9	1430	*/
JerrySzczurak	20:cf211a3b3d9e	1431	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1432	status \|= vl53l0x_get_limit_check_value( dev, i,
JerrySzczurak	20:cf211a3b3d9e	1433	&( p_device_parameters->LimitChecksValue[i] ) );
johnAlexander	15:932d8b4e52c9	1434	} else {
johnAlexander	15:932d8b4e52c9	1435	break;
johnAlexander	15:932d8b4e52c9	1436	}
JerrySzczurak	20:cf211a3b3d9e	1437	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1438	status \|= vl53l0x_get_limit_check_enable( dev, i,
JerrySzczurak	20:cf211a3b3d9e	1439	&( p_device_parameters->LimitChecksEnable[i] ) );
johnAlexander	15:932d8b4e52c9	1440	} else {
johnAlexander	15:932d8b4e52c9	1441	break;
johnAlexander	15:932d8b4e52c9	1442	}
johnAlexander	15:932d8b4e52c9	1443	}
johnAlexander	15:932d8b4e52c9	1444	}
johnAlexander	15:932d8b4e52c9	1445
JerrySzczurak	20:cf211a3b3d9e	1446	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1447	status = vl53l0x_get_wrap_around_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	1448	&( p_device_parameters->WrapAroundCheckEnable ) );
johnAlexander	15:932d8b4e52c9	1449	}
johnAlexander	15:932d8b4e52c9	1450
johnAlexander	15:932d8b4e52c9	1451	/* Need to be done at the end as it uses VCSELPulsePeriod */
JerrySzczurak	20:cf211a3b3d9e	1452	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1453	status = vl53l0x_get_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	1454	&( p_device_parameters->MeasurementTimingBudgetMicroSeconds ) );
JerrySzczurak	20:cf211a3b3d9e	1455	}
JerrySzczurak	20:cf211a3b3d9e	1456
JerrySzczurak	20:cf211a3b3d9e	1457	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1458	return status;
JerrySzczurak	20:cf211a3b3d9e	1459	}
JerrySzczurak	20:cf211a3b3d9e	1460
JerrySzczurak	20:cf211a3b3d9e	1461	VL53L0X_Error VL53L0X::vl53l0x_set_limit_check_value( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	1462	FixPoint1616_t limit_check_value )
johnAlexander	0:c523920bcc09	1463	{
johnAlexander	16:98ce55ddbb1a	1464	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1465	uint8_t temp8;
johnAlexander	15:932d8b4e52c9	1466
JerrySzczurak	20:cf211a3b3d9e	1467	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1468
JerrySzczurak	20:cf211a3b3d9e	1469	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksEnable, limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	1470	temp8 );
JerrySzczurak	20:cf211a3b3d9e	1471
JerrySzczurak	20:cf211a3b3d9e	1472	if ( temp8 == 0 ) { /* disabled write only internal value */
JerrySzczurak	20:cf211a3b3d9e	1473	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	1474	limit_check_id, limit_check_value );
johnAlexander	15:932d8b4e52c9	1475	} else {
johnAlexander	15:932d8b4e52c9	1476
JerrySzczurak	20:cf211a3b3d9e	1477	switch ( limit_check_id ) {
johnAlexander	15:932d8b4e52c9	1478
johnAlexander	15:932d8b4e52c9	1479	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander	15:932d8b4e52c9	1480	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	1481	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	1482	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1483	limit_check_value );
johnAlexander	15:932d8b4e52c9	1484	break;
johnAlexander	15:932d8b4e52c9	1485
johnAlexander	15:932d8b4e52c9	1486	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
johnAlexander	15:932d8b4e52c9	1487
JerrySzczurak	20:cf211a3b3d9e	1488	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	1489	VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
JerrySzczurak	20:cf211a3b3d9e	1490	VL53L0X_FIXPOINT1616TOFIXPOINT97(
JerrySzczurak	20:cf211a3b3d9e	1491	limit_check_value ) );
johnAlexander	15:932d8b4e52c9	1492
johnAlexander	15:932d8b4e52c9	1493	break;
johnAlexander	15:932d8b4e52c9	1494
johnAlexander	15:932d8b4e52c9	1495	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander	15:932d8b4e52c9	1496
johnAlexander	15:932d8b4e52c9	1497	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	1498	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	1499	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	1500	limit_check_value );
johnAlexander	15:932d8b4e52c9	1501
johnAlexander	15:932d8b4e52c9	1502	break;
johnAlexander	15:932d8b4e52c9	1503
johnAlexander	15:932d8b4e52c9	1504	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander	15:932d8b4e52c9	1505
johnAlexander	15:932d8b4e52c9	1506	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	1507	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	1508	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	1509	limit_check_value );
johnAlexander	15:932d8b4e52c9	1510
johnAlexander	15:932d8b4e52c9	1511	break;
johnAlexander	15:932d8b4e52c9	1512
johnAlexander	15:932d8b4e52c9	1513	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander	15:932d8b4e52c9	1514	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
johnAlexander	15:932d8b4e52c9	1515
JerrySzczurak	20:cf211a3b3d9e	1516	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	1517	VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT,
JerrySzczurak	20:cf211a3b3d9e	1518	VL53L0X_FIXPOINT1616TOFIXPOINT97(
JerrySzczurak	20:cf211a3b3d9e	1519	limit_check_value ) );
johnAlexander	15:932d8b4e52c9	1520
johnAlexander	15:932d8b4e52c9	1521	break;
johnAlexander	15:932d8b4e52c9	1522
johnAlexander	15:932d8b4e52c9	1523	default:
johnAlexander	16:98ce55ddbb1a	1524	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	1525
johnAlexander	15:932d8b4e52c9	1526	}
johnAlexander	15:932d8b4e52c9	1527
JerrySzczurak	20:cf211a3b3d9e	1528	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1529	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	1530	limit_check_id, limit_check_value );
johnAlexander	15:932d8b4e52c9	1531	}
johnAlexander	15:932d8b4e52c9	1532	}
johnAlexander	15:932d8b4e52c9	1533
JerrySzczurak	20:cf211a3b3d9e	1534	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1535	return status;
JerrySzczurak	20:cf211a3b3d9e	1536	}
JerrySzczurak	20:cf211a3b3d9e	1537
JerrySzczurak	20:cf211a3b3d9e	1538	VL53L0X_Error VL53L0X::vl53l0x_data_init( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	1539	{
johnAlexander	16:98ce55ddbb1a	1540	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	1541	VL53L0X_DeviceParameters_t CurrentParameters;
johnAlexander	15:932d8b4e52c9	1542	int i;
johnAlexander	15:932d8b4e52c9	1543	uint8_t StopVariable;
johnAlexander	15:932d8b4e52c9	1544
JerrySzczurak	20:cf211a3b3d9e	1545	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	1546
johnAlexander	15:932d8b4e52c9	1547	/* by default the I2C is running at 1V8 if you want to change it you
johnAlexander	15:932d8b4e52c9	1548	* need to include this define at compilation level. */
johnAlexander	0:c523920bcc09	1549	#ifdef USE_I2C_2V8
JerrySzczurak	21:627b65069e6d	1550	Status = vl53l0x_update_word( Dev,
JerrySzczurak	20:cf211a3b3d9e	1551	VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV,
JerrySzczurak	20:cf211a3b3d9e	1552	0xFE,
JerrySzczurak	20:cf211a3b3d9e	1553	0x01 );
johnAlexander	0:c523920bcc09	1554	#endif
johnAlexander	0:c523920bcc09	1555
johnAlexander	15:932d8b4e52c9	1556	/* Set I2C standard mode */
JerrySzczurak	20:cf211a3b3d9e	1557	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1558	status = vl53l0x_write_byte( dev, 0x88, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1559
JerrySzczurak	20:cf211a3b3d9e	1560	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, ReadDataFromDeviceDone, 0 );
johnAlexander	0:c523920bcc09	1561
johnAlexander	0:c523920bcc09	1562	#ifdef USE_IQC_STATION
JerrySzczurak	20:cf211a3b3d9e	1563	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1564	Status = VL53L0X_apply_offset_adjustment( Dev );
johnAlexander	0:c523920bcc09	1565	#endif
johnAlexander	0:c523920bcc09	1566
johnAlexander	15:932d8b4e52c9	1567	/* Default value is 1000 for Linearity Corrective Gain */
JerrySzczurak	20:cf211a3b3d9e	1568	PALDevDataSet( dev, LinearityCorrectiveGain, 1000 );
johnAlexander	15:932d8b4e52c9	1569
johnAlexander	15:932d8b4e52c9	1570	/* Dmax default Parameter */
JerrySzczurak	20:cf211a3b3d9e	1571	PALDevDataSet( dev, DmaxCalRangeMilliMeter, 400 );
JerrySzczurak	20:cf211a3b3d9e	1572	PALDevDataSet( dev, DmaxCalSignalRateRtnMegaCps,
JerrySzczurak	20:cf211a3b3d9e	1573	( FixPoint1616_t )( ( 0x00016B85 ) ) ); /* 1.42 No Cover Glass*/
johnAlexander	15:932d8b4e52c9	1574
johnAlexander	15:932d8b4e52c9	1575	/* Set Default static parameters
johnAlexander	15:932d8b4e52c9	1576	set first temporary values 9.44MHz 65536 = 618660 */
JerrySzczurak	20:cf211a3b3d9e	1577	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, OscFrequencyMHz, 618660 );
johnAlexander	15:932d8b4e52c9	1578
johnAlexander	15:932d8b4e52c9	1579	/* Set Default XTalkCompensationRateMegaCps to 0 */
JerrySzczurak	20:cf211a3b3d9e	1580	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationRateMegaCps, 0 );
johnAlexander	15:932d8b4e52c9	1581
johnAlexander	15:932d8b4e52c9	1582	/* Get default parameters */
JerrySzczurak	20:cf211a3b3d9e	1583	status = vl53l0x_get_device_parameters( dev, &CurrentParameters );
JerrySzczurak	20:cf211a3b3d9e	1584	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	1585	/* initialize PAL values */
johnAlexander	15:932d8b4e52c9	1586	CurrentParameters.DeviceMode = VL53L0X_DEVICEMODE_SINGLE_RANGING;
johnAlexander	15:932d8b4e52c9	1587	CurrentParameters.HistogramMode = VL53L0X_HISTOGRAMMODE_DISABLED;
JerrySzczurak	20:cf211a3b3d9e	1588	PALDevDataSet( dev, CurrentParameters, CurrentParameters );
johnAlexander	15:932d8b4e52c9	1589	}
johnAlexander	15:932d8b4e52c9	1590
johnAlexander	15:932d8b4e52c9	1591	/* Sigma estimator variable */
JerrySzczurak	20:cf211a3b3d9e	1592	PALDevDataSet( dev, SigmaEstRefArray, 100 );
JerrySzczurak	20:cf211a3b3d9e	1593	PALDevDataSet( dev, SigmaEstEffPulseWidth, 900 );
JerrySzczurak	20:cf211a3b3d9e	1594	PALDevDataSet( dev, SigmaEstEffAmbWidth, 500 );
JerrySzczurak	20:cf211a3b3d9e	1595	PALDevDataSet( dev, targetRefRate, 0x0A00 ); /* 20 MCPS in 9:7 format */
johnAlexander	15:932d8b4e52c9	1596
johnAlexander	15:932d8b4e52c9	1597	/* Use internal default settings */
JerrySzczurak	20:cf211a3b3d9e	1598	PALDevDataSet( dev, UseInternalTuningSettings, 1 );
JerrySzczurak	20:cf211a3b3d9e	1599
JerrySzczurak	20:cf211a3b3d9e	1600	status \|= vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1601	status \|= vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1602	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1603	status \|= vl53l0x_read_byte( dev, 0x91, &StopVariable );
JerrySzczurak	20:cf211a3b3d9e	1604	PALDevDataSet( dev, StopVariable, StopVariable );
JerrySzczurak	20:cf211a3b3d9e	1605	status \|= vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1606	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1607	status \|= vl53l0x_write_byte( dev, 0x80, 0x00 );
johnAlexander	15:932d8b4e52c9	1608
johnAlexander	15:932d8b4e52c9	1609	/* Enable all check */
JerrySzczurak	20:cf211a3b3d9e	1610	for ( i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++ ) {
JerrySzczurak	20:cf211a3b3d9e	1611	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1612	status \|= vl53l0x_set_limit_check_enable( dev, i, 1 );
johnAlexander	15:932d8b4e52c9	1613	else
johnAlexander	15:932d8b4e52c9	1614	break;
johnAlexander	15:932d8b4e52c9	1615
johnAlexander	15:932d8b4e52c9	1616	}
johnAlexander	15:932d8b4e52c9	1617
johnAlexander	15:932d8b4e52c9	1618	/* Disable the following checks */
JerrySzczurak	20:cf211a3b3d9e	1619	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1620	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	1621	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, 0 );
JerrySzczurak	20:cf211a3b3d9e	1622
JerrySzczurak	20:cf211a3b3d9e	1623	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1624	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	1625	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0 );
JerrySzczurak	20:cf211a3b3d9e	1626
JerrySzczurak	20:cf211a3b3d9e	1627	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1628	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	1629	VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC, 0 );
JerrySzczurak	20:cf211a3b3d9e	1630
JerrySzczurak	20:cf211a3b3d9e	1631	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1632	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	1633	VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE, 0 );
johnAlexander	15:932d8b4e52c9	1634
johnAlexander	15:932d8b4e52c9	1635	/* Limit default values */
JerrySzczurak	20:cf211a3b3d9e	1636	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1637	status = vl53l0x_set_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	1638	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1639	( FixPoint1616_t )( 18 * 65536 ) );
JerrySzczurak	20:cf211a3b3d9e	1640	}
JerrySzczurak	20:cf211a3b3d9e	1641	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1642	status = vl53l0x_set_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	1643	VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	1644	( FixPoint1616_t )( 25 * 65536 / 100 ) );
johnAlexander	15:932d8b4e52c9	1645	/* 0.25 * 65536 */
johnAlexander	15:932d8b4e52c9	1646	}
johnAlexander	15:932d8b4e52c9	1647
JerrySzczurak	20:cf211a3b3d9e	1648	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1649	status = vl53l0x_set_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	1650	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	1651	( FixPoint1616_t )( 35 * 65536 ) );
JerrySzczurak	20:cf211a3b3d9e	1652	}
JerrySzczurak	20:cf211a3b3d9e	1653
JerrySzczurak	20:cf211a3b3d9e	1654	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1655	status = vl53l0x_set_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	1656	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	1657	( FixPoint1616_t )( 0 * 65536 ) );
JerrySzczurak	20:cf211a3b3d9e	1658	}
JerrySzczurak	20:cf211a3b3d9e	1659
JerrySzczurak	20:cf211a3b3d9e	1660	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1661
JerrySzczurak	20:cf211a3b3d9e	1662	PALDevDataSet( dev, SequenceConfig, 0xFF );
JerrySzczurak	20:cf211a3b3d9e	1663	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	1664	0xFF );
johnAlexander	15:932d8b4e52c9	1665
johnAlexander	15:932d8b4e52c9	1666	/* Set PAL state to tell that we are waiting for call to
johnAlexander	15:932d8b4e52c9	1667	* VL53L0X_StaticInit */
JerrySzczurak	20:cf211a3b3d9e	1668	PALDevDataSet( dev, PalState, VL53L0X_STATE_WAIT_STATICINIT );
JerrySzczurak	20:cf211a3b3d9e	1669	}
JerrySzczurak	20:cf211a3b3d9e	1670
JerrySzczurak	20:cf211a3b3d9e	1671	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1672	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, RefSpadsInitialised, 0 );
JerrySzczurak	20:cf211a3b3d9e	1673
JerrySzczurak	20:cf211a3b3d9e	1674
JerrySzczurak	20:cf211a3b3d9e	1675	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1676	return status;
JerrySzczurak	20:cf211a3b3d9e	1677	}
JerrySzczurak	20:cf211a3b3d9e	1678
JerrySzczurak	20:cf211a3b3d9e	1679	VL53L0X_Error VL53L0X::vl53l0x_check_part_used( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	1680	uint8_t *revision,
JerrySzczurak	20:cf211a3b3d9e	1681	VL53L0X_DeviceInfo_t *p_vl53l0x_device_info )
johnAlexander	0:c523920bcc09	1682	{
johnAlexander	16:98ce55ddbb1a	1683	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1684	uint8_t module_id_int;
johnAlexander	16:98ce55ddbb1a	1685	char *product_id_tmp;
johnAlexander	15:932d8b4e52c9	1686
JerrySzczurak	20:cf211a3b3d9e	1687	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1688
JerrySzczurak	20:cf211a3b3d9e	1689	status = vl53l0x_get_info_from_device( dev, 2 );
JerrySzczurak	20:cf211a3b3d9e	1690
JerrySzczurak	20:cf211a3b3d9e	1691	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1692	module_id_int = VL53L0X_GETDEVICESPECIFICPARAMETER( dev, ModuleId );
JerrySzczurak	20:cf211a3b3d9e	1693
JerrySzczurak	20:cf211a3b3d9e	1694	if ( module_id_int == 0 ) {
johnAlexander	16:98ce55ddbb1a	1695	*revision = 0;
JerrySzczurak	20:cf211a3b3d9e	1696	VL53L0X_COPYSTRING( p_vl53l0x_device_info->ProductId, "" );
johnAlexander	15:932d8b4e52c9	1697	} else {
JerrySzczurak	20:cf211a3b3d9e	1698	*revision = VL53L0X_GETDEVICESPECIFICPARAMETER( dev, Revision );
JerrySzczurak	20:cf211a3b3d9e	1699	product_id_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	1700	ProductId );
JerrySzczurak	20:cf211a3b3d9e	1701	VL53L0X_COPYSTRING( p_vl53l0x_device_info->ProductId, product_id_tmp );
johnAlexander	15:932d8b4e52c9	1702	}
johnAlexander	15:932d8b4e52c9	1703	}
johnAlexander	15:932d8b4e52c9	1704
JerrySzczurak	20:cf211a3b3d9e	1705	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1706	return status;
JerrySzczurak	20:cf211a3b3d9e	1707	}
JerrySzczurak	20:cf211a3b3d9e	1708
JerrySzczurak	20:cf211a3b3d9e	1709	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_device_info( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1710	VL53L0X_DeviceInfo_t *p_vl53l0x_device_info )
johnAlexander	0:c523920bcc09	1711	{
johnAlexander	16:98ce55ddbb1a	1712	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	1713	uint8_t revision_id;
johnAlexander	16:98ce55ddbb1a	1714	uint8_t revision;
johnAlexander	16:98ce55ddbb1a	1715
JerrySzczurak	20:cf211a3b3d9e	1716	status = vl53l0x_check_part_used( dev, &revision, p_vl53l0x_device_info );
JerrySzczurak	20:cf211a3b3d9e	1717
JerrySzczurak	20:cf211a3b3d9e	1718	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1719	if ( revision == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	1720	VL53L0X_COPYSTRING( p_vl53l0x_device_info->Name,
JerrySzczurak	20:cf211a3b3d9e	1721	VL53L0X_STRING_DEVICE_INFO_NAME_TS0 );
JerrySzczurak	20:cf211a3b3d9e	1722	} else if ( ( revision <= 34 ) && ( revision != 32 ) ) {
JerrySzczurak	20:cf211a3b3d9e	1723	VL53L0X_COPYSTRING( p_vl53l0x_device_info->Name,
JerrySzczurak	20:cf211a3b3d9e	1724	VL53L0X_STRING_DEVICE_INFO_NAME_TS1 );
JerrySzczurak	20:cf211a3b3d9e	1725	} else if ( revision < 39 ) {
JerrySzczurak	20:cf211a3b3d9e	1726	VL53L0X_COPYSTRING( p_vl53l0x_device_info->Name,
JerrySzczurak	20:cf211a3b3d9e	1727	VL53L0X_STRING_DEVICE_INFO_NAME_TS2 );
johnAlexander	15:932d8b4e52c9	1728	} else {
JerrySzczurak	20:cf211a3b3d9e	1729	VL53L0X_COPYSTRING( p_vl53l0x_device_info->Name,
JerrySzczurak	20:cf211a3b3d9e	1730	VL53L0X_STRING_DEVICE_INFO_NAME_ES1 );
johnAlexander	15:932d8b4e52c9	1731	}
johnAlexander	15:932d8b4e52c9	1732
JerrySzczurak	20:cf211a3b3d9e	1733	VL53L0X_COPYSTRING( p_vl53l0x_device_info->Type,
JerrySzczurak	20:cf211a3b3d9e	1734	VL53L0X_STRING_DEVICE_INFO_TYPE );
JerrySzczurak	20:cf211a3b3d9e	1735
JerrySzczurak	20:cf211a3b3d9e	1736	}
JerrySzczurak	20:cf211a3b3d9e	1737
JerrySzczurak	20:cf211a3b3d9e	1738	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1739	status = vl53l0x_read_byte( dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
JerrySzczurak	20:cf211a3b3d9e	1740	&p_vl53l0x_device_info->ProductType );
JerrySzczurak	20:cf211a3b3d9e	1741	}
JerrySzczurak	20:cf211a3b3d9e	1742
JerrySzczurak	20:cf211a3b3d9e	1743	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1744	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1745	VL53L0X_REG_IDENTIFICATION_REVISION_ID,
JerrySzczurak	20:cf211a3b3d9e	1746	&revision_id );
johnAlexander	16:98ce55ddbb1a	1747	p_vl53l0x_device_info->ProductRevisionMajor = 1;
johnAlexander	16:98ce55ddbb1a	1748	p_vl53l0x_device_info->ProductRevisionMinor =
JerrySzczurak	20:cf211a3b3d9e	1749	( revision_id & 0xF0 ) >> 4;
JerrySzczurak	20:cf211a3b3d9e	1750	}
JerrySzczurak	20:cf211a3b3d9e	1751
JerrySzczurak	20:cf211a3b3d9e	1752	return status;
JerrySzczurak	20:cf211a3b3d9e	1753	}
JerrySzczurak	20:cf211a3b3d9e	1754
JerrySzczurak	20:cf211a3b3d9e	1755	VL53L0X_Error VL53L0X::vl53l0x_get_device_info( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1756	VL53L0X_DeviceInfo_t *p_vl53l0x_device_info )
johnAlexander	0:c523920bcc09	1757	{
johnAlexander	16:98ce55ddbb1a	1758	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	1759	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1760
JerrySzczurak	20:cf211a3b3d9e	1761	status = wrapped_vl53l0x_get_device_info( dev, p_vl53l0x_device_info );
JerrySzczurak	20:cf211a3b3d9e	1762
JerrySzczurak	20:cf211a3b3d9e	1763	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1764	return status;
JerrySzczurak	20:cf211a3b3d9e	1765	}
JerrySzczurak	20:cf211a3b3d9e	1766
JerrySzczurak	20:cf211a3b3d9e	1767	VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_mask_status( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1768	uint32_t *p_interrupt_mask_status )
johnAlexander	0:c523920bcc09	1769	{
johnAlexander	16:98ce55ddbb1a	1770	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1771	uint8_t byte;
JerrySzczurak	20:cf211a3b3d9e	1772	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1773
JerrySzczurak	20:cf211a3b3d9e	1774	status = vl53l0x_read_byte( dev, VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte );
johnAlexander	17:1b842521063a	1775	*p_interrupt_mask_status = byte & 0x07;
johnAlexander	16:98ce55ddbb1a	1776
JerrySzczurak	20:cf211a3b3d9e	1777	if ( byte & 0x18 )
johnAlexander	16:98ce55ddbb1a	1778	status = VL53L0X_ERROR_RANGE_ERROR;
johnAlexander	16:98ce55ddbb1a	1779
JerrySzczurak	20:cf211a3b3d9e	1780	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1781	return status;
JerrySzczurak	20:cf211a3b3d9e	1782	}
JerrySzczurak	20:cf211a3b3d9e	1783
JerrySzczurak	20:cf211a3b3d9e	1784	VL53L0X_Error VL53L0X::vl53l0x_get_measurement_data_ready( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1785	uint8_t *p_measurement_data_ready )
johnAlexander	0:c523920bcc09	1786	{
johnAlexander	16:98ce55ddbb1a	1787	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1788	uint8_t sys_range_status_register;
johnAlexander	16:98ce55ddbb1a	1789	uint8_t interrupt_config;
johnAlexander	16:98ce55ddbb1a	1790	uint32_t interrupt_mask;
JerrySzczurak	20:cf211a3b3d9e	1791	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	1792
JerrySzczurak	20:cf211a3b3d9e	1793	interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	1794	Pin0GpioFunctionality );
JerrySzczurak	20:cf211a3b3d9e	1795
JerrySzczurak	20:cf211a3b3d9e	1796	if ( interrupt_config ==
JerrySzczurak	20:cf211a3b3d9e	1797	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY ) {
JerrySzczurak	20:cf211a3b3d9e	1798	status = vl53l0x_get_interrupt_mask_status( dev, &interrupt_mask );
JerrySzczurak	20:cf211a3b3d9e	1799	if ( interrupt_mask ==
JerrySzczurak	20:cf211a3b3d9e	1800	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY )
johnAlexander	17:1b842521063a	1801	*p_measurement_data_ready = 1;
johnAlexander	15:932d8b4e52c9	1802	else
johnAlexander	17:1b842521063a	1803	*p_measurement_data_ready = 0;
johnAlexander	15:932d8b4e52c9	1804	} else {
JerrySzczurak	20:cf211a3b3d9e	1805	status = vl53l0x_read_byte( dev, VL53L0X_REG_RESULT_RANGE_STATUS,
JerrySzczurak	20:cf211a3b3d9e	1806	&sys_range_status_register );
JerrySzczurak	20:cf211a3b3d9e	1807	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	1808	if ( sys_range_status_register & 0x01 )
johnAlexander	17:1b842521063a	1809	*p_measurement_data_ready = 1;
johnAlexander	15:932d8b4e52c9	1810	else
johnAlexander	17:1b842521063a	1811	*p_measurement_data_ready = 0;
johnAlexander	15:932d8b4e52c9	1812	}
johnAlexander	15:932d8b4e52c9	1813	}
johnAlexander	15:932d8b4e52c9	1814
JerrySzczurak	20:cf211a3b3d9e	1815	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1816	return status;
JerrySzczurak	20:cf211a3b3d9e	1817	}
JerrySzczurak	20:cf211a3b3d9e	1818
JerrySzczurak	20:cf211a3b3d9e	1819	VL53L0X_Error VL53L0X::vl53l0x_polling_delay( VL53L0X_DEV dev )
johnAlexander	15:932d8b4e52c9	1820	{
johnAlexander	0:c523920bcc09	1821	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	0:c523920bcc09	1822
johnAlexander	0:c523920bcc09	1823	// do nothing
johnAlexander	0:c523920bcc09	1824	VL53L0X_OsDelay();
johnAlexander	0:c523920bcc09	1825	return status;
johnAlexander	0:c523920bcc09	1826	}
johnAlexander	0:c523920bcc09	1827
JerrySzczurak	20:cf211a3b3d9e	1828	VL53L0X_Error VL53L0X::vl53l0x_measurement_poll_for_completion( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	1829	{
johnAlexander	16:98ce55ddbb1a	1830	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1831	uint8_t new_data_ready = 0;
johnAlexander	16:98ce55ddbb1a	1832	uint32_t loop_nb;
johnAlexander	15:932d8b4e52c9	1833
JerrySzczurak	20:cf211a3b3d9e	1834	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	1835
johnAlexander	16:98ce55ddbb1a	1836	loop_nb = 0;
johnAlexander	15:932d8b4e52c9	1837
johnAlexander	15:932d8b4e52c9	1838	do {
JerrySzczurak	20:cf211a3b3d9e	1839	status = vl53l0x_get_measurement_data_ready( dev, &new_data_ready );
JerrySzczurak	20:cf211a3b3d9e	1840	if ( status != 0 )
johnAlexander	15:932d8b4e52c9	1841	break; /* the error is set */
johnAlexander	15:932d8b4e52c9	1842
JerrySzczurak	20:cf211a3b3d9e	1843	if ( new_data_ready == 1 )
johnAlexander	15:932d8b4e52c9	1844	break; /* done note that status == 0 */
johnAlexander	15:932d8b4e52c9	1845
johnAlexander	16:98ce55ddbb1a	1846	loop_nb++;
JerrySzczurak	20:cf211a3b3d9e	1847	if ( loop_nb >= VL53L0X_DEFAULT_MAX_LOOP ) {
johnAlexander	16:98ce55ddbb1a	1848	status = VL53L0X_ERROR_TIME_OUT;
johnAlexander	15:932d8b4e52c9	1849	break;
johnAlexander	15:932d8b4e52c9	1850	}
johnAlexander	15:932d8b4e52c9	1851
JerrySzczurak	20:cf211a3b3d9e	1852	vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	1853	} while ( 1 );
JerrySzczurak	20:cf211a3b3d9e	1854
JerrySzczurak	20:cf211a3b3d9e	1855	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	1856
johnAlexander	16:98ce55ddbb1a	1857	return status;
johnAlexander	0:c523920bcc09	1858	}
johnAlexander	0:c523920bcc09	1859
johnAlexander	0:c523920bcc09	1860	/* Group PAL Interrupt Functions */
JerrySzczurak	20:cf211a3b3d9e	1861	VL53L0X_Error VL53L0X::vl53l0x_clear_interrupt_mask( VL53L0X_DEV dev, uint32_t interrupt_mask )
johnAlexander	0:c523920bcc09	1862	{
johnAlexander	16:98ce55ddbb1a	1863	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1864	uint8_t loop_count;
johnAlexander	17:1b842521063a	1865	uint8_t byte;
JerrySzczurak	20:cf211a3b3d9e	1866	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	1867
johnAlexander	15:932d8b4e52c9	1868	/* clear bit 0 range interrupt, bit 1 error interrupt */
johnAlexander	16:98ce55ddbb1a	1869	loop_count = 0;
johnAlexander	15:932d8b4e52c9	1870	do {
JerrySzczurak	20:cf211a3b3d9e	1871	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1872	VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1873	status \|= vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1874	VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1875	status \|= vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	1876	VL53L0X_REG_RESULT_INTERRUPT_STATUS, &byte );
johnAlexander	16:98ce55ddbb1a	1877	loop_count++;
JerrySzczurak	20:cf211a3b3d9e	1878	} while ( ( ( byte & 0x07 ) != 0x00 )
JerrySzczurak	20:cf211a3b3d9e	1879	&& ( loop_count < 3 )
JerrySzczurak	20:cf211a3b3d9e	1880	&& ( status == VL53L0X_ERROR_NONE ) );
JerrySzczurak	20:cf211a3b3d9e	1881
JerrySzczurak	20:cf211a3b3d9e	1882
JerrySzczurak	20:cf211a3b3d9e	1883	if ( loop_count >= 3 )
johnAlexander	16:98ce55ddbb1a	1884	status = VL53L0X_ERROR_INTERRUPT_NOT_CLEARED;
johnAlexander	16:98ce55ddbb1a	1885
JerrySzczurak	20:cf211a3b3d9e	1886	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	1887	return status;
JerrySzczurak	20:cf211a3b3d9e	1888	}
JerrySzczurak	20:cf211a3b3d9e	1889
JerrySzczurak	20:cf211a3b3d9e	1890	VL53L0X_Error VL53L0X::vl53l0x_perform_single_ref_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	1891	uint8_t vhv_init_byte )
johnAlexander	0:c523920bcc09	1892	{
johnAlexander	16:98ce55ddbb1a	1893	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1894
JerrySzczurak	20:cf211a3b3d9e	1895	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1896	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSRANGE_START,
JerrySzczurak	20:cf211a3b3d9e	1897	VL53L0X_REG_SYSRANGE_MODE_START_STOP \|
JerrySzczurak	20:cf211a3b3d9e	1898	vhv_init_byte );
JerrySzczurak	20:cf211a3b3d9e	1899
JerrySzczurak	20:cf211a3b3d9e	1900	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1901	status = vl53l0x_measurement_poll_for_completion( dev );
JerrySzczurak	20:cf211a3b3d9e	1902
JerrySzczurak	20:cf211a3b3d9e	1903	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1904	status = vl53l0x_clear_interrupt_mask( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	1905
JerrySzczurak	20:cf211a3b3d9e	1906	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1907	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSRANGE_START, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1908
JerrySzczurak	20:cf211a3b3d9e	1909	return status;
JerrySzczurak	20:cf211a3b3d9e	1910	}
JerrySzczurak	20:cf211a3b3d9e	1911
JerrySzczurak	20:cf211a3b3d9e	1912	VL53L0X_Error VL53L0X::vl53l0x_ref_calibration_io( VL53L0X_DEV dev, uint8_t read_not_write,
johnAlexander	16:98ce55ddbb1a	1913	uint8_t vhv_settings, uint8_t phase_cal,
johnAlexander	16:98ce55ddbb1a	1914	uint8_t p_vhv_settings, uint8_t p_phase_cal,
JerrySzczurak	20:cf211a3b3d9e	1915	const uint8_t vhv_enable, const uint8_t phase_enable )
johnAlexander	0:c523920bcc09	1916	{
johnAlexander	16:98ce55ddbb1a	1917	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1918	uint8_t phase_calint = 0;
johnAlexander	15:932d8b4e52c9	1919
johnAlexander	15:932d8b4e52c9	1920	/* Read VHV from device */
JerrySzczurak	20:cf211a3b3d9e	1921	status \|= vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1922	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1923	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1924
JerrySzczurak	20:cf211a3b3d9e	1925	if ( read_not_write ) {
JerrySzczurak	20:cf211a3b3d9e	1926	if ( vhv_enable )
JerrySzczurak	20:cf211a3b3d9e	1927	status \|= vl53l0x_read_byte( dev, 0xCB, p_vhv_settings );
JerrySzczurak	20:cf211a3b3d9e	1928	if ( phase_enable )
JerrySzczurak	20:cf211a3b3d9e	1929	status \|= vl53l0x_read_byte( dev, 0xEE, &phase_calint );
johnAlexander	15:932d8b4e52c9	1930	} else {
JerrySzczurak	20:cf211a3b3d9e	1931	if ( vhv_enable )
JerrySzczurak	20:cf211a3b3d9e	1932	status \|= vl53l0x_write_byte( dev, 0xCB, vhv_settings );
JerrySzczurak	20:cf211a3b3d9e	1933	if ( phase_enable )
JerrySzczurak	20:cf211a3b3d9e	1934	status \|= vl53l0x_update_byte( dev, 0xEE, 0x80, phase_cal );
JerrySzczurak	20:cf211a3b3d9e	1935	}
JerrySzczurak	20:cf211a3b3d9e	1936
JerrySzczurak	20:cf211a3b3d9e	1937	status \|= vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1938	status \|= vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1939	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	1940
JerrySzczurak	20:cf211a3b3d9e	1941	*p_phase_cal = ( uint8_t )( phase_calint & 0xEF );
JerrySzczurak	20:cf211a3b3d9e	1942
JerrySzczurak	20:cf211a3b3d9e	1943	return status;
JerrySzczurak	20:cf211a3b3d9e	1944	}
JerrySzczurak	20:cf211a3b3d9e	1945
JerrySzczurak	20:cf211a3b3d9e	1946	VL53L0X_Error VL53L0X::vl53l0x_perform_vhv_calibration( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	1947	uint8_t *p_vhv_settings, const uint8_t get_data_enable,
JerrySzczurak	20:cf211a3b3d9e	1948	const uint8_t restore_config )
johnAlexander	0:c523920bcc09	1949	{
johnAlexander	16:98ce55ddbb1a	1950	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1951	uint8_t sequence_config = 0;
johnAlexander	16:98ce55ddbb1a	1952	uint8_t vhv_settings = 0;
johnAlexander	16:98ce55ddbb1a	1953	uint8_t phase_cal = 0;
johnAlexander	16:98ce55ddbb1a	1954	uint8_t phase_cal_int = 0;
johnAlexander	15:932d8b4e52c9	1955
johnAlexander	15:932d8b4e52c9	1956	/* store the value of the sequence config,
johnAlexander	15:932d8b4e52c9	1957	* this will be reset before the end of the function
johnAlexander	15:932d8b4e52c9	1958	*/
johnAlexander	15:932d8b4e52c9	1959
JerrySzczurak	20:cf211a3b3d9e	1960	if ( restore_config )
JerrySzczurak	20:cf211a3b3d9e	1961	sequence_config = PALDevDataGet( dev, SequenceConfig );
johnAlexander	15:932d8b4e52c9	1962
johnAlexander	15:932d8b4e52c9	1963	/* Run VHV */
JerrySzczurak	20:cf211a3b3d9e	1964	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	1965
JerrySzczurak	20:cf211a3b3d9e	1966	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1967	status = vl53l0x_perform_single_ref_calibration( dev, 0x40 );
johnAlexander	15:932d8b4e52c9	1968
johnAlexander	15:932d8b4e52c9	1969	/* Read VHV from device */
JerrySzczurak	20:cf211a3b3d9e	1970	if ( ( status == VL53L0X_ERROR_NONE ) && ( get_data_enable == 1 ) ) {
JerrySzczurak	20:cf211a3b3d9e	1971	status = vl53l0x_ref_calibration_io( dev, 1,
JerrySzczurak	20:cf211a3b3d9e	1972	vhv_settings, phase_cal, /* Not used here */
JerrySzczurak	20:cf211a3b3d9e	1973	p_vhv_settings, &phase_cal_int,
JerrySzczurak	20:cf211a3b3d9e	1974	1, 0 );
johnAlexander	15:932d8b4e52c9	1975	} else
johnAlexander	16:98ce55ddbb1a	1976	*p_vhv_settings = 0;
johnAlexander	16:98ce55ddbb1a	1977
johnAlexander	16:98ce55ddbb1a	1978
JerrySzczurak	20:cf211a3b3d9e	1979	if ( ( status == VL53L0X_ERROR_NONE ) && restore_config ) {
johnAlexander	15:932d8b4e52c9	1980	/* restore the previous Sequence Config */
JerrySzczurak	20:cf211a3b3d9e	1981	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	1982	sequence_config );
JerrySzczurak	20:cf211a3b3d9e	1983	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	1984	PALDevDataSet( dev, SequenceConfig, sequence_config );
JerrySzczurak	20:cf211a3b3d9e	1985
JerrySzczurak	20:cf211a3b3d9e	1986	}
JerrySzczurak	20:cf211a3b3d9e	1987
JerrySzczurak	20:cf211a3b3d9e	1988	return status;
JerrySzczurak	20:cf211a3b3d9e	1989	}
JerrySzczurak	20:cf211a3b3d9e	1990
JerrySzczurak	20:cf211a3b3d9e	1991	VL53L0X_Error VL53L0X::vl53l0x_perform_phase_calibration( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	1992	uint8_t *p_phase_cal, const uint8_t get_data_enable,
JerrySzczurak	20:cf211a3b3d9e	1993	const uint8_t restore_config )
johnAlexander	0:c523920bcc09	1994	{
johnAlexander	16:98ce55ddbb1a	1995	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	1996	uint8_t sequence_config = 0;
johnAlexander	16:98ce55ddbb1a	1997	uint8_t vhv_settings = 0;
johnAlexander	16:98ce55ddbb1a	1998	uint8_t phase_cal = 0;
johnAlexander	16:98ce55ddbb1a	1999	uint8_t vhv_settingsint;
johnAlexander	15:932d8b4e52c9	2000
johnAlexander	15:932d8b4e52c9	2001	/* store the value of the sequence config,
johnAlexander	15:932d8b4e52c9	2002	* this will be reset before the end of the function
johnAlexander	15:932d8b4e52c9	2003	*/
johnAlexander	15:932d8b4e52c9	2004
JerrySzczurak	20:cf211a3b3d9e	2005	if ( restore_config )
JerrySzczurak	20:cf211a3b3d9e	2006	sequence_config = PALDevDataGet( dev, SequenceConfig );
johnAlexander	15:932d8b4e52c9	2007
johnAlexander	15:932d8b4e52c9	2008	/* Run PhaseCal */
JerrySzczurak	20:cf211a3b3d9e	2009	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0x02 );
JerrySzczurak	20:cf211a3b3d9e	2010
JerrySzczurak	20:cf211a3b3d9e	2011	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2012	status = vl53l0x_perform_single_ref_calibration( dev, 0x0 );
johnAlexander	15:932d8b4e52c9	2013
johnAlexander	15:932d8b4e52c9	2014	/* Read PhaseCal from device */
JerrySzczurak	20:cf211a3b3d9e	2015	if ( ( status == VL53L0X_ERROR_NONE ) && ( get_data_enable == 1 ) ) {
JerrySzczurak	20:cf211a3b3d9e	2016	status = vl53l0x_ref_calibration_io( dev, 1,
JerrySzczurak	20:cf211a3b3d9e	2017	vhv_settings, phase_cal, /* Not used here */
JerrySzczurak	20:cf211a3b3d9e	2018	&vhv_settingsint, p_phase_cal,
JerrySzczurak	20:cf211a3b3d9e	2019	0, 1 );
johnAlexander	15:932d8b4e52c9	2020	} else
johnAlexander	16:98ce55ddbb1a	2021	*p_phase_cal = 0;
johnAlexander	16:98ce55ddbb1a	2022
johnAlexander	16:98ce55ddbb1a	2023
JerrySzczurak	20:cf211a3b3d9e	2024	if ( ( status == VL53L0X_ERROR_NONE ) && restore_config ) {
johnAlexander	15:932d8b4e52c9	2025	/* restore the previous Sequence Config */
JerrySzczurak	20:cf211a3b3d9e	2026	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	2027	sequence_config );
JerrySzczurak	20:cf211a3b3d9e	2028	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2029	PALDevDataSet( dev, SequenceConfig, sequence_config );
JerrySzczurak	20:cf211a3b3d9e	2030
JerrySzczurak	20:cf211a3b3d9e	2031	}
JerrySzczurak	20:cf211a3b3d9e	2032
JerrySzczurak	20:cf211a3b3d9e	2033	return status;
JerrySzczurak	20:cf211a3b3d9e	2034	}
JerrySzczurak	20:cf211a3b3d9e	2035
JerrySzczurak	20:cf211a3b3d9e	2036	VL53L0X_Error VL53L0X::vl53l0x_perform_ref_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	2037	uint8_t p_vhv_settings, uint8_t p_phase_cal, uint8_t get_data_enable )
johnAlexander	0:c523920bcc09	2038	{
johnAlexander	16:98ce55ddbb1a	2039	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2040	uint8_t sequence_config = 0;
johnAlexander	15:932d8b4e52c9	2041
johnAlexander	15:932d8b4e52c9	2042	/* store the value of the sequence config,
johnAlexander	15:932d8b4e52c9	2043	* this will be reset before the end of the function
johnAlexander	15:932d8b4e52c9	2044	*/
johnAlexander	15:932d8b4e52c9	2045
JerrySzczurak	20:cf211a3b3d9e	2046	sequence_config = PALDevDataGet( dev, SequenceConfig );
johnAlexander	15:932d8b4e52c9	2047
johnAlexander	15:932d8b4e52c9	2048	/* In the following function we don't save the config to optimize
johnAlexander	15:932d8b4e52c9	2049	* writes on device. Config is saved and restored only once. */
johnAlexander	16:98ce55ddbb1a	2050	status = vl53l0x_perform_vhv_calibration(
JerrySzczurak	20:cf211a3b3d9e	2051	dev, p_vhv_settings, get_data_enable, 0 );
JerrySzczurak	20:cf211a3b3d9e	2052
JerrySzczurak	20:cf211a3b3d9e	2053
JerrySzczurak	20:cf211a3b3d9e	2054	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	2055	status = vl53l0x_perform_phase_calibration(
JerrySzczurak	20:cf211a3b3d9e	2056	dev, p_phase_cal, get_data_enable, 0 );
JerrySzczurak	20:cf211a3b3d9e	2057
JerrySzczurak	20:cf211a3b3d9e	2058
JerrySzczurak	20:cf211a3b3d9e	2059	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2060	/* restore the previous Sequence Config */
JerrySzczurak	20:cf211a3b3d9e	2061	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	2062	sequence_config );
JerrySzczurak	20:cf211a3b3d9e	2063	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2064	PALDevDataSet( dev, SequenceConfig, sequence_config );
JerrySzczurak	20:cf211a3b3d9e	2065
JerrySzczurak	20:cf211a3b3d9e	2066	}
JerrySzczurak	20:cf211a3b3d9e	2067
JerrySzczurak	20:cf211a3b3d9e	2068	return status;
JerrySzczurak	20:cf211a3b3d9e	2069	}
JerrySzczurak	20:cf211a3b3d9e	2070
JerrySzczurak	20:cf211a3b3d9e	2071	void VL53L0X::get_next_good_spad( uint8_t good_spad_array[], uint32_t size,
JerrySzczurak	20:cf211a3b3d9e	2072	uint32_t curr, int32_t *p_next )
johnAlexander	0:c523920bcc09	2073	{
johnAlexander	16:98ce55ddbb1a	2074	uint32_t start_index;
johnAlexander	16:98ce55ddbb1a	2075	uint32_t fine_offset;
johnAlexander	16:98ce55ddbb1a	2076	uint32_t c_spads_per_byte = 8;
johnAlexander	16:98ce55ddbb1a	2077	uint32_t coarse_index;
johnAlexander	16:98ce55ddbb1a	2078	uint32_t fine_index;
johnAlexander	16:98ce55ddbb1a	2079	uint8_t data_byte;
johnAlexander	15:932d8b4e52c9	2080	uint8_t success = 0;
johnAlexander	15:932d8b4e52c9	2081
johnAlexander	15:932d8b4e52c9	2082	/*
johnAlexander	15:932d8b4e52c9	2083	* Starting with the current good spad, loop through the array to find
johnAlexander	15:932d8b4e52c9	2084	* the next. i.e. the next bit set in the sequence.
johnAlexander	15:932d8b4e52c9	2085	*
johnAlexander	15:932d8b4e52c9	2086	* The coarse index is the byte index of the array and the fine index is
johnAlexander	15:932d8b4e52c9	2087	* the index of the bit within each byte.
johnAlexander	15:932d8b4e52c9	2088	*/
johnAlexander	15:932d8b4e52c9	2089
johnAlexander	16:98ce55ddbb1a	2090	*p_next = -1;
johnAlexander	16:98ce55ddbb1a	2091
johnAlexander	16:98ce55ddbb1a	2092	start_index = curr / c_spads_per_byte;
johnAlexander	16:98ce55ddbb1a	2093	fine_offset = curr % c_spads_per_byte;
johnAlexander	16:98ce55ddbb1a	2094
JerrySzczurak	20:cf211a3b3d9e	2095	for ( coarse_index = start_index; ( ( coarse_index < size ) && !success );
JerrySzczurak	20:cf211a3b3d9e	2096	coarse_index++ ) {
johnAlexander	16:98ce55ddbb1a	2097	fine_index = 0;
johnAlexander	16:98ce55ddbb1a	2098	data_byte = good_spad_array[coarse_index];
johnAlexander	16:98ce55ddbb1a	2099
JerrySzczurak	20:cf211a3b3d9e	2100	if ( coarse_index == start_index ) {
johnAlexander	15:932d8b4e52c9	2101	/* locate the bit position of the provided current
johnAlexander	15:932d8b4e52c9	2102	* spad bit before iterating */
johnAlexander	16:98ce55ddbb1a	2103	data_byte >>= fine_offset;
johnAlexander	16:98ce55ddbb1a	2104	fine_index = fine_offset;
johnAlexander	15:932d8b4e52c9	2105	}
johnAlexander	15:932d8b4e52c9	2106
JerrySzczurak	20:cf211a3b3d9e	2107	while ( fine_index < c_spads_per_byte ) {
JerrySzczurak	20:cf211a3b3d9e	2108	if ( ( data_byte & 0x1 ) == 1 ) {
johnAlexander	15:932d8b4e52c9	2109	success = 1;
johnAlexander	16:98ce55ddbb1a	2110	p_next = coarse_index c_spads_per_byte + fine_index;
johnAlexander	15:932d8b4e52c9	2111	break;
johnAlexander	15:932d8b4e52c9	2112	}
johnAlexander	16:98ce55ddbb1a	2113	data_byte >>= 1;
johnAlexander	16:98ce55ddbb1a	2114	fine_index++;
johnAlexander	15:932d8b4e52c9	2115	}
johnAlexander	15:932d8b4e52c9	2116	}
johnAlexander	0:c523920bcc09	2117	}
johnAlexander	0:c523920bcc09	2118
JerrySzczurak	20:cf211a3b3d9e	2119	uint8_t VL53L0X::is_aperture( uint32_t spad_index )
johnAlexander	0:c523920bcc09	2120	{
johnAlexander	15:932d8b4e52c9	2121	/*
johnAlexander	15:932d8b4e52c9	2122	* This function reports if a given spad index is an aperture SPAD by
johnAlexander	15:932d8b4e52c9	2123	* deriving the quadrant.
johnAlexander	15:932d8b4e52c9	2124	*/
johnAlexander	15:932d8b4e52c9	2125	uint32_t quadrant;
johnAlexander	16:98ce55ddbb1a	2126	uint8_t is_aperture = 1;
johnAlexander	16:98ce55ddbb1a	2127	quadrant = spad_index >> 6;
JerrySzczurak	20:cf211a3b3d9e	2128	if ( refArrayQuadrants[quadrant] == REF_ARRAY_SPAD_0 )
johnAlexander	16:98ce55ddbb1a	2129	is_aperture = 0;
johnAlexander	16:98ce55ddbb1a	2130
johnAlexander	16:98ce55ddbb1a	2131	return is_aperture;
johnAlexander	0:c523920bcc09	2132	}
johnAlexander	0:c523920bcc09	2133
JerrySzczurak	20:cf211a3b3d9e	2134	VL53L0X_Error VL53L0X::enable_spad_bit( uint8_t spad_array[], uint32_t size,
JerrySzczurak	20:cf211a3b3d9e	2135	uint32_t spad_index )
johnAlexander	0:c523920bcc09	2136	{
johnAlexander	15:932d8b4e52c9	2137	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2138	uint32_t c_spads_per_byte = 8;
johnAlexander	16:98ce55ddbb1a	2139	uint32_t coarse_index;
johnAlexander	16:98ce55ddbb1a	2140	uint32_t fine_index;
johnAlexander	16:98ce55ddbb1a	2141
johnAlexander	16:98ce55ddbb1a	2142	coarse_index = spad_index / c_spads_per_byte;
johnAlexander	16:98ce55ddbb1a	2143	fine_index = spad_index % c_spads_per_byte;
JerrySzczurak	20:cf211a3b3d9e	2144	if ( coarse_index >= size )
johnAlexander	15:932d8b4e52c9	2145	status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander	15:932d8b4e52c9	2146	else
JerrySzczurak	20:cf211a3b3d9e	2147	spad_array[coarse_index] \|= ( 1 << fine_index );
JerrySzczurak	20:cf211a3b3d9e	2148
JerrySzczurak	20:cf211a3b3d9e	2149	return status;
JerrySzczurak	20:cf211a3b3d9e	2150	}
JerrySzczurak	20:cf211a3b3d9e	2151
JerrySzczurak	20:cf211a3b3d9e	2152	VL53L0X_Error VL53L0X::set_ref_spad_map( VL53L0X_DEV dev, uint8_t *p_ref_spad_array )
JerrySzczurak	20:cf211a3b3d9e	2153	{
JerrySzczurak	20:cf211a3b3d9e	2154	VL53L0X_Error status = vl53l0x_write_multi( dev,
johnAlexander	15:932d8b4e52c9	2155	VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
JerrySzczurak	20:cf211a3b3d9e	2156	p_ref_spad_array, 6 );
JerrySzczurak	20:cf211a3b3d9e	2157
JerrySzczurak	20:cf211a3b3d9e	2158	return status;
JerrySzczurak	20:cf211a3b3d9e	2159	}
JerrySzczurak	20:cf211a3b3d9e	2160
JerrySzczurak	20:cf211a3b3d9e	2161	VL53L0X_Error VL53L0X::get_ref_spad_map( VL53L0X_DEV dev, uint8_t *p_ref_spad_array )
JerrySzczurak	20:cf211a3b3d9e	2162	{
JerrySzczurak	20:cf211a3b3d9e	2163	VL53L0X_Error status = vl53l0x_read_multi( dev,
johnAlexander	15:932d8b4e52c9	2164	VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0,
johnAlexander	16:98ce55ddbb1a	2165	p_ref_spad_array,
JerrySzczurak	20:cf211a3b3d9e	2166	6 );
johnAlexander	0:c523920bcc09	2167	// VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	0:c523920bcc09	2168	// uint8_t count=0;
johnAlexander	0:c523920bcc09	2169
johnAlexander	0:c523920bcc09	2170	// for (count = 0; count < 6; count++)
JerrySzczurak	21:627b65069e6d	2171	// status = vl53l0x_read_byte(Dev, (VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 + count), &refSpadArray[count]);
johnAlexander	15:932d8b4e52c9	2172	return status;
johnAlexander	0:c523920bcc09	2173	}
johnAlexander	0:c523920bcc09	2174
JerrySzczurak	20:cf211a3b3d9e	2175	VL53L0X_Error VL53L0X::enable_ref_spads( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	2176	uint8_t aperture_spads,
JerrySzczurak	20:cf211a3b3d9e	2177	uint8_t good_spad_array[],
JerrySzczurak	20:cf211a3b3d9e	2178	uint8_t spad_array[],
JerrySzczurak	20:cf211a3b3d9e	2179	uint32_t size,
JerrySzczurak	20:cf211a3b3d9e	2180	uint32_t start,
JerrySzczurak	20:cf211a3b3d9e	2181	uint32_t offset,
JerrySzczurak	20:cf211a3b3d9e	2182	uint32_t spad_count,
JerrySzczurak	20:cf211a3b3d9e	2183	uint32_t *p_last_spad )
johnAlexander	0:c523920bcc09	2184	{
johnAlexander	15:932d8b4e52c9	2185	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	2186	uint32_t index;
johnAlexander	15:932d8b4e52c9	2187	uint32_t i;
johnAlexander	16:98ce55ddbb1a	2188	int32_t next_good_spad = offset;
johnAlexander	16:98ce55ddbb1a	2189	uint32_t current_spad;
johnAlexander	16:98ce55ddbb1a	2190	uint8_t check_spad_array[6];
johnAlexander	15:932d8b4e52c9	2191
johnAlexander	15:932d8b4e52c9	2192	/*
johnAlexander	15:932d8b4e52c9	2193	* This function takes in a spad array which may or may not have SPADS
johnAlexander	15:932d8b4e52c9	2194	* already enabled and appends from a given offset a requested number
johnAlexander	15:932d8b4e52c9	2195	* of new SPAD enables. The 'good spad map' is applied to
johnAlexander	15:932d8b4e52c9	2196	* determine the next SPADs to enable.
johnAlexander	15:932d8b4e52c9	2197	*
johnAlexander	15:932d8b4e52c9	2198	* This function applies to only aperture or only non-aperture spads.
johnAlexander	15:932d8b4e52c9	2199	* Checks are performed to ensure this.
johnAlexander	15:932d8b4e52c9	2200	*/
johnAlexander	15:932d8b4e52c9	2201
johnAlexander	16:98ce55ddbb1a	2202	current_spad = offset;
JerrySzczurak	20:cf211a3b3d9e	2203	for ( index = 0; index < spad_count; index++ ) {
JerrySzczurak	20:cf211a3b3d9e	2204	get_next_good_spad( good_spad_array, size, current_spad,
JerrySzczurak	20:cf211a3b3d9e	2205	&next_good_spad );
JerrySzczurak	20:cf211a3b3d9e	2206
JerrySzczurak	20:cf211a3b3d9e	2207	if ( next_good_spad == -1 ) {
johnAlexander	15:932d8b4e52c9	2208	status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander	15:932d8b4e52c9	2209	break;
johnAlexander	15:932d8b4e52c9	2210	}
johnAlexander	15:932d8b4e52c9	2211
johnAlexander	15:932d8b4e52c9	2212	/* Confirm that the next good SPAD is non-aperture */
JerrySzczurak	20:cf211a3b3d9e	2213	if ( is_aperture( start + next_good_spad ) != aperture_spads ) {
johnAlexander	15:932d8b4e52c9	2214	/* if we can't get the required number of good aperture
johnAlexander	15:932d8b4e52c9	2215	* spads from the current quadrant then this is an error
johnAlexander	15:932d8b4e52c9	2216	*/
johnAlexander	15:932d8b4e52c9	2217	status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander	15:932d8b4e52c9	2218	break;
johnAlexander	15:932d8b4e52c9	2219	}
JerrySzczurak	20:cf211a3b3d9e	2220	current_spad = ( uint32_t )next_good_spad;
JerrySzczurak	20:cf211a3b3d9e	2221	enable_spad_bit( spad_array, size, current_spad );
johnAlexander	16:98ce55ddbb1a	2222	current_spad++;
johnAlexander	15:932d8b4e52c9	2223	}
johnAlexander	16:98ce55ddbb1a	2224	*p_last_spad = current_spad;
johnAlexander	15:932d8b4e52c9	2225
JerrySzczurak	20:cf211a3b3d9e	2226	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2227	status = set_ref_spad_map( dev, spad_array );
JerrySzczurak	20:cf211a3b3d9e	2228
JerrySzczurak	20:cf211a3b3d9e	2229
JerrySzczurak	20:cf211a3b3d9e	2230	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	2231	status = get_ref_spad_map( dev, check_spad_array );
johnAlexander	15:932d8b4e52c9	2232
johnAlexander	15:932d8b4e52c9	2233	i = 0;
johnAlexander	15:932d8b4e52c9	2234
johnAlexander	15:932d8b4e52c9	2235	/* Compare spad maps. If not equal report error. */
JerrySzczurak	20:cf211a3b3d9e	2236	while ( i < size ) {
JerrySzczurak	20:cf211a3b3d9e	2237	if ( spad_array[i] != check_spad_array[i] ) {
johnAlexander	15:932d8b4e52c9	2238	status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander	15:932d8b4e52c9	2239	break;
johnAlexander	15:932d8b4e52c9	2240	}
johnAlexander	15:932d8b4e52c9	2241	i++;
johnAlexander	15:932d8b4e52c9	2242	}
johnAlexander	15:932d8b4e52c9	2243	}
johnAlexander	15:932d8b4e52c9	2244	return status;
johnAlexander	0:c523920bcc09	2245	}
johnAlexander	0:c523920bcc09	2246
JerrySzczurak	20:cf211a3b3d9e	2247	VL53L0X_Error VL53L0X::vl53l0x_set_device_mode( VL53L0X_DEV dev, VL53L0X_DeviceModes device_mode )
johnAlexander	0:c523920bcc09	2248	{
johnAlexander	16:98ce55ddbb1a	2249	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	2250
JerrySzczurak	20:cf211a3b3d9e	2251	LOG_FUNCTION_START( "%d", ( int )DeviceMode );
JerrySzczurak	20:cf211a3b3d9e	2252
JerrySzczurak	20:cf211a3b3d9e	2253	switch ( device_mode ) {
johnAlexander	15:932d8b4e52c9	2254	case VL53L0X_DEVICEMODE_SINGLE_RANGING:
johnAlexander	15:932d8b4e52c9	2255	case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
johnAlexander	15:932d8b4e52c9	2256	case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
johnAlexander	15:932d8b4e52c9	2257	case VL53L0X_DEVICEMODE_GPIO_DRIVE:
johnAlexander	15:932d8b4e52c9	2258	case VL53L0X_DEVICEMODE_GPIO_OSC:
johnAlexander	15:932d8b4e52c9	2259	/* Supported modes */
JerrySzczurak	20:cf211a3b3d9e	2260	VL53L0X_SETPARAMETERFIELD( dev, DeviceMode, device_mode );
johnAlexander	15:932d8b4e52c9	2261	break;
johnAlexander	15:932d8b4e52c9	2262	default:
johnAlexander	15:932d8b4e52c9	2263	/* Unsupported mode */
johnAlexander	16:98ce55ddbb1a	2264	status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
johnAlexander	15:932d8b4e52c9	2265	}
johnAlexander	15:932d8b4e52c9	2266
JerrySzczurak	20:cf211a3b3d9e	2267	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2268	return status;
JerrySzczurak	20:cf211a3b3d9e	2269	}
JerrySzczurak	20:cf211a3b3d9e	2270
JerrySzczurak	20:cf211a3b3d9e	2271	VL53L0X_Error VL53L0X::vl53l0x_set_interrupt_thresholds( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2272	VL53L0X_DeviceModes device_mode, FixPoint1616_t threshold_low,
JerrySzczurak	20:cf211a3b3d9e	2273	FixPoint1616_t threshold_high )
johnAlexander	13:615f7e38568c	2274	{
johnAlexander	16:98ce55ddbb1a	2275	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2276	uint16_t threshold16;
JerrySzczurak	20:cf211a3b3d9e	2277	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2278
johnAlexander	15:932d8b4e52c9	2279	/* no dependency on DeviceMode for Ewok */
johnAlexander	15:932d8b4e52c9	2280	/* Need to divide by 2 because the FW will apply a x2 */
JerrySzczurak	20:cf211a3b3d9e	2281	threshold16 = ( uint16_t )( ( threshold_low >> 17 ) & 0x00fff );
JerrySzczurak	20:cf211a3b3d9e	2282	status = vl53l0x_write_word( dev, VL53L0X_REG_SYSTEM_THRESH_LOW, threshold16 );
JerrySzczurak	20:cf211a3b3d9e	2283
JerrySzczurak	20:cf211a3b3d9e	2284	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2285	/* Need to divide by 2 because the FW will apply a x2 */
JerrySzczurak	20:cf211a3b3d9e	2286	threshold16 = ( uint16_t )( ( threshold_high >> 17 ) & 0x00fff );
JerrySzczurak	20:cf211a3b3d9e	2287	status = vl53l0x_write_word( dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
JerrySzczurak	20:cf211a3b3d9e	2288	threshold16 );
JerrySzczurak	20:cf211a3b3d9e	2289	}
JerrySzczurak	20:cf211a3b3d9e	2290
JerrySzczurak	20:cf211a3b3d9e	2291	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2292	return status;
JerrySzczurak	20:cf211a3b3d9e	2293	}
JerrySzczurak	20:cf211a3b3d9e	2294
JerrySzczurak	20:cf211a3b3d9e	2295	VL53L0X_Error VL53L0X::vl53l0x_get_interrupt_thresholds( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2296	VL53L0X_DeviceModes device_mode, FixPoint1616_t *p_threshold_low,
JerrySzczurak	20:cf211a3b3d9e	2297	FixPoint1616_t *p_threshold_high )
johnAlexander	0:c523920bcc09	2298	{
johnAlexander	16:98ce55ddbb1a	2299	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2300	uint16_t threshold16;
JerrySzczurak	20:cf211a3b3d9e	2301	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2302
johnAlexander	15:932d8b4e52c9	2303	/* no dependency on DeviceMode for Ewok */
johnAlexander	15:932d8b4e52c9	2304
JerrySzczurak	20:cf211a3b3d9e	2305	status = vl53l0x_read_word( dev, VL53L0X_REG_SYSTEM_THRESH_LOW, &threshold16 );
johnAlexander	15:932d8b4e52c9	2306	/* Need to multiply by 2 because the FW will apply a x2 */
JerrySzczurak	20:cf211a3b3d9e	2307	*p_threshold_low = ( FixPoint1616_t )( ( 0x00fff & threshold16 ) << 17 );
JerrySzczurak	20:cf211a3b3d9e	2308
JerrySzczurak	20:cf211a3b3d9e	2309	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	2310	status = vl53l0x_read_word( dev, VL53L0X_REG_SYSTEM_THRESH_HIGH,
JerrySzczurak	20:cf211a3b3d9e	2311	&threshold16 );
johnAlexander	15:932d8b4e52c9	2312	/* Need to multiply by 2 because the FW will apply a x2 */
johnAlexander	16:98ce55ddbb1a	2313	*p_threshold_high =
JerrySzczurak	20:cf211a3b3d9e	2314	( FixPoint1616_t )( ( 0x00fff & threshold16 ) << 17 );
JerrySzczurak	20:cf211a3b3d9e	2315	}
JerrySzczurak	20:cf211a3b3d9e	2316
JerrySzczurak	20:cf211a3b3d9e	2317	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2318	return status;
JerrySzczurak	20:cf211a3b3d9e	2319	}
JerrySzczurak	20:cf211a3b3d9e	2320
JerrySzczurak	20:cf211a3b3d9e	2321	VL53L0X_Error VL53L0X::vl53l0x_load_tuning_settings( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	2322	uint8_t *p_tuning_setting_buffer )
johnAlexander	0:c523920bcc09	2323	{
johnAlexander	16:98ce55ddbb1a	2324	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	2325	int i;
johnAlexander	16:98ce55ddbb1a	2326	int index;
johnAlexander	15:932d8b4e52c9	2327	uint8_t msb;
johnAlexander	15:932d8b4e52c9	2328	uint8_t lsb;
johnAlexander	16:98ce55ddbb1a	2329	uint8_t select_param;
johnAlexander	16:98ce55ddbb1a	2330	uint8_t number_of_writes;
johnAlexander	16:98ce55ddbb1a	2331	uint8_t address;
johnAlexander	16:98ce55ddbb1a	2332	uint8_t local_buffer[4]; /* max */
johnAlexander	16:98ce55ddbb1a	2333	uint16_t temp16;
johnAlexander	15:932d8b4e52c9	2334
JerrySzczurak	20:cf211a3b3d9e	2335	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2336
johnAlexander	16:98ce55ddbb1a	2337	index = 0;
johnAlexander	16:98ce55ddbb1a	2338
JerrySzczurak	20:cf211a3b3d9e	2339	while ( ( *( p_tuning_setting_buffer + index ) != 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	2340	( status == VL53L0X_ERROR_NONE ) ) {
JerrySzczurak	20:cf211a3b3d9e	2341	number_of_writes = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2342	index++;
JerrySzczurak	20:cf211a3b3d9e	2343	if ( number_of_writes == 0xFF ) {
johnAlexander	15:932d8b4e52c9	2344	/* internal parameters */
JerrySzczurak	20:cf211a3b3d9e	2345	select_param = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2346	index++;
JerrySzczurak	20:cf211a3b3d9e	2347	switch ( select_param ) {
johnAlexander	15:932d8b4e52c9	2348	case 0: /* uint16_t SigmaEstRefArray -> 2 bytes */
JerrySzczurak	20:cf211a3b3d9e	2349	msb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2350	index++;
JerrySzczurak	20:cf211a3b3d9e	2351	lsb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2352	index++;
JerrySzczurak	20:cf211a3b3d9e	2353	temp16 = VL53L0X_MAKEUINT16( lsb, msb );
JerrySzczurak	20:cf211a3b3d9e	2354	PALDevDataSet( dev, SigmaEstRefArray, temp16 );
johnAlexander	15:932d8b4e52c9	2355	break;
johnAlexander	15:932d8b4e52c9	2356	case 1: /* uint16_t SigmaEstEffPulseWidth -> 2 bytes */
JerrySzczurak	20:cf211a3b3d9e	2357	msb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2358	index++;
JerrySzczurak	20:cf211a3b3d9e	2359	lsb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2360	index++;
JerrySzczurak	20:cf211a3b3d9e	2361	temp16 = VL53L0X_MAKEUINT16( lsb, msb );
JerrySzczurak	20:cf211a3b3d9e	2362	PALDevDataSet( dev, SigmaEstEffPulseWidth,
JerrySzczurak	20:cf211a3b3d9e	2363	temp16 );
johnAlexander	15:932d8b4e52c9	2364	break;
johnAlexander	15:932d8b4e52c9	2365	case 2: /* uint16_t SigmaEstEffAmbWidth -> 2 bytes */
JerrySzczurak	20:cf211a3b3d9e	2366	msb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2367	index++;
JerrySzczurak	20:cf211a3b3d9e	2368	lsb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2369	index++;
JerrySzczurak	20:cf211a3b3d9e	2370	temp16 = VL53L0X_MAKEUINT16( lsb, msb );
JerrySzczurak	20:cf211a3b3d9e	2371	PALDevDataSet( dev, SigmaEstEffAmbWidth, temp16 );
johnAlexander	15:932d8b4e52c9	2372	break;
johnAlexander	15:932d8b4e52c9	2373	case 3: /* uint16_t targetRefRate -> 2 bytes */
JerrySzczurak	20:cf211a3b3d9e	2374	msb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2375	index++;
JerrySzczurak	20:cf211a3b3d9e	2376	lsb = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2377	index++;
JerrySzczurak	20:cf211a3b3d9e	2378	temp16 = VL53L0X_MAKEUINT16( lsb, msb );
JerrySzczurak	20:cf211a3b3d9e	2379	PALDevDataSet( dev, targetRefRate, temp16 );
johnAlexander	15:932d8b4e52c9	2380	break;
johnAlexander	15:932d8b4e52c9	2381	default: /* invalid parameter */
johnAlexander	16:98ce55ddbb1a	2382	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	2383	}
johnAlexander	15:932d8b4e52c9	2384
JerrySzczurak	20:cf211a3b3d9e	2385	} else if ( number_of_writes <= 4 ) {
JerrySzczurak	20:cf211a3b3d9e	2386	address = *( p_tuning_setting_buffer + index );
johnAlexander	16:98ce55ddbb1a	2387	index++;
johnAlexander	16:98ce55ddbb1a	2388
JerrySzczurak	20:cf211a3b3d9e	2389	for ( i = 0; i < number_of_writes; i++ ) {
JerrySzczurak	20:cf211a3b3d9e	2390	local_buffer[i] = *( p_tuning_setting_buffer +
JerrySzczurak	20:cf211a3b3d9e	2391	index );
johnAlexander	16:98ce55ddbb1a	2392	index++;
johnAlexander	15:932d8b4e52c9	2393	}
johnAlexander	15:932d8b4e52c9	2394
JerrySzczurak	20:cf211a3b3d9e	2395	status = vl53l0x_write_multi( dev, address, local_buffer,
JerrySzczurak	20:cf211a3b3d9e	2396	number_of_writes );
johnAlexander	15:932d8b4e52c9	2397
johnAlexander	15:932d8b4e52c9	2398	} else {
johnAlexander	16:98ce55ddbb1a	2399	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	2400	}
johnAlexander	15:932d8b4e52c9	2401	}
johnAlexander	15:932d8b4e52c9	2402
JerrySzczurak	20:cf211a3b3d9e	2403	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2404	return status;
JerrySzczurak	20:cf211a3b3d9e	2405	}
JerrySzczurak	20:cf211a3b3d9e	2406
JerrySzczurak	20:cf211a3b3d9e	2407	VL53L0X_Error VL53L0X::vl53l0x_check_and_load_interrupt_settings( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	2408	uint8_t start_not_stopflag )
johnAlexander	0:c523920bcc09	2409	{
johnAlexander	16:98ce55ddbb1a	2410	uint8_t interrupt_config;
johnAlexander	16:98ce55ddbb1a	2411	FixPoint1616_t threshold_low;
johnAlexander	16:98ce55ddbb1a	2412	FixPoint1616_t threshold_high;
johnAlexander	16:98ce55ddbb1a	2413	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2414
JerrySzczurak	20:cf211a3b3d9e	2415	interrupt_config = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	2416	Pin0GpioFunctionality );
JerrySzczurak	20:cf211a3b3d9e	2417
JerrySzczurak	20:cf211a3b3d9e	2418	if ( ( interrupt_config ==
JerrySzczurak	20:cf211a3b3d9e	2419	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW ) \|\|
JerrySzczurak	20:cf211a3b3d9e	2420	( interrupt_config ==
JerrySzczurak	20:cf211a3b3d9e	2421	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH ) \|\|
JerrySzczurak	20:cf211a3b3d9e	2422	( interrupt_config ==
JerrySzczurak	20:cf211a3b3d9e	2423	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT ) ) {
JerrySzczurak	20:cf211a3b3d9e	2424
JerrySzczurak	20:cf211a3b3d9e	2425	status = vl53l0x_get_interrupt_thresholds( dev,
johnAlexander	16:98ce55ddbb1a	2426	VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
JerrySzczurak	20:cf211a3b3d9e	2427	&threshold_low, &threshold_high );
JerrySzczurak	20:cf211a3b3d9e	2428
JerrySzczurak	20:cf211a3b3d9e	2429	if ( ( ( threshold_low > 255 * 65536 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	2430	( threshold_high > 255 * 65536 ) ) &&
JerrySzczurak	20:cf211a3b3d9e	2431	( status == VL53L0X_ERROR_NONE ) ) {
JerrySzczurak	20:cf211a3b3d9e	2432
JerrySzczurak	20:cf211a3b3d9e	2433	if ( start_not_stopflag != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	2434	status = vl53l0x_load_tuning_settings( dev,
JerrySzczurak	20:cf211a3b3d9e	2435	InterruptThresholdSettings );
johnAlexander	15:932d8b4e52c9	2436	} else {
JerrySzczurak	20:cf211a3b3d9e	2437	status \|= vl53l0x_write_byte( dev, 0xFF, 0x04 );
JerrySzczurak	20:cf211a3b3d9e	2438	status \|= vl53l0x_write_byte( dev, 0x70, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	2439	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	2440	status \|= vl53l0x_write_byte( dev, 0x80, 0x00 );
johnAlexander	15:932d8b4e52c9	2441	}
johnAlexander	15:932d8b4e52c9	2442
johnAlexander	15:932d8b4e52c9	2443	}
johnAlexander	15:932d8b4e52c9	2444
johnAlexander	15:932d8b4e52c9	2445
johnAlexander	15:932d8b4e52c9	2446	}
johnAlexander	15:932d8b4e52c9	2447
johnAlexander	16:98ce55ddbb1a	2448	return status;
johnAlexander	0:c523920bcc09	2449
johnAlexander	0:c523920bcc09	2450	}
johnAlexander	0:c523920bcc09	2451
JerrySzczurak	20:cf211a3b3d9e	2452	VL53L0X_Error VL53L0X::vl53l0x_start_measurement( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	2453	{
johnAlexander	16:98ce55ddbb1a	2454	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2455	VL53L0X_DeviceModes device_mode;
johnAlexander	16:98ce55ddbb1a	2456	uint8_t byte;
johnAlexander	16:98ce55ddbb1a	2457	uint8_t start_stop_byte = VL53L0X_REG_SYSRANGE_MODE_START_STOP;
johnAlexander	16:98ce55ddbb1a	2458	uint32_t loop_nb;
JerrySzczurak	20:cf211a3b3d9e	2459	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2460
johnAlexander	15:932d8b4e52c9	2461	/* Get Current DeviceMode */
JerrySzczurak	20:cf211a3b3d9e	2462	vl53l0x_get_device_mode( dev, &device_mode );
JerrySzczurak	20:cf211a3b3d9e	2463
JerrySzczurak	20:cf211a3b3d9e	2464	status = vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	2465	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	2466	status = vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	2467	status = vl53l0x_write_byte( dev, 0x91, PALDevDataGet( dev, StopVariable ) );
JerrySzczurak	20:cf211a3b3d9e	2468	status = vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	2469	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	2470	status = vl53l0x_write_byte( dev, 0x80, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	2471
JerrySzczurak	20:cf211a3b3d9e	2472	switch ( device_mode ) {
johnAlexander	15:932d8b4e52c9	2473	case VL53L0X_DEVICEMODE_SINGLE_RANGING:
JerrySzczurak	20:cf211a3b3d9e	2474	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSRANGE_START, 0x01 );
johnAlexander	16:98ce55ddbb1a	2475
johnAlexander	16:98ce55ddbb1a	2476	byte = start_stop_byte;
JerrySzczurak	20:cf211a3b3d9e	2477	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2478	/* Wait until start bit has been cleared */
johnAlexander	16:98ce55ddbb1a	2479	loop_nb = 0;
johnAlexander	15:932d8b4e52c9	2480	do {
JerrySzczurak	20:cf211a3b3d9e	2481	if ( loop_nb > 0 )
JerrySzczurak	20:cf211a3b3d9e	2482	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	2483	VL53L0X_REG_SYSRANGE_START, &byte );
johnAlexander	16:98ce55ddbb1a	2484	loop_nb = loop_nb + 1;
JerrySzczurak	20:cf211a3b3d9e	2485	} while ( ( ( byte & start_stop_byte ) == start_stop_byte )
JerrySzczurak	20:cf211a3b3d9e	2486	&& ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2487	&& ( loop_nb < VL53L0X_DEFAULT_MAX_LOOP ) );
JerrySzczurak	20:cf211a3b3d9e	2488
JerrySzczurak	20:cf211a3b3d9e	2489	if ( loop_nb >= VL53L0X_DEFAULT_MAX_LOOP )
johnAlexander	16:98ce55ddbb1a	2490	status = VL53L0X_ERROR_TIME_OUT;
johnAlexander	15:932d8b4e52c9	2491
johnAlexander	15:932d8b4e52c9	2492	}
johnAlexander	15:932d8b4e52c9	2493
johnAlexander	15:932d8b4e52c9	2494	break;
johnAlexander	15:932d8b4e52c9	2495	case VL53L0X_DEVICEMODE_CONTINUOUS_RANGING:
johnAlexander	15:932d8b4e52c9	2496	/* Back-to-back mode */
johnAlexander	15:932d8b4e52c9	2497
johnAlexander	15:932d8b4e52c9	2498	/* Check if need to apply interrupt settings */
JerrySzczurak	20:cf211a3b3d9e	2499	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2500	status = vl53l0x_check_and_load_interrupt_settings( dev, 1 );
JerrySzczurak	20:cf211a3b3d9e	2501
JerrySzczurak	20:cf211a3b3d9e	2502	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	2503	VL53L0X_REG_SYSRANGE_START,
JerrySzczurak	20:cf211a3b3d9e	2504	VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK );
JerrySzczurak	20:cf211a3b3d9e	2505	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2506	/* Set PAL State to Running */
JerrySzczurak	20:cf211a3b3d9e	2507	PALDevDataSet( dev, PalState, VL53L0X_STATE_RUNNING );
johnAlexander	15:932d8b4e52c9	2508	}
johnAlexander	15:932d8b4e52c9	2509	break;
johnAlexander	15:932d8b4e52c9	2510	case VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING:
johnAlexander	15:932d8b4e52c9	2511	/* Continuous mode */
johnAlexander	15:932d8b4e52c9	2512	/* Check if need to apply interrupt settings */
JerrySzczurak	20:cf211a3b3d9e	2513	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2514	status = vl53l0x_check_and_load_interrupt_settings( dev, 1 );
JerrySzczurak	20:cf211a3b3d9e	2515
JerrySzczurak	20:cf211a3b3d9e	2516	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	2517	VL53L0X_REG_SYSRANGE_START,
JerrySzczurak	20:cf211a3b3d9e	2518	VL53L0X_REG_SYSRANGE_MODE_TIMED );
JerrySzczurak	20:cf211a3b3d9e	2519
JerrySzczurak	20:cf211a3b3d9e	2520	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2521	/* Set PAL State to Running */
JerrySzczurak	20:cf211a3b3d9e	2522	PALDevDataSet( dev, PalState, VL53L0X_STATE_RUNNING );
johnAlexander	15:932d8b4e52c9	2523	}
johnAlexander	15:932d8b4e52c9	2524	break;
johnAlexander	15:932d8b4e52c9	2525	default:
johnAlexander	15:932d8b4e52c9	2526	/* Selected mode not supported */
johnAlexander	16:98ce55ddbb1a	2527	status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
johnAlexander	15:932d8b4e52c9	2528	}
johnAlexander	15:932d8b4e52c9	2529
johnAlexander	15:932d8b4e52c9	2530
JerrySzczurak	20:cf211a3b3d9e	2531	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	2532	return status;
johnAlexander	0:c523920bcc09	2533	}
johnAlexander	0:c523920bcc09	2534
johnAlexander	0:c523920bcc09	2535	/* Group PAL Measurement Functions */
JerrySzczurak	20:cf211a3b3d9e	2536	VL53L0X_Error VL53L0X::vl53l0x_perform_single_measurement( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	2537	{
johnAlexander	16:98ce55ddbb1a	2538	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2539	VL53L0X_DeviceModes device_mode;
johnAlexander	15:932d8b4e52c9	2540
JerrySzczurak	20:cf211a3b3d9e	2541	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2542
johnAlexander	15:932d8b4e52c9	2543	/* Get Current DeviceMode */
JerrySzczurak	20:cf211a3b3d9e	2544	status = vl53l0x_get_device_mode( dev, &device_mode );
johnAlexander	15:932d8b4e52c9	2545
johnAlexander	15:932d8b4e52c9	2546	/* Start immediately to run a single ranging measurement in case of
johnAlexander	15:932d8b4e52c9	2547	* single ranging or single histogram */
JerrySzczurak	20:cf211a3b3d9e	2548	if ( status == VL53L0X_ERROR_NONE
JerrySzczurak	20:cf211a3b3d9e	2549	&& device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING )
JerrySzczurak	20:cf211a3b3d9e	2550	status = vl53l0x_start_measurement( dev );
JerrySzczurak	20:cf211a3b3d9e	2551
JerrySzczurak	20:cf211a3b3d9e	2552
JerrySzczurak	20:cf211a3b3d9e	2553	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	2554	status = vl53l0x_measurement_poll_for_completion( dev );
johnAlexander	15:932d8b4e52c9	2555
johnAlexander	15:932d8b4e52c9	2556
johnAlexander	15:932d8b4e52c9	2557	/* Change PAL State in case of single ranging or single histogram */
JerrySzczurak	20:cf211a3b3d9e	2558	if ( status == VL53L0X_ERROR_NONE
JerrySzczurak	20:cf211a3b3d9e	2559	&& device_mode == VL53L0X_DEVICEMODE_SINGLE_RANGING )
JerrySzczurak	20:cf211a3b3d9e	2560	PALDevDataSet( dev, PalState, VL53L0X_STATE_IDLE );
JerrySzczurak	20:cf211a3b3d9e	2561
JerrySzczurak	20:cf211a3b3d9e	2562
JerrySzczurak	20:cf211a3b3d9e	2563	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2564	return status;
JerrySzczurak	20:cf211a3b3d9e	2565	}
JerrySzczurak	20:cf211a3b3d9e	2566
JerrySzczurak	20:cf211a3b3d9e	2567	VL53L0X_Error VL53L0X::vl53l0x_get_x_talk_compensation_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	2568	uint8_t *p_x_talk_compensation_enable )
johnAlexander	0:c523920bcc09	2569	{
johnAlexander	16:98ce55ddbb1a	2570	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2571	uint8_t temp8;
JerrySzczurak	20:cf211a3b3d9e	2572	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	2573
JerrySzczurak	20:cf211a3b3d9e	2574	VL53L0X_GETPARAMETERFIELD( dev, XTalkCompensationEnable, temp8 );
johnAlexander	16:98ce55ddbb1a	2575	*p_x_talk_compensation_enable = temp8;
johnAlexander	16:98ce55ddbb1a	2576
JerrySzczurak	20:cf211a3b3d9e	2577	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2578	return status;
JerrySzczurak	20:cf211a3b3d9e	2579	}
JerrySzczurak	20:cf211a3b3d9e	2580
JerrySzczurak	20:cf211a3b3d9e	2581	VL53L0X_Error VL53L0X::vl53l0x_get_total_xtalk_rate( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2582	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
JerrySzczurak	20:cf211a3b3d9e	2583	FixPoint1616_t *p_total_xtalk_rate_mcps )
johnAlexander	0:c523920bcc09	2584	{
johnAlexander	16:98ce55ddbb1a	2585	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2586
johnAlexander	16:98ce55ddbb1a	2587	uint8_t xtalk_comp_enable;
johnAlexander	16:98ce55ddbb1a	2588	FixPoint1616_t total_xtalk_mega_cps;
johnAlexander	16:98ce55ddbb1a	2589	FixPoint1616_t xtalk_per_spad_mega_cps;
johnAlexander	16:98ce55ddbb1a	2590
johnAlexander	16:98ce55ddbb1a	2591	*p_total_xtalk_rate_mcps = 0;
johnAlexander	16:98ce55ddbb1a	2592
JerrySzczurak	20:cf211a3b3d9e	2593	status = vl53l0x_get_x_talk_compensation_enable( dev, &xtalk_comp_enable );
JerrySzczurak	20:cf211a3b3d9e	2594	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	2595
JerrySzczurak	20:cf211a3b3d9e	2596	if ( xtalk_comp_enable ) {
johnAlexander	15:932d8b4e52c9	2597
johnAlexander	15:932d8b4e52c9	2598	VL53L0X_GETPARAMETERFIELD(
johnAlexander	16:98ce55ddbb1a	2599	dev,
johnAlexander	15:932d8b4e52c9	2600	XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	2601	xtalk_per_spad_mega_cps );
johnAlexander	15:932d8b4e52c9	2602
johnAlexander	15:932d8b4e52c9	2603	/* FixPoint1616 * FixPoint 8:8 = FixPoint0824 */
johnAlexander	16:98ce55ddbb1a	2604	total_xtalk_mega_cps =
johnAlexander	16:98ce55ddbb1a	2605	p_ranging_measurement_data->EffectiveSpadRtnCount *
johnAlexander	16:98ce55ddbb1a	2606	xtalk_per_spad_mega_cps;
johnAlexander	15:932d8b4e52c9	2607
johnAlexander	15:932d8b4e52c9	2608	/* FixPoint0824 >> 8 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	2609	*p_total_xtalk_rate_mcps =
JerrySzczurak	20:cf211a3b3d9e	2610	( total_xtalk_mega_cps + 0x80 ) >> 8;
johnAlexander	15:932d8b4e52c9	2611	}
johnAlexander	15:932d8b4e52c9	2612	}
johnAlexander	15:932d8b4e52c9	2613
johnAlexander	16:98ce55ddbb1a	2614	return status;
johnAlexander	0:c523920bcc09	2615	}
johnAlexander	0:c523920bcc09	2616
JerrySzczurak	20:cf211a3b3d9e	2617	VL53L0X_Error VL53L0X::vl53l0x_get_total_signal_rate( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2618	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
JerrySzczurak	20:cf211a3b3d9e	2619	FixPoint1616_t *p_total_signal_rate_mcps )
johnAlexander	0:c523920bcc09	2620	{
johnAlexander	16:98ce55ddbb1a	2621	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	2622	FixPoint1616_t total_xtalk_mega_cps;
johnAlexander	15:932d8b4e52c9	2623
JerrySzczurak	20:cf211a3b3d9e	2624	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2625
johnAlexander	16:98ce55ddbb1a	2626	*p_total_signal_rate_mcps =
johnAlexander	16:98ce55ddbb1a	2627	p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander	16:98ce55ddbb1a	2628
johnAlexander	16:98ce55ddbb1a	2629	status = vl53l0x_get_total_xtalk_rate(
JerrySzczurak	20:cf211a3b3d9e	2630	dev, p_ranging_measurement_data, &total_xtalk_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	2631
JerrySzczurak	20:cf211a3b3d9e	2632	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	2633	*p_total_signal_rate_mcps += total_xtalk_mega_cps;
johnAlexander	16:98ce55ddbb1a	2634
johnAlexander	16:98ce55ddbb1a	2635	return status;
johnAlexander	0:c523920bcc09	2636	}
johnAlexander	0:c523920bcc09	2637
johnAlexander	0:c523920bcc09	2638	/* To convert ms into register value */
JerrySzczurak	20:cf211a3b3d9e	2639	uint32_t VL53L0X::vl53l0x_calc_timeout_mclks( VL53L0X_DEV dev,
johnAlexander	15:932d8b4e52c9	2640	uint32_t timeout_period_us,
JerrySzczurak	20:cf211a3b3d9e	2641	uint8_t vcsel_period_pclks )
johnAlexander	0:c523920bcc09	2642	{
johnAlexander	15:932d8b4e52c9	2643	uint32_t macro_period_ps;
johnAlexander	15:932d8b4e52c9	2644	uint32_t macro_period_ns;
johnAlexander	15:932d8b4e52c9	2645	uint32_t timeout_period_mclks = 0;
johnAlexander	15:932d8b4e52c9	2646
JerrySzczurak	20:cf211a3b3d9e	2647	macro_period_ps = vl53l0x_calc_macro_period_ps( dev, vcsel_period_pclks );
JerrySzczurak	20:cf211a3b3d9e	2648	macro_period_ns = ( macro_period_ps + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	2649
johnAlexander	15:932d8b4e52c9	2650	timeout_period_mclks =
JerrySzczurak	20:cf211a3b3d9e	2651	( uint32_t ) ( ( ( timeout_period_us * 1000 )
JerrySzczurak	20:cf211a3b3d9e	2652	+ ( macro_period_ns / 2 ) ) / macro_period_ns );
johnAlexander	0:c523920bcc09	2653
johnAlexander	0:c523920bcc09	2654	return timeout_period_mclks;
johnAlexander	0:c523920bcc09	2655	}
johnAlexander	0:c523920bcc09	2656
JerrySzczurak	20:cf211a3b3d9e	2657	uint32_t VL53L0X::vl53l0x_isqrt( uint32_t num )
johnAlexander	0:c523920bcc09	2658	{
johnAlexander	15:932d8b4e52c9	2659	/*
johnAlexander	15:932d8b4e52c9	2660	* Implements an integer square root
johnAlexander	15:932d8b4e52c9	2661	*
johnAlexander	15:932d8b4e52c9	2662	* From: http://en.wikipedia.org/wiki/Methods_of_computing_square_roots
johnAlexander	15:932d8b4e52c9	2663	*/
johnAlexander	15:932d8b4e52c9	2664
johnAlexander	15:932d8b4e52c9	2665	uint32_t res = 0;
johnAlexander	15:932d8b4e52c9	2666	uint32_t bit = 1 << 30;
johnAlexander	15:932d8b4e52c9	2667	/* The second-to-top bit is set:
johnAlexander	15:932d8b4e52c9	2668	* 1 << 14 for 16-bits, 1 << 30 for 32 bits */
johnAlexander	15:932d8b4e52c9	2669
johnAlexander	15:932d8b4e52c9	2670	/* "bit" starts at the highest power of four <= the argument. */
JerrySzczurak	20:cf211a3b3d9e	2671	while ( bit > num )
johnAlexander	15:932d8b4e52c9	2672	bit >>= 2;
johnAlexander	15:932d8b4e52c9	2673
johnAlexander	15:932d8b4e52c9	2674
JerrySzczurak	20:cf211a3b3d9e	2675	while ( bit != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	2676	if ( num >= res + bit ) {
johnAlexander	15:932d8b4e52c9	2677	num -= res + bit;
JerrySzczurak	20:cf211a3b3d9e	2678	res = ( res >> 1 ) + bit;
johnAlexander	15:932d8b4e52c9	2679	} else
johnAlexander	15:932d8b4e52c9	2680	res >>= 1;
johnAlexander	15:932d8b4e52c9	2681
johnAlexander	15:932d8b4e52c9	2682	bit >>= 2;
johnAlexander	15:932d8b4e52c9	2683	}
johnAlexander	15:932d8b4e52c9	2684
johnAlexander	15:932d8b4e52c9	2685	return res;
johnAlexander	0:c523920bcc09	2686	}
johnAlexander	0:c523920bcc09	2687
JerrySzczurak	20:cf211a3b3d9e	2688	uint32_t VL53L0X::vl53l0x_quadrature_sum( uint32_t a, uint32_t b )
JerrySzczurak	20:cf211a3b3d9e	2689	{
JerrySzczurak	20:cf211a3b3d9e	2690	/*
JerrySzczurak	20:cf211a3b3d9e	2691	* Implements a quadrature sum
JerrySzczurak	20:cf211a3b3d9e	2692	*
JerrySzczurak	20:cf211a3b3d9e	2693	* rea = sqrt(a^2 + b^2)
JerrySzczurak	20:cf211a3b3d9e	2694	*
JerrySzczurak	20:cf211a3b3d9e	2695	* Trap overflow case max input value is 65535 (16-bit value)
JerrySzczurak	20:cf211a3b3d9e	2696	* as internal calc are 32-bit wide
JerrySzczurak	20:cf211a3b3d9e	2697	*
JerrySzczurak	20:cf211a3b3d9e	2698	* If overflow then seta output to maximum
JerrySzczurak	20:cf211a3b3d9e	2699	*/
JerrySzczurak	20:cf211a3b3d9e	2700	uint32_t res = 0;
JerrySzczurak	20:cf211a3b3d9e	2701
JerrySzczurak	20:cf211a3b3d9e	2702	if ( a > 65535 \|\| b > 65535 )
JerrySzczurak	20:cf211a3b3d9e	2703	res = 65535;
JerrySzczurak	20:cf211a3b3d9e	2704	else
JerrySzczurak	20:cf211a3b3d9e	2705	res = vl53l0x_isqrt( a * a + b * b );
JerrySzczurak	20:cf211a3b3d9e	2706
JerrySzczurak	20:cf211a3b3d9e	2707	return res;
JerrySzczurak	20:cf211a3b3d9e	2708	}
JerrySzczurak	20:cf211a3b3d9e	2709
johnAlexander	16:98ce55ddbb1a	2710	VL53L0X_Error VL53L0X::vl53l0x_calc_dmax(
johnAlexander	16:98ce55ddbb1a	2711	VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2712	FixPoint1616_t total_signal_rate_mcps,
johnAlexander	16:98ce55ddbb1a	2713	FixPoint1616_t total_corr_signal_rate_mcps,
johnAlexander	16:98ce55ddbb1a	2714	FixPoint1616_t pw_mult,
johnAlexander	16:98ce55ddbb1a	2715	uint32_t sigma_estimate_p1,
johnAlexander	16:98ce55ddbb1a	2716	FixPoint1616_t sigma_estimate_p2,
johnAlexander	16:98ce55ddbb1a	2717	uint32_t peak_vcsel_duration_us,
JerrySzczurak	20:cf211a3b3d9e	2718	uint32_t *pd_max_mm )
johnAlexander	0:c523920bcc09	2719	{
johnAlexander	16:98ce55ddbb1a	2720	const uint32_t c_sigma_limit = 18;
johnAlexander	16:98ce55ddbb1a	2721	const FixPoint1616_t c_signal_limit = 0x4000; /* 0.25 */
johnAlexander	16:98ce55ddbb1a	2722	const FixPoint1616_t c_sigma_est_ref = 0x00000042; /* 0.001 */
johnAlexander	16:98ce55ddbb1a	2723	const uint32_t c_amb_eff_width_sigma_est_ns = 6;
johnAlexander	16:98ce55ddbb1a	2724	const uint32_t c_amb_eff_width_d_max_ns = 7;
johnAlexander	16:98ce55ddbb1a	2725	uint32_t dmax_cal_range_mm;
johnAlexander	16:98ce55ddbb1a	2726	FixPoint1616_t dmax_cal_signal_rate_rtn_mcps;
johnAlexander	16:98ce55ddbb1a	2727	FixPoint1616_t min_signal_needed;
johnAlexander	16:98ce55ddbb1a	2728	FixPoint1616_t min_signal_needed_p1;
johnAlexander	16:98ce55ddbb1a	2729	FixPoint1616_t min_signal_needed_p2;
johnAlexander	16:98ce55ddbb1a	2730	FixPoint1616_t min_signal_needed_p3;
johnAlexander	16:98ce55ddbb1a	2731	FixPoint1616_t min_signal_needed_p4;
johnAlexander	16:98ce55ddbb1a	2732	FixPoint1616_t sigma_limit_tmp;
johnAlexander	16:98ce55ddbb1a	2733	FixPoint1616_t sigma_est_sq_tmp;
johnAlexander	16:98ce55ddbb1a	2734	FixPoint1616_t signal_limit_tmp;
johnAlexander	16:98ce55ddbb1a	2735	FixPoint1616_t signal_at0_mm;
johnAlexander	16:98ce55ddbb1a	2736	FixPoint1616_t dmax_dark;
johnAlexander	16:98ce55ddbb1a	2737	FixPoint1616_t dmax_ambient;
johnAlexander	16:98ce55ddbb1a	2738	FixPoint1616_t dmax_dark_tmp;
johnAlexander	16:98ce55ddbb1a	2739	FixPoint1616_t sigma_est_p2_tmp;
johnAlexander	16:98ce55ddbb1a	2740	uint32_t signal_rate_temp_mcps;
johnAlexander	16:98ce55ddbb1a	2741
johnAlexander	16:98ce55ddbb1a	2742	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	2743
JerrySzczurak	20:cf211a3b3d9e	2744	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	2745
johnAlexander	16:98ce55ddbb1a	2746	dmax_cal_range_mm =
JerrySzczurak	20:cf211a3b3d9e	2747	PALDevDataGet( dev, DmaxCalRangeMilliMeter );
johnAlexander	16:98ce55ddbb1a	2748
johnAlexander	16:98ce55ddbb1a	2749	dmax_cal_signal_rate_rtn_mcps =
JerrySzczurak	20:cf211a3b3d9e	2750	PALDevDataGet( dev, DmaxCalSignalRateRtnMegaCps );
johnAlexander	15:932d8b4e52c9	2751
johnAlexander	15:932d8b4e52c9	2752	/* uint32 * FixPoint1616 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	2753	signal_at0_mm = dmax_cal_range_mm * dmax_cal_signal_rate_rtn_mcps;
johnAlexander	15:932d8b4e52c9	2754
johnAlexander	15:932d8b4e52c9	2755	/* FixPoint1616 >> 8 = FixPoint2408 */
JerrySzczurak	20:cf211a3b3d9e	2756	signal_at0_mm = ( signal_at0_mm + 0x80 ) >> 8;
johnAlexander	16:98ce55ddbb1a	2757	signal_at0_mm *= dmax_cal_range_mm;
johnAlexander	16:98ce55ddbb1a	2758
johnAlexander	16:98ce55ddbb1a	2759	min_signal_needed_p1 = 0;
JerrySzczurak	20:cf211a3b3d9e	2760	if ( total_corr_signal_rate_mcps > 0 ) {
johnAlexander	15:932d8b4e52c9	2761
johnAlexander	15:932d8b4e52c9	2762	/* Shift by 10 bits to increase resolution prior to the
johnAlexander	15:932d8b4e52c9	2763	* division */
johnAlexander	16:98ce55ddbb1a	2764	signal_rate_temp_mcps = total_signal_rate_mcps << 10;
johnAlexander	15:932d8b4e52c9	2765
johnAlexander	15:932d8b4e52c9	2766	/* Add rounding value prior to division */
johnAlexander	16:98ce55ddbb1a	2767	min_signal_needed_p1 = signal_rate_temp_mcps +
JerrySzczurak	20:cf211a3b3d9e	2768	( total_corr_signal_rate_mcps / 2 );
johnAlexander	15:932d8b4e52c9	2769
johnAlexander	15:932d8b4e52c9	2770	/* FixPoint0626/FixPoint1616 = FixPoint2210 */
johnAlexander	16:98ce55ddbb1a	2771	min_signal_needed_p1 /= total_corr_signal_rate_mcps;
johnAlexander	15:932d8b4e52c9	2772
johnAlexander	15:932d8b4e52c9	2773	/* Apply a factored version of the speed of light.
johnAlexander	15:932d8b4e52c9	2774	Correction to be applied at the end */
johnAlexander	16:98ce55ddbb1a	2775	min_signal_needed_p1 *= 3;
johnAlexander	15:932d8b4e52c9	2776
johnAlexander	15:932d8b4e52c9	2777	/* FixPoint2210 * FixPoint2210 = FixPoint1220 */
johnAlexander	16:98ce55ddbb1a	2778	min_signal_needed_p1 *= min_signal_needed_p1;
johnAlexander	15:932d8b4e52c9	2779
johnAlexander	15:932d8b4e52c9	2780	/* FixPoint1220 >> 16 = FixPoint2804 */
JerrySzczurak	20:cf211a3b3d9e	2781	min_signal_needed_p1 = ( min_signal_needed_p1 + 0x8000 ) >> 16;
johnAlexander	15:932d8b4e52c9	2782	}
johnAlexander	15:932d8b4e52c9	2783
johnAlexander	16:98ce55ddbb1a	2784	min_signal_needed_p2 = pw_mult * sigma_estimate_p1;
johnAlexander	15:932d8b4e52c9	2785
johnAlexander	15:932d8b4e52c9	2786	/* FixPoint1616 >> 16 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2787	min_signal_needed_p2 = ( min_signal_needed_p2 + 0x8000 ) >> 16;
johnAlexander	15:932d8b4e52c9	2788
johnAlexander	15:932d8b4e52c9	2789	/* uint32 * uint32 = uint32 */
johnAlexander	16:98ce55ddbb1a	2790	min_signal_needed_p2 *= min_signal_needed_p2;
johnAlexander	15:932d8b4e52c9	2791
johnAlexander	15:932d8b4e52c9	2792	/* Check sigmaEstimateP2
johnAlexander	15:932d8b4e52c9	2793	* If this value is too high there is not enough signal rate
johnAlexander	15:932d8b4e52c9	2794	* to calculate dmax value so set a suitable value to ensure
johnAlexander	15:932d8b4e52c9	2795	* a very small dmax.
johnAlexander	15:932d8b4e52c9	2796	*/
JerrySzczurak	20:cf211a3b3d9e	2797	sigma_est_p2_tmp = ( sigma_estimate_p2 + 0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	2798	sigma_est_p2_tmp = ( sigma_est_p2_tmp + c_amb_eff_width_sigma_est_ns / 2 ) /
johnAlexander	16:98ce55ddbb1a	2799	c_amb_eff_width_sigma_est_ns;
johnAlexander	16:98ce55ddbb1a	2800	sigma_est_p2_tmp *= c_amb_eff_width_d_max_ns;
johnAlexander	16:98ce55ddbb1a	2801
JerrySzczurak	20:cf211a3b3d9e	2802	if ( sigma_est_p2_tmp > 0xffff ) {
johnAlexander	16:98ce55ddbb1a	2803	min_signal_needed_p3 = 0xfff00000;
johnAlexander	15:932d8b4e52c9	2804	} else {
johnAlexander	15:932d8b4e52c9	2805
johnAlexander	15:932d8b4e52c9	2806	/* DMAX uses a different ambient width from sigma, so apply
johnAlexander	15:932d8b4e52c9	2807	* correction.
johnAlexander	15:932d8b4e52c9	2808	* Perform division before multiplication to prevent overflow.
johnAlexander	15:932d8b4e52c9	2809	*/
JerrySzczurak	20:cf211a3b3d9e	2810	sigma_estimate_p2 = ( sigma_estimate_p2 + c_amb_eff_width_sigma_est_ns / 2 ) /
johnAlexander	16:98ce55ddbb1a	2811	c_amb_eff_width_sigma_est_ns;
johnAlexander	16:98ce55ddbb1a	2812	sigma_estimate_p2 *= c_amb_eff_width_d_max_ns;
johnAlexander	15:932d8b4e52c9	2813
johnAlexander	15:932d8b4e52c9	2814	/* FixPoint1616 >> 16 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2815	min_signal_needed_p3 = ( sigma_estimate_p2 + 0x8000 ) >> 16;
johnAlexander	16:98ce55ddbb1a	2816
johnAlexander	16:98ce55ddbb1a	2817	min_signal_needed_p3 *= min_signal_needed_p3;
johnAlexander	15:932d8b4e52c9	2818
johnAlexander	15:932d8b4e52c9	2819	}
johnAlexander	15:932d8b4e52c9	2820
johnAlexander	15:932d8b4e52c9	2821	/* FixPoint1814 / uint32 = FixPoint1814 */
JerrySzczurak	20:cf211a3b3d9e	2822	sigma_limit_tmp = ( ( c_sigma_limit << 14 ) + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	2823
johnAlexander	15:932d8b4e52c9	2824	/* FixPoint1814 * FixPoint1814 = FixPoint3628 := FixPoint0428 */
johnAlexander	16:98ce55ddbb1a	2825	sigma_limit_tmp *= sigma_limit_tmp;
johnAlexander	15:932d8b4e52c9	2826
johnAlexander	15:932d8b4e52c9	2827	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander	16:98ce55ddbb1a	2828	sigma_est_sq_tmp = c_sigma_est_ref * c_sigma_est_ref;
johnAlexander	15:932d8b4e52c9	2829
johnAlexander	15:932d8b4e52c9	2830	/* FixPoint3232 >> 4 = FixPoint0428 */
JerrySzczurak	20:cf211a3b3d9e	2831	sigma_est_sq_tmp = ( sigma_est_sq_tmp + 0x08 ) >> 4;
johnAlexander	15:932d8b4e52c9	2832
johnAlexander	15:932d8b4e52c9	2833	/* FixPoint0428 - FixPoint0428 = FixPoint0428 */
johnAlexander	16:98ce55ddbb1a	2834	sigma_limit_tmp -= sigma_est_sq_tmp;
johnAlexander	15:932d8b4e52c9	2835
johnAlexander	15:932d8b4e52c9	2836	/* uint32_t * FixPoint0428 = FixPoint0428 */
johnAlexander	16:98ce55ddbb1a	2837	min_signal_needed_p4 = 4 * 12 * sigma_limit_tmp;
johnAlexander	15:932d8b4e52c9	2838
johnAlexander	15:932d8b4e52c9	2839	/* FixPoint0428 >> 14 = FixPoint1814 */
JerrySzczurak	20:cf211a3b3d9e	2840	min_signal_needed_p4 = ( min_signal_needed_p4 + 0x2000 ) >> 14;
johnAlexander	15:932d8b4e52c9	2841
johnAlexander	15:932d8b4e52c9	2842	/* uint32 + uint32 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2843	min_signal_needed = ( min_signal_needed_p2 + min_signal_needed_p3 );
johnAlexander	15:932d8b4e52c9	2844
johnAlexander	15:932d8b4e52c9	2845	/* uint32 / uint32 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2846	min_signal_needed += ( peak_vcsel_duration_us / 2 );
johnAlexander	16:98ce55ddbb1a	2847	min_signal_needed /= peak_vcsel_duration_us;
johnAlexander	15:932d8b4e52c9	2848
johnAlexander	15:932d8b4e52c9	2849	/* uint32 << 14 = FixPoint1814 */
johnAlexander	16:98ce55ddbb1a	2850	min_signal_needed <<= 14;
johnAlexander	15:932d8b4e52c9	2851
johnAlexander	15:932d8b4e52c9	2852	/* FixPoint1814 / FixPoint1814 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2853	min_signal_needed += ( min_signal_needed_p4 / 2 );
johnAlexander	16:98ce55ddbb1a	2854	min_signal_needed /= min_signal_needed_p4;
johnAlexander	15:932d8b4e52c9	2855
johnAlexander	15:932d8b4e52c9	2856	/* FixPoint3200 * FixPoint2804 := FixPoint2804*/
johnAlexander	16:98ce55ddbb1a	2857	min_signal_needed *= min_signal_needed_p1;
johnAlexander	15:932d8b4e52c9	2858
johnAlexander	15:932d8b4e52c9	2859	/* Apply correction by dividing by 1000000.
johnAlexander	15:932d8b4e52c9	2860	* This assumes 10E16 on the numerator of the equation
johnAlexander	15:932d8b4e52c9	2861	* and 10E-22 on the denominator.
johnAlexander	15:932d8b4e52c9	2862	* We do this because 32bit fix point calculation can't
johnAlexander	15:932d8b4e52c9	2863	* handle the larger and smaller elements of this equation,
johnAlexander	15:932d8b4e52c9	2864	* i.e. speed of light and pulse widths.
johnAlexander	15:932d8b4e52c9	2865	*/
JerrySzczurak	20:cf211a3b3d9e	2866	min_signal_needed = ( min_signal_needed + 500 ) / 1000;
johnAlexander	16:98ce55ddbb1a	2867	min_signal_needed <<= 4;
johnAlexander	16:98ce55ddbb1a	2868
JerrySzczurak	20:cf211a3b3d9e	2869	min_signal_needed = ( min_signal_needed + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	2870
johnAlexander	15:932d8b4e52c9	2871	/* FixPoint1616 >> 8 = FixPoint2408 */
JerrySzczurak	20:cf211a3b3d9e	2872	signal_limit_tmp = ( c_signal_limit + 0x80 ) >> 8;
johnAlexander	15:932d8b4e52c9	2873
johnAlexander	15:932d8b4e52c9	2874	/* FixPoint2408/FixPoint2408 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2875	if ( signal_limit_tmp != 0 )
JerrySzczurak	20:cf211a3b3d9e	2876	dmax_dark_tmp = ( signal_at0_mm + ( signal_limit_tmp / 2 ) )
johnAlexander	16:98ce55ddbb1a	2877	/ signal_limit_tmp;
johnAlexander	15:932d8b4e52c9	2878	else
johnAlexander	16:98ce55ddbb1a	2879	dmax_dark_tmp = 0;
johnAlexander	16:98ce55ddbb1a	2880
JerrySzczurak	20:cf211a3b3d9e	2881	dmax_dark = vl53l0x_isqrt( dmax_dark_tmp );
johnAlexander	15:932d8b4e52c9	2882
johnAlexander	15:932d8b4e52c9	2883	/* FixPoint2408/FixPoint2408 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	2884	if ( min_signal_needed != 0 )
JerrySzczurak	20:cf211a3b3d9e	2885	dmax_ambient = ( signal_at0_mm + min_signal_needed / 2 )
johnAlexander	16:98ce55ddbb1a	2886	/ min_signal_needed;
johnAlexander	15:932d8b4e52c9	2887	else
johnAlexander	16:98ce55ddbb1a	2888	dmax_ambient = 0;
johnAlexander	16:98ce55ddbb1a	2889
JerrySzczurak	20:cf211a3b3d9e	2890	dmax_ambient = vl53l0x_isqrt( dmax_ambient );
johnAlexander	16:98ce55ddbb1a	2891
johnAlexander	16:98ce55ddbb1a	2892	*pd_max_mm = dmax_dark;
JerrySzczurak	20:cf211a3b3d9e	2893	if ( dmax_dark > dmax_ambient )
johnAlexander	16:98ce55ddbb1a	2894	*pd_max_mm = dmax_ambient;
johnAlexander	16:98ce55ddbb1a	2895
JerrySzczurak	20:cf211a3b3d9e	2896	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	2897
JerrySzczurak	20:cf211a3b3d9e	2898	return status;
JerrySzczurak	20:cf211a3b3d9e	2899	}
JerrySzczurak	20:cf211a3b3d9e	2900
JerrySzczurak	20:cf211a3b3d9e	2901	VL53L0X_Error VL53L0X::vl53l0x_calc_sigma_estimate( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	2902	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
johnAlexander	16:98ce55ddbb1a	2903	FixPoint1616_t *p_sigma_estimate,
JerrySzczurak	20:cf211a3b3d9e	2904	uint32_t *p_dmax_mm )
johnAlexander	0:c523920bcc09	2905	{
johnAlexander	15:932d8b4e52c9	2906	/* Expressed in 100ths of a ns, i.e. centi-ns */
johnAlexander	16:98ce55ddbb1a	2907	const uint32_t c_pulse_effective_width_centi_ns = 800;
johnAlexander	15:932d8b4e52c9	2908	/* Expressed in 100ths of a ns, i.e. centi-ns */
johnAlexander	16:98ce55ddbb1a	2909	const uint32_t c_ambient_effective_width_centi_ns = 600;
johnAlexander	16:98ce55ddbb1a	2910	const FixPoint1616_t c_dflt_final_range_integration_time_milli_secs = 0x00190000; /* 25ms */
johnAlexander	16:98ce55ddbb1a	2911	const uint32_t c_vcsel_pulse_width_ps = 4700; /* pico secs */
johnAlexander	16:98ce55ddbb1a	2912	const FixPoint1616_t c_sigma_est_max = 0x028F87AE;
johnAlexander	16:98ce55ddbb1a	2913	const FixPoint1616_t c_sigma_est_rtn_max = 0xF000;
JerrySzczurak	20:cf211a3b3d9e	2914	const FixPoint1616_t c_amb_to_signal_ratio_max = 0xF0000000 /
johnAlexander	16:98ce55ddbb1a	2915	c_ambient_effective_width_centi_ns;
johnAlexander	15:932d8b4e52c9	2916	/* Time Of Flight per mm (6.6 pico secs) */
johnAlexander	16:98ce55ddbb1a	2917	const FixPoint1616_t c_tof_per_mm_ps = 0x0006999A;
johnAlexander	16:98ce55ddbb1a	2918	const uint32_t c_16bit_rounding_param = 0x00008000;
johnAlexander	16:98ce55ddbb1a	2919	const FixPoint1616_t c_max_x_talk_kcps = 0x00320000;
johnAlexander	16:98ce55ddbb1a	2920	const uint32_t c_pll_period_ps = 1655;
johnAlexander	16:98ce55ddbb1a	2921
johnAlexander	16:98ce55ddbb1a	2922	uint32_t vcsel_total_events_rtn;
johnAlexander	16:98ce55ddbb1a	2923	uint32_t final_range_timeout_micro_secs;
johnAlexander	16:98ce55ddbb1a	2924	uint32_t pre_range_timeout_micro_secs;
johnAlexander	16:98ce55ddbb1a	2925	uint32_t final_range_integration_time_milli_secs;
johnAlexander	16:98ce55ddbb1a	2926	FixPoint1616_t sigma_estimate_p1;
johnAlexander	16:98ce55ddbb1a	2927	FixPoint1616_t sigma_estimate_p2;
johnAlexander	16:98ce55ddbb1a	2928	FixPoint1616_t sigma_estimate_p3;
johnAlexander	16:98ce55ddbb1a	2929	FixPoint1616_t delta_t_ps;
johnAlexander	16:98ce55ddbb1a	2930	FixPoint1616_t pw_mult;
johnAlexander	16:98ce55ddbb1a	2931	FixPoint1616_t sigma_est_rtn;
johnAlexander	16:98ce55ddbb1a	2932	FixPoint1616_t sigma_estimate;
johnAlexander	16:98ce55ddbb1a	2933	FixPoint1616_t x_talk_correction;
johnAlexander	16:98ce55ddbb1a	2934	FixPoint1616_t ambient_rate_kcps;
johnAlexander	16:98ce55ddbb1a	2935	FixPoint1616_t peak_signal_rate_kcps;
johnAlexander	16:98ce55ddbb1a	2936	FixPoint1616_t x_talk_comp_rate_mcps;
johnAlexander	16:98ce55ddbb1a	2937	uint32_t x_talk_comp_rate_kcps;
johnAlexander	16:98ce55ddbb1a	2938	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	2939	FixPoint1616_t diff1_mcps;
johnAlexander	15:932d8b4e52c9	2940	FixPoint1616_t diff2_mcps;
johnAlexander	15:932d8b4e52c9	2941	FixPoint1616_t sqr1;
johnAlexander	15:932d8b4e52c9	2942	FixPoint1616_t sqr2;
johnAlexander	16:98ce55ddbb1a	2943	FixPoint1616_t sqr_sum;
johnAlexander	16:98ce55ddbb1a	2944	FixPoint1616_t sqrt_result_centi_ns;
johnAlexander	16:98ce55ddbb1a	2945	FixPoint1616_t sqrt_result;
johnAlexander	16:98ce55ddbb1a	2946	FixPoint1616_t total_signal_rate_mcps;
johnAlexander	16:98ce55ddbb1a	2947	FixPoint1616_t corrected_signal_rate_mcps;
johnAlexander	16:98ce55ddbb1a	2948	FixPoint1616_t sigma_est_ref;
johnAlexander	16:98ce55ddbb1a	2949	uint32_t vcsel_width;
johnAlexander	16:98ce55ddbb1a	2950	uint32_t final_range_macro_pclks;
johnAlexander	16:98ce55ddbb1a	2951	uint32_t pre_range_macro_pclks;
johnAlexander	16:98ce55ddbb1a	2952	uint32_t peak_vcsel_duration_us;
johnAlexander	16:98ce55ddbb1a	2953	uint8_t final_range_vcsel_pclks;
johnAlexander	16:98ce55ddbb1a	2954	uint8_t pre_range_vcsel_pclks;
johnAlexander	15:932d8b4e52c9	2955	/*! \addtogroup calc_sigma_estimate
johnAlexander	15:932d8b4e52c9	2956	* @{
johnAlexander	15:932d8b4e52c9	2957	*
johnAlexander	15:932d8b4e52c9	2958	* Estimates the range sigma
johnAlexander	15:932d8b4e52c9	2959	*/
johnAlexander	15:932d8b4e52c9	2960
JerrySzczurak	20:cf211a3b3d9e	2961	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	2962
JerrySzczurak	20:cf211a3b3d9e	2963	VL53L0X_GETPARAMETERFIELD( dev, XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	2964	x_talk_comp_rate_mcps );
johnAlexander	15:932d8b4e52c9	2965
johnAlexander	15:932d8b4e52c9	2966	/*
johnAlexander	15:932d8b4e52c9	2967	* We work in kcps rather than mcps as this helps keep within the
johnAlexander	15:932d8b4e52c9	2968	* confines of the 32 Fix1616 type.
johnAlexander	15:932d8b4e52c9	2969	*/
johnAlexander	15:932d8b4e52c9	2970
johnAlexander	16:98ce55ddbb1a	2971	ambient_rate_kcps =
JerrySzczurak	20:cf211a3b3d9e	2972	( p_ranging_measurement_data->AmbientRateRtnMegaCps * 1000 ) >> 16;
johnAlexander	16:98ce55ddbb1a	2973
johnAlexander	16:98ce55ddbb1a	2974	corrected_signal_rate_mcps =
johnAlexander	16:98ce55ddbb1a	2975	p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander	16:98ce55ddbb1a	2976
johnAlexander	16:98ce55ddbb1a	2977
johnAlexander	16:98ce55ddbb1a	2978	status = vl53l0x_get_total_signal_rate(
JerrySzczurak	20:cf211a3b3d9e	2979	dev, p_ranging_measurement_data, &total_signal_rate_mcps );
johnAlexander	16:98ce55ddbb1a	2980	status = vl53l0x_get_total_xtalk_rate(
JerrySzczurak	20:cf211a3b3d9e	2981	dev, p_ranging_measurement_data, &x_talk_comp_rate_mcps );
johnAlexander	15:932d8b4e52c9	2982
johnAlexander	15:932d8b4e52c9	2983
johnAlexander	15:932d8b4e52c9	2984	/* Signal rate measurement provided by device is the
johnAlexander	15:932d8b4e52c9	2985	* peak signal rate, not average.
johnAlexander	15:932d8b4e52c9	2986	*/
JerrySzczurak	20:cf211a3b3d9e	2987	peak_signal_rate_kcps = ( total_signal_rate_mcps * 1000 );
JerrySzczurak	20:cf211a3b3d9e	2988	peak_signal_rate_kcps = ( peak_signal_rate_kcps + 0x8000 ) >> 16;
johnAlexander	16:98ce55ddbb1a	2989
johnAlexander	16:98ce55ddbb1a	2990	x_talk_comp_rate_kcps = x_talk_comp_rate_mcps * 1000;
johnAlexander	16:98ce55ddbb1a	2991
JerrySzczurak	20:cf211a3b3d9e	2992	if ( x_talk_comp_rate_kcps > c_max_x_talk_kcps )
johnAlexander	16:98ce55ddbb1a	2993	x_talk_comp_rate_kcps = c_max_x_talk_kcps;
johnAlexander	16:98ce55ddbb1a	2994
JerrySzczurak	20:cf211a3b3d9e	2995	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	2996
johnAlexander	15:932d8b4e52c9	2997	/* Calculate final range macro periods */
johnAlexander	16:98ce55ddbb1a	2998	final_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER(
JerrySzczurak	20:cf211a3b3d9e	2999	dev, FinalRangeTimeoutMicroSecs );
johnAlexander	16:98ce55ddbb1a	3000
johnAlexander	16:98ce55ddbb1a	3001	final_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
JerrySzczurak	20:cf211a3b3d9e	3002	dev, FinalRangeVcselPulsePeriod );
johnAlexander	16:98ce55ddbb1a	3003
johnAlexander	16:98ce55ddbb1a	3004	final_range_macro_pclks = vl53l0x_calc_timeout_mclks(
JerrySzczurak	20:cf211a3b3d9e	3005	dev, final_range_timeout_micro_secs, final_range_vcsel_pclks );
johnAlexander	15:932d8b4e52c9	3006
johnAlexander	15:932d8b4e52c9	3007	/* Calculate pre-range macro periods */
johnAlexander	16:98ce55ddbb1a	3008	pre_range_timeout_micro_secs = VL53L0X_GETDEVICESPECIFICPARAMETER(
JerrySzczurak	20:cf211a3b3d9e	3009	dev, PreRangeTimeoutMicroSecs );
johnAlexander	16:98ce55ddbb1a	3010
johnAlexander	16:98ce55ddbb1a	3011	pre_range_vcsel_pclks = VL53L0X_GETDEVICESPECIFICPARAMETER(
JerrySzczurak	20:cf211a3b3d9e	3012	dev, PreRangeVcselPulsePeriod );
johnAlexander	16:98ce55ddbb1a	3013
johnAlexander	16:98ce55ddbb1a	3014	pre_range_macro_pclks = vl53l0x_calc_timeout_mclks(
JerrySzczurak	20:cf211a3b3d9e	3015	dev, pre_range_timeout_micro_secs, pre_range_vcsel_pclks );
johnAlexander	16:98ce55ddbb1a	3016
johnAlexander	16:98ce55ddbb1a	3017	vcsel_width = 3;
JerrySzczurak	20:cf211a3b3d9e	3018	if ( final_range_vcsel_pclks == 8 )
johnAlexander	16:98ce55ddbb1a	3019	vcsel_width = 2;
johnAlexander	16:98ce55ddbb1a	3020
johnAlexander	16:98ce55ddbb1a	3021
johnAlexander	16:98ce55ddbb1a	3022	peak_vcsel_duration_us = vcsel_width * 2048 *
JerrySzczurak	20:cf211a3b3d9e	3023	( pre_range_macro_pclks + final_range_macro_pclks );
JerrySzczurak	20:cf211a3b3d9e	3024	peak_vcsel_duration_us = ( peak_vcsel_duration_us + 500 ) / 1000;
johnAlexander	16:98ce55ddbb1a	3025	peak_vcsel_duration_us *= c_pll_period_ps;
JerrySzczurak	20:cf211a3b3d9e	3026	peak_vcsel_duration_us = ( peak_vcsel_duration_us + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	3027
johnAlexander	15:932d8b4e52c9	3028	/* Fix1616 >> 8 = Fix2408 */
JerrySzczurak	20:cf211a3b3d9e	3029	total_signal_rate_mcps = ( total_signal_rate_mcps + 0x80 ) >> 8;
johnAlexander	15:932d8b4e52c9	3030
johnAlexander	15:932d8b4e52c9	3031	/* Fix2408 * uint32 = Fix2408 */
johnAlexander	16:98ce55ddbb1a	3032	vcsel_total_events_rtn = total_signal_rate_mcps *
johnAlexander	16:98ce55ddbb1a	3033	peak_vcsel_duration_us;
johnAlexander	15:932d8b4e52c9	3034
johnAlexander	15:932d8b4e52c9	3035	/* Fix2408 >> 8 = uint32 */
JerrySzczurak	20:cf211a3b3d9e	3036	vcsel_total_events_rtn = ( vcsel_total_events_rtn + 0x80 ) >> 8;
johnAlexander	15:932d8b4e52c9	3037
johnAlexander	15:932d8b4e52c9	3038	/* Fix2408 << 8 = Fix1616 = */
johnAlexander	16:98ce55ddbb1a	3039	total_signal_rate_mcps <<= 8;
johnAlexander	15:932d8b4e52c9	3040	}
johnAlexander	15:932d8b4e52c9	3041
JerrySzczurak	20:cf211a3b3d9e	3042	if ( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	3043	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	3044	return status;
johnAlexander	15:932d8b4e52c9	3045	}
johnAlexander	15:932d8b4e52c9	3046
JerrySzczurak	20:cf211a3b3d9e	3047	if ( peak_signal_rate_kcps == 0 ) {
johnAlexander	16:98ce55ddbb1a	3048	*p_sigma_estimate = c_sigma_est_max;
JerrySzczurak	20:cf211a3b3d9e	3049	PALDevDataSet( dev, SigmaEstimate, c_sigma_est_max );
johnAlexander	16:98ce55ddbb1a	3050	*p_dmax_mm = 0;
johnAlexander	15:932d8b4e52c9	3051	} else {
JerrySzczurak	20:cf211a3b3d9e	3052	if ( vcsel_total_events_rtn < 1 )
johnAlexander	16:98ce55ddbb1a	3053	vcsel_total_events_rtn = 1;
johnAlexander	16:98ce55ddbb1a	3054
johnAlexander	16:98ce55ddbb1a	3055	sigma_estimate_p1 = c_pulse_effective_width_centi_ns;
johnAlexander	15:932d8b4e52c9	3056
johnAlexander	15:932d8b4e52c9	3057	/* ((FixPoint1616 << 16)* uint32)/uint32 = FixPoint1616 */
JerrySzczurak	20:cf211a3b3d9e	3058	sigma_estimate_p2 = ( ambient_rate_kcps << 16 ) / peak_signal_rate_kcps;
JerrySzczurak	20:cf211a3b3d9e	3059	if ( sigma_estimate_p2 > c_amb_to_signal_ratio_max ) {
johnAlexander	15:932d8b4e52c9	3060	/* Clip to prevent overflow. Will ensure safe
johnAlexander	15:932d8b4e52c9	3061	* max result. */
johnAlexander	16:98ce55ddbb1a	3062	sigma_estimate_p2 = c_amb_to_signal_ratio_max;
johnAlexander	15:932d8b4e52c9	3063	}
johnAlexander	16:98ce55ddbb1a	3064	sigma_estimate_p2 *= c_ambient_effective_width_centi_ns;
johnAlexander	16:98ce55ddbb1a	3065
JerrySzczurak	20:cf211a3b3d9e	3066	sigma_estimate_p3 = 2 * vl53l0x_isqrt( vcsel_total_events_rtn * 12 );
johnAlexander	15:932d8b4e52c9	3067
johnAlexander	15:932d8b4e52c9	3068	/* uint32 * FixPoint1616 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	3069	delta_t_ps = p_ranging_measurement_data->RangeMilliMeter *
johnAlexander	16:98ce55ddbb1a	3070	c_tof_per_mm_ps;
johnAlexander	15:932d8b4e52c9	3071
johnAlexander	15:932d8b4e52c9	3072	/*
johnAlexander	15:932d8b4e52c9	3073	* vcselRate - xtalkCompRate
johnAlexander	15:932d8b4e52c9	3074	* (uint32 << 16) - FixPoint1616 = FixPoint1616.
johnAlexander	15:932d8b4e52c9	3075	* Divide result by 1000 to convert to mcps.
johnAlexander	15:932d8b4e52c9	3076	* 500 is added to ensure rounding when integer division
johnAlexander	15:932d8b4e52c9	3077	* truncates.
johnAlexander	15:932d8b4e52c9	3078	*/
JerrySzczurak	20:cf211a3b3d9e	3079	diff1_mcps = ( ( ( peak_signal_rate_kcps << 16 ) -
JerrySzczurak	20:cf211a3b3d9e	3080	2 * x_talk_comp_rate_kcps ) + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	3081
johnAlexander	15:932d8b4e52c9	3082	/* vcselRate + xtalkCompRate */
JerrySzczurak	20:cf211a3b3d9e	3083	diff2_mcps = ( ( peak_signal_rate_kcps << 16 ) + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	3084
johnAlexander	15:932d8b4e52c9	3085	/* Shift by 8 bits to increase resolution prior to the
johnAlexander	15:932d8b4e52c9	3086	* division */
johnAlexander	15:932d8b4e52c9	3087	diff1_mcps <<= 8;
johnAlexander	15:932d8b4e52c9	3088
johnAlexander	15:932d8b4e52c9	3089	/* FixPoint0824/FixPoint1616 = FixPoint2408 */
johnAlexander	0:c523920bcc09	3090	// xTalkCorrection = abs(diff1_mcps/diff2_mcps);
johnAlexander	0:c523920bcc09	3091	// abs is causing compiler overloading isue in C++, but unsigned types. So, redundant call anyway!
JerrySzczurak	20:cf211a3b3d9e	3092	x_talk_correction = diff1_mcps / diff2_mcps;
johnAlexander	15:932d8b4e52c9	3093
johnAlexander	15:932d8b4e52c9	3094	/* FixPoint2408 << 8 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	3095	x_talk_correction <<= 8;
johnAlexander	16:98ce55ddbb1a	3096
JerrySzczurak	20:cf211a3b3d9e	3097	if( p_ranging_measurement_data->RangeStatus != 0 ) {
johnAlexander	16:98ce55ddbb1a	3098	pw_mult = 1 << 16;
johnAlexander	15:932d8b4e52c9	3099	} else {
johnAlexander	15:932d8b4e52c9	3100	/* FixPoint1616/uint32 = FixPoint1616 */
JerrySzczurak	20:cf211a3b3d9e	3101	pw_mult = delta_t_ps / c_vcsel_pulse_width_ps; /* smaller than 1.0f */
johnAlexander	15:932d8b4e52c9	3102
johnAlexander	15:932d8b4e52c9	3103	/*
johnAlexander	15:932d8b4e52c9	3104	* FixPoint1616 * FixPoint1616 = FixPoint3232, however both
johnAlexander	15:932d8b4e52c9	3105	* values are small enough such that32 bits will not be
johnAlexander	15:932d8b4e52c9	3106	* exceeded.
johnAlexander	15:932d8b4e52c9	3107	*/
JerrySzczurak	20:cf211a3b3d9e	3108	pw_mult *= ( ( 1 << 16 ) - x_talk_correction );
johnAlexander	15:932d8b4e52c9	3109
johnAlexander	15:932d8b4e52c9	3110	/* (FixPoint3232 >> 16) = FixPoint1616 */
JerrySzczurak	20:cf211a3b3d9e	3111	pw_mult = ( pw_mult + c_16bit_rounding_param ) >> 16;
johnAlexander	15:932d8b4e52c9	3112
johnAlexander	15:932d8b4e52c9	3113	/* FixPoint1616 + FixPoint1616 = FixPoint1616 */
JerrySzczurak	20:cf211a3b3d9e	3114	pw_mult += ( 1 << 16 );
johnAlexander	15:932d8b4e52c9	3115
johnAlexander	15:932d8b4e52c9	3116	/*
johnAlexander	15:932d8b4e52c9	3117	* At this point the value will be 1.xx, therefore if we square
johnAlexander	15:932d8b4e52c9	3118	* the value this will exceed 32 bits. To address this perform
johnAlexander	15:932d8b4e52c9	3119	* a single shift to the right before the multiplication.
johnAlexander	15:932d8b4e52c9	3120	*/
johnAlexander	16:98ce55ddbb1a	3121	pw_mult >>= 1;
johnAlexander	15:932d8b4e52c9	3122	/* FixPoint1715 * FixPoint1715 = FixPoint3430 */
johnAlexander	16:98ce55ddbb1a	3123	pw_mult = pw_mult * pw_mult;
johnAlexander	15:932d8b4e52c9	3124
johnAlexander	15:932d8b4e52c9	3125	/* (FixPoint3430 >> 14) = Fix1616 */
johnAlexander	16:98ce55ddbb1a	3126	pw_mult >>= 14;
johnAlexander	15:932d8b4e52c9	3127	}
johnAlexander	15:932d8b4e52c9	3128
johnAlexander	15:932d8b4e52c9	3129	/* FixPoint1616 * uint32 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	3130	sqr1 = pw_mult * sigma_estimate_p1;
johnAlexander	15:932d8b4e52c9	3131
johnAlexander	15:932d8b4e52c9	3132	/* (FixPoint1616 >> 16) = FixPoint3200 */
JerrySzczurak	20:cf211a3b3d9e	3133	sqr1 = ( sqr1 + 0x8000 ) >> 16;
johnAlexander	15:932d8b4e52c9	3134
johnAlexander	15:932d8b4e52c9	3135	/* FixPoint3200 * FixPoint3200 = FixPoint6400 */
johnAlexander	15:932d8b4e52c9	3136	sqr1 *= sqr1;
johnAlexander	15:932d8b4e52c9	3137
johnAlexander	16:98ce55ddbb1a	3138	sqr2 = sigma_estimate_p2;
johnAlexander	15:932d8b4e52c9	3139
johnAlexander	15:932d8b4e52c9	3140	/* (FixPoint1616 >> 16) = FixPoint3200 */
JerrySzczurak	20:cf211a3b3d9e	3141	sqr2 = ( sqr2 + 0x8000 ) >> 16;
johnAlexander	15:932d8b4e52c9	3142
johnAlexander	15:932d8b4e52c9	3143	/* FixPoint3200 * FixPoint3200 = FixPoint6400 */
johnAlexander	15:932d8b4e52c9	3144	sqr2 *= sqr2;
johnAlexander	15:932d8b4e52c9	3145
johnAlexander	15:932d8b4e52c9	3146	/* FixPoint64000 + FixPoint6400 = FixPoint6400 */
johnAlexander	16:98ce55ddbb1a	3147	sqr_sum = sqr1 + sqr2;
johnAlexander	15:932d8b4e52c9	3148
johnAlexander	15:932d8b4e52c9	3149	/* SQRT(FixPoin6400) = FixPoint3200 */
JerrySzczurak	20:cf211a3b3d9e	3150	sqrt_result_centi_ns = vl53l0x_isqrt( sqr_sum );
johnAlexander	15:932d8b4e52c9	3151
johnAlexander	15:932d8b4e52c9	3152	/* (FixPoint3200 << 16) = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	3153	sqrt_result_centi_ns <<= 16;
johnAlexander	15:932d8b4e52c9	3154
johnAlexander	15:932d8b4e52c9	3155	/*
johnAlexander	15:932d8b4e52c9	3156	* Note that the Speed Of Light is expressed in um per 1E-10
johnAlexander	15:932d8b4e52c9	3157	* seconds (2997) Therefore to get mm/ns we have to divide by
johnAlexander	15:932d8b4e52c9	3158	* 10000
johnAlexander	15:932d8b4e52c9	3159	*/
JerrySzczurak	20:cf211a3b3d9e	3160	sigma_est_rtn = ( ( ( sqrt_result_centi_ns + 50 ) / 100 ) /
JerrySzczurak	20:cf211a3b3d9e	3161	sigma_estimate_p3 );
johnAlexander	16:98ce55ddbb1a	3162	sigma_est_rtn *= VL53L0X_SPEED_OF_LIGHT_IN_AIR;
johnAlexander	15:932d8b4e52c9	3163
johnAlexander	15:932d8b4e52c9	3164	/* Add 5000 before dividing by 10000 to ensure rounding. */
johnAlexander	16:98ce55ddbb1a	3165	sigma_est_rtn += 5000;
johnAlexander	16:98ce55ddbb1a	3166	sigma_est_rtn /= 10000;
johnAlexander	16:98ce55ddbb1a	3167
JerrySzczurak	20:cf211a3b3d9e	3168	if ( sigma_est_rtn > c_sigma_est_rtn_max ) {
johnAlexander	15:932d8b4e52c9	3169	/* Clip to prevent overflow. Will ensure safe
johnAlexander	15:932d8b4e52c9	3170	* max result. */
johnAlexander	16:98ce55ddbb1a	3171	sigma_est_rtn = c_sigma_est_rtn_max;
johnAlexander	15:932d8b4e52c9	3172	}
johnAlexander	16:98ce55ddbb1a	3173	final_range_integration_time_milli_secs =
JerrySzczurak	20:cf211a3b3d9e	3174	( final_range_timeout_micro_secs + pre_range_timeout_micro_secs + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	3175
johnAlexander	15:932d8b4e52c9	3176	/* sigmaEstRef = 1mm * 25ms/final range integration time (inc pre-range)
johnAlexander	15:932d8b4e52c9	3177	* sqrt(FixPoint1616/int) = FixPoint2408)
johnAlexander	15:932d8b4e52c9	3178	*/
johnAlexander	16:98ce55ddbb1a	3179	sigma_est_ref =
JerrySzczurak	20:cf211a3b3d9e	3180	vl53l0x_isqrt( ( c_dflt_final_range_integration_time_milli_secs +
JerrySzczurak	20:cf211a3b3d9e	3181	final_range_integration_time_milli_secs / 2 ) /
JerrySzczurak	20:cf211a3b3d9e	3182	final_range_integration_time_milli_secs );
johnAlexander	15:932d8b4e52c9	3183
johnAlexander	15:932d8b4e52c9	3184	/* FixPoint2408 << 8 = FixPoint1616 */
johnAlexander	16:98ce55ddbb1a	3185	sigma_est_ref <<= 8;
JerrySzczurak	20:cf211a3b3d9e	3186	sigma_est_ref = ( sigma_est_ref + 500 ) / 1000;
johnAlexander	15:932d8b4e52c9	3187
johnAlexander	15:932d8b4e52c9	3188	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander	16:98ce55ddbb1a	3189	sqr1 = sigma_est_rtn * sigma_est_rtn;
johnAlexander	15:932d8b4e52c9	3190	/* FixPoint1616 * FixPoint1616 = FixPoint3232 */
johnAlexander	16:98ce55ddbb1a	3191	sqr2 = sigma_est_ref * sigma_est_ref;
johnAlexander	15:932d8b4e52c9	3192
johnAlexander	15:932d8b4e52c9	3193	/* sqrt(FixPoint3232) = FixPoint1616 */
JerrySzczurak	20:cf211a3b3d9e	3194	sqrt_result = vl53l0x_isqrt( ( sqr1 + sqr2 ) );
johnAlexander	15:932d8b4e52c9	3195	/*
johnAlexander	15:932d8b4e52c9	3196	* Note that the Shift by 4 bits increases resolution prior to
johnAlexander	15:932d8b4e52c9	3197	* the sqrt, therefore the result must be shifted by 2 bits to
johnAlexander	15:932d8b4e52c9	3198	* the right to revert back to the FixPoint1616 format.
johnAlexander	15:932d8b4e52c9	3199	*/
johnAlexander	15:932d8b4e52c9	3200
johnAlexander	16:98ce55ddbb1a	3201	sigma_estimate = 1000 * sqrt_result;
johnAlexander	16:98ce55ddbb1a	3202
JerrySzczurak	20:cf211a3b3d9e	3203	if ( ( peak_signal_rate_kcps < 1 ) \|\| ( vcsel_total_events_rtn < 1 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	3204	( sigma_estimate > c_sigma_est_max ) ) {
johnAlexander	16:98ce55ddbb1a	3205	sigma_estimate = c_sigma_est_max;
johnAlexander	15:932d8b4e52c9	3206	}
johnAlexander	15:932d8b4e52c9	3207
JerrySzczurak	20:cf211a3b3d9e	3208	*p_sigma_estimate = ( uint32_t )( sigma_estimate );
JerrySzczurak	20:cf211a3b3d9e	3209	PALDevDataSet( dev, SigmaEstimate, *p_sigma_estimate );
johnAlexander	16:98ce55ddbb1a	3210	status = vl53l0x_calc_dmax(
johnAlexander	16:98ce55ddbb1a	3211	dev,
johnAlexander	16:98ce55ddbb1a	3212	total_signal_rate_mcps,
johnAlexander	16:98ce55ddbb1a	3213	corrected_signal_rate_mcps,
johnAlexander	16:98ce55ddbb1a	3214	pw_mult,
johnAlexander	16:98ce55ddbb1a	3215	sigma_estimate_p1,
johnAlexander	16:98ce55ddbb1a	3216	sigma_estimate_p2,
johnAlexander	16:98ce55ddbb1a	3217	peak_vcsel_duration_us,
JerrySzczurak	20:cf211a3b3d9e	3218	p_dmax_mm );
JerrySzczurak	20:cf211a3b3d9e	3219	}
JerrySzczurak	20:cf211a3b3d9e	3220
JerrySzczurak	20:cf211a3b3d9e	3221	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	3222	return status;
JerrySzczurak	20:cf211a3b3d9e	3223	}
JerrySzczurak	20:cf211a3b3d9e	3224
JerrySzczurak	20:cf211a3b3d9e	3225	VL53L0X_Error VL53L0X::vl53l0x_get_pal_range_status( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	3226	uint8_t device_range_status,
johnAlexander	16:98ce55ddbb1a	3227	FixPoint1616_t signal_rate,
johnAlexander	16:98ce55ddbb1a	3228	uint16_t effective_spad_rtn_count,
johnAlexander	16:98ce55ddbb1a	3229	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data,
JerrySzczurak	20:cf211a3b3d9e	3230	uint8_t *p_pal_range_status )
johnAlexander	0:c523920bcc09	3231	{
johnAlexander	16:98ce55ddbb1a	3232	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	3233	uint8_t none_flag;
johnAlexander	16:98ce55ddbb1a	3234	uint8_t sigma_limitflag = 0;
johnAlexander	16:98ce55ddbb1a	3235	uint8_t signal_ref_clipflag = 0;
johnAlexander	16:98ce55ddbb1a	3236	uint8_t range_ignore_thresholdflag = 0;
johnAlexander	16:98ce55ddbb1a	3237	uint8_t sigma_limit_check_enable = 0;
johnAlexander	16:98ce55ddbb1a	3238	uint8_t signal_rate_final_range_limit_check_enable = 0;
johnAlexander	16:98ce55ddbb1a	3239	uint8_t signal_ref_clip_limit_check_enable = 0;
johnAlexander	16:98ce55ddbb1a	3240	uint8_t range_ignore_threshold_limit_check_enable = 0;
johnAlexander	16:98ce55ddbb1a	3241	FixPoint1616_t sigma_estimate;
johnAlexander	16:98ce55ddbb1a	3242	FixPoint1616_t sigma_limit_value;
johnAlexander	16:98ce55ddbb1a	3243	FixPoint1616_t signal_ref_clip_value;
johnAlexander	16:98ce55ddbb1a	3244	FixPoint1616_t range_ignore_threshold_value;
johnAlexander	16:98ce55ddbb1a	3245	FixPoint1616_t signal_rate_per_spad;
johnAlexander	16:98ce55ddbb1a	3246	uint8_t device_range_status_internal = 0;
johnAlexander	16:98ce55ddbb1a	3247	uint16_t tmp_word = 0;
johnAlexander	16:98ce55ddbb1a	3248	uint8_t temp8;
johnAlexander	16:98ce55ddbb1a	3249	uint32_t dmax_mm = 0;
johnAlexander	16:98ce55ddbb1a	3250	FixPoint1616_t last_signal_ref_mcps;
johnAlexander	15:932d8b4e52c9	3251
JerrySzczurak	20:cf211a3b3d9e	3252	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	3253
johnAlexander	15:932d8b4e52c9	3254
johnAlexander	15:932d8b4e52c9	3255	/*
johnAlexander	15:932d8b4e52c9	3256	* VL53L0X has a good ranging when the value of the
johnAlexander	15:932d8b4e52c9	3257	* DeviceRangeStatus = 11. This function will replace the value 0 with
johnAlexander	15:932d8b4e52c9	3258	* the value 11 in the DeviceRangeStatus.
johnAlexander	15:932d8b4e52c9	3259	* In addition, the SigmaEstimator is not included in the VL53L0X
johnAlexander	15:932d8b4e52c9	3260	* DeviceRangeStatus, this will be added in the PalRangeStatus.
johnAlexander	15:932d8b4e52c9	3261	*/
johnAlexander	15:932d8b4e52c9	3262
JerrySzczurak	20:cf211a3b3d9e	3263	device_range_status_internal = ( ( device_range_status & 0x78 ) >> 3 );
JerrySzczurak	20:cf211a3b3d9e	3264
JerrySzczurak	20:cf211a3b3d9e	3265	if ( device_range_status_internal == 0 \|\|
johnAlexander	16:98ce55ddbb1a	3266	device_range_status_internal == 5 \|\|
johnAlexander	16:98ce55ddbb1a	3267	device_range_status_internal == 7 \|\|
johnAlexander	16:98ce55ddbb1a	3268	device_range_status_internal == 12 \|\|
johnAlexander	16:98ce55ddbb1a	3269	device_range_status_internal == 13 \|\|
johnAlexander	16:98ce55ddbb1a	3270	device_range_status_internal == 14 \|\|
johnAlexander	16:98ce55ddbb1a	3271	device_range_status_internal == 15
johnAlexander	15:932d8b4e52c9	3272	) {
johnAlexander	16:98ce55ddbb1a	3273	none_flag = 1;
johnAlexander	15:932d8b4e52c9	3274	} else {
johnAlexander	16:98ce55ddbb1a	3275	none_flag = 0;
johnAlexander	15:932d8b4e52c9	3276	}
johnAlexander	15:932d8b4e52c9	3277
johnAlexander	15:932d8b4e52c9	3278	/*
johnAlexander	15:932d8b4e52c9	3279	* Check if Sigma limit is enabled, if yes then do comparison with limit
johnAlexander	15:932d8b4e52c9	3280	* value and put the result back into pPalRangeStatus.
johnAlexander	15:932d8b4e52c9	3281	*/
JerrySzczurak	20:cf211a3b3d9e	3282	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3283	status = vl53l0x_get_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	3284	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	3285	&sigma_limit_check_enable );
JerrySzczurak	20:cf211a3b3d9e	3286
JerrySzczurak	20:cf211a3b3d9e	3287	if ( ( sigma_limit_check_enable != 0 ) && ( status == VL53L0X_ERROR_NONE ) ) {
johnAlexander	15:932d8b4e52c9	3288	/*
johnAlexander	15:932d8b4e52c9	3289	* compute the Sigma and check with limit
johnAlexander	15:932d8b4e52c9	3290	*/
johnAlexander	16:98ce55ddbb1a	3291	status = vl53l0x_calc_sigma_estimate(
johnAlexander	16:98ce55ddbb1a	3292	dev,
johnAlexander	16:98ce55ddbb1a	3293	p_ranging_measurement_data,
johnAlexander	16:98ce55ddbb1a	3294	&sigma_estimate,
JerrySzczurak	20:cf211a3b3d9e	3295	&dmax_mm );
JerrySzczurak	20:cf211a3b3d9e	3296	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	3297	p_ranging_measurement_data->RangeDMaxMilliMeter = dmax_mm;
johnAlexander	16:98ce55ddbb1a	3298
JerrySzczurak	20:cf211a3b3d9e	3299	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	3300	status = vl53l0x_get_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	3301	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	3302	&sigma_limit_value );
JerrySzczurak	20:cf211a3b3d9e	3303
JerrySzczurak	20:cf211a3b3d9e	3304	if ( ( sigma_limit_value > 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3305	( sigma_estimate > sigma_limit_value ) )
johnAlexander	15:932d8b4e52c9	3306	/* Limit Fail */
johnAlexander	16:98ce55ddbb1a	3307	sigma_limitflag = 1;
johnAlexander	15:932d8b4e52c9	3308	}
johnAlexander	15:932d8b4e52c9	3309	}
johnAlexander	15:932d8b4e52c9	3310
johnAlexander	15:932d8b4e52c9	3311	/*
johnAlexander	15:932d8b4e52c9	3312	* Check if Signal ref clip limit is enabled, if yes then do comparison
johnAlexander	15:932d8b4e52c9	3313	* with limit value and put the result back into pPalRangeStatus.
johnAlexander	15:932d8b4e52c9	3314	*/
JerrySzczurak	20:cf211a3b3d9e	3315	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3316	status = vl53l0x_get_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	3317	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	3318	&signal_ref_clip_limit_check_enable );
JerrySzczurak	20:cf211a3b3d9e	3319
JerrySzczurak	20:cf211a3b3d9e	3320	if ( ( signal_ref_clip_limit_check_enable != 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3321	( status == VL53L0X_ERROR_NONE ) ) {
JerrySzczurak	20:cf211a3b3d9e	3322
JerrySzczurak	20:cf211a3b3d9e	3323	status = vl53l0x_get_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	3324	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	3325	&signal_ref_clip_value );
johnAlexander	15:932d8b4e52c9	3326
johnAlexander	15:932d8b4e52c9	3327	/* Read LastSignalRefMcps from device */
JerrySzczurak	20:cf211a3b3d9e	3328	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3329	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	3330
JerrySzczurak	20:cf211a3b3d9e	3331	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3332	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	3333	VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
JerrySzczurak	20:cf211a3b3d9e	3334	&tmp_word );
JerrySzczurak	20:cf211a3b3d9e	3335
JerrySzczurak	20:cf211a3b3d9e	3336	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3337	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3338
JerrySzczurak	20:cf211a3b3d9e	3339	last_signal_ref_mcps = VL53L0X_FIXPOINT97TOFIXPOINT1616( tmp_word );
JerrySzczurak	20:cf211a3b3d9e	3340	PALDevDataSet( dev, LastSignalRefMcps, last_signal_ref_mcps );
JerrySzczurak	20:cf211a3b3d9e	3341
JerrySzczurak	20:cf211a3b3d9e	3342	if ( ( signal_ref_clip_value > 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3343	( last_signal_ref_mcps > signal_ref_clip_value ) ) {
johnAlexander	15:932d8b4e52c9	3344	/* Limit Fail */
johnAlexander	16:98ce55ddbb1a	3345	signal_ref_clipflag = 1;
johnAlexander	15:932d8b4e52c9	3346	}
johnAlexander	15:932d8b4e52c9	3347	}
johnAlexander	15:932d8b4e52c9	3348
johnAlexander	15:932d8b4e52c9	3349	/*
johnAlexander	15:932d8b4e52c9	3350	* Check if Signal ref clip limit is enabled, if yes then do comparison
johnAlexander	15:932d8b4e52c9	3351	* with limit value and put the result back into pPalRangeStatus.
johnAlexander	15:932d8b4e52c9	3352	* EffectiveSpadRtnCount has a format 8.8
johnAlexander	15:932d8b4e52c9	3353	* If (Return signal rate < (1.5 x Xtalk x number of Spads)) : FAIL
johnAlexander	15:932d8b4e52c9	3354	*/
JerrySzczurak	20:cf211a3b3d9e	3355	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3356	status = vl53l0x_get_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	3357	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	3358	&range_ignore_threshold_limit_check_enable );
JerrySzczurak	20:cf211a3b3d9e	3359
JerrySzczurak	20:cf211a3b3d9e	3360	if ( ( range_ignore_threshold_limit_check_enable != 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3361	( status == VL53L0X_ERROR_NONE ) ) {
johnAlexander	15:932d8b4e52c9	3362
johnAlexander	15:932d8b4e52c9	3363	/* Compute the signal rate per spad */
JerrySzczurak	20:cf211a3b3d9e	3364	if ( effective_spad_rtn_count == 0 ) {
johnAlexander	16:98ce55ddbb1a	3365	signal_rate_per_spad = 0;
johnAlexander	15:932d8b4e52c9	3366	} else {
JerrySzczurak	20:cf211a3b3d9e	3367	signal_rate_per_spad = ( FixPoint1616_t )( ( 256 * signal_rate )
JerrySzczurak	20:cf211a3b3d9e	3368	/ effective_spad_rtn_count );
johnAlexander	15:932d8b4e52c9	3369	}
johnAlexander	15:932d8b4e52c9	3370
JerrySzczurak	20:cf211a3b3d9e	3371	status = vl53l0x_get_limit_check_value( dev,
JerrySzczurak	20:cf211a3b3d9e	3372	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	3373	&range_ignore_threshold_value );
JerrySzczurak	20:cf211a3b3d9e	3374
JerrySzczurak	20:cf211a3b3d9e	3375	if ( ( range_ignore_threshold_value > 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3376	( signal_rate_per_spad < range_ignore_threshold_value ) ) {
johnAlexander	15:932d8b4e52c9	3377	/* Limit Fail add 2^6 to range status */
johnAlexander	16:98ce55ddbb1a	3378	range_ignore_thresholdflag = 1;
johnAlexander	15:932d8b4e52c9	3379	}
johnAlexander	15:932d8b4e52c9	3380	}
johnAlexander	15:932d8b4e52c9	3381
JerrySzczurak	20:cf211a3b3d9e	3382	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	3383	if ( none_flag == 1 ) {
johnAlexander	16:98ce55ddbb1a	3384	p_pal_range_status = 255; / NONE */
JerrySzczurak	20:cf211a3b3d9e	3385	} else if ( device_range_status_internal == 1 \|\|
JerrySzczurak	20:cf211a3b3d9e	3386	device_range_status_internal == 2 \|\|
JerrySzczurak	20:cf211a3b3d9e	3387	device_range_status_internal == 3 ) {
johnAlexander	16:98ce55ddbb1a	3388	p_pal_range_status = 5; / HW fail */
JerrySzczurak	20:cf211a3b3d9e	3389	} else if ( device_range_status_internal == 6 \|\|
JerrySzczurak	20:cf211a3b3d9e	3390	device_range_status_internal == 9 ) {
johnAlexander	16:98ce55ddbb1a	3391	p_pal_range_status = 4; / Phase fail */
JerrySzczurak	20:cf211a3b3d9e	3392	} else if ( device_range_status_internal == 8 \|\|
JerrySzczurak	20:cf211a3b3d9e	3393	device_range_status_internal == 10 \|\|
JerrySzczurak	20:cf211a3b3d9e	3394	signal_ref_clipflag == 1 ) {
johnAlexander	16:98ce55ddbb1a	3395	p_pal_range_status = 3; / Min range */
JerrySzczurak	20:cf211a3b3d9e	3396	} else if ( device_range_status_internal == 4 \|\|
JerrySzczurak	20:cf211a3b3d9e	3397	range_ignore_thresholdflag == 1 ) {
johnAlexander	16:98ce55ddbb1a	3398	p_pal_range_status = 2; / Signal Fail */
JerrySzczurak	20:cf211a3b3d9e	3399	} else if ( sigma_limitflag == 1 ) {
johnAlexander	16:98ce55ddbb1a	3400	p_pal_range_status = 1; / Sigma Fail */
johnAlexander	15:932d8b4e52c9	3401	} else {
johnAlexander	16:98ce55ddbb1a	3402	p_pal_range_status = 0; / Range Valid */
johnAlexander	15:932d8b4e52c9	3403	}
johnAlexander	15:932d8b4e52c9	3404	}
johnAlexander	15:932d8b4e52c9	3405
johnAlexander	15:932d8b4e52c9	3406	/* DMAX only relevant during range error */
JerrySzczurak	20:cf211a3b3d9e	3407	if ( *p_pal_range_status == 0 )
johnAlexander	16:98ce55ddbb1a	3408	p_ranging_measurement_data->RangeDMaxMilliMeter = 0;
johnAlexander	15:932d8b4e52c9	3409
johnAlexander	15:932d8b4e52c9	3410	/* fill the Limit Check Status */
johnAlexander	15:932d8b4e52c9	3411
JerrySzczurak	20:cf211a3b3d9e	3412	status = vl53l0x_get_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	3413	VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	3414	&signal_rate_final_range_limit_check_enable );
JerrySzczurak	20:cf211a3b3d9e	3415
JerrySzczurak	20:cf211a3b3d9e	3416	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	3417	if ( ( sigma_limit_check_enable == 0 ) \|\| ( sigma_limitflag == 1 ) )
johnAlexander	16:98ce55ddbb1a	3418	temp8 = 1;
johnAlexander	15:932d8b4e52c9	3419	else
johnAlexander	16:98ce55ddbb1a	3420	temp8 = 0;
JerrySzczurak	20:cf211a3b3d9e	3421	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksStatus,
JerrySzczurak	20:cf211a3b3d9e	3422	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, temp8 );
JerrySzczurak	20:cf211a3b3d9e	3423
JerrySzczurak	20:cf211a3b3d9e	3424	if ( ( device_range_status_internal == 4 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	3425	( signal_rate_final_range_limit_check_enable == 0 ) )
johnAlexander	16:98ce55ddbb1a	3426	temp8 = 1;
johnAlexander	15:932d8b4e52c9	3427	else
johnAlexander	16:98ce55ddbb1a	3428	temp8 = 0;
JerrySzczurak	20:cf211a3b3d9e	3429	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksStatus,
JerrySzczurak	20:cf211a3b3d9e	3430	VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	3431	temp8 );
JerrySzczurak	20:cf211a3b3d9e	3432
JerrySzczurak	20:cf211a3b3d9e	3433	if ( ( signal_ref_clip_limit_check_enable == 0 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	3434	( signal_ref_clipflag == 1 ) )
johnAlexander	16:98ce55ddbb1a	3435	temp8 = 1;
johnAlexander	15:932d8b4e52c9	3436	else
johnAlexander	16:98ce55ddbb1a	3437	temp8 = 0;
johnAlexander	16:98ce55ddbb1a	3438
JerrySzczurak	20:cf211a3b3d9e	3439	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksStatus,
JerrySzczurak	20:cf211a3b3d9e	3440	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP, temp8 );
JerrySzczurak	20:cf211a3b3d9e	3441
JerrySzczurak	20:cf211a3b3d9e	3442	if ( ( range_ignore_threshold_limit_check_enable == 0 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	3443	( range_ignore_thresholdflag == 1 ) )
johnAlexander	16:98ce55ddbb1a	3444	temp8 = 1;
johnAlexander	15:932d8b4e52c9	3445	else
johnAlexander	16:98ce55ddbb1a	3446	temp8 = 0;
johnAlexander	16:98ce55ddbb1a	3447
JerrySzczurak	20:cf211a3b3d9e	3448	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksStatus,
JerrySzczurak	20:cf211a3b3d9e	3449	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	3450	temp8 );
JerrySzczurak	20:cf211a3b3d9e	3451	}
JerrySzczurak	20:cf211a3b3d9e	3452
JerrySzczurak	20:cf211a3b3d9e	3453	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	3454	return status;
JerrySzczurak	20:cf211a3b3d9e	3455
JerrySzczurak	20:cf211a3b3d9e	3456	}
JerrySzczurak	20:cf211a3b3d9e	3457
JerrySzczurak	20:cf211a3b3d9e	3458	VL53L0X_Error VL53L0X::vl53l0x_get_ranging_measurement_data( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	3459	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data )
johnAlexander	0:c523920bcc09	3460	{
johnAlexander	16:98ce55ddbb1a	3461	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	3462	uint8_t device_range_status;
johnAlexander	16:98ce55ddbb1a	3463	uint8_t range_fractional_enable;
johnAlexander	16:98ce55ddbb1a	3464	uint8_t pal_range_status;
johnAlexander	16:98ce55ddbb1a	3465	uint8_t x_talk_compensation_enable;
johnAlexander	16:98ce55ddbb1a	3466	uint16_t ambient_rate;
johnAlexander	16:98ce55ddbb1a	3467	FixPoint1616_t signal_rate;
johnAlexander	16:98ce55ddbb1a	3468	uint16_t x_talk_compensation_rate_mega_cps;
johnAlexander	16:98ce55ddbb1a	3469	uint16_t effective_spad_rtn_count;
johnAlexander	15:932d8b4e52c9	3470	uint16_t tmpuint16;
johnAlexander	16:98ce55ddbb1a	3471	uint16_t xtalk_range_milli_meter;
johnAlexander	16:98ce55ddbb1a	3472	uint16_t linearity_corrective_gain;
johnAlexander	15:932d8b4e52c9	3473	uint8_t localBuffer[12];
johnAlexander	16:98ce55ddbb1a	3474	VL53L0X_RangingMeasurementData_t last_range_data_buffer;
johnAlexander	15:932d8b4e52c9	3475
JerrySzczurak	20:cf211a3b3d9e	3476	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	3477
johnAlexander	15:932d8b4e52c9	3478	/*
johnAlexander	15:932d8b4e52c9	3479	* use multi read even if some registers are not useful, result will
johnAlexander	15:932d8b4e52c9	3480	* be more efficient
johnAlexander	15:932d8b4e52c9	3481	* start reading at 0x14 dec20
johnAlexander	15:932d8b4e52c9	3482	* end reading at 0x21 dec33 total 14 bytes to read
johnAlexander	15:932d8b4e52c9	3483	*/
JerrySzczurak	20:cf211a3b3d9e	3484	status = vl53l0x_read_multi( dev, 0x14, localBuffer, 12 );
JerrySzczurak	20:cf211a3b3d9e	3485
JerrySzczurak	20:cf211a3b3d9e	3486	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	3487
johnAlexander	16:98ce55ddbb1a	3488	p_ranging_measurement_data->ZoneId = 0; /* Only one zone */
johnAlexander	16:98ce55ddbb1a	3489	p_ranging_measurement_data->TimeStamp = 0; /* Not Implemented */
johnAlexander	15:932d8b4e52c9	3490
JerrySzczurak	20:cf211a3b3d9e	3491	tmpuint16 = VL53L0X_MAKEUINT16( localBuffer[11], localBuffer[10] );
johnAlexander	15:932d8b4e52c9	3492	/* cut1.1 if SYSTEM__RANGE_CONFIG if 1 range is 2bits fractional
johnAlexander	15:932d8b4e52c9	3493	*(format 11.2) else no fractional
johnAlexander	15:932d8b4e52c9	3494	*/
johnAlexander	15:932d8b4e52c9	3495
johnAlexander	16:98ce55ddbb1a	3496	p_ranging_measurement_data->MeasurementTimeUsec = 0;
johnAlexander	16:98ce55ddbb1a	3497
johnAlexander	16:98ce55ddbb1a	3498	signal_rate = VL53L0X_FIXPOINT97TOFIXPOINT1616(
JerrySzczurak	20:cf211a3b3d9e	3499	VL53L0X_MAKEUINT16( localBuffer[7], localBuffer[6] ) );
johnAlexander	15:932d8b4e52c9	3500	/* peak_signal_count_rate_rtn_mcps */
johnAlexander	16:98ce55ddbb1a	3501	p_ranging_measurement_data->SignalRateRtnMegaCps = signal_rate;
johnAlexander	16:98ce55ddbb1a	3502
JerrySzczurak	20:cf211a3b3d9e	3503	ambient_rate = VL53L0X_MAKEUINT16( localBuffer[9], localBuffer[8] );
johnAlexander	16:98ce55ddbb1a	3504	p_ranging_measurement_data->AmbientRateRtnMegaCps =
JerrySzczurak	20:cf211a3b3d9e	3505	VL53L0X_FIXPOINT97TOFIXPOINT1616( ambient_rate );
JerrySzczurak	20:cf211a3b3d9e	3506
JerrySzczurak	20:cf211a3b3d9e	3507	effective_spad_rtn_count = VL53L0X_MAKEUINT16( localBuffer[3],
JerrySzczurak	20:cf211a3b3d9e	3508	localBuffer[2] );
johnAlexander	15:932d8b4e52c9	3509	/* EffectiveSpadRtnCount is 8.8 format */
johnAlexander	16:98ce55ddbb1a	3510	p_ranging_measurement_data->EffectiveSpadRtnCount =
johnAlexander	16:98ce55ddbb1a	3511	effective_spad_rtn_count;
johnAlexander	16:98ce55ddbb1a	3512
johnAlexander	16:98ce55ddbb1a	3513	device_range_status = localBuffer[0];
johnAlexander	15:932d8b4e52c9	3514
johnAlexander	15:932d8b4e52c9	3515	/* Get Linearity Corrective Gain */
JerrySzczurak	20:cf211a3b3d9e	3516	linearity_corrective_gain = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	3517	LinearityCorrectiveGain );
johnAlexander	15:932d8b4e52c9	3518
johnAlexander	15:932d8b4e52c9	3519	/* Get ranging configuration */
JerrySzczurak	20:cf211a3b3d9e	3520	range_fractional_enable = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	3521	RangeFractionalEnable );
JerrySzczurak	20:cf211a3b3d9e	3522
JerrySzczurak	20:cf211a3b3d9e	3523	if ( linearity_corrective_gain != 1000 ) {
JerrySzczurak	20:cf211a3b3d9e	3524
JerrySzczurak	20:cf211a3b3d9e	3525	tmpuint16 = ( uint16_t )( ( linearity_corrective_gain
JerrySzczurak	20:cf211a3b3d9e	3526	* tmpuint16 + 500 ) / 1000 );
johnAlexander	15:932d8b4e52c9	3527
johnAlexander	15:932d8b4e52c9	3528	/* Implement Xtalk */
JerrySzczurak	20:cf211a3b3d9e	3529	VL53L0X_GETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	3530	XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	3531	x_talk_compensation_rate_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	3532	VL53L0X_GETPARAMETERFIELD( dev, XTalkCompensationEnable,
JerrySzczurak	20:cf211a3b3d9e	3533	x_talk_compensation_enable );
JerrySzczurak	20:cf211a3b3d9e	3534
JerrySzczurak	20:cf211a3b3d9e	3535	if ( x_talk_compensation_enable ) {
JerrySzczurak	20:cf211a3b3d9e	3536
JerrySzczurak	20:cf211a3b3d9e	3537	if ( ( signal_rate
JerrySzczurak	20:cf211a3b3d9e	3538	- ( ( x_talk_compensation_rate_mega_cps
JerrySzczurak	20:cf211a3b3d9e	3539	* effective_spad_rtn_count ) >> 8 ) )
JerrySzczurak	20:cf211a3b3d9e	3540	<= 0 ) {
JerrySzczurak	20:cf211a3b3d9e	3541	if ( range_fractional_enable )
johnAlexander	16:98ce55ddbb1a	3542	xtalk_range_milli_meter = 8888;
johnAlexander	15:932d8b4e52c9	3543	else
johnAlexander	16:98ce55ddbb1a	3544	xtalk_range_milli_meter = 8888
johnAlexander	16:98ce55ddbb1a	3545	<< 2;
johnAlexander	15:932d8b4e52c9	3546	} else {
johnAlexander	16:98ce55ddbb1a	3547	xtalk_range_milli_meter =
JerrySzczurak	20:cf211a3b3d9e	3548	( tmpuint16 * signal_rate )
JerrySzczurak	20:cf211a3b3d9e	3549	/ ( signal_rate
JerrySzczurak	20:cf211a3b3d9e	3550	- ( ( x_talk_compensation_rate_mega_cps
JerrySzczurak	20:cf211a3b3d9e	3551	* effective_spad_rtn_count )
JerrySzczurak	20:cf211a3b3d9e	3552	>> 8 ) );
johnAlexander	15:932d8b4e52c9	3553	}
johnAlexander	15:932d8b4e52c9	3554
johnAlexander	16:98ce55ddbb1a	3555	tmpuint16 = xtalk_range_milli_meter;
johnAlexander	15:932d8b4e52c9	3556	}
johnAlexander	15:932d8b4e52c9	3557
johnAlexander	15:932d8b4e52c9	3558	}
johnAlexander	15:932d8b4e52c9	3559
JerrySzczurak	20:cf211a3b3d9e	3560	if ( range_fractional_enable ) {
johnAlexander	16:98ce55ddbb1a	3561	p_ranging_measurement_data->RangeMilliMeter =
JerrySzczurak	20:cf211a3b3d9e	3562	( uint16_t )( ( tmpuint16 ) >> 2 );
johnAlexander	16:98ce55ddbb1a	3563	p_ranging_measurement_data->RangeFractionalPart =
JerrySzczurak	20:cf211a3b3d9e	3564	( uint8_t )( ( tmpuint16 & 0x03 ) << 6 );
johnAlexander	15:932d8b4e52c9	3565	} else {
johnAlexander	16:98ce55ddbb1a	3566	p_ranging_measurement_data->RangeMilliMeter = tmpuint16;
johnAlexander	16:98ce55ddbb1a	3567	p_ranging_measurement_data->RangeFractionalPart = 0;
johnAlexander	15:932d8b4e52c9	3568	}
johnAlexander	15:932d8b4e52c9	3569
johnAlexander	15:932d8b4e52c9	3570	/*
johnAlexander	15:932d8b4e52c9	3571	* For a standard definition of RangeStatus, this should
johnAlexander	15:932d8b4e52c9	3572	* return 0 in case of good result after a ranging
johnAlexander	15:932d8b4e52c9	3573	* The range status depends on the device so call a device
johnAlexander	15:932d8b4e52c9	3574	* specific function to obtain the right Status.
johnAlexander	15:932d8b4e52c9	3575	*/
JerrySzczurak	20:cf211a3b3d9e	3576	status \|= vl53l0x_get_pal_range_status( dev, device_range_status,
JerrySzczurak	20:cf211a3b3d9e	3577	signal_rate, effective_spad_rtn_count,
JerrySzczurak	20:cf211a3b3d9e	3578	p_ranging_measurement_data, &pal_range_status );
JerrySzczurak	20:cf211a3b3d9e	3579
JerrySzczurak	20:cf211a3b3d9e	3580	if ( status == VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	3581	p_ranging_measurement_data->RangeStatus = pal_range_status;
johnAlexander	15:932d8b4e52c9	3582
johnAlexander	15:932d8b4e52c9	3583	}
johnAlexander	15:932d8b4e52c9	3584
JerrySzczurak	20:cf211a3b3d9e	3585	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	3586	/* Copy last read data into Dev buffer */
JerrySzczurak	20:cf211a3b3d9e	3587	last_range_data_buffer = PALDevDataGet( dev, LastRangeMeasure );
johnAlexander	16:98ce55ddbb1a	3588
johnAlexander	16:98ce55ddbb1a	3589	last_range_data_buffer.RangeMilliMeter =
johnAlexander	16:98ce55ddbb1a	3590	p_ranging_measurement_data->RangeMilliMeter;
johnAlexander	16:98ce55ddbb1a	3591	last_range_data_buffer.RangeFractionalPart =
johnAlexander	16:98ce55ddbb1a	3592	p_ranging_measurement_data->RangeFractionalPart;
johnAlexander	16:98ce55ddbb1a	3593	last_range_data_buffer.RangeDMaxMilliMeter =
johnAlexander	16:98ce55ddbb1a	3594	p_ranging_measurement_data->RangeDMaxMilliMeter;
johnAlexander	16:98ce55ddbb1a	3595	last_range_data_buffer.MeasurementTimeUsec =
johnAlexander	16:98ce55ddbb1a	3596	p_ranging_measurement_data->MeasurementTimeUsec;
johnAlexander	16:98ce55ddbb1a	3597	last_range_data_buffer.SignalRateRtnMegaCps =
johnAlexander	16:98ce55ddbb1a	3598	p_ranging_measurement_data->SignalRateRtnMegaCps;
johnAlexander	16:98ce55ddbb1a	3599	last_range_data_buffer.AmbientRateRtnMegaCps =
johnAlexander	16:98ce55ddbb1a	3600	p_ranging_measurement_data->AmbientRateRtnMegaCps;
johnAlexander	16:98ce55ddbb1a	3601	last_range_data_buffer.EffectiveSpadRtnCount =
johnAlexander	16:98ce55ddbb1a	3602	p_ranging_measurement_data->EffectiveSpadRtnCount;
johnAlexander	16:98ce55ddbb1a	3603	last_range_data_buffer.RangeStatus =
johnAlexander	16:98ce55ddbb1a	3604	p_ranging_measurement_data->RangeStatus;
johnAlexander	16:98ce55ddbb1a	3605
JerrySzczurak	20:cf211a3b3d9e	3606	PALDevDataSet( dev, LastRangeMeasure, last_range_data_buffer );
JerrySzczurak	20:cf211a3b3d9e	3607	}
JerrySzczurak	20:cf211a3b3d9e	3608
JerrySzczurak	20:cf211a3b3d9e	3609	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	3610	return status;
JerrySzczurak	20:cf211a3b3d9e	3611	}
JerrySzczurak	20:cf211a3b3d9e	3612
JerrySzczurak	20:cf211a3b3d9e	3613	VL53L0X_Error VL53L0X::vl53l0x_perform_single_ranging_measurement( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	3614	VL53L0X_RangingMeasurementData_t *p_ranging_measurement_data )
johnAlexander	0:c523920bcc09	3615	{
johnAlexander	16:98ce55ddbb1a	3616	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	3617
JerrySzczurak	20:cf211a3b3d9e	3618	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	3619
johnAlexander	15:932d8b4e52c9	3620	/* This function will do a complete single ranging
johnAlexander	15:932d8b4e52c9	3621	* Here we fix the mode! */
JerrySzczurak	20:cf211a3b3d9e	3622	status = vl53l0x_set_device_mode( dev, VL53L0X_DEVICEMODE_SINGLE_RANGING );
JerrySzczurak	20:cf211a3b3d9e	3623
JerrySzczurak	20:cf211a3b3d9e	3624	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3625	status = vl53l0x_perform_single_measurement( dev );
JerrySzczurak	20:cf211a3b3d9e	3626
JerrySzczurak	20:cf211a3b3d9e	3627
JerrySzczurak	20:cf211a3b3d9e	3628	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3629	status = vl53l0x_get_ranging_measurement_data( dev,
JerrySzczurak	20:cf211a3b3d9e	3630	p_ranging_measurement_data );
JerrySzczurak	20:cf211a3b3d9e	3631
JerrySzczurak	20:cf211a3b3d9e	3632
JerrySzczurak	20:cf211a3b3d9e	3633	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3634	status = vl53l0x_clear_interrupt_mask( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	3635
JerrySzczurak	20:cf211a3b3d9e	3636
JerrySzczurak	20:cf211a3b3d9e	3637	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	3638	return status;
JerrySzczurak	20:cf211a3b3d9e	3639	}
JerrySzczurak	20:cf211a3b3d9e	3640
JerrySzczurak	20:cf211a3b3d9e	3641	VL53L0X_Error VL53L0X::perform_ref_signal_measurement( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	3642	uint16_t *p_ref_signal_rate )
johnAlexander	0:c523920bcc09	3643	{
johnAlexander	15:932d8b4e52c9	3644	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	3645	VL53L0X_RangingMeasurementData_t ranging_measurement_data;
johnAlexander	16:98ce55ddbb1a	3646
johnAlexander	16:98ce55ddbb1a	3647	uint8_t sequence_config = 0;
johnAlexander	15:932d8b4e52c9	3648
johnAlexander	15:932d8b4e52c9	3649	/* store the value of the sequence config,
johnAlexander	15:932d8b4e52c9	3650	* this will be reset before the end of the function
johnAlexander	15:932d8b4e52c9	3651	*/
johnAlexander	15:932d8b4e52c9	3652
JerrySzczurak	20:cf211a3b3d9e	3653	sequence_config = PALDevDataGet( dev, SequenceConfig );
johnAlexander	15:932d8b4e52c9	3654
johnAlexander	15:932d8b4e52c9	3655	/*
johnAlexander	15:932d8b4e52c9	3656	* This function performs a reference signal rate measurement.
johnAlexander	15:932d8b4e52c9	3657	*/
JerrySzczurak	20:cf211a3b3d9e	3658	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3659	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3660	VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, 0xC0 );
JerrySzczurak	20:cf211a3b3d9e	3661
JerrySzczurak	20:cf211a3b3d9e	3662	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3663	status = vl53l0x_perform_single_ranging_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	3664	&ranging_measurement_data );
JerrySzczurak	20:cf211a3b3d9e	3665
JerrySzczurak	20:cf211a3b3d9e	3666	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3667	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	3668
JerrySzczurak	20:cf211a3b3d9e	3669	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3670	status = vl53l0x_read_word( dev,
JerrySzczurak	20:cf211a3b3d9e	3671	VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF,
JerrySzczurak	20:cf211a3b3d9e	3672	p_ref_signal_rate );
JerrySzczurak	20:cf211a3b3d9e	3673
JerrySzczurak	20:cf211a3b3d9e	3674	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3675	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3676
JerrySzczurak	20:cf211a3b3d9e	3677	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	3678	/* restore the previous Sequence Config */
JerrySzczurak	20:cf211a3b3d9e	3679	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	3680	sequence_config );
JerrySzczurak	20:cf211a3b3d9e	3681	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3682	PALDevDataSet( dev, SequenceConfig, sequence_config );
JerrySzczurak	20:cf211a3b3d9e	3683	}
JerrySzczurak	20:cf211a3b3d9e	3684
JerrySzczurak	20:cf211a3b3d9e	3685	return status;
JerrySzczurak	20:cf211a3b3d9e	3686	}
JerrySzczurak	20:cf211a3b3d9e	3687
JerrySzczurak	20:cf211a3b3d9e	3688	VL53L0X_Error VL53L0X::wrapped_vl53l0x_perform_ref_spad_management( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	3689	uint32_t *ref_spad_count,
JerrySzczurak	20:cf211a3b3d9e	3690	uint8_t *is_aperture_spads )
johnAlexander	0:c523920bcc09	3691	{
johnAlexander	16:98ce55ddbb1a	3692	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	3693	uint8_t last_spad_array[6];
johnAlexander	16:98ce55ddbb1a	3694	uint8_t start_select = 0xB4;
johnAlexander	16:98ce55ddbb1a	3695	uint32_t minimum_spad_count = 3;
johnAlexander	16:98ce55ddbb1a	3696	uint32_t max_spad_count = 44;
johnAlexander	16:98ce55ddbb1a	3697	uint32_t current_spad_index = 0;
johnAlexander	16:98ce55ddbb1a	3698	uint32_t last_spad_index = 0;
johnAlexander	16:98ce55ddbb1a	3699	int32_t next_good_spad = 0;
johnAlexander	16:98ce55ddbb1a	3700	uint16_t target_ref_rate = 0x0A00; /* 20 MCPS in 9:7 format */
johnAlexander	16:98ce55ddbb1a	3701	uint16_t peak_signal_rate_ref;
johnAlexander	16:98ce55ddbb1a	3702	uint32_t need_apt_spads = 0;
johnAlexander	15:932d8b4e52c9	3703	uint32_t index = 0;
johnAlexander	16:98ce55ddbb1a	3704	uint32_t spad_array_size = 6;
johnAlexander	16:98ce55ddbb1a	3705	uint32_t signal_rate_diff = 0;
johnAlexander	16:98ce55ddbb1a	3706	uint32_t last_signal_rate_diff = 0;
johnAlexander	15:932d8b4e52c9	3707	uint8_t complete = 0;
johnAlexander	16:98ce55ddbb1a	3708	uint8_t vhv_settings = 0;
johnAlexander	16:98ce55ddbb1a	3709	uint8_t phase_cal = 0;
johnAlexander	16:98ce55ddbb1a	3710	uint32_t ref_spad_count_int = 0;
johnAlexander	16:98ce55ddbb1a	3711	uint8_t is_aperture_spads_int = 0;
johnAlexander	15:932d8b4e52c9	3712
johnAlexander	15:932d8b4e52c9	3713	/*
johnAlexander	15:932d8b4e52c9	3714	* The reference SPAD initialization procedure determines the minimum
johnAlexander	15:932d8b4e52c9	3715	* amount of reference spads to be enables to achieve a target reference
johnAlexander	15:932d8b4e52c9	3716	* signal rate and should be performed once during initialization.
johnAlexander	15:932d8b4e52c9	3717	*
johnAlexander	15:932d8b4e52c9	3718	* Either aperture or non-aperture spads are applied but never both.
johnAlexander	15:932d8b4e52c9	3719	* Firstly non-aperture spads are set, begining with 5 spads, and
johnAlexander	15:932d8b4e52c9	3720	* increased one spad at a time until the closest measurement to the
johnAlexander	15:932d8b4e52c9	3721	* target rate is achieved.
johnAlexander	15:932d8b4e52c9	3722	*
johnAlexander	15:932d8b4e52c9	3723	* If the target rate is exceeded when 5 non-aperture spads are enabled,
johnAlexander	15:932d8b4e52c9	3724	* initialization is performed instead with aperture spads.
johnAlexander	15:932d8b4e52c9	3725	*
johnAlexander	15:932d8b4e52c9	3726	* When setting spads, a 'Good Spad Map' is applied.
johnAlexander	15:932d8b4e52c9	3727	*
johnAlexander	15:932d8b4e52c9	3728	* This procedure operates within a SPAD window of interest of a maximum
johnAlexander	15:932d8b4e52c9	3729	* 44 spads.
johnAlexander	15:932d8b4e52c9	3730	* The start point is currently fixed to 180, which lies towards the end
johnAlexander	15:932d8b4e52c9	3731	* of the non-aperture quadrant and runs in to the adjacent aperture
johnAlexander	15:932d8b4e52c9	3732	* quadrant.
johnAlexander	15:932d8b4e52c9	3733	*/
johnAlexander	15:932d8b4e52c9	3734
johnAlexander	15:932d8b4e52c9	3735
JerrySzczurak	20:cf211a3b3d9e	3736	target_ref_rate = PALDevDataGet( dev, targetRefRate );
johnAlexander	15:932d8b4e52c9	3737
johnAlexander	15:932d8b4e52c9	3738	/*
johnAlexander	15:932d8b4e52c9	3739	* Initialize Spad arrays.
johnAlexander	15:932d8b4e52c9	3740	* Currently the good spad map is initialised to 'All good'.
johnAlexander	15:932d8b4e52c9	3741	* This is a short term implementation. The good spad map will be
johnAlexander	15:932d8b4e52c9	3742	* provided as an input.
johnAlexander	15:932d8b4e52c9	3743	* Note that there are 6 bytes. Only the first 44 bits will be used to
johnAlexander	15:932d8b4e52c9	3744	* represent spads.
johnAlexander	15:932d8b4e52c9	3745	*/
JerrySzczurak	20:cf211a3b3d9e	3746	for ( index = 0; index < spad_array_size; index++ )
johnAlexander	16:98ce55ddbb1a	3747	dev->Data.SpadData.RefSpadEnables[index] = 0;
johnAlexander	16:98ce55ddbb1a	3748
johnAlexander	16:98ce55ddbb1a	3749
JerrySzczurak	20:cf211a3b3d9e	3750	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	3751
JerrySzczurak	20:cf211a3b3d9e	3752	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3753	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3754	VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3755
JerrySzczurak	20:cf211a3b3d9e	3756	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3757	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3758	VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C );
JerrySzczurak	20:cf211a3b3d9e	3759
JerrySzczurak	20:cf211a3b3d9e	3760	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3761	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3762
JerrySzczurak	20:cf211a3b3d9e	3763	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3764	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3765	VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
JerrySzczurak	20:cf211a3b3d9e	3766	start_select );
JerrySzczurak	20:cf211a3b3d9e	3767
JerrySzczurak	20:cf211a3b3d9e	3768
JerrySzczurak	20:cf211a3b3d9e	3769	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3770	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3771	VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE, 0 );
johnAlexander	15:932d8b4e52c9	3772
johnAlexander	15:932d8b4e52c9	3773	/* Perform ref calibration */
JerrySzczurak	20:cf211a3b3d9e	3774	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3775	status = vl53l0x_perform_ref_calibration( dev, &vhv_settings,
JerrySzczurak	20:cf211a3b3d9e	3776	&phase_cal, 0 );
JerrySzczurak	20:cf211a3b3d9e	3777
JerrySzczurak	20:cf211a3b3d9e	3778	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	3779	/* Enable Minimum NON-APERTURE Spads */
johnAlexander	16:98ce55ddbb1a	3780	current_spad_index = 0;
johnAlexander	16:98ce55ddbb1a	3781	last_spad_index = current_spad_index;
johnAlexander	16:98ce55ddbb1a	3782	need_apt_spads = 0;
JerrySzczurak	20:cf211a3b3d9e	3783	status = enable_ref_spads( dev,
JerrySzczurak	20:cf211a3b3d9e	3784	need_apt_spads,
JerrySzczurak	20:cf211a3b3d9e	3785	dev->Data.SpadData.RefGoodSpadMap,
JerrySzczurak	20:cf211a3b3d9e	3786	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3787	spad_array_size,
JerrySzczurak	20:cf211a3b3d9e	3788	start_select,
JerrySzczurak	20:cf211a3b3d9e	3789	current_spad_index,
JerrySzczurak	20:cf211a3b3d9e	3790	minimum_spad_count,
JerrySzczurak	20:cf211a3b3d9e	3791	&last_spad_index );
JerrySzczurak	20:cf211a3b3d9e	3792	}
JerrySzczurak	20:cf211a3b3d9e	3793
JerrySzczurak	20:cf211a3b3d9e	3794	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	3795	current_spad_index = last_spad_index;
johnAlexander	16:98ce55ddbb1a	3796
JerrySzczurak	20:cf211a3b3d9e	3797	status = perform_ref_signal_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	3798	&peak_signal_rate_ref );
JerrySzczurak	20:cf211a3b3d9e	3799	if ( ( status == VL53L0X_ERROR_NONE ) &&
JerrySzczurak	20:cf211a3b3d9e	3800	( peak_signal_rate_ref > target_ref_rate ) ) {
johnAlexander	15:932d8b4e52c9	3801	/* Signal rate measurement too high,
johnAlexander	15:932d8b4e52c9	3802	* switch to APERTURE SPADs */
johnAlexander	15:932d8b4e52c9	3803
JerrySzczurak	20:cf211a3b3d9e	3804	for ( index = 0; index < spad_array_size; index++ )
johnAlexander	16:98ce55ddbb1a	3805	dev->Data.SpadData.RefSpadEnables[index] = 0;
johnAlexander	15:932d8b4e52c9	3806
johnAlexander	15:932d8b4e52c9	3807
johnAlexander	15:932d8b4e52c9	3808	/* Increment to the first APERTURE spad */
JerrySzczurak	20:cf211a3b3d9e	3809	while ( ( is_aperture( start_select + current_spad_index )
JerrySzczurak	20:cf211a3b3d9e	3810	== 0 ) && ( current_spad_index < max_spad_count ) ) {
johnAlexander	16:98ce55ddbb1a	3811	current_spad_index++;
johnAlexander	15:932d8b4e52c9	3812	}
johnAlexander	15:932d8b4e52c9	3813
johnAlexander	16:98ce55ddbb1a	3814	need_apt_spads = 1;
johnAlexander	16:98ce55ddbb1a	3815
JerrySzczurak	20:cf211a3b3d9e	3816	status = enable_ref_spads( dev,
JerrySzczurak	20:cf211a3b3d9e	3817	need_apt_spads,
JerrySzczurak	20:cf211a3b3d9e	3818	dev->Data.SpadData.RefGoodSpadMap,
JerrySzczurak	20:cf211a3b3d9e	3819	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3820	spad_array_size,
JerrySzczurak	20:cf211a3b3d9e	3821	start_select,
JerrySzczurak	20:cf211a3b3d9e	3822	current_spad_index,
JerrySzczurak	20:cf211a3b3d9e	3823	minimum_spad_count,
JerrySzczurak	20:cf211a3b3d9e	3824	&last_spad_index );
JerrySzczurak	20:cf211a3b3d9e	3825
JerrySzczurak	20:cf211a3b3d9e	3826	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	3827	current_spad_index = last_spad_index;
JerrySzczurak	20:cf211a3b3d9e	3828	status = perform_ref_signal_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	3829	&peak_signal_rate_ref );
JerrySzczurak	20:cf211a3b3d9e	3830
JerrySzczurak	20:cf211a3b3d9e	3831	if ( ( status == VL53L0X_ERROR_NONE ) &&
JerrySzczurak	20:cf211a3b3d9e	3832	( peak_signal_rate_ref > target_ref_rate ) ) {
johnAlexander	15:932d8b4e52c9	3833	/* Signal rate still too high after
johnAlexander	15:932d8b4e52c9	3834	* setting the minimum number of
johnAlexander	15:932d8b4e52c9	3835	* APERTURE spads. Can do no more
johnAlexander	15:932d8b4e52c9	3836	* therefore set the min number of
johnAlexander	15:932d8b4e52c9	3837	* aperture spads as the result.
johnAlexander	15:932d8b4e52c9	3838	*/
johnAlexander	16:98ce55ddbb1a	3839	is_aperture_spads_int = 1;
johnAlexander	16:98ce55ddbb1a	3840	ref_spad_count_int = minimum_spad_count;
johnAlexander	15:932d8b4e52c9	3841	}
johnAlexander	15:932d8b4e52c9	3842	}
johnAlexander	15:932d8b4e52c9	3843	} else {
johnAlexander	16:98ce55ddbb1a	3844	need_apt_spads = 0;
johnAlexander	15:932d8b4e52c9	3845	}
johnAlexander	15:932d8b4e52c9	3846	}
johnAlexander	15:932d8b4e52c9	3847
JerrySzczurak	20:cf211a3b3d9e	3848	if ( ( status == VL53L0X_ERROR_NONE ) &&
JerrySzczurak	20:cf211a3b3d9e	3849	( peak_signal_rate_ref < target_ref_rate ) ) {
johnAlexander	15:932d8b4e52c9	3850	/* At this point, the minimum number of either aperture
johnAlexander	15:932d8b4e52c9	3851	* or non-aperture spads have been set. Proceed to add
johnAlexander	15:932d8b4e52c9	3852	* spads and perform measurements until the target
johnAlexander	15:932d8b4e52c9	3853	* reference is reached.
johnAlexander	15:932d8b4e52c9	3854	*/
johnAlexander	16:98ce55ddbb1a	3855	is_aperture_spads_int = need_apt_spads;
johnAlexander	16:98ce55ddbb1a	3856	ref_spad_count_int = minimum_spad_count;
johnAlexander	16:98ce55ddbb1a	3857
JerrySzczurak	20:cf211a3b3d9e	3858	memcpy( last_spad_array, dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3859	spad_array_size );
JerrySzczurak	20:cf211a3b3d9e	3860	last_signal_rate_diff = abs( peak_signal_rate_ref -
JerrySzczurak	20:cf211a3b3d9e	3861	target_ref_rate );
johnAlexander	15:932d8b4e52c9	3862	complete = 0;
johnAlexander	15:932d8b4e52c9	3863
JerrySzczurak	20:cf211a3b3d9e	3864	while ( !complete ) {
johnAlexander	15:932d8b4e52c9	3865	get_next_good_spad(
johnAlexander	16:98ce55ddbb1a	3866	dev->Data.SpadData.RefGoodSpadMap,
johnAlexander	16:98ce55ddbb1a	3867	spad_array_size, current_spad_index,
JerrySzczurak	20:cf211a3b3d9e	3868	&next_good_spad );
JerrySzczurak	20:cf211a3b3d9e	3869
JerrySzczurak	20:cf211a3b3d9e	3870	if ( next_good_spad == -1 ) {
johnAlexander	16:98ce55ddbb1a	3871	status = VL53L0X_ERROR_REF_SPAD_INIT;
johnAlexander	15:932d8b4e52c9	3872	break;
johnAlexander	15:932d8b4e52c9	3873	}
johnAlexander	15:932d8b4e52c9	3874
johnAlexander	15:932d8b4e52c9	3875	/* Cannot combine Aperture and Non-Aperture spads, so
johnAlexander	15:932d8b4e52c9	3876	* ensure the current spad is of the correct type.
johnAlexander	15:932d8b4e52c9	3877	*/
JerrySzczurak	20:cf211a3b3d9e	3878	if ( is_aperture( ( uint32_t )start_select + next_good_spad ) !=
JerrySzczurak	20:cf211a3b3d9e	3879	need_apt_spads ) {
johnAlexander	15:932d8b4e52c9	3880	/* At this point we have enabled the maximum
johnAlexander	15:932d8b4e52c9	3881	* number of Aperture spads.
johnAlexander	15:932d8b4e52c9	3882	*/
johnAlexander	15:932d8b4e52c9	3883	complete = 1;
johnAlexander	15:932d8b4e52c9	3884	break;
johnAlexander	15:932d8b4e52c9	3885	}
johnAlexander	15:932d8b4e52c9	3886
JerrySzczurak	20:cf211a3b3d9e	3887	( ref_spad_count_int )++;
johnAlexander	16:98ce55ddbb1a	3888
johnAlexander	16:98ce55ddbb1a	3889	current_spad_index = next_good_spad;
johnAlexander	16:98ce55ddbb1a	3890	status = enable_spad_bit(
johnAlexander	16:98ce55ddbb1a	3891	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3892	spad_array_size, current_spad_index );
JerrySzczurak	20:cf211a3b3d9e	3893
JerrySzczurak	20:cf211a3b3d9e	3894	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	3895	current_spad_index++;
johnAlexander	15:932d8b4e52c9	3896	/* Proceed to apply the additional spad and
johnAlexander	15:932d8b4e52c9	3897	* perform measurement. */
JerrySzczurak	20:cf211a3b3d9e	3898	status = set_ref_spad_map( dev,
JerrySzczurak	20:cf211a3b3d9e	3899	dev->Data.SpadData.RefSpadEnables );
johnAlexander	15:932d8b4e52c9	3900	}
johnAlexander	15:932d8b4e52c9	3901
JerrySzczurak	20:cf211a3b3d9e	3902	if ( status != VL53L0X_ERROR_NONE )
johnAlexander	15:932d8b4e52c9	3903	break;
johnAlexander	15:932d8b4e52c9	3904
JerrySzczurak	20:cf211a3b3d9e	3905	status = perform_ref_signal_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	3906	&peak_signal_rate_ref );
JerrySzczurak	20:cf211a3b3d9e	3907
JerrySzczurak	20:cf211a3b3d9e	3908	if ( status != VL53L0X_ERROR_NONE )
johnAlexander	15:932d8b4e52c9	3909	break;
johnAlexander	15:932d8b4e52c9	3910
JerrySzczurak	20:cf211a3b3d9e	3911	signal_rate_diff = abs( peak_signal_rate_ref - target_ref_rate );
JerrySzczurak	20:cf211a3b3d9e	3912
JerrySzczurak	20:cf211a3b3d9e	3913	if ( peak_signal_rate_ref > target_ref_rate ) {
johnAlexander	15:932d8b4e52c9	3914	/* Select the spad map that provides the
johnAlexander	15:932d8b4e52c9	3915	* measurement closest to the target rate,
johnAlexander	15:932d8b4e52c9	3916	* either above or below it.
johnAlexander	15:932d8b4e52c9	3917	*/
JerrySzczurak	20:cf211a3b3d9e	3918	if ( signal_rate_diff > last_signal_rate_diff ) {
johnAlexander	15:932d8b4e52c9	3919	/* Previous spad map produced a closer
johnAlexander	15:932d8b4e52c9	3920	* measurement, so choose this. */
JerrySzczurak	20:cf211a3b3d9e	3921	status = set_ref_spad_map( dev,
JerrySzczurak	20:cf211a3b3d9e	3922	last_spad_array );
johnAlexander	15:932d8b4e52c9	3923	memcpy(
johnAlexander	16:98ce55ddbb1a	3924	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3925	last_spad_array, spad_array_size );
JerrySzczurak	20:cf211a3b3d9e	3926
JerrySzczurak	20:cf211a3b3d9e	3927	( ref_spad_count_int )--;
johnAlexander	15:932d8b4e52c9	3928	}
johnAlexander	15:932d8b4e52c9	3929	complete = 1;
johnAlexander	15:932d8b4e52c9	3930	} else {
johnAlexander	15:932d8b4e52c9	3931	/* Continue to add spads */
johnAlexander	16:98ce55ddbb1a	3932	last_signal_rate_diff = signal_rate_diff;
JerrySzczurak	20:cf211a3b3d9e	3933	memcpy( last_spad_array,
JerrySzczurak	20:cf211a3b3d9e	3934	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	3935	spad_array_size );
johnAlexander	15:932d8b4e52c9	3936	}
johnAlexander	15:932d8b4e52c9	3937
johnAlexander	15:932d8b4e52c9	3938	} /* while */
johnAlexander	15:932d8b4e52c9	3939	}
johnAlexander	15:932d8b4e52c9	3940
JerrySzczurak	20:cf211a3b3d9e	3941	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	3942	*ref_spad_count = ref_spad_count_int;
johnAlexander	16:98ce55ddbb1a	3943	*is_aperture_spads = is_aperture_spads_int;
johnAlexander	16:98ce55ddbb1a	3944
JerrySzczurak	20:cf211a3b3d9e	3945	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, RefSpadsInitialised, 1 );
JerrySzczurak	20:cf211a3b3d9e	3946	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	3947	ReferenceSpadCount, ( uint8_t )( *ref_spad_count ) );
JerrySzczurak	20:cf211a3b3d9e	3948	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	3949	ReferenceSpadType, *is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	3950	}
JerrySzczurak	20:cf211a3b3d9e	3951
JerrySzczurak	20:cf211a3b3d9e	3952	return status;
JerrySzczurak	20:cf211a3b3d9e	3953	}
JerrySzczurak	20:cf211a3b3d9e	3954
JerrySzczurak	20:cf211a3b3d9e	3955	VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_reference_spads( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	3956	uint32_t count, uint8_t is_aperture_spads )
johnAlexander	0:c523920bcc09	3957	{
johnAlexander	16:98ce55ddbb1a	3958	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	3959	uint32_t current_spad_index = 0;
johnAlexander	16:98ce55ddbb1a	3960	uint8_t start_select = 0xB4;
johnAlexander	16:98ce55ddbb1a	3961	uint32_t spad_array_size = 6;
johnAlexander	16:98ce55ddbb1a	3962	uint32_t max_spad_count = 44;
johnAlexander	16:98ce55ddbb1a	3963	uint32_t last_spad_index;
johnAlexander	15:932d8b4e52c9	3964	uint32_t index;
johnAlexander	15:932d8b4e52c9	3965
johnAlexander	15:932d8b4e52c9	3966	/*
johnAlexander	15:932d8b4e52c9	3967	* This function applies a requested number of reference spads, either
johnAlexander	15:932d8b4e52c9	3968	* aperture or
johnAlexander	15:932d8b4e52c9	3969	* non-aperture, as requested.
johnAlexander	15:932d8b4e52c9	3970	* The good spad map will be applied.
johnAlexander	15:932d8b4e52c9	3971	*/
johnAlexander	15:932d8b4e52c9	3972
JerrySzczurak	20:cf211a3b3d9e	3973	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	3974
JerrySzczurak	20:cf211a3b3d9e	3975	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3976	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3977	VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3978
JerrySzczurak	20:cf211a3b3d9e	3979	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3980	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3981	VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD, 0x2C );
JerrySzczurak	20:cf211a3b3d9e	3982
JerrySzczurak	20:cf211a3b3d9e	3983	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3984	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	3985
JerrySzczurak	20:cf211a3b3d9e	3986	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	3987	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	3988	VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT,
JerrySzczurak	20:cf211a3b3d9e	3989	start_select );
JerrySzczurak	20:cf211a3b3d9e	3990
JerrySzczurak	20:cf211a3b3d9e	3991	for ( index = 0; index < spad_array_size; index++ )
johnAlexander	16:98ce55ddbb1a	3992	dev->Data.SpadData.RefSpadEnables[index] = 0;
johnAlexander	16:98ce55ddbb1a	3993
JerrySzczurak	20:cf211a3b3d9e	3994	if ( is_aperture_spads ) {
johnAlexander	15:932d8b4e52c9	3995	/* Increment to the first APERTURE spad */
JerrySzczurak	20:cf211a3b3d9e	3996	while ( ( is_aperture( start_select + current_spad_index ) == 0 ) &&
JerrySzczurak	20:cf211a3b3d9e	3997	( current_spad_index < max_spad_count ) ) {
johnAlexander	16:98ce55ddbb1a	3998	current_spad_index++;
johnAlexander	15:932d8b4e52c9	3999	}
johnAlexander	15:932d8b4e52c9	4000	}
JerrySzczurak	20:cf211a3b3d9e	4001	status = enable_ref_spads( dev,
JerrySzczurak	20:cf211a3b3d9e	4002	is_aperture_spads,
JerrySzczurak	20:cf211a3b3d9e	4003	dev->Data.SpadData.RefGoodSpadMap,
JerrySzczurak	20:cf211a3b3d9e	4004	dev->Data.SpadData.RefSpadEnables,
JerrySzczurak	20:cf211a3b3d9e	4005	spad_array_size,
JerrySzczurak	20:cf211a3b3d9e	4006	start_select,
JerrySzczurak	20:cf211a3b3d9e	4007	current_spad_index,
JerrySzczurak	20:cf211a3b3d9e	4008	count,
JerrySzczurak	20:cf211a3b3d9e	4009	&last_spad_index );
JerrySzczurak	20:cf211a3b3d9e	4010
JerrySzczurak	20:cf211a3b3d9e	4011	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4012	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, RefSpadsInitialised, 1 );
JerrySzczurak	20:cf211a3b3d9e	4013	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4014	ReferenceSpadCount, ( uint8_t )( count ) );
JerrySzczurak	20:cf211a3b3d9e	4015	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4016	ReferenceSpadType, is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	4017	}
JerrySzczurak	20:cf211a3b3d9e	4018
JerrySzczurak	20:cf211a3b3d9e	4019	return status;
JerrySzczurak	20:cf211a3b3d9e	4020	}
JerrySzczurak	20:cf211a3b3d9e	4021
JerrySzczurak	20:cf211a3b3d9e	4022	VL53L0X_Error VL53L0X::vl53l0x_wait_device_booted( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	4023	{
johnAlexander	16:98ce55ddbb1a	4024	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	4025	LOG_FUNCTION_START( "" );
johnAlexander	15:932d8b4e52c9	4026
johnAlexander	15:932d8b4e52c9	4027	/* not implemented on VL53L0X */
johnAlexander	15:932d8b4e52c9	4028
JerrySzczurak	20:cf211a3b3d9e	4029	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4030	return status;
JerrySzczurak	20:cf211a3b3d9e	4031	}
JerrySzczurak	20:cf211a3b3d9e	4032
JerrySzczurak	20:cf211a3b3d9e	4033	VL53L0X_Error VL53L0X::vl53l0x_perform_ref_calibration( VL53L0X_DEV dev, uint8_t *p_vhv_settings,
JerrySzczurak	20:cf211a3b3d9e	4034	uint8_t *p_phase_cal )
johnAlexander	0:c523920bcc09	4035	{
johnAlexander	16:98ce55ddbb1a	4036	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4037	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4038
JerrySzczurak	20:cf211a3b3d9e	4039	status = vl53l0x_perform_ref_calibration( dev, p_vhv_settings,
JerrySzczurak	20:cf211a3b3d9e	4040	p_phase_cal, 1 );
JerrySzczurak	20:cf211a3b3d9e	4041
JerrySzczurak	20:cf211a3b3d9e	4042	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4043	return status;
JerrySzczurak	20:cf211a3b3d9e	4044	}
JerrySzczurak	20:cf211a3b3d9e	4045
JerrySzczurak	20:cf211a3b3d9e	4046	VL53L0X_Error VL53L0X::vl53l0x_perform_ref_spad_management( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	4047	uint32_t ref_spad_count, uint8_t is_aperture_spads )
johnAlexander	0:c523920bcc09	4048	{
johnAlexander	16:98ce55ddbb1a	4049	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4050	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4051
JerrySzczurak	20:cf211a3b3d9e	4052	status = wrapped_vl53l0x_perform_ref_spad_management( dev, ref_spad_count,
JerrySzczurak	20:cf211a3b3d9e	4053	is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	4054
JerrySzczurak	20:cf211a3b3d9e	4055	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	4056
johnAlexander	16:98ce55ddbb1a	4057	return status;
johnAlexander	0:c523920bcc09	4058	}
johnAlexander	0:c523920bcc09	4059
johnAlexander	0:c523920bcc09	4060	/* Group PAL Init Functions */
JerrySzczurak	20:cf211a3b3d9e	4061	VL53L0X_Error VL53L0X::vl53l0x_set_device_address( VL53L0X_DEV dev, uint8_t device_address )
johnAlexander	0:c523920bcc09	4062	{
johnAlexander	16:98ce55ddbb1a	4063	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4064	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4065
JerrySzczurak	20:cf211a3b3d9e	4066	status = vl53l0x_write_byte( dev, VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS,
JerrySzczurak	20:cf211a3b3d9e	4067	device_address / 2 );
JerrySzczurak	20:cf211a3b3d9e	4068
JerrySzczurak	20:cf211a3b3d9e	4069	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4070	return status;
JerrySzczurak	20:cf211a3b3d9e	4071	}
JerrySzczurak	20:cf211a3b3d9e	4072
JerrySzczurak	20:cf211a3b3d9e	4073	VL53L0X_Error VL53L0X::vl53l0x_set_gpio_config( VL53L0X_DEV dev, uint8_t pin,
johnAlexander	16:98ce55ddbb1a	4074	VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
JerrySzczurak	20:cf211a3b3d9e	4075	VL53L0X_InterruptPolarity polarity )
johnAlexander	0:c523920bcc09	4076	{
johnAlexander	16:98ce55ddbb1a	4077	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	15:932d8b4e52c9	4078	uint8_t data;
johnAlexander	15:932d8b4e52c9	4079
JerrySzczurak	20:cf211a3b3d9e	4080	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4081
JerrySzczurak	20:cf211a3b3d9e	4082	if ( pin != 0 ) {
johnAlexander	16:98ce55ddbb1a	4083	status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
JerrySzczurak	20:cf211a3b3d9e	4084	} else if ( device_mode == VL53L0X_DEVICEMODE_GPIO_DRIVE ) {
JerrySzczurak	20:cf211a3b3d9e	4085	if ( polarity == VL53L0X_INTERRUPTPOLARITY_LOW )
johnAlexander	15:932d8b4e52c9	4086	data = 0x10;
johnAlexander	15:932d8b4e52c9	4087	else
johnAlexander	15:932d8b4e52c9	4088	data = 1;
johnAlexander	15:932d8b4e52c9	4089
JerrySzczurak	20:cf211a3b3d9e	4090	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4091	VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data );
JerrySzczurak	20:cf211a3b3d9e	4092
JerrySzczurak	20:cf211a3b3d9e	4093	} else if ( device_mode == VL53L0X_DEVICEMODE_GPIO_OSC ) {
JerrySzczurak	20:cf211a3b3d9e	4094
JerrySzczurak	20:cf211a3b3d9e	4095	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4096	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4097
JerrySzczurak	20:cf211a3b3d9e	4098	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4099	status \|= vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4100	status \|= vl53l0x_write_byte( dev, 0x85, 0x02 );
JerrySzczurak	20:cf211a3b3d9e	4101
JerrySzczurak	20:cf211a3b3d9e	4102	status \|= vl53l0x_write_byte( dev, 0xff, 0x04 );
JerrySzczurak	20:cf211a3b3d9e	4103	status \|= vl53l0x_write_byte( dev, 0xcd, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4104	status \|= vl53l0x_write_byte( dev, 0xcc, 0x11 );
JerrySzczurak	20:cf211a3b3d9e	4105
JerrySzczurak	20:cf211a3b3d9e	4106	status \|= vl53l0x_write_byte( dev, 0xff, 0x07 );
JerrySzczurak	20:cf211a3b3d9e	4107	status \|= vl53l0x_write_byte( dev, 0xbe, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4108
JerrySzczurak	20:cf211a3b3d9e	4109	status \|= vl53l0x_write_byte( dev, 0xff, 0x06 );
JerrySzczurak	20:cf211a3b3d9e	4110	status \|= vl53l0x_write_byte( dev, 0xcc, 0x09 );
JerrySzczurak	20:cf211a3b3d9e	4111
JerrySzczurak	20:cf211a3b3d9e	4112	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4113	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4114	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
johnAlexander	15:932d8b4e52c9	4115
johnAlexander	15:932d8b4e52c9	4116	} else {
johnAlexander	15:932d8b4e52c9	4117
JerrySzczurak	20:cf211a3b3d9e	4118	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4119	switch ( functionality ) {
johnAlexander	15:932d8b4e52c9	4120	case VL53L0X_GPIOFUNCTIONALITY_OFF:
johnAlexander	15:932d8b4e52c9	4121	data = 0x00;
johnAlexander	15:932d8b4e52c9	4122	break;
johnAlexander	15:932d8b4e52c9	4123	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
johnAlexander	15:932d8b4e52c9	4124	data = 0x01;
johnAlexander	15:932d8b4e52c9	4125	break;
johnAlexander	15:932d8b4e52c9	4126	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
johnAlexander	15:932d8b4e52c9	4127	data = 0x02;
johnAlexander	15:932d8b4e52c9	4128	break;
johnAlexander	15:932d8b4e52c9	4129	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
johnAlexander	15:932d8b4e52c9	4130	data = 0x03;
johnAlexander	15:932d8b4e52c9	4131	break;
johnAlexander	15:932d8b4e52c9	4132	case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
johnAlexander	15:932d8b4e52c9	4133	data = 0x04;
johnAlexander	15:932d8b4e52c9	4134	break;
johnAlexander	15:932d8b4e52c9	4135	default:
johnAlexander	16:98ce55ddbb1a	4136	status =
johnAlexander	15:932d8b4e52c9	4137	VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
johnAlexander	15:932d8b4e52c9	4138	}
johnAlexander	15:932d8b4e52c9	4139	}
johnAlexander	15:932d8b4e52c9	4140
JerrySzczurak	20:cf211a3b3d9e	4141	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4142	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4143	VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data );
JerrySzczurak	20:cf211a3b3d9e	4144
JerrySzczurak	20:cf211a3b3d9e	4145	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4146	if ( polarity == VL53L0X_INTERRUPTPOLARITY_LOW )
johnAlexander	15:932d8b4e52c9	4147	data = 0;
johnAlexander	15:932d8b4e52c9	4148	else
JerrySzczurak	20:cf211a3b3d9e	4149	data = ( uint8_t )( 1 << 4 );
JerrySzczurak	20:cf211a3b3d9e	4150
JerrySzczurak	20:cf211a3b3d9e	4151	status = vl53l0x_update_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4152	VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data );
johnAlexander	15:932d8b4e52c9	4153	}
johnAlexander	15:932d8b4e52c9	4154
JerrySzczurak	20:cf211a3b3d9e	4155	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4156	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4157	Pin0GpioFunctionality, functionality );
JerrySzczurak	20:cf211a3b3d9e	4158
JerrySzczurak	20:cf211a3b3d9e	4159	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4160	status = vl53l0x_clear_interrupt_mask( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	4161
JerrySzczurak	20:cf211a3b3d9e	4162	}
JerrySzczurak	20:cf211a3b3d9e	4163	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4164	return status;
JerrySzczurak	20:cf211a3b3d9e	4165	}
JerrySzczurak	20:cf211a3b3d9e	4166
JerrySzczurak	20:cf211a3b3d9e	4167	VL53L0X_Error VL53L0X::vl53l0x_get_fraction_enable( VL53L0X_DEV dev, uint8_t *p_enabled )
johnAlexander	0:c523920bcc09	4168	{
johnAlexander	16:98ce55ddbb1a	4169	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4170	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4171
JerrySzczurak	20:cf211a3b3d9e	4172	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, p_enabled );
JerrySzczurak	20:cf211a3b3d9e	4173
JerrySzczurak	20:cf211a3b3d9e	4174	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4175	p_enabled = ( p_enabled & 1 );
JerrySzczurak	20:cf211a3b3d9e	4176
JerrySzczurak	20:cf211a3b3d9e	4177	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4178	return status;
JerrySzczurak	20:cf211a3b3d9e	4179	}
JerrySzczurak	20:cf211a3b3d9e	4180
JerrySzczurak	20:cf211a3b3d9e	4181	uint16_t VL53L0X::vl53l0x_encode_timeout( uint32_t timeout_macro_clks )
johnAlexander	0:c523920bcc09	4182	{
johnAlexander	15:932d8b4e52c9	4183	/*!
johnAlexander	15:932d8b4e52c9	4184	* Encode timeout in macro periods in (LSByte * 2^MSByte) + 1 format
johnAlexander	15:932d8b4e52c9	4185	*/
johnAlexander	15:932d8b4e52c9	4186
johnAlexander	15:932d8b4e52c9	4187	uint16_t encoded_timeout = 0;
johnAlexander	15:932d8b4e52c9	4188	uint32_t ls_byte = 0;
johnAlexander	15:932d8b4e52c9	4189	uint16_t ms_byte = 0;
johnAlexander	15:932d8b4e52c9	4190
JerrySzczurak	20:cf211a3b3d9e	4191	if ( timeout_macro_clks > 0 ) {
johnAlexander	15:932d8b4e52c9	4192	ls_byte = timeout_macro_clks - 1;
johnAlexander	15:932d8b4e52c9	4193
JerrySzczurak	20:cf211a3b3d9e	4194	while ( ( ls_byte & 0xFFFFFF00 ) > 0 ) {
johnAlexander	15:932d8b4e52c9	4195	ls_byte = ls_byte >> 1;
johnAlexander	15:932d8b4e52c9	4196	ms_byte++;
johnAlexander	15:932d8b4e52c9	4197	}
johnAlexander	15:932d8b4e52c9	4198
JerrySzczurak	20:cf211a3b3d9e	4199	encoded_timeout = ( ms_byte << 8 )
JerrySzczurak	20:cf211a3b3d9e	4200	+ ( uint16_t ) ( ls_byte & 0x000000FF );
johnAlexander	15:932d8b4e52c9	4201	}
johnAlexander	15:932d8b4e52c9	4202
johnAlexander	15:932d8b4e52c9	4203	return encoded_timeout;
johnAlexander	0:c523920bcc09	4204
johnAlexander	0:c523920bcc09	4205	}
johnAlexander	0:c523920bcc09	4206
JerrySzczurak	20:cf211a3b3d9e	4207	VL53L0X_Error VL53L0X::set_sequence_step_timeout( VL53L0X_DEV dev,
johnAlexander	16:98ce55ddbb1a	4208	VL53L0X_SequenceStepId sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	4209	uint32_t timeout_micro_secs )
johnAlexander	0:c523920bcc09	4210	{
johnAlexander	16:98ce55ddbb1a	4211	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4212	uint8_t current_vcsel_pulse_period_p_clk;
johnAlexander	16:98ce55ddbb1a	4213	uint8_t msrc_encoded_time_out;
johnAlexander	16:98ce55ddbb1a	4214	uint16_t pre_range_encoded_time_out;
johnAlexander	16:98ce55ddbb1a	4215	uint16_t pre_range_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	4216	uint16_t msrc_range_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	4217	uint32_t final_range_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	4218	uint16_t final_range_encoded_time_out;
johnAlexander	16:98ce55ddbb1a	4219	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander	16:98ce55ddbb1a	4220
JerrySzczurak	20:cf211a3b3d9e	4221	if ( ( sequence_step_id == VL53L0X_SEQUENCESTEP_TCC ) \|\|
JerrySzczurak	20:cf211a3b3d9e	4222	( sequence_step_id == VL53L0X_SEQUENCESTEP_DSS ) \|\|
JerrySzczurak	20:cf211a3b3d9e	4223	( sequence_step_id == VL53L0X_SEQUENCESTEP_MSRC ) ) {
JerrySzczurak	20:cf211a3b3d9e	4224
JerrySzczurak	20:cf211a3b3d9e	4225	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	4226	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4227	&current_vcsel_pulse_period_p_clk );
JerrySzczurak	20:cf211a3b3d9e	4228
JerrySzczurak	20:cf211a3b3d9e	4229	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4230	msrc_range_time_out_m_clks = vl53l0x_calc_timeout_mclks( dev,
johnAlexander	16:98ce55ddbb1a	4231	timeout_micro_secs,
JerrySzczurak	20:cf211a3b3d9e	4232	( uint8_t )current_vcsel_pulse_period_p_clk );
JerrySzczurak	20:cf211a3b3d9e	4233
JerrySzczurak	20:cf211a3b3d9e	4234	if ( msrc_range_time_out_m_clks > 256 )
johnAlexander	16:98ce55ddbb1a	4235	msrc_encoded_time_out = 255;
johnAlexander	15:932d8b4e52c9	4236	else
johnAlexander	16:98ce55ddbb1a	4237	msrc_encoded_time_out =
JerrySzczurak	20:cf211a3b3d9e	4238	( uint8_t )msrc_range_time_out_m_clks - 1;
JerrySzczurak	20:cf211a3b3d9e	4239
JerrySzczurak	20:cf211a3b3d9e	4240	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4241	LastEncodedTimeout,
JerrySzczurak	20:cf211a3b3d9e	4242	msrc_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4243	}
johnAlexander	15:932d8b4e52c9	4244
JerrySzczurak	20:cf211a3b3d9e	4245	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4246	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4247	VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP,
JerrySzczurak	20:cf211a3b3d9e	4248	msrc_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4249	}
johnAlexander	15:932d8b4e52c9	4250	} else {
johnAlexander	15:932d8b4e52c9	4251
JerrySzczurak	20:cf211a3b3d9e	4252	if ( sequence_step_id == VL53L0X_SEQUENCESTEP_PRE_RANGE ) {
JerrySzczurak	20:cf211a3b3d9e	4253
JerrySzczurak	20:cf211a3b3d9e	4254	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4255	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	4256	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4257	&current_vcsel_pulse_period_p_clk );
johnAlexander	16:98ce55ddbb1a	4258	pre_range_time_out_m_clks =
JerrySzczurak	20:cf211a3b3d9e	4259	vl53l0x_calc_timeout_mclks( dev,
JerrySzczurak	20:cf211a3b3d9e	4260	timeout_micro_secs,
JerrySzczurak	20:cf211a3b3d9e	4261	( uint8_t )current_vcsel_pulse_period_p_clk );
johnAlexander	16:98ce55ddbb1a	4262	pre_range_encoded_time_out = vl53l0x_encode_timeout(
JerrySzczurak	20:cf211a3b3d9e	4263	pre_range_time_out_m_clks );
JerrySzczurak	20:cf211a3b3d9e	4264
JerrySzczurak	20:cf211a3b3d9e	4265	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4266	LastEncodedTimeout,
JerrySzczurak	20:cf211a3b3d9e	4267	pre_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4268	}
johnAlexander	15:932d8b4e52c9	4269
JerrySzczurak	20:cf211a3b3d9e	4270	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4271	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	4272	VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI,
JerrySzczurak	20:cf211a3b3d9e	4273	pre_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4274	}
johnAlexander	15:932d8b4e52c9	4275
JerrySzczurak	20:cf211a3b3d9e	4276	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4277	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	16:98ce55ddbb1a	4278	dev,
johnAlexander	15:932d8b4e52c9	4279	PreRangeTimeoutMicroSecs,
JerrySzczurak	20:cf211a3b3d9e	4280	timeout_micro_secs );
johnAlexander	15:932d8b4e52c9	4281	}
JerrySzczurak	20:cf211a3b3d9e	4282	} else if ( sequence_step_id == VL53L0X_SEQUENCESTEP_FINAL_RANGE ) {
johnAlexander	15:932d8b4e52c9	4283
johnAlexander	15:932d8b4e52c9	4284	/* For the final range timeout, the pre-range timeout
johnAlexander	15:932d8b4e52c9	4285	* must be added. To do this both final and pre-range
johnAlexander	15:932d8b4e52c9	4286	* timeouts must be expressed in macro periods MClks
johnAlexander	15:932d8b4e52c9	4287	* because they have different vcsel periods.
johnAlexander	15:932d8b4e52c9	4288	*/
johnAlexander	15:932d8b4e52c9	4289
JerrySzczurak	20:cf211a3b3d9e	4290	vl53l0x_get_sequence_step_enables( dev,
JerrySzczurak	20:cf211a3b3d9e	4291	&scheduler_sequence_steps );
johnAlexander	16:98ce55ddbb1a	4292	pre_range_time_out_m_clks = 0;
JerrySzczurak	20:cf211a3b3d9e	4293	if ( scheduler_sequence_steps.PreRangeOn ) {
johnAlexander	15:932d8b4e52c9	4294
johnAlexander	15:932d8b4e52c9	4295	/* Retrieve PRE-RANGE VCSEL Period */
JerrySzczurak	20:cf211a3b3d9e	4296	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	4297	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4298	&current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	4299
johnAlexander	15:932d8b4e52c9	4300	/* Retrieve PRE-RANGE Timeout in Macro periods
johnAlexander	15:932d8b4e52c9	4301	* (MCLKS) */
JerrySzczurak	20:cf211a3b3d9e	4302	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4303	status = vl53l0x_read_word( dev, 0x51,
JerrySzczurak	20:cf211a3b3d9e	4304	&pre_range_encoded_time_out );
johnAlexander	16:98ce55ddbb1a	4305	pre_range_time_out_m_clks =
johnAlexander	16:98ce55ddbb1a	4306	vl53l0x_decode_timeout(
JerrySzczurak	20:cf211a3b3d9e	4307	pre_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4308	}
johnAlexander	15:932d8b4e52c9	4309	}
johnAlexander	15:932d8b4e52c9	4310
johnAlexander	15:932d8b4e52c9	4311	/* Calculate FINAL RANGE Timeout in Macro Periods
johnAlexander	15:932d8b4e52c9	4312	* (MCLKS) and add PRE-RANGE value
johnAlexander	15:932d8b4e52c9	4313	*/
JerrySzczurak	20:cf211a3b3d9e	4314	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4315
JerrySzczurak	20:cf211a3b3d9e	4316	status = vl53l0x_get_vcsel_pulse_period( dev,
JerrySzczurak	20:cf211a3b3d9e	4317	VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4318	&current_vcsel_pulse_period_p_clk );
johnAlexander	15:932d8b4e52c9	4319	}
JerrySzczurak	20:cf211a3b3d9e	4320	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	4321
johnAlexander	16:98ce55ddbb1a	4322	final_range_time_out_m_clks =
JerrySzczurak	20:cf211a3b3d9e	4323	vl53l0x_calc_timeout_mclks( dev,
JerrySzczurak	20:cf211a3b3d9e	4324	timeout_micro_secs,
JerrySzczurak	20:cf211a3b3d9e	4325	( uint8_t ) current_vcsel_pulse_period_p_clk );
johnAlexander	16:98ce55ddbb1a	4326
johnAlexander	16:98ce55ddbb1a	4327	final_range_time_out_m_clks += pre_range_time_out_m_clks;
johnAlexander	16:98ce55ddbb1a	4328
johnAlexander	16:98ce55ddbb1a	4329	final_range_encoded_time_out =
JerrySzczurak	20:cf211a3b3d9e	4330	vl53l0x_encode_timeout( final_range_time_out_m_clks );
JerrySzczurak	20:cf211a3b3d9e	4331
JerrySzczurak	20:cf211a3b3d9e	4332	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4333	status = vl53l0x_write_word( dev, 0x71,
JerrySzczurak	20:cf211a3b3d9e	4334	final_range_encoded_time_out );
johnAlexander	15:932d8b4e52c9	4335	}
johnAlexander	15:932d8b4e52c9	4336
JerrySzczurak	20:cf211a3b3d9e	4337	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4338	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	16:98ce55ddbb1a	4339	dev,
johnAlexander	15:932d8b4e52c9	4340	FinalRangeTimeoutMicroSecs,
JerrySzczurak	20:cf211a3b3d9e	4341	timeout_micro_secs );
johnAlexander	15:932d8b4e52c9	4342	}
johnAlexander	15:932d8b4e52c9	4343	}
johnAlexander	15:932d8b4e52c9	4344	} else
johnAlexander	16:98ce55ddbb1a	4345	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4346
johnAlexander	15:932d8b4e52c9	4347	}
johnAlexander	16:98ce55ddbb1a	4348	return status;
johnAlexander	0:c523920bcc09	4349	}
johnAlexander	0:c523920bcc09	4350
JerrySzczurak	20:cf211a3b3d9e	4351	VL53L0X_Error VL53L0X::wrapped_vl53l0x_set_measurement_timing_budget_micro_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	4352	uint32_t measurement_timing_budget_micro_seconds )
johnAlexander	0:c523920bcc09	4353	{
johnAlexander	16:98ce55ddbb1a	4354	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4355	uint32_t final_range_timing_budget_micro_seconds;
johnAlexander	16:98ce55ddbb1a	4356	VL53L0X_SchedulerSequenceSteps_t scheduler_sequence_steps;
johnAlexander	16:98ce55ddbb1a	4357	uint32_t msrc_dcc_tcc_timeout_micro_seconds = 2000;
johnAlexander	16:98ce55ddbb1a	4358	uint32_t start_overhead_micro_seconds = 1910;
johnAlexander	16:98ce55ddbb1a	4359	uint32_t end_overhead_micro_seconds = 960;
johnAlexander	16:98ce55ddbb1a	4360	uint32_t msrc_overhead_micro_seconds = 660;
johnAlexander	16:98ce55ddbb1a	4361	uint32_t tcc_overhead_micro_seconds = 590;
johnAlexander	16:98ce55ddbb1a	4362	uint32_t dss_overhead_micro_seconds = 690;
johnAlexander	16:98ce55ddbb1a	4363	uint32_t pre_range_overhead_micro_seconds = 660;
johnAlexander	16:98ce55ddbb1a	4364	uint32_t final_range_overhead_micro_seconds = 550;
johnAlexander	16:98ce55ddbb1a	4365	uint32_t pre_range_timeout_micro_seconds = 0;
johnAlexander	16:98ce55ddbb1a	4366	uint32_t c_min_timing_budget_micro_seconds = 20000;
johnAlexander	16:98ce55ddbb1a	4367	uint32_t sub_timeout = 0;
johnAlexander	15:932d8b4e52c9	4368
JerrySzczurak	20:cf211a3b3d9e	4369	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4370
JerrySzczurak	20:cf211a3b3d9e	4371	if ( measurement_timing_budget_micro_seconds
JerrySzczurak	20:cf211a3b3d9e	4372	< c_min_timing_budget_micro_seconds ) {
johnAlexander	16:98ce55ddbb1a	4373	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	16:98ce55ddbb1a	4374	return status;
johnAlexander	15:932d8b4e52c9	4375	}
johnAlexander	15:932d8b4e52c9	4376
johnAlexander	16:98ce55ddbb1a	4377	final_range_timing_budget_micro_seconds =
johnAlexander	16:98ce55ddbb1a	4378	measurement_timing_budget_micro_seconds -
JerrySzczurak	20:cf211a3b3d9e	4379	( start_overhead_micro_seconds + end_overhead_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4380
JerrySzczurak	20:cf211a3b3d9e	4381	status = vl53l0x_get_sequence_step_enables( dev, &scheduler_sequence_steps );
JerrySzczurak	20:cf211a3b3d9e	4382
JerrySzczurak	20:cf211a3b3d9e	4383	if ( status == VL53L0X_ERROR_NONE &&
JerrySzczurak	20:cf211a3b3d9e	4384	( scheduler_sequence_steps.TccOn \|\|
JerrySzczurak	20:cf211a3b3d9e	4385	scheduler_sequence_steps.MsrcOn \|\|
JerrySzczurak	20:cf211a3b3d9e	4386	scheduler_sequence_steps.DssOn ) ) {
johnAlexander	15:932d8b4e52c9	4387
johnAlexander	15:932d8b4e52c9	4388	/* TCC, MSRC and DSS all share the same timeout */
JerrySzczurak	20:cf211a3b3d9e	4389	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	4390	VL53L0X_SEQUENCESTEP_MSRC,
JerrySzczurak	20:cf211a3b3d9e	4391	&msrc_dcc_tcc_timeout_micro_seconds );
johnAlexander	15:932d8b4e52c9	4392
johnAlexander	15:932d8b4e52c9	4393	/* Subtract the TCC, MSRC and DSS timeouts if they are
johnAlexander	15:932d8b4e52c9	4394	* enabled. */
johnAlexander	15:932d8b4e52c9	4395
JerrySzczurak	20:cf211a3b3d9e	4396	if ( status != VL53L0X_ERROR_NONE )
johnAlexander	16:98ce55ddbb1a	4397	return status;
johnAlexander	15:932d8b4e52c9	4398
johnAlexander	15:932d8b4e52c9	4399	/* TCC */
JerrySzczurak	20:cf211a3b3d9e	4400	if ( scheduler_sequence_steps.TccOn ) {
johnAlexander	16:98ce55ddbb1a	4401
johnAlexander	16:98ce55ddbb1a	4402	sub_timeout = msrc_dcc_tcc_timeout_micro_seconds
johnAlexander	16:98ce55ddbb1a	4403	+ tcc_overhead_micro_seconds;
johnAlexander	16:98ce55ddbb1a	4404
JerrySzczurak	20:cf211a3b3d9e	4405	if ( sub_timeout <
JerrySzczurak	20:cf211a3b3d9e	4406	final_range_timing_budget_micro_seconds ) {
johnAlexander	16:98ce55ddbb1a	4407	final_range_timing_budget_micro_seconds -=
johnAlexander	16:98ce55ddbb1a	4408	sub_timeout;
johnAlexander	15:932d8b4e52c9	4409	} else {
johnAlexander	15:932d8b4e52c9	4410	/* Requested timeout too big. */
johnAlexander	16:98ce55ddbb1a	4411	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4412	}
johnAlexander	15:932d8b4e52c9	4413	}
johnAlexander	15:932d8b4e52c9	4414
JerrySzczurak	20:cf211a3b3d9e	4415	if ( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4416	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	4417	return status;
johnAlexander	15:932d8b4e52c9	4418	}
johnAlexander	15:932d8b4e52c9	4419
johnAlexander	15:932d8b4e52c9	4420	/* DSS */
JerrySzczurak	20:cf211a3b3d9e	4421	if ( scheduler_sequence_steps.DssOn ) {
JerrySzczurak	20:cf211a3b3d9e	4422
JerrySzczurak	20:cf211a3b3d9e	4423	sub_timeout = 2 * ( msrc_dcc_tcc_timeout_micro_seconds +
JerrySzczurak	20:cf211a3b3d9e	4424	dss_overhead_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4425
JerrySzczurak	20:cf211a3b3d9e	4426	if ( sub_timeout < final_range_timing_budget_micro_seconds ) {
johnAlexander	16:98ce55ddbb1a	4427	final_range_timing_budget_micro_seconds
johnAlexander	16:98ce55ddbb1a	4428	-= sub_timeout;
johnAlexander	15:932d8b4e52c9	4429	} else {
johnAlexander	15:932d8b4e52c9	4430	/* Requested timeout too big. */
johnAlexander	16:98ce55ddbb1a	4431	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4432	}
JerrySzczurak	20:cf211a3b3d9e	4433	} else if ( scheduler_sequence_steps.MsrcOn ) {
johnAlexander	15:932d8b4e52c9	4434	/* MSRC */
johnAlexander	16:98ce55ddbb1a	4435	sub_timeout = msrc_dcc_tcc_timeout_micro_seconds +
johnAlexander	16:98ce55ddbb1a	4436	msrc_overhead_micro_seconds;
johnAlexander	16:98ce55ddbb1a	4437
JerrySzczurak	20:cf211a3b3d9e	4438	if ( sub_timeout < final_range_timing_budget_micro_seconds ) {
johnAlexander	16:98ce55ddbb1a	4439	final_range_timing_budget_micro_seconds
johnAlexander	16:98ce55ddbb1a	4440	-= sub_timeout;
johnAlexander	15:932d8b4e52c9	4441	} else {
johnAlexander	15:932d8b4e52c9	4442	/* Requested timeout too big. */
johnAlexander	16:98ce55ddbb1a	4443	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4444	}
johnAlexander	15:932d8b4e52c9	4445	}
johnAlexander	15:932d8b4e52c9	4446
johnAlexander	15:932d8b4e52c9	4447	}
johnAlexander	15:932d8b4e52c9	4448
JerrySzczurak	20:cf211a3b3d9e	4449	if ( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4450	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	4451	return status;
johnAlexander	15:932d8b4e52c9	4452	}
johnAlexander	15:932d8b4e52c9	4453
JerrySzczurak	20:cf211a3b3d9e	4454	if ( scheduler_sequence_steps.PreRangeOn ) {
johnAlexander	15:932d8b4e52c9	4455
johnAlexander	15:932d8b4e52c9	4456	/* Subtract the Pre-range timeout if enabled. */
johnAlexander	15:932d8b4e52c9	4457
JerrySzczurak	20:cf211a3b3d9e	4458	status = get_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	4459	VL53L0X_SEQUENCESTEP_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4460	&pre_range_timeout_micro_seconds );
johnAlexander	16:98ce55ddbb1a	4461
johnAlexander	16:98ce55ddbb1a	4462	sub_timeout = pre_range_timeout_micro_seconds +
johnAlexander	16:98ce55ddbb1a	4463	pre_range_overhead_micro_seconds;
johnAlexander	16:98ce55ddbb1a	4464
JerrySzczurak	20:cf211a3b3d9e	4465	if ( sub_timeout < final_range_timing_budget_micro_seconds ) {
johnAlexander	16:98ce55ddbb1a	4466	final_range_timing_budget_micro_seconds -= sub_timeout;
johnAlexander	15:932d8b4e52c9	4467	} else {
johnAlexander	15:932d8b4e52c9	4468	/* Requested timeout too big. */
johnAlexander	16:98ce55ddbb1a	4469	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4470	}
johnAlexander	15:932d8b4e52c9	4471	}
johnAlexander	15:932d8b4e52c9	4472
johnAlexander	15:932d8b4e52c9	4473
JerrySzczurak	20:cf211a3b3d9e	4474	if ( status == VL53L0X_ERROR_NONE &&
JerrySzczurak	20:cf211a3b3d9e	4475	scheduler_sequence_steps.FinalRangeOn ) {
johnAlexander	16:98ce55ddbb1a	4476
johnAlexander	16:98ce55ddbb1a	4477	final_range_timing_budget_micro_seconds -=
johnAlexander	16:98ce55ddbb1a	4478	final_range_overhead_micro_seconds;
johnAlexander	15:932d8b4e52c9	4479
johnAlexander	15:932d8b4e52c9	4480	/* Final Range Timeout
johnAlexander	15:932d8b4e52c9	4481	* Note that the final range timeout is determined by the timing
johnAlexander	15:932d8b4e52c9	4482	* budget and the sum of all other timeouts within the sequence.
johnAlexander	15:932d8b4e52c9	4483	* If there is no room for the final range timeout, then an error
johnAlexander	15:932d8b4e52c9	4484	* will be set. Otherwise the remaining time will be applied to
johnAlexander	15:932d8b4e52c9	4485	* the final range.
johnAlexander	15:932d8b4e52c9	4486	*/
JerrySzczurak	20:cf211a3b3d9e	4487	status = set_sequence_step_timeout( dev,
JerrySzczurak	20:cf211a3b3d9e	4488	VL53L0X_SEQUENCESTEP_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4489	final_range_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4490
JerrySzczurak	20:cf211a3b3d9e	4491	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	4492	MeasurementTimingBudgetMicroSeconds,
JerrySzczurak	20:cf211a3b3d9e	4493	measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4494	}
JerrySzczurak	20:cf211a3b3d9e	4495
JerrySzczurak	20:cf211a3b3d9e	4496	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4497
JerrySzczurak	20:cf211a3b3d9e	4498	return status;
JerrySzczurak	20:cf211a3b3d9e	4499	}
JerrySzczurak	20:cf211a3b3d9e	4500
JerrySzczurak	20:cf211a3b3d9e	4501	VL53L0X_Error VL53L0X::vl53l0x_set_measurement_timing_budget_micro_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	4502	uint32_t measurement_timing_budget_micro_seconds )
johnAlexander	0:c523920bcc09	4503	{
johnAlexander	16:98ce55ddbb1a	4504	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4505	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4506
JerrySzczurak	20:cf211a3b3d9e	4507	status = wrapped_vl53l0x_set_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	4508	measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4509
JerrySzczurak	20:cf211a3b3d9e	4510	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4511
JerrySzczurak	20:cf211a3b3d9e	4512	return status;
JerrySzczurak	20:cf211a3b3d9e	4513	}
JerrySzczurak	20:cf211a3b3d9e	4514
JerrySzczurak	20:cf211a3b3d9e	4515	VL53L0X_Error VL53L0X::vl53l0x_set_sequence_step_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	4516	VL53L0X_SequenceStepId sequence_step_id, uint8_t sequence_step_enabled )
johnAlexander	0:c523920bcc09	4517	{
johnAlexander	16:98ce55ddbb1a	4518	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4519	uint8_t sequence_config = 0;
johnAlexander	16:98ce55ddbb1a	4520	uint8_t sequence_config_new = 0;
johnAlexander	16:98ce55ddbb1a	4521	uint32_t measurement_timing_budget_micro_seconds;
JerrySzczurak	20:cf211a3b3d9e	4522	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4523
JerrySzczurak	20:cf211a3b3d9e	4524	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	4525	&sequence_config );
johnAlexander	16:98ce55ddbb1a	4526
johnAlexander	16:98ce55ddbb1a	4527	sequence_config_new = sequence_config;
johnAlexander	16:98ce55ddbb1a	4528
JerrySzczurak	20:cf211a3b3d9e	4529	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4530	if ( sequence_step_enabled == 1 ) {
johnAlexander	15:932d8b4e52c9	4531
johnAlexander	15:932d8b4e52c9	4532	/* Enable requested sequence step
johnAlexander	15:932d8b4e52c9	4533	*/
JerrySzczurak	20:cf211a3b3d9e	4534	switch ( sequence_step_id ) {
johnAlexander	15:932d8b4e52c9	4535	case VL53L0X_SEQUENCESTEP_TCC:
johnAlexander	16:98ce55ddbb1a	4536	sequence_config_new \|= 0x10;
johnAlexander	15:932d8b4e52c9	4537	break;
johnAlexander	15:932d8b4e52c9	4538	case VL53L0X_SEQUENCESTEP_DSS:
johnAlexander	16:98ce55ddbb1a	4539	sequence_config_new \|= 0x28;
johnAlexander	15:932d8b4e52c9	4540	break;
johnAlexander	15:932d8b4e52c9	4541	case VL53L0X_SEQUENCESTEP_MSRC:
johnAlexander	16:98ce55ddbb1a	4542	sequence_config_new \|= 0x04;
johnAlexander	15:932d8b4e52c9	4543	break;
johnAlexander	15:932d8b4e52c9	4544	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
johnAlexander	16:98ce55ddbb1a	4545	sequence_config_new \|= 0x40;
johnAlexander	15:932d8b4e52c9	4546	break;
johnAlexander	15:932d8b4e52c9	4547	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
johnAlexander	16:98ce55ddbb1a	4548	sequence_config_new \|= 0x80;
johnAlexander	15:932d8b4e52c9	4549	break;
johnAlexander	15:932d8b4e52c9	4550	default:
johnAlexander	16:98ce55ddbb1a	4551	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4552	}
johnAlexander	15:932d8b4e52c9	4553	} else {
johnAlexander	15:932d8b4e52c9	4554	/* Disable requested sequence step
johnAlexander	15:932d8b4e52c9	4555	*/
JerrySzczurak	20:cf211a3b3d9e	4556	switch ( sequence_step_id ) {
johnAlexander	15:932d8b4e52c9	4557	case VL53L0X_SEQUENCESTEP_TCC:
johnAlexander	16:98ce55ddbb1a	4558	sequence_config_new &= 0xef;
johnAlexander	15:932d8b4e52c9	4559	break;
johnAlexander	15:932d8b4e52c9	4560	case VL53L0X_SEQUENCESTEP_DSS:
johnAlexander	16:98ce55ddbb1a	4561	sequence_config_new &= 0xd7;
johnAlexander	15:932d8b4e52c9	4562	break;
johnAlexander	15:932d8b4e52c9	4563	case VL53L0X_SEQUENCESTEP_MSRC:
johnAlexander	16:98ce55ddbb1a	4564	sequence_config_new &= 0xfb;
johnAlexander	15:932d8b4e52c9	4565	break;
johnAlexander	15:932d8b4e52c9	4566	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
johnAlexander	16:98ce55ddbb1a	4567	sequence_config_new &= 0xbf;
johnAlexander	15:932d8b4e52c9	4568	break;
johnAlexander	15:932d8b4e52c9	4569	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
johnAlexander	16:98ce55ddbb1a	4570	sequence_config_new &= 0x7f;
johnAlexander	15:932d8b4e52c9	4571	break;
johnAlexander	15:932d8b4e52c9	4572	default:
johnAlexander	16:98ce55ddbb1a	4573	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4574	}
johnAlexander	15:932d8b4e52c9	4575	}
johnAlexander	15:932d8b4e52c9	4576	}
johnAlexander	15:932d8b4e52c9	4577
JerrySzczurak	20:cf211a3b3d9e	4578	if ( sequence_config_new != sequence_config ) {
johnAlexander	15:932d8b4e52c9	4579	/* Apply New Setting */
JerrySzczurak	20:cf211a3b3d9e	4580	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4581	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4582	VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, sequence_config_new );
johnAlexander	15:932d8b4e52c9	4583	}
JerrySzczurak	20:cf211a3b3d9e	4584	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4585	PALDevDataSet( dev, SequenceConfig, sequence_config_new );
johnAlexander	15:932d8b4e52c9	4586
johnAlexander	15:932d8b4e52c9	4587
johnAlexander	15:932d8b4e52c9	4588	/* Recalculate timing budget */
JerrySzczurak	20:cf211a3b3d9e	4589	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4590	VL53L0X_GETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	4591	MeasurementTimingBudgetMicroSeconds,
JerrySzczurak	20:cf211a3b3d9e	4592	measurement_timing_budget_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	4593
JerrySzczurak	20:cf211a3b3d9e	4594	vl53l0x_set_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	4595	measurement_timing_budget_micro_seconds );
johnAlexander	15:932d8b4e52c9	4596	}
johnAlexander	15:932d8b4e52c9	4597	}
johnAlexander	15:932d8b4e52c9	4598
JerrySzczurak	20:cf211a3b3d9e	4599	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4600
JerrySzczurak	20:cf211a3b3d9e	4601	return status;
JerrySzczurak	20:cf211a3b3d9e	4602	}
JerrySzczurak	20:cf211a3b3d9e	4603
JerrySzczurak	20:cf211a3b3d9e	4604	VL53L0X_Error VL53L0X::vl53l0x_set_limit_check_enable( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	4605	uint8_t limit_check_enable )
johnAlexander	0:c523920bcc09	4606	{
johnAlexander	16:98ce55ddbb1a	4607	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4608	FixPoint1616_t temp_fix1616 = 0;
johnAlexander	16:98ce55ddbb1a	4609	uint8_t limit_check_enable_int = 0;
johnAlexander	16:98ce55ddbb1a	4610	uint8_t limit_check_disable = 0;
johnAlexander	16:98ce55ddbb1a	4611	uint8_t temp8;
johnAlexander	15:932d8b4e52c9	4612
JerrySzczurak	20:cf211a3b3d9e	4613	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4614
JerrySzczurak	20:cf211a3b3d9e	4615	if ( limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS ) {
johnAlexander	16:98ce55ddbb1a	4616	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4617	} else {
JerrySzczurak	20:cf211a3b3d9e	4618	if ( limit_check_enable == 0 ) {
johnAlexander	16:98ce55ddbb1a	4619	temp_fix1616 = 0;
johnAlexander	16:98ce55ddbb1a	4620	limit_check_enable_int = 0;
johnAlexander	16:98ce55ddbb1a	4621	limit_check_disable = 1;
johnAlexander	15:932d8b4e52c9	4622
johnAlexander	15:932d8b4e52c9	4623	} else {
JerrySzczurak	20:cf211a3b3d9e	4624	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksValue,
JerrySzczurak	20:cf211a3b3d9e	4625	limit_check_id, temp_fix1616 );
johnAlexander	16:98ce55ddbb1a	4626	limit_check_disable = 0;
johnAlexander	15:932d8b4e52c9	4627	/* this to be sure to have either 0 or 1 */
johnAlexander	16:98ce55ddbb1a	4628	limit_check_enable_int = 1;
johnAlexander	15:932d8b4e52c9	4629	}
johnAlexander	15:932d8b4e52c9	4630
JerrySzczurak	20:cf211a3b3d9e	4631	switch ( limit_check_id ) {
johnAlexander	15:932d8b4e52c9	4632
johnAlexander	15:932d8b4e52c9	4633	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
johnAlexander	15:932d8b4e52c9	4634	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	4635	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	4636	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4637	limit_check_enable_int );
johnAlexander	15:932d8b4e52c9	4638
johnAlexander	15:932d8b4e52c9	4639	break;
johnAlexander	15:932d8b4e52c9	4640
johnAlexander	15:932d8b4e52c9	4641	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
johnAlexander	15:932d8b4e52c9	4642
JerrySzczurak	20:cf211a3b3d9e	4643	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	4644	VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT,
JerrySzczurak	20:cf211a3b3d9e	4645	VL53L0X_FIXPOINT1616TOFIXPOINT97( temp_fix1616 ) );
johnAlexander	15:932d8b4e52c9	4646
johnAlexander	15:932d8b4e52c9	4647	break;
johnAlexander	15:932d8b4e52c9	4648
johnAlexander	15:932d8b4e52c9	4649	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
johnAlexander	15:932d8b4e52c9	4650
johnAlexander	15:932d8b4e52c9	4651	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	4652	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	4653	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	4654	limit_check_enable_int );
johnAlexander	15:932d8b4e52c9	4655
johnAlexander	15:932d8b4e52c9	4656	break;
johnAlexander	15:932d8b4e52c9	4657
johnAlexander	15:932d8b4e52c9	4658	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
johnAlexander	15:932d8b4e52c9	4659
johnAlexander	15:932d8b4e52c9	4660	/* internal computation: */
JerrySzczurak	20:cf211a3b3d9e	4661	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	4662	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD,
JerrySzczurak	20:cf211a3b3d9e	4663	limit_check_enable_int );
johnAlexander	15:932d8b4e52c9	4664
johnAlexander	15:932d8b4e52c9	4665	break;
johnAlexander	15:932d8b4e52c9	4666
johnAlexander	15:932d8b4e52c9	4667	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
johnAlexander	15:932d8b4e52c9	4668
JerrySzczurak	20:cf211a3b3d9e	4669	temp8 = ( uint8_t )( limit_check_disable << 1 );
JerrySzczurak	20:cf211a3b3d9e	4670	status = vl53l0x_update_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4671	VL53L0X_REG_MSRC_CONFIG_CONTROL,
JerrySzczurak	20:cf211a3b3d9e	4672	0xFE, temp8 );
johnAlexander	15:932d8b4e52c9	4673
johnAlexander	15:932d8b4e52c9	4674	break;
johnAlexander	15:932d8b4e52c9	4675
johnAlexander	15:932d8b4e52c9	4676	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
johnAlexander	15:932d8b4e52c9	4677
JerrySzczurak	20:cf211a3b3d9e	4678	temp8 = ( uint8_t )( limit_check_disable << 4 );
JerrySzczurak	20:cf211a3b3d9e	4679	status = vl53l0x_update_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4680	VL53L0X_REG_MSRC_CONFIG_CONTROL,
JerrySzczurak	20:cf211a3b3d9e	4681	0xEF, temp8 );
johnAlexander	15:932d8b4e52c9	4682
johnAlexander	15:932d8b4e52c9	4683	break;
johnAlexander	15:932d8b4e52c9	4684
johnAlexander	15:932d8b4e52c9	4685
johnAlexander	15:932d8b4e52c9	4686	default:
johnAlexander	16:98ce55ddbb1a	4687	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	4688
johnAlexander	15:932d8b4e52c9	4689	}
johnAlexander	15:932d8b4e52c9	4690
johnAlexander	15:932d8b4e52c9	4691	}
johnAlexander	15:932d8b4e52c9	4692
JerrySzczurak	20:cf211a3b3d9e	4693	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4694	if ( limit_check_enable == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	4695	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	4696	limit_check_id, 0 );
johnAlexander	15:932d8b4e52c9	4697	} else {
JerrySzczurak	20:cf211a3b3d9e	4698	VL53L0X_SETARRAYPARAMETERFIELD( dev, LimitChecksEnable,
JerrySzczurak	20:cf211a3b3d9e	4699	limit_check_id, 1 );
johnAlexander	15:932d8b4e52c9	4700	}
johnAlexander	15:932d8b4e52c9	4701	}
johnAlexander	15:932d8b4e52c9	4702
JerrySzczurak	20:cf211a3b3d9e	4703	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4704	return status;
JerrySzczurak	20:cf211a3b3d9e	4705	}
JerrySzczurak	20:cf211a3b3d9e	4706
JerrySzczurak	20:cf211a3b3d9e	4707	VL53L0X_Error VL53L0X::vl53l0x_static_init( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	4708	{
johnAlexander	16:98ce55ddbb1a	4709	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4710	VL53L0X_DeviceParameters_t current_parameters = {0};
johnAlexander	16:98ce55ddbb1a	4711	uint8_t *p_tuning_setting_buffer;
johnAlexander	15:932d8b4e52c9	4712	uint16_t tempword = 0;
johnAlexander	15:932d8b4e52c9	4713	uint8_t tempbyte = 0;
johnAlexander	16:98ce55ddbb1a	4714	uint8_t use_internal_tuning_settings = 0;
johnAlexander	15:932d8b4e52c9	4715	uint32_t count = 0;
johnAlexander	16:98ce55ddbb1a	4716	uint8_t is_aperture_spads = 0;
johnAlexander	16:98ce55ddbb1a	4717	uint32_t ref_spad_count = 0;
johnAlexander	16:98ce55ddbb1a	4718	uint8_t aperture_spads = 0;
johnAlexander	16:98ce55ddbb1a	4719	uint8_t vcsel_pulse_period_pclk;
johnAlexander	16:98ce55ddbb1a	4720	uint32_t seq_timeout_micro_secs;
johnAlexander	15:932d8b4e52c9	4721
JerrySzczurak	20:cf211a3b3d9e	4722	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4723
JerrySzczurak	20:cf211a3b3d9e	4724	status = vl53l0x_get_info_from_device( dev, 1 );
johnAlexander	15:932d8b4e52c9	4725
johnAlexander	15:932d8b4e52c9	4726	/* set the ref spad from NVM */
JerrySzczurak	20:cf211a3b3d9e	4727	count = ( uint32_t )VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4728	ReferenceSpadCount );
JerrySzczurak	20:cf211a3b3d9e	4729	aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	4730	ReferenceSpadType );
johnAlexander	15:932d8b4e52c9	4731
johnAlexander	15:932d8b4e52c9	4732	/* NVM value invalid */
JerrySzczurak	20:cf211a3b3d9e	4733	if ( ( aperture_spads > 1 ) \|\|
JerrySzczurak	20:cf211a3b3d9e	4734	( ( aperture_spads == 1 ) && ( count > 32 ) ) \|\|
JerrySzczurak	20:cf211a3b3d9e	4735	( ( aperture_spads == 0 ) && ( count > 12 ) ) )
JerrySzczurak	20:cf211a3b3d9e	4736	status = wrapped_vl53l0x_perform_ref_spad_management( dev, &ref_spad_count,
JerrySzczurak	20:cf211a3b3d9e	4737	&is_aperture_spads );
johnAlexander	15:932d8b4e52c9	4738	else
JerrySzczurak	20:cf211a3b3d9e	4739	status = wrapped_vl53l0x_set_reference_spads( dev, count, aperture_spads );
johnAlexander	15:932d8b4e52c9	4740
johnAlexander	15:932d8b4e52c9	4741
johnAlexander	15:932d8b4e52c9	4742	/* Initialize tuning settings buffer to prevent compiler warning. */
johnAlexander	16:98ce55ddbb1a	4743	p_tuning_setting_buffer = DefaultTuningSettings;
johnAlexander	16:98ce55ddbb1a	4744
JerrySzczurak	20:cf211a3b3d9e	4745	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4746	use_internal_tuning_settings = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	4747	UseInternalTuningSettings );
JerrySzczurak	20:cf211a3b3d9e	4748
JerrySzczurak	20:cf211a3b3d9e	4749	if ( use_internal_tuning_settings == 0 )
JerrySzczurak	20:cf211a3b3d9e	4750	p_tuning_setting_buffer = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	4751	pTuningSettingsPointer );
johnAlexander	15:932d8b4e52c9	4752	else
johnAlexander	16:98ce55ddbb1a	4753	p_tuning_setting_buffer = DefaultTuningSettings;
johnAlexander	15:932d8b4e52c9	4754
johnAlexander	15:932d8b4e52c9	4755	}
johnAlexander	15:932d8b4e52c9	4756
JerrySzczurak	20:cf211a3b3d9e	4757	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4758	status = vl53l0x_load_tuning_settings( dev, p_tuning_setting_buffer );
johnAlexander	15:932d8b4e52c9	4759
johnAlexander	15:932d8b4e52c9	4760
johnAlexander	15:932d8b4e52c9	4761	/* Set interrupt config to new sample ready */
JerrySzczurak	20:cf211a3b3d9e	4762	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4763	status = vl53l0x_set_gpio_config( dev, 0, 0,
JerrySzczurak	20:cf211a3b3d9e	4764	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
JerrySzczurak	20:cf211a3b3d9e	4765	VL53L0X_INTERRUPTPOLARITY_LOW );
JerrySzczurak	20:cf211a3b3d9e	4766	}
JerrySzczurak	20:cf211a3b3d9e	4767
JerrySzczurak	20:cf211a3b3d9e	4768	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4769	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4770	status \|= vl53l0x_read_word( dev, 0x84, &tempword );
JerrySzczurak	20:cf211a3b3d9e	4771	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4772	}
JerrySzczurak	20:cf211a3b3d9e	4773
JerrySzczurak	20:cf211a3b3d9e	4774	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4775	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, OscFrequencyMHz,
JerrySzczurak	20:cf211a3b3d9e	4776	VL53L0X_FIXPOINT412TOFIXPOINT1616( tempword ) );
johnAlexander	15:932d8b4e52c9	4777	}
johnAlexander	15:932d8b4e52c9	4778
johnAlexander	15:932d8b4e52c9	4779	/* After static init, some device parameters may be changed,
johnAlexander	15:932d8b4e52c9	4780	* so update them */
JerrySzczurak	20:cf211a3b3d9e	4781	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4782	status = vl53l0x_get_device_parameters( dev, &current_parameters );
JerrySzczurak	20:cf211a3b3d9e	4783
JerrySzczurak	20:cf211a3b3d9e	4784
JerrySzczurak	20:cf211a3b3d9e	4785	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4786	status = vl53l0x_get_fraction_enable( dev, &tempbyte );
JerrySzczurak	20:cf211a3b3d9e	4787	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4788	PALDevDataSet( dev, RangeFractionalEnable, tempbyte );
JerrySzczurak	20:cf211a3b3d9e	4789
JerrySzczurak	20:cf211a3b3d9e	4790	}
JerrySzczurak	20:cf211a3b3d9e	4791
JerrySzczurak	20:cf211a3b3d9e	4792	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4793	PALDevDataSet( dev, CurrentParameters, current_parameters );
johnAlexander	15:932d8b4e52c9	4794
johnAlexander	15:932d8b4e52c9	4795
johnAlexander	15:932d8b4e52c9	4796	/* read the sequence config and save it */
JerrySzczurak	20:cf211a3b3d9e	4797	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	4798	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	4799	VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &tempbyte );
JerrySzczurak	20:cf211a3b3d9e	4800	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4801	PALDevDataSet( dev, SequenceConfig, tempbyte );
johnAlexander	15:932d8b4e52c9	4802
johnAlexander	15:932d8b4e52c9	4803	}
johnAlexander	15:932d8b4e52c9	4804
johnAlexander	15:932d8b4e52c9	4805	/* Disable MSRC and TCC by default */
JerrySzczurak	20:cf211a3b3d9e	4806	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4807	status = vl53l0x_set_sequence_step_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	4808	VL53L0X_SEQUENCESTEP_TCC, 0 );
JerrySzczurak	20:cf211a3b3d9e	4809
JerrySzczurak	20:cf211a3b3d9e	4810
JerrySzczurak	20:cf211a3b3d9e	4811	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4812	status = vl53l0x_set_sequence_step_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	4813	VL53L0X_SEQUENCESTEP_MSRC, 0 );
johnAlexander	15:932d8b4e52c9	4814
johnAlexander	15:932d8b4e52c9	4815
johnAlexander	15:932d8b4e52c9	4816	/* Set PAL State to standby */
JerrySzczurak	20:cf211a3b3d9e	4817	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4818	PALDevDataSet( dev, PalState, VL53L0X_STATE_IDLE );
johnAlexander	15:932d8b4e52c9	4819
johnAlexander	15:932d8b4e52c9	4820
johnAlexander	15:932d8b4e52c9	4821
johnAlexander	15:932d8b4e52c9	4822	/* Store pre-range vcsel period */
JerrySzczurak	20:cf211a3b3d9e	4823	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	4824	status = vl53l0x_get_vcsel_pulse_period(
JerrySzczurak	20:cf211a3b3d9e	4825	dev,
JerrySzczurak	20:cf211a3b3d9e	4826	VL53L0X_VCSEL_PERIOD_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4827	&vcsel_pulse_period_pclk );
JerrySzczurak	20:cf211a3b3d9e	4828	}
JerrySzczurak	20:cf211a3b3d9e	4829
JerrySzczurak	20:cf211a3b3d9e	4830	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4831	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	17:1b842521063a	4832	dev,
johnAlexander	15:932d8b4e52c9	4833	PreRangeVcselPulsePeriod,
JerrySzczurak	20:cf211a3b3d9e	4834	vcsel_pulse_period_pclk );
johnAlexander	15:932d8b4e52c9	4835	}
johnAlexander	15:932d8b4e52c9	4836
johnAlexander	15:932d8b4e52c9	4837	/* Store final-range vcsel period */
JerrySzczurak	20:cf211a3b3d9e	4838	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	4839	status = vl53l0x_get_vcsel_pulse_period(
JerrySzczurak	20:cf211a3b3d9e	4840	dev,
JerrySzczurak	20:cf211a3b3d9e	4841	VL53L0X_VCSEL_PERIOD_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4842	&vcsel_pulse_period_pclk );
JerrySzczurak	20:cf211a3b3d9e	4843	}
JerrySzczurak	20:cf211a3b3d9e	4844
JerrySzczurak	20:cf211a3b3d9e	4845	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4846	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	17:1b842521063a	4847	dev,
johnAlexander	15:932d8b4e52c9	4848	FinalRangeVcselPulsePeriod,
JerrySzczurak	20:cf211a3b3d9e	4849	vcsel_pulse_period_pclk );
johnAlexander	15:932d8b4e52c9	4850	}
johnAlexander	15:932d8b4e52c9	4851
johnAlexander	15:932d8b4e52c9	4852	/* Store pre-range timeout */
JerrySzczurak	20:cf211a3b3d9e	4853	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	4854	status = get_sequence_step_timeout(
johnAlexander	17:1b842521063a	4855	dev,
johnAlexander	15:932d8b4e52c9	4856	VL53L0X_SEQUENCESTEP_PRE_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4857	&seq_timeout_micro_secs );
JerrySzczurak	20:cf211a3b3d9e	4858	}
JerrySzczurak	20:cf211a3b3d9e	4859
JerrySzczurak	20:cf211a3b3d9e	4860	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4861	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	17:1b842521063a	4862	dev,
johnAlexander	15:932d8b4e52c9	4863	PreRangeTimeoutMicroSecs,
JerrySzczurak	20:cf211a3b3d9e	4864	seq_timeout_micro_secs );
johnAlexander	15:932d8b4e52c9	4865	}
johnAlexander	15:932d8b4e52c9	4866
johnAlexander	15:932d8b4e52c9	4867	/* Store final-range timeout */
JerrySzczurak	20:cf211a3b3d9e	4868	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	4869	status = get_sequence_step_timeout(
johnAlexander	17:1b842521063a	4870	dev,
johnAlexander	15:932d8b4e52c9	4871	VL53L0X_SEQUENCESTEP_FINAL_RANGE,
JerrySzczurak	20:cf211a3b3d9e	4872	&seq_timeout_micro_secs );
JerrySzczurak	20:cf211a3b3d9e	4873	}
JerrySzczurak	20:cf211a3b3d9e	4874
JerrySzczurak	20:cf211a3b3d9e	4875	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4876	VL53L0X_SETDEVICESPECIFICPARAMETER(
johnAlexander	17:1b842521063a	4877	dev,
johnAlexander	15:932d8b4e52c9	4878	FinalRangeTimeoutMicroSecs,
JerrySzczurak	20:cf211a3b3d9e	4879	seq_timeout_micro_secs );
JerrySzczurak	20:cf211a3b3d9e	4880	}
JerrySzczurak	20:cf211a3b3d9e	4881
JerrySzczurak	20:cf211a3b3d9e	4882	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4883	return status;
JerrySzczurak	20:cf211a3b3d9e	4884	}
JerrySzczurak	20:cf211a3b3d9e	4885
JerrySzczurak	20:cf211a3b3d9e	4886
JerrySzczurak	20:cf211a3b3d9e	4887	VL53L0X_Error VL53L0X::vl53l0x_stop_measurement( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	4888	{
johnAlexander	16:98ce55ddbb1a	4889	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	4890	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4891
JerrySzczurak	20:cf211a3b3d9e	4892	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSRANGE_START,
JerrySzczurak	20:cf211a3b3d9e	4893	VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT );
JerrySzczurak	20:cf211a3b3d9e	4894
JerrySzczurak	20:cf211a3b3d9e	4895	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4896	status = vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4897	status = vl53l0x_write_byte( dev, 0x91, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4898	status = vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4899	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4900
JerrySzczurak	20:cf211a3b3d9e	4901	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	15:932d8b4e52c9	4902	/* Set PAL State to Idle */
JerrySzczurak	20:cf211a3b3d9e	4903	PALDevDataSet( dev, PalState, VL53L0X_STATE_IDLE );
johnAlexander	15:932d8b4e52c9	4904	}
johnAlexander	15:932d8b4e52c9	4905
johnAlexander	15:932d8b4e52c9	4906	/* Check if need to apply interrupt settings */
JerrySzczurak	20:cf211a3b3d9e	4907	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4908	status = vl53l0x_check_and_load_interrupt_settings( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	4909
JerrySzczurak	20:cf211a3b3d9e	4910	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	4911	return status;
JerrySzczurak	20:cf211a3b3d9e	4912	}
JerrySzczurak	20:cf211a3b3d9e	4913
JerrySzczurak	20:cf211a3b3d9e	4914	VL53L0X_Error VL53L0X::vl53l0x_get_stop_completed_status( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	4915	uint32_t *p_stop_status )
johnAlexander	0:c523920bcc09	4916	{
johnAlexander	16:98ce55ddbb1a	4917	VL53L0X_Error status = VL53L0X_ERROR_NONE;
johnAlexander	16:98ce55ddbb1a	4918	uint8_t byte = 0;
JerrySzczurak	20:cf211a3b3d9e	4919	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	4920
JerrySzczurak	20:cf211a3b3d9e	4921	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4922
JerrySzczurak	20:cf211a3b3d9e	4923	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4924	status = vl53l0x_read_byte( dev, 0x04, &byte );
JerrySzczurak	20:cf211a3b3d9e	4925
JerrySzczurak	20:cf211a3b3d9e	4926	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	4927	status = vl53l0x_write_byte( dev, 0xFF, 0x0 );
johnAlexander	16:98ce55ddbb1a	4928
johnAlexander	16:98ce55ddbb1a	4929	*p_stop_status = byte;
johnAlexander	16:98ce55ddbb1a	4930
JerrySzczurak	20:cf211a3b3d9e	4931	if ( byte == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	4932	status = vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4933	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4934	status = vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4935	status = vl53l0x_write_byte( dev, 0x91,
JerrySzczurak	20:cf211a3b3d9e	4936	PALDevDataGet( dev, StopVariable ) );
JerrySzczurak	20:cf211a3b3d9e	4937	status = vl53l0x_write_byte( dev, 0x00, 0x01 );
JerrySzczurak	20:cf211a3b3d9e	4938	status = vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4939	status = vl53l0x_write_byte( dev, 0x80, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	4940	}
JerrySzczurak	20:cf211a3b3d9e	4941
JerrySzczurak	20:cf211a3b3d9e	4942	LOG_FUNCTION_END( status );
johnAlexander	16:98ce55ddbb1a	4943	return status;
johnAlexander	0:c523920bcc09	4944	}
johnAlexander	0:c523920bcc09	4945
johnAlexander	0:c523920bcc09	4946	/**************** Write and read functions from I2C ***********************/
johnAlexander	0:c523920bcc09	4947
JerrySzczurak	20:cf211a3b3d9e	4948	VL53L0X_Error VL53L0X::vl53l0x_write_multi( VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count )
johnAlexander	0:c523920bcc09	4949	{
johnAlexander	15:932d8b4e52c9	4950	int status;
johnAlexander	15:932d8b4e52c9	4951
JerrySzczurak	20:cf211a3b3d9e	4952	status = vl53l0x_i2c_write( dev->I2cDevAddr, index, p_data, ( uint16_t )count );
JerrySzczurak	20:cf211a3b3d9e	4953	return status;
JerrySzczurak	20:cf211a3b3d9e	4954	}
JerrySzczurak	20:cf211a3b3d9e	4955
JerrySzczurak	20:cf211a3b3d9e	4956	VL53L0X_Error VL53L0X::vl53l0x_read_multi( VL53L0X_DEV dev, uint8_t index, uint8_t *p_data, uint32_t count )
johnAlexander	0:c523920bcc09	4957	{
johnAlexander	0:c523920bcc09	4958	int status;
johnAlexander	0:c523920bcc09	4959
JerrySzczurak	20:cf211a3b3d9e	4960	if ( count >= VL53L0X_MAX_I2C_XFER_SIZE ) {
johnAlexander	0:c523920bcc09	4961	status = VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	0:c523920bcc09	4962	}
johnAlexander	0:c523920bcc09	4963
JerrySzczurak	20:cf211a3b3d9e	4964	status = vl53l0x_i2c_read( dev->I2cDevAddr, index, p_data, ( uint16_t )count );
JerrySzczurak	20:cf211a3b3d9e	4965
JerrySzczurak	20:cf211a3b3d9e	4966	return status;
JerrySzczurak	20:cf211a3b3d9e	4967	}
JerrySzczurak	20:cf211a3b3d9e	4968
JerrySzczurak	20:cf211a3b3d9e	4969
JerrySzczurak	20:cf211a3b3d9e	4970	VL53L0X_Error VL53L0X::vl53l0x_write_byte( VL53L0X_DEV Dev, uint8_t index, uint8_t data )
johnAlexander	0:c523920bcc09	4971	{
johnAlexander	15:932d8b4e52c9	4972	int status;
johnAlexander	15:932d8b4e52c9	4973
JerrySzczurak	20:cf211a3b3d9e	4974	status = vl53l0x_i2c_write( Dev->I2cDevAddr, index, &data, 1 );
JerrySzczurak	20:cf211a3b3d9e	4975	return status;
JerrySzczurak	20:cf211a3b3d9e	4976	}
JerrySzczurak	20:cf211a3b3d9e	4977
JerrySzczurak	20:cf211a3b3d9e	4978	VL53L0X_Error VL53L0X::vl53l0x_write_word( VL53L0X_DEV dev, uint8_t index, uint16_t data )
johnAlexander	0:c523920bcc09	4979	{
johnAlexander	15:932d8b4e52c9	4980	int status;
johnAlexander	15:932d8b4e52c9	4981	uint8_t buffer[2];
johnAlexander	15:932d8b4e52c9	4982
johnAlexander	15:932d8b4e52c9	4983	buffer[0] = data >> 8;
johnAlexander	15:932d8b4e52c9	4984	buffer[1] = data & 0x00FF;
JerrySzczurak	20:cf211a3b3d9e	4985	status = vl53l0x_i2c_write( dev->I2cDevAddr, index, ( uint8_t * )buffer, 2 );
JerrySzczurak	20:cf211a3b3d9e	4986	return status;
JerrySzczurak	20:cf211a3b3d9e	4987	}
JerrySzczurak	20:cf211a3b3d9e	4988
JerrySzczurak	20:cf211a3b3d9e	4989	VL53L0X_Error VL53L0X::vl53l0x_write_dword( VL53L0X_DEV Dev, uint8_t index, uint32_t data )
johnAlexander	0:c523920bcc09	4990	{
johnAlexander	15:932d8b4e52c9	4991	int status;
johnAlexander	15:932d8b4e52c9	4992	uint8_t buffer[4];
johnAlexander	15:932d8b4e52c9	4993
JerrySzczurak	20:cf211a3b3d9e	4994	buffer[0] = ( data >> 24 ) & 0xFF;
JerrySzczurak	20:cf211a3b3d9e	4995	buffer[1] = ( data >> 16 ) & 0xFF;
JerrySzczurak	20:cf211a3b3d9e	4996	buffer[2] = ( data >> 8 ) & 0xFF;
JerrySzczurak	20:cf211a3b3d9e	4997	buffer[3] = ( data >> 0 ) & 0xFF;
JerrySzczurak	20:cf211a3b3d9e	4998	status = vl53l0x_i2c_write( Dev->I2cDevAddr, index, ( uint8_t * )buffer, 4 );
JerrySzczurak	20:cf211a3b3d9e	4999	return status;
JerrySzczurak	20:cf211a3b3d9e	5000	}
JerrySzczurak	20:cf211a3b3d9e	5001
JerrySzczurak	20:cf211a3b3d9e	5002
JerrySzczurak	20:cf211a3b3d9e	5003	VL53L0X_Error VL53L0X::vl53l0x_read_byte( VL53L0X_DEV Dev, uint8_t index, uint8_t *p_data )
johnAlexander	0:c523920bcc09	5004	{
johnAlexander	15:932d8b4e52c9	5005	int status;
johnAlexander	15:932d8b4e52c9	5006
JerrySzczurak	20:cf211a3b3d9e	5007	status = vl53l0x_i2c_read( Dev->I2cDevAddr, index, p_data, 1 );
JerrySzczurak	20:cf211a3b3d9e	5008
JerrySzczurak	20:cf211a3b3d9e	5009	if( status )
johnAlexander	15:932d8b4e52c9	5010	return -1;
johnAlexander	15:932d8b4e52c9	5011
johnAlexander	15:932d8b4e52c9	5012	return 0;
johnAlexander	0:c523920bcc09	5013	}
johnAlexander	15:932d8b4e52c9	5014
JerrySzczurak	20:cf211a3b3d9e	5015	VL53L0X_Error VL53L0X::vl53l0x_read_word( VL53L0X_DEV Dev, uint8_t index, uint16_t *p_data )
johnAlexander	0:c523920bcc09	5016	{
johnAlexander	15:932d8b4e52c9	5017	int status;
JerrySzczurak	20:cf211a3b3d9e	5018	uint8_t buffer[2] = {0, 0};
JerrySzczurak	20:cf211a3b3d9e	5019
JerrySzczurak	20:cf211a3b3d9e	5020	status = vl53l0x_i2c_read( Dev->I2cDevAddr, index, buffer, 2 );
JerrySzczurak	20:cf211a3b3d9e	5021	if ( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5022	*p_data = ( buffer[0] << 8 ) + buffer[1];
JerrySzczurak	20:cf211a3b3d9e	5023	}
JerrySzczurak	20:cf211a3b3d9e	5024	return status;
JerrySzczurak	20:cf211a3b3d9e	5025
JerrySzczurak	20:cf211a3b3d9e	5026	}
JerrySzczurak	20:cf211a3b3d9e	5027
JerrySzczurak	20:cf211a3b3d9e	5028	VL53L0X_Error VL53L0X::vl53l0x_read_dword( VL53L0X_DEV Dev, uint8_t index, uint32_t *p_data )
johnAlexander	0:c523920bcc09	5029	{
johnAlexander	15:932d8b4e52c9	5030	int status;
JerrySzczurak	20:cf211a3b3d9e	5031	uint8_t buffer[4] = {0, 0, 0, 0};
JerrySzczurak	20:cf211a3b3d9e	5032
JerrySzczurak	20:cf211a3b3d9e	5033	status = vl53l0x_i2c_read( Dev->I2cDevAddr, index, buffer, 4 );
JerrySzczurak	20:cf211a3b3d9e	5034	if( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5035	*p_data = ( buffer[0] << 24 ) + ( buffer[1] << 16 ) + ( buffer[2] << 8 ) + buffer[3];
JerrySzczurak	20:cf211a3b3d9e	5036	}
JerrySzczurak	20:cf211a3b3d9e	5037	return status;
JerrySzczurak	20:cf211a3b3d9e	5038
JerrySzczurak	20:cf211a3b3d9e	5039	}
JerrySzczurak	20:cf211a3b3d9e	5040
JerrySzczurak	20:cf211a3b3d9e	5041	VL53L0X_Error VL53L0X::vl53l0x_update_byte( VL53L0X_DEV Dev, uint8_t index, uint8_t and_data, uint8_t or_data )
johnAlexander	0:c523920bcc09	5042	{
johnAlexander	15:932d8b4e52c9	5043	int status;
johnAlexander	15:932d8b4e52c9	5044	uint8_t buffer = 0;
johnAlexander	15:932d8b4e52c9	5045
johnAlexander	15:932d8b4e52c9	5046	/* read data direct onto buffer */
JerrySzczurak	20:cf211a3b3d9e	5047	status = vl53l0x_i2c_read( Dev->I2cDevAddr, index, &buffer, 1 );
JerrySzczurak	20:cf211a3b3d9e	5048	if ( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5049	buffer = ( buffer & and_data ) \| or_data;
JerrySzczurak	20:cf211a3b3d9e	5050	status = vl53l0x_i2c_write( Dev->I2cDevAddr, index, &buffer, ( uint8_t )1 );
JerrySzczurak	20:cf211a3b3d9e	5051	}
JerrySzczurak	20:cf211a3b3d9e	5052	return status;
JerrySzczurak	20:cf211a3b3d9e	5053	}
JerrySzczurak	20:cf211a3b3d9e	5054
JerrySzczurak	20:cf211a3b3d9e	5055	VL53L0X_Error VL53L0X::vl53l0x_i2c_write( uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
JerrySzczurak	20:cf211a3b3d9e	5056	uint16_t NumByteToWrite )
johnAlexander	0:c523920bcc09	5057	{
johnAlexander	15:932d8b4e52c9	5058	int ret;
johnAlexander	15:932d8b4e52c9	5059
JerrySzczurak	20:cf211a3b3d9e	5060	ret = dev_i2c.i2c_write( p_data, DeviceAddr, RegisterAddr, NumByteToWrite );
JerrySzczurak	20:cf211a3b3d9e	5061
JerrySzczurak	20:cf211a3b3d9e	5062	if( ret )
johnAlexander	15:932d8b4e52c9	5063	return -1;
johnAlexander	15:932d8b4e52c9	5064	return 0;
johnAlexander	0:c523920bcc09	5065	}
johnAlexander	15:932d8b4e52c9	5066
JerrySzczurak	20:cf211a3b3d9e	5067	VL53L0X_Error VL53L0X::vl53l0x_i2c_read( uint8_t DeviceAddr, uint8_t RegisterAddr, uint8_t *p_data,
JerrySzczurak	20:cf211a3b3d9e	5068	uint16_t NumByteToRead )
johnAlexander	0:c523920bcc09	5069	{
johnAlexander	15:932d8b4e52c9	5070	int ret;
johnAlexander	15:932d8b4e52c9	5071
JerrySzczurak	20:cf211a3b3d9e	5072	ret = dev_i2c.i2c_read( p_data, DeviceAddr, RegisterAddr, NumByteToRead );
JerrySzczurak	20:cf211a3b3d9e	5073
JerrySzczurak	20:cf211a3b3d9e	5074	if( ret )
johnAlexander	15:932d8b4e52c9	5075	return -1;
johnAlexander	15:932d8b4e52c9	5076	return 0;
johnAlexander	15:932d8b4e52c9	5077	}
johnAlexander	0:c523920bcc09	5078
JerrySzczurak	20:cf211a3b3d9e	5079	int VL53L0X::read_id( uint8_t *id )
johnAlexander	0:c523920bcc09	5080	{
johnAlexander	0:c523920bcc09	5081	int status = 0;
JerrySzczurak	20:cf211a3b3d9e	5082	uint16_t rl_id = 0;
JerrySzczurak	20:cf211a3b3d9e	5083
JerrySzczurak	20:cf211a3b3d9e	5084	status = vl53l0x_read_word( _device, VL53L0X_REG_IDENTIFICATION_MODEL_ID, &rl_id );
JerrySzczurak	20:cf211a3b3d9e	5085	if ( rl_id == 0xEEAA )
johnAlexander	0:c523920bcc09	5086	return status;
johnAlexander	15:932d8b4e52c9	5087
johnAlexander	0:c523920bcc09	5088	return -1;
johnAlexander	0:c523920bcc09	5089	}
JerrySzczurak	11:ceaa5a026412	5090
johnAlexander	15:932d8b4e52c9	5091
JerrySzczurak	20:cf211a3b3d9e	5092	VL53L0X_Error VL53L0X::wait_measurement_data_ready( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	5093	{
johnAlexander	16:98ce55ddbb1a	5094	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5095	uint8_t new_dat_ready = 0;
johnAlexander	16:98ce55ddbb1a	5096	uint32_t loop_nb;
johnAlexander	0:c523920bcc09	5097
johnAlexander	0:c523920bcc09	5098	// Wait until it finished
johnAlexander	0:c523920bcc09	5099	// use timeout to avoid deadlock
JerrySzczurak	20:cf211a3b3d9e	5100	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	5101	loop_nb = 0;
johnAlexander	0:c523920bcc09	5102	do {
JerrySzczurak	20:cf211a3b3d9e	5103	status = vl53l0x_get_measurement_data_ready( dev, &new_dat_ready );
JerrySzczurak	20:cf211a3b3d9e	5104	if ( ( new_dat_ready == 0x01 ) \|\| status != VL53L0X_ERROR_NONE ) {
johnAlexander	0:c523920bcc09	5105	break;
johnAlexander	0:c523920bcc09	5106	}
johnAlexander	16:98ce55ddbb1a	5107	loop_nb = loop_nb + 1;
JerrySzczurak	20:cf211a3b3d9e	5108	vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	5109	} while ( loop_nb < VL53L0X_DEFAULT_MAX_LOOP );
JerrySzczurak	20:cf211a3b3d9e	5110
JerrySzczurak	20:cf211a3b3d9e	5111	if ( loop_nb >= VL53L0X_DEFAULT_MAX_LOOP ) {
johnAlexander	16:98ce55ddbb1a	5112	status = VL53L0X_ERROR_TIME_OUT;
johnAlexander	0:c523920bcc09	5113	}
johnAlexander	0:c523920bcc09	5114	}
johnAlexander	0:c523920bcc09	5115
johnAlexander	16:98ce55ddbb1a	5116	return status;
johnAlexander	0:c523920bcc09	5117	}
johnAlexander	0:c523920bcc09	5118
JerrySzczurak	20:cf211a3b3d9e	5119	VL53L0X_Error VL53L0X::wait_stop_completed( VL53L0X_DEV dev )
johnAlexander	0:c523920bcc09	5120	{
johnAlexander	16:98ce55ddbb1a	5121	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5122	uint32_t stop_completed = 0;
johnAlexander	16:98ce55ddbb1a	5123	uint32_t loop_nb;
johnAlexander	0:c523920bcc09	5124
johnAlexander	0:c523920bcc09	5125	// Wait until it finished
johnAlexander	0:c523920bcc09	5126	// use timeout to avoid deadlock
JerrySzczurak	20:cf211a3b3d9e	5127	if ( status == VL53L0X_ERROR_NONE ) {
johnAlexander	16:98ce55ddbb1a	5128	loop_nb = 0;
johnAlexander	0:c523920bcc09	5129	do {
JerrySzczurak	20:cf211a3b3d9e	5130	status = vl53l0x_get_stop_completed_status( dev, &stop_completed );
JerrySzczurak	20:cf211a3b3d9e	5131	if ( ( stop_completed == 0x00 ) \|\| status != VL53L0X_ERROR_NONE ) {
johnAlexander	0:c523920bcc09	5132	break;
johnAlexander	0:c523920bcc09	5133	}
johnAlexander	16:98ce55ddbb1a	5134	loop_nb = loop_nb + 1;
JerrySzczurak	20:cf211a3b3d9e	5135	vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	5136	} while ( loop_nb < VL53L0X_DEFAULT_MAX_LOOP );
JerrySzczurak	20:cf211a3b3d9e	5137
JerrySzczurak	20:cf211a3b3d9e	5138	if ( loop_nb >= VL53L0X_DEFAULT_MAX_LOOP ) {
johnAlexander	16:98ce55ddbb1a	5139	status = VL53L0X_ERROR_TIME_OUT;
johnAlexander	0:c523920bcc09	5140	}
johnAlexander	0:c523920bcc09	5141
johnAlexander	0:c523920bcc09	5142	}
johnAlexander	0:c523920bcc09	5143
johnAlexander	16:98ce55ddbb1a	5144	return status;
johnAlexander	0:c523920bcc09	5145	}
johnAlexander	0:c523920bcc09	5146
johnAlexander	0:c523920bcc09	5147
JerrySzczurak	20:cf211a3b3d9e	5148	int VL53L0X::init_sensor( uint8_t new_addr )
johnAlexander	0:c523920bcc09	5149	{
johnAlexander	15:932d8b4e52c9	5150	int status;
johnAlexander	15:932d8b4e52c9	5151
johnAlexander	16:98ce55ddbb1a	5152	vl53l0x_off();
johnAlexander	16:98ce55ddbb1a	5153	vl53l0x_on();
johnAlexander	0:c523920bcc09	5154
johnAlexander	0:c523920bcc09	5155	// status=VL53L0X_WaitDeviceBooted(Device);
johnAlexander	0:c523920bcc09	5156	// if(status)
johnAlexander	0:c523920bcc09	5157	// printf("WaitDeviceBooted fail\n\r");
JerrySzczurak	20:cf211a3b3d9e	5158	status = is_present();
JerrySzczurak	20:cf211a3b3d9e	5159	if( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5160	status = init( &_my_device );
JerrySzczurak	20:cf211a3b3d9e	5161	if( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5162	printf( "Failed to init VL53L0X sensor!\n\r" );
johnAlexander	0:c523920bcc09	5163	return status;
johnAlexander	15:932d8b4e52c9	5164	}
johnAlexander	15:932d8b4e52c9	5165
johnAlexander	15:932d8b4e52c9	5166	// deduce silicon version
JerrySzczurak	20:cf211a3b3d9e	5167	status = vl53l0x_get_device_info( &_my_device, &_device_info );
JerrySzczurak	20:cf211a3b3d9e	5168
JerrySzczurak	20:cf211a3b3d9e	5169
JerrySzczurak	20:cf211a3b3d9e	5170	status = prepare();
JerrySzczurak	20:cf211a3b3d9e	5171	if( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5172	printf( "Failed to prepare VL53L0X!\n\r" );
johnAlexander	15:932d8b4e52c9	5173	return status;
johnAlexander	15:932d8b4e52c9	5174	}
johnAlexander	15:932d8b4e52c9	5175
JerrySzczurak	20:cf211a3b3d9e	5176	if( new_addr != DEFAULT_DEVICE_ADDRESS ) {
JerrySzczurak	20:cf211a3b3d9e	5177	status = set_device_address( new_addr );
JerrySzczurak	20:cf211a3b3d9e	5178	if( status ) {
JerrySzczurak	20:cf211a3b3d9e	5179	printf( "Failed to change I2C address!\n\r" );
johnAlexander	15:932d8b4e52c9	5180	return status;
johnAlexander	15:932d8b4e52c9	5181	}
johnAlexander	15:932d8b4e52c9	5182	} else {
JerrySzczurak	20:cf211a3b3d9e	5183	printf( "Invalid new address!\n\r" );
johnAlexander	15:932d8b4e52c9	5184	return VL53L0X_ERROR_INVALID_PARAMS;
johnAlexander	15:932d8b4e52c9	5185	}
johnAlexander	15:932d8b4e52c9	5186	}
johnAlexander	15:932d8b4e52c9	5187	return status;
johnAlexander	0:c523920bcc09	5188	}
johnAlexander	12:f6e2bad00dc7	5189
JerrySzczurak	20:cf211a3b3d9e	5190	int VL53L0X::range_meas_int_continuous_mode( void ( *fptr )( void ) )
johnAlexander	12:f6e2bad00dc7	5191	{
johnAlexander	16:98ce55ddbb1a	5192	int status, clr_status;
johnAlexander	16:98ce55ddbb1a	5193
JerrySzczurak	20:cf211a3b3d9e	5194	status = vl53l0x_stop_measurement( _device ); // it is safer to do this while sensor is stopped
johnAlexander	13:615f7e38568c	5195
johnAlexander	13:615f7e38568c	5196	// status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
johnAlexander	13:615f7e38568c	5197
JerrySzczurak	20:cf211a3b3d9e	5198	status = vl53l0x_set_gpio_config( _device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
JerrySzczurak	20:cf211a3b3d9e	5199	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
JerrySzczurak	20:cf211a3b3d9e	5200	VL53L0X_INTERRUPTPOLARITY_HIGH );
JerrySzczurak	20:cf211a3b3d9e	5201
JerrySzczurak	20:cf211a3b3d9e	5202	if ( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5203	attach_interrupt_measure_detection_irq( fptr );
johnAlexander	16:98ce55ddbb1a	5204	enable_interrupt_measure_detection_irq();
johnAlexander	15:932d8b4e52c9	5205	}
johnAlexander	15:932d8b4e52c9	5206
JerrySzczurak	20:cf211a3b3d9e	5207	clr_status = clear_interrupt( VL53L0X_REG_RESULT_INTERRUPT_STATUS \| VL53L0X_REG_RESULT_RANGE_STATUS );
JerrySzczurak	20:cf211a3b3d9e	5208	if( clr_status )
JerrySzczurak	20:cf211a3b3d9e	5209	VL53L0X_ErrLog( "VL53L0X_ClearErrorInterrupt fail\r\n" );
JerrySzczurak	20:cf211a3b3d9e	5210
JerrySzczurak	20:cf211a3b3d9e	5211	if( !status ) {
JerrySzczurak	20:cf211a3b3d9e	5212	status = range_start_continuous_mode();
JerrySzczurak	20:cf211a3b3d9e	5213	}
JerrySzczurak	20:cf211a3b3d9e	5214	return status;
JerrySzczurak	20:cf211a3b3d9e	5215	}
JerrySzczurak	20:cf211a3b3d9e	5216
JerrySzczurak	20:cf211a3b3d9e	5217
JerrySzczurak	20:cf211a3b3d9e	5218	int VL53L0X::start_measurement( OperatingMode operating_mode, void ( *fptr )( void ) )
johnAlexander	0:c523920bcc09	5219	{
johnAlexander	0:c523920bcc09	5220	int Status = VL53L0X_ERROR_NONE;
johnAlexander	13:615f7e38568c	5221	int ClrStatus;
johnAlexander	0:c523920bcc09	5222
johnAlexander	0:c523920bcc09	5223	uint8_t VhvSettings;
johnAlexander	0:c523920bcc09	5224	uint8_t PhaseCal;
johnAlexander	0:c523920bcc09	5225	// *** from mass market cube expansion v1.1, ranging with satellites.
johnAlexander	0:c523920bcc09	5226	// default settings, for normal range.
JerrySzczurak	20:cf211a3b3d9e	5227	FixPoint1616_t signalLimit = ( FixPoint1616_t )( 0.25 * 65536 );
JerrySzczurak	20:cf211a3b3d9e	5228	FixPoint1616_t sigmaLimit = ( FixPoint1616_t )( 18 * 65536 );
johnAlexander	15:932d8b4e52c9	5229	uint32_t timingBudget = 33000;
johnAlexander	15:932d8b4e52c9	5230	uint8_t preRangeVcselPeriod = 14;
johnAlexander	15:932d8b4e52c9	5231	uint8_t finalRangeVcselPeriod = 10;
johnAlexander	15:932d8b4e52c9	5232
JerrySzczurak	20:cf211a3b3d9e	5233	if ( operating_mode == range_continuous_interrupt ) {
JerrySzczurak	20:cf211a3b3d9e	5234	if ( gpio1Int == NULL ) {
JerrySzczurak	20:cf211a3b3d9e	5235	printf ( "GPIO1 Error\r\n" );
johnAlexander	12:f6e2bad00dc7	5236	return 1;
johnAlexander	12:f6e2bad00dc7	5237	}
johnAlexander	13:615f7e38568c	5238
JerrySzczurak	20:cf211a3b3d9e	5239	Status = vl53l0x_stop_measurement( _device ); // it is safer to do this while sensor is stopped
johnAlexander	13:615f7e38568c	5240
johnAlexander	13:615f7e38568c	5241	// Status = VL53L0X_SetInterruptThresholds(Device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING, 0, 300);
johnAlexander	13:615f7e38568c	5242
JerrySzczurak	20:cf211a3b3d9e	5243	Status = vl53l0x_set_gpio_config( _device, 0, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING,
JerrySzczurak	20:cf211a3b3d9e	5244	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY,
JerrySzczurak	20:cf211a3b3d9e	5245	VL53L0X_INTERRUPTPOLARITY_HIGH );
JerrySzczurak	20:cf211a3b3d9e	5246
JerrySzczurak	20:cf211a3b3d9e	5247	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5248	attach_interrupt_measure_detection_irq( fptr );
johnAlexander	16:98ce55ddbb1a	5249	enable_interrupt_measure_detection_irq();
johnAlexander	12:f6e2bad00dc7	5250	}
johnAlexander	13:615f7e38568c	5251
JerrySzczurak	20:cf211a3b3d9e	5252	ClrStatus = clear_interrupt( VL53L0X_REG_RESULT_INTERRUPT_STATUS \| VL53L0X_REG_RESULT_RANGE_STATUS );
JerrySzczurak	20:cf211a3b3d9e	5253	if( ClrStatus )
JerrySzczurak	20:cf211a3b3d9e	5254	VL53L0X_ErrLog( "VL53L0X_ClearErrorInterrupt fail\r\n" );
JerrySzczurak	20:cf211a3b3d9e	5255
JerrySzczurak	20:cf211a3b3d9e	5256	if( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5257	Status = vl53l0x_set_device_mode( _device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING ); // Setup in continuous ranging mode
johnAlexander	13:615f7e38568c	5258	}
johnAlexander	13:615f7e38568c	5259
JerrySzczurak	20:cf211a3b3d9e	5260	if( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5261	Status = vl53l0x_start_measurement( _device );
johnAlexander	13:615f7e38568c	5262	}
johnAlexander	12:f6e2bad00dc7	5263	}
johnAlexander	0:c523920bcc09	5264
JerrySzczurak	20:cf211a3b3d9e	5265	if ( operating_mode == range_single_shot_polling ) {
johnAlexander	0:c523920bcc09	5266	// singelshot, polled ranging
JerrySzczurak	20:cf211a3b3d9e	5267	if( Status == VL53L0X_ERROR_NONE ) {
johnAlexander	0:c523920bcc09	5268	// no need to do this when we use VL53L0X_PerformSingleRangingMeasurement
JerrySzczurak	20:cf211a3b3d9e	5269	Status = vl53l0x_set_device_mode( _device, VL53L0X_DEVICEMODE_SINGLE_RANGING ); // Setup in single ranging mode
johnAlexander	0:c523920bcc09	5270	}
johnAlexander	0:c523920bcc09	5271
johnAlexander	0:c523920bcc09	5272	// Enable/Disable Sigma and Signal check
JerrySzczurak	20:cf211a3b3d9e	5273	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5274	Status = vl53l0x_set_limit_check_enable( _device,
JerrySzczurak	20:cf211a3b3d9e	5275	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, 1 );
johnAlexander	0:c523920bcc09	5276	}
JerrySzczurak	20:cf211a3b3d9e	5277	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5278	Status = vl53l0x_set_limit_check_enable( _device,
JerrySzczurak	20:cf211a3b3d9e	5279	VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, 1 );
johnAlexander	0:c523920bcc09	5280	}
johnAlexander	0:c523920bcc09	5281
johnAlexander	0:c523920bcc09	5282	// *** from mass market cube expansion v1.1, ranging with satellites.
johnAlexander	15:932d8b4e52c9	5283	/* Ranging configuration */
johnAlexander	0:c523920bcc09	5284	//*
johnAlexander	0:c523920bcc09	5285	// switch(rangingConfig) {
johnAlexander	0:c523920bcc09	5286	// case LONG_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5287	signalLimit = ( FixPoint1616_t )( 0.1 * 65536 );
JerrySzczurak	20:cf211a3b3d9e	5288	sigmaLimit = ( FixPoint1616_t )( 60 * 65536 );
johnAlexander	15:932d8b4e52c9	5289	timingBudget = 33000;
johnAlexander	15:932d8b4e52c9	5290	preRangeVcselPeriod = 18;
johnAlexander	15:932d8b4e52c9	5291	finalRangeVcselPeriod = 14;
johnAlexander	15:932d8b4e52c9	5292	/* break;
johnAlexander	15:932d8b4e52c9	5293	case HIGH_ACCURACY:
johnAlexander	15:932d8b4e52c9	5294	signalLimit = (FixPoint1616_t)(0.25*65536);
johnAlexander	15:932d8b4e52c9	5295	sigmaLimit = (FixPoint1616_t)(18*65536);
johnAlexander	15:932d8b4e52c9	5296	timingBudget = 200000;
johnAlexander	15:932d8b4e52c9	5297	preRangeVcselPeriod = 14;
johnAlexander	15:932d8b4e52c9	5298	finalRangeVcselPeriod = 10;
johnAlexander	15:932d8b4e52c9	5299	break;
johnAlexander	15:932d8b4e52c9	5300	case HIGH_SPEED:
johnAlexander	15:932d8b4e52c9	5301	signalLimit = (FixPoint1616_t)(0.25*65536);
johnAlexander	15:932d8b4e52c9	5302	sigmaLimit = (FixPoint1616_t)(32*65536);
johnAlexander	15:932d8b4e52c9	5303	timingBudget = 20000;
johnAlexander	15:932d8b4e52c9	5304	preRangeVcselPeriod = 14;
johnAlexander	15:932d8b4e52c9	5305	finalRangeVcselPeriod = 10;
johnAlexander	15:932d8b4e52c9	5306	break;
johnAlexander	15:932d8b4e52c9	5307	default:
johnAlexander	15:932d8b4e52c9	5308	debug_printf("Not Supported");
johnAlexander	15:932d8b4e52c9	5309	}
johnAlexander	15:932d8b4e52c9	5310	*/
johnAlexander	0:c523920bcc09	5311
JerrySzczurak	20:cf211a3b3d9e	5312	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5313	Status = vl53l0x_set_limit_check_value( _device,
JerrySzczurak	20:cf211a3b3d9e	5314	VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE, signalLimit );
johnAlexander	15:932d8b4e52c9	5315	}
johnAlexander	0:c523920bcc09	5316
JerrySzczurak	20:cf211a3b3d9e	5317	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5318	Status = vl53l0x_set_limit_check_value( _device,
JerrySzczurak	20:cf211a3b3d9e	5319	VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE, sigmaLimit );
johnAlexander	15:932d8b4e52c9	5320	}
johnAlexander	0:c523920bcc09	5321
JerrySzczurak	20:cf211a3b3d9e	5322	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5323	Status = vl53l0x_set_measurement_timing_budget_micro_seconds( _device, timingBudget );
johnAlexander	0:c523920bcc09	5324	}
johnAlexander	0:c523920bcc09	5325
JerrySzczurak	20:cf211a3b3d9e	5326	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5327	Status = vl53l0x_set_vcsel_pulse_period( _device,
JerrySzczurak	20:cf211a3b3d9e	5328	VL53L0X_VCSEL_PERIOD_PRE_RANGE, preRangeVcselPeriod );
johnAlexander	15:932d8b4e52c9	5329	}
johnAlexander	0:c523920bcc09	5330
JerrySzczurak	20:cf211a3b3d9e	5331	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5332	Status = vl53l0x_set_vcsel_pulse_period( _device,
JerrySzczurak	20:cf211a3b3d9e	5333	VL53L0X_VCSEL_PERIOD_FINAL_RANGE, finalRangeVcselPeriod );
johnAlexander	15:932d8b4e52c9	5334	}
johnAlexander	0:c523920bcc09	5335
JerrySzczurak	20:cf211a3b3d9e	5336	if ( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5337	Status = vl53l0x_perform_ref_calibration( _device, &VhvSettings, &PhaseCal );
johnAlexander	15:932d8b4e52c9	5338	}
johnAlexander	0:c523920bcc09	5339
johnAlexander	0:c523920bcc09	5340	}
johnAlexander	0:c523920bcc09	5341
JerrySzczurak	20:cf211a3b3d9e	5342	if ( operating_mode == range_continuous_polling ) {
JerrySzczurak	20:cf211a3b3d9e	5343	if( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5344	printf ( "Call of VL53L0X_SetDeviceMode\n" );
JerrySzczurak	20:cf211a3b3d9e	5345	Status = vl53l0x_set_device_mode( _device, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING ); // Setup in continuous ranging mode
johnAlexander	0:c523920bcc09	5346	}
johnAlexander	0:c523920bcc09	5347
JerrySzczurak	20:cf211a3b3d9e	5348	if( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5349	printf ( "Call of VL53L0X_StartMeasurement\n" );
JerrySzczurak	20:cf211a3b3d9e	5350	Status = vl53l0x_start_measurement( _device );
johnAlexander	0:c523920bcc09	5351	}
johnAlexander	0:c523920bcc09	5352	}
johnAlexander	0:c523920bcc09	5353
johnAlexander	0:c523920bcc09	5354	return Status;
johnAlexander	0:c523920bcc09	5355	}
johnAlexander	15:932d8b4e52c9	5356
johnAlexander	15:932d8b4e52c9	5357
JerrySzczurak	20:cf211a3b3d9e	5358	int VL53L0X::get_measurement( OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *p_data )
johnAlexander	0:c523920bcc09	5359	{
johnAlexander	0:c523920bcc09	5360	int Status = VL53L0X_ERROR_NONE;
johnAlexander	0:c523920bcc09	5361
JerrySzczurak	20:cf211a3b3d9e	5362	if ( operating_mode == range_single_shot_polling ) {
JerrySzczurak	20:cf211a3b3d9e	5363	Status = vl53l0x_perform_single_ranging_measurement( _device, p_data );
JerrySzczurak	20:cf211a3b3d9e	5364	}
JerrySzczurak	20:cf211a3b3d9e	5365
JerrySzczurak	20:cf211a3b3d9e	5366	if ( operating_mode == range_continuous_polling ) {
JerrySzczurak	20:cf211a3b3d9e	5367	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	5368	Status = vl53l0x_measurement_poll_for_completion( _device );
JerrySzczurak	20:cf211a3b3d9e	5369
JerrySzczurak	20:cf211a3b3d9e	5370	if( Status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5371	Status = vl53l0x_get_ranging_measurement_data( _device, p_data );
johnAlexander	0:c523920bcc09	5372
johnAlexander	15:932d8b4e52c9	5373	// Clear the interrupt
JerrySzczurak	20:cf211a3b3d9e	5374	vl53l0x_clear_interrupt_mask( _device, VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY );
JerrySzczurak	20:cf211a3b3d9e	5375	vl53l0x_polling_delay( _device );
johnAlexander	0:c523920bcc09	5376	}
johnAlexander	0:c523920bcc09	5377	}
johnAlexander	0:c523920bcc09	5378
JerrySzczurak	20:cf211a3b3d9e	5379	if ( operating_mode == range_continuous_interrupt ) {
JerrySzczurak	20:cf211a3b3d9e	5380	Status = vl53l0x_get_ranging_measurement_data( _device, p_data );
JerrySzczurak	20:cf211a3b3d9e	5381	vl53l0x_clear_interrupt_mask( _device, VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR \| VL53L0X_REG_RESULT_INTERRUPT_STATUS );
johnAlexander	15:932d8b4e52c9	5382	}
johnAlexander	0:c523920bcc09	5383
johnAlexander	0:c523920bcc09	5384	return Status;
johnAlexander	0:c523920bcc09	5385	}
johnAlexander	15:932d8b4e52c9	5386
johnAlexander	0:c523920bcc09	5387
JerrySzczurak	20:cf211a3b3d9e	5388	int VL53L0X::stop_measurement( OperatingMode operating_mode )
johnAlexander	0:c523920bcc09	5389	{
johnAlexander	0:c523920bcc09	5390	int status = VL53L0X_ERROR_NONE;
johnAlexander	0:c523920bcc09	5391
johnAlexander	0:c523920bcc09	5392
johnAlexander	15:932d8b4e52c9	5393	// don't need to stop for a singleshot range!
JerrySzczurak	20:cf211a3b3d9e	5394	if ( operating_mode == range_single_shot_polling ) {
JerrySzczurak	20:cf211a3b3d9e	5395	}
JerrySzczurak	20:cf211a3b3d9e	5396
JerrySzczurak	20:cf211a3b3d9e	5397	if ( operating_mode == range_continuous_interrupt \|\| operating_mode == range_continuous_polling ) {
johnAlexander	15:932d8b4e52c9	5398	// continuous mode
JerrySzczurak	20:cf211a3b3d9e	5399	if( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5400	printf ( "Call of VL53L0X_StopMeasurement\n" );
JerrySzczurak	20:cf211a3b3d9e	5401	status = vl53l0x_stop_measurement( _device );
johnAlexander	0:c523920bcc09	5402	}
johnAlexander	0:c523920bcc09	5403
JerrySzczurak	20:cf211a3b3d9e	5404	if( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5405	printf ( "Wait Stop to be competed\n" );
JerrySzczurak	20:cf211a3b3d9e	5406	status = wait_stop_completed( _device );
johnAlexander	0:c523920bcc09	5407	}
johnAlexander	0:c523920bcc09	5408
JerrySzczurak	20:cf211a3b3d9e	5409	if( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	5410	status = vl53l0x_clear_interrupt_mask( _device,
JerrySzczurak	20:cf211a3b3d9e	5411	VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY );
JerrySzczurak	20:cf211a3b3d9e	5412	}
JerrySzczurak	20:cf211a3b3d9e	5413
JerrySzczurak	20:cf211a3b3d9e	5414	return status;
JerrySzczurak	20:cf211a3b3d9e	5415	}
JerrySzczurak	20:cf211a3b3d9e	5416
JerrySzczurak	20:cf211a3b3d9e	5417
JerrySzczurak	20:cf211a3b3d9e	5418	int VL53L0X::handle_irq( OperatingMode operating_mode, VL53L0X_RangingMeasurementData_t *data )
johnAlexander	0:c523920bcc09	5419	{
johnAlexander	15:932d8b4e52c9	5420	int status;
JerrySzczurak	20:cf211a3b3d9e	5421	status = get_measurement( operating_mode, data );
johnAlexander	16:98ce55ddbb1a	5422	enable_interrupt_measure_detection_irq();
johnAlexander	15:932d8b4e52c9	5423	return status;
johnAlexander	0:c523920bcc09	5424	}
johnAlexander	15:932d8b4e52c9	5425
JerrySzczurak	20:cf211a3b3d9e	5426	int32_t VL53L0X::vl53l0x_cycle_power( void )
JerrySzczurak	20:cf211a3b3d9e	5427	{
JerrySzczurak	20:cf211a3b3d9e	5428	int32_t status = STATUS_OK;
JerrySzczurak	20:cf211a3b3d9e	5429	#ifdef VL53L0X_LOG_ENABLE
JerrySzczurak	20:cf211a3b3d9e	5430	trace_i2c( "// cycle sensor power\n" );
JerrySzczurak	20:cf211a3b3d9e	5431	#endif
JerrySzczurak	20:cf211a3b3d9e	5432	return status;
JerrySzczurak	20:cf211a3b3d9e	5433	}
JerrySzczurak	20:cf211a3b3d9e	5434
JerrySzczurak	20:cf211a3b3d9e	5435	uint8_t VL53L0X::vl53l0x_encode_vcsel_period( uint8_t vcsel_period_pclks )
JerrySzczurak	20:cf211a3b3d9e	5436	{
JerrySzczurak	20:cf211a3b3d9e	5437	/*!
JerrySzczurak	20:cf211a3b3d9e	5438	* Converts the encoded VCSEL period register value into the real period
JerrySzczurak	20:cf211a3b3d9e	5439	* in PLL clocks
JerrySzczurak	20:cf211a3b3d9e	5440	*/
JerrySzczurak	20:cf211a3b3d9e	5441
JerrySzczurak	20:cf211a3b3d9e	5442	uint8_t vcsel_period_reg = 0;
JerrySzczurak	20:cf211a3b3d9e	5443
JerrySzczurak	20:cf211a3b3d9e	5444	vcsel_period_reg = ( vcsel_period_pclks >> 1 ) - 1;
JerrySzczurak	20:cf211a3b3d9e	5445
JerrySzczurak	20:cf211a3b3d9e	5446	return vcsel_period_reg;
JerrySzczurak	20:cf211a3b3d9e	5447	}
JerrySzczurak	20:cf211a3b3d9e	5448
JerrySzczurak	20:cf211a3b3d9e	5449	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_device_error_string( VL53L0X_DeviceError error_code,
JerrySzczurak	20:cf211a3b3d9e	5450	char *p_device_error_string )
JerrySzczurak	20:cf211a3b3d9e	5451	{
JerrySzczurak	20:cf211a3b3d9e	5452	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5453
JerrySzczurak	20:cf211a3b3d9e	5454	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5455
JerrySzczurak	20:cf211a3b3d9e	5456	switch ( error_code ) {
JerrySzczurak	20:cf211a3b3d9e	5457	case VL53L0X_DEVICEERROR_NONE:
JerrySzczurak	20:cf211a3b3d9e	5458	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5459	VL53L0X_STRING_DEVICEERROR_NONE );
JerrySzczurak	20:cf211a3b3d9e	5460	break;
JerrySzczurak	20:cf211a3b3d9e	5461	case VL53L0X_DEVICEERROR_VCSELCONTINUITYTESTFAILURE:
JerrySzczurak	20:cf211a3b3d9e	5462	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5463	VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE );
JerrySzczurak	20:cf211a3b3d9e	5464	break;
JerrySzczurak	20:cf211a3b3d9e	5465	case VL53L0X_DEVICEERROR_VCSELWATCHDOGTESTFAILURE:
JerrySzczurak	20:cf211a3b3d9e	5466	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5467	VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE );
JerrySzczurak	20:cf211a3b3d9e	5468	break;
JerrySzczurak	20:cf211a3b3d9e	5469	case VL53L0X_DEVICEERROR_NOVHVVALUEFOUND:
JerrySzczurak	20:cf211a3b3d9e	5470	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5471	VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND );
JerrySzczurak	20:cf211a3b3d9e	5472	break;
JerrySzczurak	20:cf211a3b3d9e	5473	case VL53L0X_DEVICEERROR_MSRCNOTARGET:
JerrySzczurak	20:cf211a3b3d9e	5474	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5475	VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET );
JerrySzczurak	20:cf211a3b3d9e	5476	break;
JerrySzczurak	20:cf211a3b3d9e	5477	case VL53L0X_DEVICEERROR_SNRCHECK:
JerrySzczurak	20:cf211a3b3d9e	5478	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5479	VL53L0X_STRING_DEVICEERROR_SNRCHECK );
JerrySzczurak	20:cf211a3b3d9e	5480	break;
JerrySzczurak	20:cf211a3b3d9e	5481	case VL53L0X_DEVICEERROR_RANGEPHASECHECK:
JerrySzczurak	20:cf211a3b3d9e	5482	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5483	VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK );
JerrySzczurak	20:cf211a3b3d9e	5484	break;
JerrySzczurak	20:cf211a3b3d9e	5485	case VL53L0X_DEVICEERROR_SIGMATHRESHOLDCHECK:
JerrySzczurak	20:cf211a3b3d9e	5486	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5487	VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK );
JerrySzczurak	20:cf211a3b3d9e	5488	break;
JerrySzczurak	20:cf211a3b3d9e	5489	case VL53L0X_DEVICEERROR_TCC:
JerrySzczurak	20:cf211a3b3d9e	5490	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5491	VL53L0X_STRING_DEVICEERROR_TCC );
JerrySzczurak	20:cf211a3b3d9e	5492	break;
JerrySzczurak	20:cf211a3b3d9e	5493	case VL53L0X_DEVICEERROR_PHASECONSISTENCY:
JerrySzczurak	20:cf211a3b3d9e	5494	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5495	VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY );
JerrySzczurak	20:cf211a3b3d9e	5496	break;
JerrySzczurak	20:cf211a3b3d9e	5497	case VL53L0X_DEVICEERROR_MINCLIP:
JerrySzczurak	20:cf211a3b3d9e	5498	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5499	VL53L0X_STRING_DEVICEERROR_MINCLIP );
JerrySzczurak	20:cf211a3b3d9e	5500	break;
JerrySzczurak	20:cf211a3b3d9e	5501	case VL53L0X_DEVICEERROR_RANGECOMPLETE:
JerrySzczurak	20:cf211a3b3d9e	5502	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5503	VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE );
JerrySzczurak	20:cf211a3b3d9e	5504	break;
JerrySzczurak	20:cf211a3b3d9e	5505	case VL53L0X_DEVICEERROR_ALGOUNDERFLOW:
JerrySzczurak	20:cf211a3b3d9e	5506	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5507	VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW );
JerrySzczurak	20:cf211a3b3d9e	5508	break;
JerrySzczurak	20:cf211a3b3d9e	5509	case VL53L0X_DEVICEERROR_ALGOOVERFLOW:
JerrySzczurak	20:cf211a3b3d9e	5510	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5511	VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW );
JerrySzczurak	20:cf211a3b3d9e	5512	break;
JerrySzczurak	20:cf211a3b3d9e	5513	case VL53L0X_DEVICEERROR_RANGEIGNORETHRESHOLD:
JerrySzczurak	20:cf211a3b3d9e	5514	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5515	VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD );
JerrySzczurak	20:cf211a3b3d9e	5516	break;
JerrySzczurak	20:cf211a3b3d9e	5517
JerrySzczurak	20:cf211a3b3d9e	5518	default:
JerrySzczurak	20:cf211a3b3d9e	5519	VL53L0X_COPYSTRING( p_device_error_string,
JerrySzczurak	20:cf211a3b3d9e	5520	VL53L0X_STRING_UNKNOW_ERROR_CODE );
JerrySzczurak	20:cf211a3b3d9e	5521
JerrySzczurak	20:cf211a3b3d9e	5522	}
JerrySzczurak	20:cf211a3b3d9e	5523
JerrySzczurak	20:cf211a3b3d9e	5524	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5525	return status;
JerrySzczurak	20:cf211a3b3d9e	5526	}
JerrySzczurak	20:cf211a3b3d9e	5527
JerrySzczurak	20:cf211a3b3d9e	5528
JerrySzczurak	20:cf211a3b3d9e	5529	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_limit_check_info( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	5530	char *p_limit_check_string )
JerrySzczurak	20:cf211a3b3d9e	5531	{
JerrySzczurak	20:cf211a3b3d9e	5532
JerrySzczurak	20:cf211a3b3d9e	5533	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5534
JerrySzczurak	20:cf211a3b3d9e	5535	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5536
JerrySzczurak	20:cf211a3b3d9e	5537	switch ( limit_check_id ) {
JerrySzczurak	20:cf211a3b3d9e	5538	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5539	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5540	VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE );
JerrySzczurak	20:cf211a3b3d9e	5541	break;
JerrySzczurak	20:cf211a3b3d9e	5542	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5543	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5544	VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE );
JerrySzczurak	20:cf211a3b3d9e	5545	break;
JerrySzczurak	20:cf211a3b3d9e	5546	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
JerrySzczurak	20:cf211a3b3d9e	5547	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5548	VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP );
JerrySzczurak	20:cf211a3b3d9e	5549	break;
JerrySzczurak	20:cf211a3b3d9e	5550	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
JerrySzczurak	20:cf211a3b3d9e	5551	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5552	VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD );
JerrySzczurak	20:cf211a3b3d9e	5553	break;
JerrySzczurak	20:cf211a3b3d9e	5554
JerrySzczurak	20:cf211a3b3d9e	5555	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
JerrySzczurak	20:cf211a3b3d9e	5556	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5557	VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC );
JerrySzczurak	20:cf211a3b3d9e	5558	break;
JerrySzczurak	20:cf211a3b3d9e	5559
JerrySzczurak	20:cf211a3b3d9e	5560	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5561	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5562	VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE );
JerrySzczurak	20:cf211a3b3d9e	5563	break;
JerrySzczurak	20:cf211a3b3d9e	5564
JerrySzczurak	20:cf211a3b3d9e	5565	default:
JerrySzczurak	20:cf211a3b3d9e	5566	VL53L0X_COPYSTRING( p_limit_check_string,
JerrySzczurak	20:cf211a3b3d9e	5567	VL53L0X_STRING_UNKNOW_ERROR_CODE );
JerrySzczurak	20:cf211a3b3d9e	5568
JerrySzczurak	20:cf211a3b3d9e	5569	}
JerrySzczurak	20:cf211a3b3d9e	5570
JerrySzczurak	20:cf211a3b3d9e	5571	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5572	return status;
JerrySzczurak	20:cf211a3b3d9e	5573	}
JerrySzczurak	20:cf211a3b3d9e	5574
JerrySzczurak	20:cf211a3b3d9e	5575	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_pal_error_string( VL53L0X_Error pal_error_code,
JerrySzczurak	20:cf211a3b3d9e	5576	char *p_pal_error_string )
JerrySzczurak	20:cf211a3b3d9e	5577	{
JerrySzczurak	20:cf211a3b3d9e	5578	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5579
JerrySzczurak	20:cf211a3b3d9e	5580	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5581
JerrySzczurak	20:cf211a3b3d9e	5582	switch ( pal_error_code ) {
JerrySzczurak	20:cf211a3b3d9e	5583	case VL53L0X_ERROR_NONE:
JerrySzczurak	20:cf211a3b3d9e	5584	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5585	VL53L0X_STRING_ERROR_NONE );
JerrySzczurak	20:cf211a3b3d9e	5586	break;
JerrySzczurak	20:cf211a3b3d9e	5587	case VL53L0X_ERROR_CALIBRATION_WARNING:
JerrySzczurak	20:cf211a3b3d9e	5588	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5589	VL53L0X_STRING_ERROR_CALIBRATION_WARNING );
JerrySzczurak	20:cf211a3b3d9e	5590	break;
JerrySzczurak	20:cf211a3b3d9e	5591	case VL53L0X_ERROR_MIN_CLIPPED:
JerrySzczurak	20:cf211a3b3d9e	5592	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5593	VL53L0X_STRING_ERROR_MIN_CLIPPED );
JerrySzczurak	20:cf211a3b3d9e	5594	break;
JerrySzczurak	20:cf211a3b3d9e	5595	case VL53L0X_ERROR_UNDEFINED:
JerrySzczurak	20:cf211a3b3d9e	5596	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5597	VL53L0X_STRING_ERROR_UNDEFINED );
JerrySzczurak	20:cf211a3b3d9e	5598	break;
JerrySzczurak	20:cf211a3b3d9e	5599	case VL53L0X_ERROR_INVALID_PARAMS:
JerrySzczurak	20:cf211a3b3d9e	5600	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5601	VL53L0X_STRING_ERROR_INVALID_PARAMS );
JerrySzczurak	20:cf211a3b3d9e	5602	break;
JerrySzczurak	20:cf211a3b3d9e	5603	case VL53L0X_ERROR_NOT_SUPPORTED:
JerrySzczurak	20:cf211a3b3d9e	5604	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5605	VL53L0X_STRING_ERROR_NOT_SUPPORTED );
JerrySzczurak	20:cf211a3b3d9e	5606	break;
JerrySzczurak	20:cf211a3b3d9e	5607	case VL53L0X_ERROR_INTERRUPT_NOT_CLEARED:
JerrySzczurak	20:cf211a3b3d9e	5608	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5609	VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED );
JerrySzczurak	20:cf211a3b3d9e	5610	break;
JerrySzczurak	20:cf211a3b3d9e	5611	case VL53L0X_ERROR_RANGE_ERROR:
JerrySzczurak	20:cf211a3b3d9e	5612	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5613	VL53L0X_STRING_ERROR_RANGE_ERROR );
JerrySzczurak	20:cf211a3b3d9e	5614	break;
JerrySzczurak	20:cf211a3b3d9e	5615	case VL53L0X_ERROR_TIME_OUT:
JerrySzczurak	20:cf211a3b3d9e	5616	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5617	VL53L0X_STRING_ERROR_TIME_OUT );
JerrySzczurak	20:cf211a3b3d9e	5618	break;
JerrySzczurak	20:cf211a3b3d9e	5619	case VL53L0X_ERROR_MODE_NOT_SUPPORTED:
JerrySzczurak	20:cf211a3b3d9e	5620	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5621	VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED );
JerrySzczurak	20:cf211a3b3d9e	5622	break;
JerrySzczurak	20:cf211a3b3d9e	5623	case VL53L0X_ERROR_BUFFER_TOO_SMALL:
JerrySzczurak	20:cf211a3b3d9e	5624	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5625	VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL );
JerrySzczurak	20:cf211a3b3d9e	5626	break;
JerrySzczurak	20:cf211a3b3d9e	5627	case VL53L0X_ERROR_GPIO_NOT_EXISTING:
JerrySzczurak	20:cf211a3b3d9e	5628	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5629	VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING );
JerrySzczurak	20:cf211a3b3d9e	5630	break;
JerrySzczurak	20:cf211a3b3d9e	5631	case VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED:
JerrySzczurak	20:cf211a3b3d9e	5632	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5633	VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED );
JerrySzczurak	20:cf211a3b3d9e	5634	break;
JerrySzczurak	20:cf211a3b3d9e	5635	case VL53L0X_ERROR_CONTROL_INTERFACE:
JerrySzczurak	20:cf211a3b3d9e	5636	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5637	VL53L0X_STRING_ERROR_CONTROL_INTERFACE );
JerrySzczurak	20:cf211a3b3d9e	5638	break;
JerrySzczurak	20:cf211a3b3d9e	5639	case VL53L0X_ERROR_INVALID_COMMAND:
JerrySzczurak	20:cf211a3b3d9e	5640	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5641	VL53L0X_STRING_ERROR_INVALID_COMMAND );
JerrySzczurak	20:cf211a3b3d9e	5642	break;
JerrySzczurak	20:cf211a3b3d9e	5643	case VL53L0X_ERROR_DIVISION_BY_ZERO:
JerrySzczurak	20:cf211a3b3d9e	5644	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5645	VL53L0X_STRING_ERROR_DIVISION_BY_ZERO );
JerrySzczurak	20:cf211a3b3d9e	5646	break;
JerrySzczurak	20:cf211a3b3d9e	5647	case VL53L0X_ERROR_REF_SPAD_INIT:
JerrySzczurak	20:cf211a3b3d9e	5648	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5649	VL53L0X_STRING_ERROR_REF_SPAD_INIT );
JerrySzczurak	20:cf211a3b3d9e	5650	break;
JerrySzczurak	20:cf211a3b3d9e	5651	case VL53L0X_ERROR_NOT_IMPLEMENTED:
JerrySzczurak	20:cf211a3b3d9e	5652	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5653	VL53L0X_STRING_ERROR_NOT_IMPLEMENTED );
JerrySzczurak	20:cf211a3b3d9e	5654	break;
JerrySzczurak	20:cf211a3b3d9e	5655
JerrySzczurak	20:cf211a3b3d9e	5656	default:
JerrySzczurak	20:cf211a3b3d9e	5657	VL53L0X_COPYSTRING( p_pal_error_string,
JerrySzczurak	20:cf211a3b3d9e	5658	VL53L0X_STRING_UNKNOW_ERROR_CODE );
JerrySzczurak	20:cf211a3b3d9e	5659	}
JerrySzczurak	20:cf211a3b3d9e	5660
JerrySzczurak	20:cf211a3b3d9e	5661	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5662	return status;
JerrySzczurak	20:cf211a3b3d9e	5663	}
JerrySzczurak	20:cf211a3b3d9e	5664
JerrySzczurak	20:cf211a3b3d9e	5665	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_pal_state_string( VL53L0X_State pal_state_code,
JerrySzczurak	20:cf211a3b3d9e	5666	char *p_pal_state_string )
JerrySzczurak	20:cf211a3b3d9e	5667	{
JerrySzczurak	20:cf211a3b3d9e	5668	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5669
JerrySzczurak	20:cf211a3b3d9e	5670	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5671
JerrySzczurak	20:cf211a3b3d9e	5672	switch ( pal_state_code ) {
JerrySzczurak	20:cf211a3b3d9e	5673	case VL53L0X_STATE_POWERDOWN:
JerrySzczurak	20:cf211a3b3d9e	5674	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5675	VL53L0X_STRING_STATE_POWERDOWN );
JerrySzczurak	20:cf211a3b3d9e	5676	break;
JerrySzczurak	20:cf211a3b3d9e	5677	case VL53L0X_STATE_WAIT_STATICINIT:
JerrySzczurak	20:cf211a3b3d9e	5678	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5679	VL53L0X_STRING_STATE_WAIT_STATICINIT );
JerrySzczurak	20:cf211a3b3d9e	5680	break;
JerrySzczurak	20:cf211a3b3d9e	5681	case VL53L0X_STATE_STANDBY:
JerrySzczurak	20:cf211a3b3d9e	5682	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5683	VL53L0X_STRING_STATE_STANDBY );
JerrySzczurak	20:cf211a3b3d9e	5684	break;
JerrySzczurak	20:cf211a3b3d9e	5685	case VL53L0X_STATE_IDLE:
JerrySzczurak	20:cf211a3b3d9e	5686	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5687	VL53L0X_STRING_STATE_IDLE );
JerrySzczurak	20:cf211a3b3d9e	5688	break;
JerrySzczurak	20:cf211a3b3d9e	5689	case VL53L0X_STATE_RUNNING:
JerrySzczurak	20:cf211a3b3d9e	5690	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5691	VL53L0X_STRING_STATE_RUNNING );
JerrySzczurak	20:cf211a3b3d9e	5692	break;
JerrySzczurak	20:cf211a3b3d9e	5693	case VL53L0X_STATE_UNKNOWN:
JerrySzczurak	20:cf211a3b3d9e	5694	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5695	VL53L0X_STRING_STATE_UNKNOWN );
JerrySzczurak	20:cf211a3b3d9e	5696	break;
JerrySzczurak	20:cf211a3b3d9e	5697	case VL53L0X_STATE_ERROR:
JerrySzczurak	20:cf211a3b3d9e	5698	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5699	VL53L0X_STRING_STATE_ERROR );
JerrySzczurak	20:cf211a3b3d9e	5700	break;
JerrySzczurak	20:cf211a3b3d9e	5701
JerrySzczurak	20:cf211a3b3d9e	5702	default:
JerrySzczurak	20:cf211a3b3d9e	5703	VL53L0X_COPYSTRING( p_pal_state_string,
JerrySzczurak	20:cf211a3b3d9e	5704	VL53L0X_STRING_STATE_UNKNOWN );
JerrySzczurak	20:cf211a3b3d9e	5705	}
JerrySzczurak	20:cf211a3b3d9e	5706
JerrySzczurak	20:cf211a3b3d9e	5707	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5708	return status;
JerrySzczurak	20:cf211a3b3d9e	5709	}
JerrySzczurak	20:cf211a3b3d9e	5710
JerrySzczurak	20:cf211a3b3d9e	5711	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_range_status_string( uint8_t range_status,
JerrySzczurak	20:cf211a3b3d9e	5712	char *p_range_status_string )
JerrySzczurak	20:cf211a3b3d9e	5713	{
JerrySzczurak	20:cf211a3b3d9e	5714	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5715
JerrySzczurak	20:cf211a3b3d9e	5716	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5717
JerrySzczurak	20:cf211a3b3d9e	5718	switch ( range_status ) {
JerrySzczurak	20:cf211a3b3d9e	5719	case 0:
JerrySzczurak	20:cf211a3b3d9e	5720	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5721	VL53L0X_STRING_RANGESTATUS_RANGEVALID );
JerrySzczurak	20:cf211a3b3d9e	5722	break;
JerrySzczurak	20:cf211a3b3d9e	5723	case 1:
JerrySzczurak	20:cf211a3b3d9e	5724	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5725	VL53L0X_STRING_RANGESTATUS_SIGMA );
JerrySzczurak	20:cf211a3b3d9e	5726	break;
JerrySzczurak	20:cf211a3b3d9e	5727	case 2:
JerrySzczurak	20:cf211a3b3d9e	5728	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5729	VL53L0X_STRING_RANGESTATUS_SIGNAL );
JerrySzczurak	20:cf211a3b3d9e	5730	break;
JerrySzczurak	20:cf211a3b3d9e	5731	case 3:
JerrySzczurak	20:cf211a3b3d9e	5732	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5733	VL53L0X_STRING_RANGESTATUS_MINRANGE );
JerrySzczurak	20:cf211a3b3d9e	5734	break;
JerrySzczurak	20:cf211a3b3d9e	5735	case 4:
JerrySzczurak	20:cf211a3b3d9e	5736	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5737	VL53L0X_STRING_RANGESTATUS_PHASE );
JerrySzczurak	20:cf211a3b3d9e	5738	break;
JerrySzczurak	20:cf211a3b3d9e	5739	case 5:
JerrySzczurak	20:cf211a3b3d9e	5740	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5741	VL53L0X_STRING_RANGESTATUS_HW );
JerrySzczurak	20:cf211a3b3d9e	5742	break;
JerrySzczurak	20:cf211a3b3d9e	5743
JerrySzczurak	20:cf211a3b3d9e	5744	default: /**/
JerrySzczurak	20:cf211a3b3d9e	5745	VL53L0X_COPYSTRING( p_range_status_string,
JerrySzczurak	20:cf211a3b3d9e	5746	VL53L0X_STRING_RANGESTATUS_NONE );
JerrySzczurak	20:cf211a3b3d9e	5747	}
JerrySzczurak	20:cf211a3b3d9e	5748
JerrySzczurak	20:cf211a3b3d9e	5749	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5750	return status;
JerrySzczurak	20:cf211a3b3d9e	5751	}
JerrySzczurak	20:cf211a3b3d9e	5752
JerrySzczurak	20:cf211a3b3d9e	5753
JerrySzczurak	20:cf211a3b3d9e	5754	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_ref_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	5755	uint8_t p_vhv_settings, uint8_t p_phase_cal )
JerrySzczurak	20:cf211a3b3d9e	5756	{
JerrySzczurak	20:cf211a3b3d9e	5757	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5758	uint8_t vhv_settings = 0;
JerrySzczurak	20:cf211a3b3d9e	5759	uint8_t phase_cal = 0;
JerrySzczurak	20:cf211a3b3d9e	5760
JerrySzczurak	20:cf211a3b3d9e	5761	status = vl53l0x_ref_calibration_io( dev, 1,
JerrySzczurak	20:cf211a3b3d9e	5762	vhv_settings, phase_cal,
JerrySzczurak	20:cf211a3b3d9e	5763	p_vhv_settings, p_phase_cal,
JerrySzczurak	20:cf211a3b3d9e	5764	1, 1 );
JerrySzczurak	20:cf211a3b3d9e	5765
JerrySzczurak	20:cf211a3b3d9e	5766	return status;
JerrySzczurak	20:cf211a3b3d9e	5767	}
JerrySzczurak	20:cf211a3b3d9e	5768
JerrySzczurak	20:cf211a3b3d9e	5769	VL53L0X_Error VL53L0X::count_enabled_spads( uint8_t spad_array[],
JerrySzczurak	20:cf211a3b3d9e	5770	uint32_t byte_count, uint32_t max_spads,
JerrySzczurak	20:cf211a3b3d9e	5771	uint32_t p_total_spads_enabled, uint8_t p_is_aperture )
JerrySzczurak	20:cf211a3b3d9e	5772	{
JerrySzczurak	20:cf211a3b3d9e	5773	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5774	uint32_t c_spads_per_byte = 8;
JerrySzczurak	20:cf211a3b3d9e	5775	uint32_t last_byte;
JerrySzczurak	20:cf211a3b3d9e	5776	uint32_t last_bit;
JerrySzczurak	20:cf211a3b3d9e	5777	uint32_t byte_index = 0;
JerrySzczurak	20:cf211a3b3d9e	5778	uint32_t bit_index = 0;
JerrySzczurak	20:cf211a3b3d9e	5779	uint8_t temp_byte;
JerrySzczurak	20:cf211a3b3d9e	5780	uint8_t spad_type_identified = 0;
JerrySzczurak	20:cf211a3b3d9e	5781
JerrySzczurak	20:cf211a3b3d9e	5782	/* The entire array will not be used for spads, therefore the last
JerrySzczurak	20:cf211a3b3d9e	5783	* byte and last bit is determined from the max spads value.
JerrySzczurak	20:cf211a3b3d9e	5784	*/
JerrySzczurak	20:cf211a3b3d9e	5785
JerrySzczurak	20:cf211a3b3d9e	5786	last_byte = max_spads / c_spads_per_byte;
JerrySzczurak	20:cf211a3b3d9e	5787	last_bit = max_spads % c_spads_per_byte;
JerrySzczurak	20:cf211a3b3d9e	5788
JerrySzczurak	20:cf211a3b3d9e	5789	/* Check that the max spads value does not exceed the array bounds. */
JerrySzczurak	20:cf211a3b3d9e	5790	if ( last_byte >= byte_count )
JerrySzczurak	20:cf211a3b3d9e	5791	status = VL53L0X_ERROR_REF_SPAD_INIT;
JerrySzczurak	20:cf211a3b3d9e	5792
JerrySzczurak	20:cf211a3b3d9e	5793	*p_total_spads_enabled = 0;
JerrySzczurak	20:cf211a3b3d9e	5794
JerrySzczurak	20:cf211a3b3d9e	5795	/* Count the bits enabled in the whole bytes */
JerrySzczurak	20:cf211a3b3d9e	5796	for ( byte_index = 0; byte_index <= ( last_byte - 1 ); byte_index++ ) {
JerrySzczurak	20:cf211a3b3d9e	5797	temp_byte = spad_array[byte_index];
JerrySzczurak	20:cf211a3b3d9e	5798
JerrySzczurak	20:cf211a3b3d9e	5799	for ( bit_index = 0; bit_index <= c_spads_per_byte; bit_index++ ) {
JerrySzczurak	20:cf211a3b3d9e	5800	if ( ( temp_byte & 0x01 ) == 1 ) {
JerrySzczurak	20:cf211a3b3d9e	5801	( *p_total_spads_enabled )++;
JerrySzczurak	20:cf211a3b3d9e	5802
JerrySzczurak	20:cf211a3b3d9e	5803	if ( !spad_type_identified ) {
JerrySzczurak	20:cf211a3b3d9e	5804	*p_is_aperture = 1;
JerrySzczurak	20:cf211a3b3d9e	5805	if ( ( byte_index < 2 ) && ( bit_index < 4 ) )
JerrySzczurak	20:cf211a3b3d9e	5806	*p_is_aperture = 0;
JerrySzczurak	20:cf211a3b3d9e	5807	spad_type_identified = 1;
JerrySzczurak	20:cf211a3b3d9e	5808	}
JerrySzczurak	20:cf211a3b3d9e	5809	}
JerrySzczurak	20:cf211a3b3d9e	5810	temp_byte >>= 1;
JerrySzczurak	20:cf211a3b3d9e	5811	}
JerrySzczurak	20:cf211a3b3d9e	5812	}
JerrySzczurak	20:cf211a3b3d9e	5813
JerrySzczurak	20:cf211a3b3d9e	5814	/* Count the number of bits enabled in the last byte accounting
JerrySzczurak	20:cf211a3b3d9e	5815	* for the fact that not all bits in the byte may be used.
JerrySzczurak	20:cf211a3b3d9e	5816	*/
JerrySzczurak	20:cf211a3b3d9e	5817	temp_byte = spad_array[last_byte];
JerrySzczurak	20:cf211a3b3d9e	5818
JerrySzczurak	20:cf211a3b3d9e	5819	for ( bit_index = 0; bit_index <= last_bit; bit_index++ ) {
JerrySzczurak	20:cf211a3b3d9e	5820	if ( ( temp_byte & 0x01 ) == 1 )
JerrySzczurak	20:cf211a3b3d9e	5821	( *p_total_spads_enabled )++;
JerrySzczurak	20:cf211a3b3d9e	5822	}
JerrySzczurak	20:cf211a3b3d9e	5823
JerrySzczurak	20:cf211a3b3d9e	5824	return status;
JerrySzczurak	20:cf211a3b3d9e	5825	}
JerrySzczurak	20:cf211a3b3d9e	5826
JerrySzczurak	20:cf211a3b3d9e	5827	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_reference_spads( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	5828	uint32_t p_spad_count, uint8_t p_is_aperture_spads )
JerrySzczurak	20:cf211a3b3d9e	5829	{
JerrySzczurak	20:cf211a3b3d9e	5830	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5831	uint8_t ref_spads_initialised;
JerrySzczurak	20:cf211a3b3d9e	5832	uint8_t ref_spad_array[6];
JerrySzczurak	20:cf211a3b3d9e	5833	uint32_t c_max_spad_count = 44;
JerrySzczurak	20:cf211a3b3d9e	5834	uint32_t c_spad_array_size = 6;
JerrySzczurak	20:cf211a3b3d9e	5835	uint32_t spads_enabled;
JerrySzczurak	20:cf211a3b3d9e	5836	uint8_t is_aperture_spads = 0;
JerrySzczurak	20:cf211a3b3d9e	5837
JerrySzczurak	20:cf211a3b3d9e	5838	ref_spads_initialised = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5839	RefSpadsInitialised );
JerrySzczurak	20:cf211a3b3d9e	5840
JerrySzczurak	20:cf211a3b3d9e	5841	if ( ref_spads_initialised == 1 ) {
JerrySzczurak	20:cf211a3b3d9e	5842
JerrySzczurak	20:cf211a3b3d9e	5843	*p_spad_count = ( uint32_t )VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5844	ReferenceSpadCount );
JerrySzczurak	20:cf211a3b3d9e	5845	*p_is_aperture_spads = VL53L0X_GETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5846	ReferenceSpadType );
JerrySzczurak	20:cf211a3b3d9e	5847	} else {
JerrySzczurak	20:cf211a3b3d9e	5848
JerrySzczurak	20:cf211a3b3d9e	5849	/* obtain spad info from device.*/
JerrySzczurak	20:cf211a3b3d9e	5850	status = get_ref_spad_map( dev, ref_spad_array );
JerrySzczurak	20:cf211a3b3d9e	5851
JerrySzczurak	20:cf211a3b3d9e	5852	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5853	/* count enabled spads within spad map array and
JerrySzczurak	20:cf211a3b3d9e	5854	* determine if Aperture or Non-Aperture.
JerrySzczurak	20:cf211a3b3d9e	5855	*/
JerrySzczurak	20:cf211a3b3d9e	5856	status = count_enabled_spads( ref_spad_array,
JerrySzczurak	20:cf211a3b3d9e	5857	c_spad_array_size,
JerrySzczurak	20:cf211a3b3d9e	5858	c_max_spad_count,
JerrySzczurak	20:cf211a3b3d9e	5859	&spads_enabled,
JerrySzczurak	20:cf211a3b3d9e	5860	&is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	5861
JerrySzczurak	20:cf211a3b3d9e	5862	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	5863
JerrySzczurak	20:cf211a3b3d9e	5864	*p_spad_count = spads_enabled;
JerrySzczurak	20:cf211a3b3d9e	5865	*p_is_aperture_spads = is_aperture_spads;
JerrySzczurak	20:cf211a3b3d9e	5866
JerrySzczurak	20:cf211a3b3d9e	5867	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5868	RefSpadsInitialised, 1 );
JerrySzczurak	20:cf211a3b3d9e	5869	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5870	ReferenceSpadCount,
JerrySzczurak	20:cf211a3b3d9e	5871	( uint8_t )spads_enabled );
JerrySzczurak	20:cf211a3b3d9e	5872	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	5873	ReferenceSpadType, is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	5874	}
JerrySzczurak	20:cf211a3b3d9e	5875	}
JerrySzczurak	20:cf211a3b3d9e	5876	}
JerrySzczurak	20:cf211a3b3d9e	5877
JerrySzczurak	20:cf211a3b3d9e	5878	return status;
JerrySzczurak	20:cf211a3b3d9e	5879	}
JerrySzczurak	20:cf211a3b3d9e	5880
JerrySzczurak	20:cf211a3b3d9e	5881	VL53L0X_Error VL53L0X::wrapped_vl53l0x_get_sequence_steps_info(
JerrySzczurak	20:cf211a3b3d9e	5882	VL53L0X_SequenceStepId sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	5883	char *p_sequence_steps_string )
JerrySzczurak	20:cf211a3b3d9e	5884	{
JerrySzczurak	20:cf211a3b3d9e	5885	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5886	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5887
JerrySzczurak	20:cf211a3b3d9e	5888	switch ( sequence_step_id ) {
JerrySzczurak	20:cf211a3b3d9e	5889	case VL53L0X_SEQUENCESTEP_TCC:
JerrySzczurak	20:cf211a3b3d9e	5890	VL53L0X_COPYSTRING( p_sequence_steps_string,
JerrySzczurak	20:cf211a3b3d9e	5891	VL53L0X_STRING_SEQUENCESTEP_TCC );
JerrySzczurak	20:cf211a3b3d9e	5892	break;
JerrySzczurak	20:cf211a3b3d9e	5893	case VL53L0X_SEQUENCESTEP_DSS:
JerrySzczurak	20:cf211a3b3d9e	5894	VL53L0X_COPYSTRING( p_sequence_steps_string,
JerrySzczurak	20:cf211a3b3d9e	5895	VL53L0X_STRING_SEQUENCESTEP_DSS );
JerrySzczurak	20:cf211a3b3d9e	5896	break;
JerrySzczurak	20:cf211a3b3d9e	5897	case VL53L0X_SEQUENCESTEP_MSRC:
JerrySzczurak	20:cf211a3b3d9e	5898	VL53L0X_COPYSTRING( p_sequence_steps_string,
JerrySzczurak	20:cf211a3b3d9e	5899	VL53L0X_STRING_SEQUENCESTEP_MSRC );
JerrySzczurak	20:cf211a3b3d9e	5900	break;
JerrySzczurak	20:cf211a3b3d9e	5901	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5902	VL53L0X_COPYSTRING( p_sequence_steps_string,
JerrySzczurak	20:cf211a3b3d9e	5903	VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE );
JerrySzczurak	20:cf211a3b3d9e	5904	break;
JerrySzczurak	20:cf211a3b3d9e	5905	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	5906	VL53L0X_COPYSTRING( p_sequence_steps_string,
JerrySzczurak	20:cf211a3b3d9e	5907	VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE );
JerrySzczurak	20:cf211a3b3d9e	5908	break;
JerrySzczurak	20:cf211a3b3d9e	5909
JerrySzczurak	20:cf211a3b3d9e	5910	default:
JerrySzczurak	20:cf211a3b3d9e	5911	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	5912	}
JerrySzczurak	20:cf211a3b3d9e	5913
JerrySzczurak	20:cf211a3b3d9e	5914	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5915
JerrySzczurak	20:cf211a3b3d9e	5916	return status;
JerrySzczurak	20:cf211a3b3d9e	5917	}
JerrySzczurak	20:cf211a3b3d9e	5918
JerrySzczurak	20:cf211a3b3d9e	5919	VL53L0X_Error VL53L0X::vl53l0x_get_sequence_steps_info( VL53L0X_SequenceStepId sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	5920	char *p_sequence_steps_string )
JerrySzczurak	20:cf211a3b3d9e	5921	{
JerrySzczurak	20:cf211a3b3d9e	5922	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5923	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5924
JerrySzczurak	20:cf211a3b3d9e	5925	status = wrapped_vl53l0x_get_sequence_steps_info(
JerrySzczurak	20:cf211a3b3d9e	5926	sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	5927	p_sequence_steps_string );
JerrySzczurak	20:cf211a3b3d9e	5928
JerrySzczurak	20:cf211a3b3d9e	5929	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5930
JerrySzczurak	20:cf211a3b3d9e	5931	return status;
JerrySzczurak	20:cf211a3b3d9e	5932	}
JerrySzczurak	20:cf211a3b3d9e	5933
JerrySzczurak	20:cf211a3b3d9e	5934	int32_t VL53L0X::vl53l0x_get_timer_frequency( int32_t *p_timer_freq_hz )
JerrySzczurak	20:cf211a3b3d9e	5935	{
JerrySzczurak	20:cf211a3b3d9e	5936	*p_timer_freq_hz = 0;
JerrySzczurak	20:cf211a3b3d9e	5937	return STATUS_FAIL;
JerrySzczurak	20:cf211a3b3d9e	5938	}
JerrySzczurak	20:cf211a3b3d9e	5939
JerrySzczurak	20:cf211a3b3d9e	5940	int32_t VL53L0X::vl53l0x_get_timer_value( int32_t *p_timer_count )
JerrySzczurak	20:cf211a3b3d9e	5941	{
JerrySzczurak	20:cf211a3b3d9e	5942	*p_timer_count = 0;
JerrySzczurak	20:cf211a3b3d9e	5943	return STATUS_FAIL;
JerrySzczurak	20:cf211a3b3d9e	5944	}
JerrySzczurak	20:cf211a3b3d9e	5945
JerrySzczurak	20:cf211a3b3d9e	5946	VL53L0X_Error VL53L0X::vl53l0x_enable_interrupt_mask( VL53L0X_DEV dev, uint32_t interrupt_mask )
JerrySzczurak	20:cf211a3b3d9e	5947	{
JerrySzczurak	20:cf211a3b3d9e	5948	VL53L0X_Error Status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	5949	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5950
JerrySzczurak	20:cf211a3b3d9e	5951	/* not implemented for VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	5952
JerrySzczurak	20:cf211a3b3d9e	5953	LOG_FUNCTION_END( Status );
JerrySzczurak	20:cf211a3b3d9e	5954	return Status;
JerrySzczurak	20:cf211a3b3d9e	5955	}
JerrySzczurak	20:cf211a3b3d9e	5956
JerrySzczurak	20:cf211a3b3d9e	5957	VL53L0X_Error VL53L0X::vl53l0x_get_device_error_status( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	5958	VL53L0X_DeviceError *p_device_error_status )
JerrySzczurak	20:cf211a3b3d9e	5959	{
JerrySzczurak	20:cf211a3b3d9e	5960	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5961	uint8_t range_status;
JerrySzczurak	20:cf211a3b3d9e	5962
JerrySzczurak	20:cf211a3b3d9e	5963	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5964
JerrySzczurak	21:627b65069e6d	5965	status = vl53l0x_read_byte( dev, VL53L0X_REG_RESULT_RANGE_STATUS,
JerrySzczurak	20:cf211a3b3d9e	5966	&range_status );
JerrySzczurak	20:cf211a3b3d9e	5967
JerrySzczurak	20:cf211a3b3d9e	5968	*p_device_error_status = ( VL53L0X_DeviceError )( ( range_status & 0x78 ) >> 3 );
JerrySzczurak	20:cf211a3b3d9e	5969
JerrySzczurak	20:cf211a3b3d9e	5970	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5971	return status;
JerrySzczurak	20:cf211a3b3d9e	5972	}
JerrySzczurak	20:cf211a3b3d9e	5973
JerrySzczurak	20:cf211a3b3d9e	5974
JerrySzczurak	20:cf211a3b3d9e	5975	VL53L0X_Error VL53L0X::vl53l0x_get_device_error_string( VL53L0X_DeviceError error_code,
JerrySzczurak	20:cf211a3b3d9e	5976	char *p_device_error_string )
JerrySzczurak	20:cf211a3b3d9e	5977	{
JerrySzczurak	20:cf211a3b3d9e	5978	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5979
JerrySzczurak	20:cf211a3b3d9e	5980	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5981
JerrySzczurak	20:cf211a3b3d9e	5982	status = wrapped_vl53l0x_get_device_error_string( error_code, p_device_error_string );
JerrySzczurak	20:cf211a3b3d9e	5983
JerrySzczurak	20:cf211a3b3d9e	5984	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	5985	return status;
JerrySzczurak	20:cf211a3b3d9e	5986	}
JerrySzczurak	20:cf211a3b3d9e	5987
JerrySzczurak	20:cf211a3b3d9e	5988	VL53L0X_Error VL53L0X::vl53l0x_get_dmax_cal_parameters( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	5989	uint16_t p_range_milli_meter, FixPoint1616_t p_signal_rate_rtn_mega_cps )
JerrySzczurak	20:cf211a3b3d9e	5990	{
JerrySzczurak	20:cf211a3b3d9e	5991	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	5992
JerrySzczurak	20:cf211a3b3d9e	5993	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	5994
JerrySzczurak	20:cf211a3b3d9e	5995	*p_range_milli_meter = PALDevDataGet( dev, DmaxCalRangeMilliMeter );
JerrySzczurak	20:cf211a3b3d9e	5996	*p_signal_rate_rtn_mega_cps = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	5997	DmaxCalSignalRateRtnMegaCps );
JerrySzczurak	20:cf211a3b3d9e	5998
JerrySzczurak	20:cf211a3b3d9e	5999	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6000	return status;
JerrySzczurak	20:cf211a3b3d9e	6001	}
JerrySzczurak	20:cf211a3b3d9e	6002
JerrySzczurak	20:cf211a3b3d9e	6003	VL53L0X_Error VL53L0X::vl53l0x_get_dmax_cal_parameters( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6004	uint16_t range_milli_meter, FixPoint1616_t signal_rate_rtn_mega_cps )
JerrySzczurak	20:cf211a3b3d9e	6005	{
JerrySzczurak	20:cf211a3b3d9e	6006	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6007	FixPoint1616_t signal_rate_rtn_mega_cps_temp = 0;
JerrySzczurak	20:cf211a3b3d9e	6008
JerrySzczurak	20:cf211a3b3d9e	6009	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6010
JerrySzczurak	20:cf211a3b3d9e	6011	/* Check if one of input parameter is zero, in that case the
JerrySzczurak	20:cf211a3b3d9e	6012	* value are get from NVM */
JerrySzczurak	20:cf211a3b3d9e	6013	if ( ( range_milli_meter == 0 ) \|\| ( signal_rate_rtn_mega_cps == 0 ) ) {
JerrySzczurak	20:cf211a3b3d9e	6014	/* NVM parameters */
JerrySzczurak	20:cf211a3b3d9e	6015	/* Run VL53L0X_get_info_from_device wit option 4 to get
JerrySzczurak	20:cf211a3b3d9e	6016	* signal rate at 400 mm if the value have been already
JerrySzczurak	20:cf211a3b3d9e	6017	* get this function will return with no access to device */
JerrySzczurak	20:cf211a3b3d9e	6018	vl53l0x_get_info_from_device( dev, 4 );
JerrySzczurak	20:cf211a3b3d9e	6019
JerrySzczurak	20:cf211a3b3d9e	6020	signal_rate_rtn_mega_cps_temp = VL53L0X_GETDEVICESPECIFICPARAMETER(
JerrySzczurak	20:cf211a3b3d9e	6021	dev, SignalRateMeasFixed400mm );
JerrySzczurak	20:cf211a3b3d9e	6022
JerrySzczurak	20:cf211a3b3d9e	6023	PALDevDataSet( dev, DmaxCalRangeMilliMeter, 400 );
JerrySzczurak	20:cf211a3b3d9e	6024	PALDevDataSet( dev, DmaxCalSignalRateRtnMegaCps,
JerrySzczurak	20:cf211a3b3d9e	6025	signal_rate_rtn_mega_cps_temp );
JerrySzczurak	20:cf211a3b3d9e	6026	} else {
JerrySzczurak	20:cf211a3b3d9e	6027	/* User parameters */
JerrySzczurak	20:cf211a3b3d9e	6028	PALDevDataSet( dev, DmaxCalRangeMilliMeter, range_milli_meter );
JerrySzczurak	20:cf211a3b3d9e	6029	PALDevDataSet( dev, DmaxCalSignalRateRtnMegaCps,
JerrySzczurak	20:cf211a3b3d9e	6030	signal_rate_rtn_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	6031	}
JerrySzczurak	20:cf211a3b3d9e	6032
JerrySzczurak	20:cf211a3b3d9e	6033	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6034	return status;
JerrySzczurak	20:cf211a3b3d9e	6035	}
JerrySzczurak	20:cf211a3b3d9e	6036
JerrySzczurak	20:cf211a3b3d9e	6037	VL53L0X_Error VL53L0X::vl53L0x_set_gpio_config( VL53L0X_DEV dev, uint8_t pin,
JerrySzczurak	20:cf211a3b3d9e	6038	VL53L0X_DeviceModes device_mode, VL53L0X_GpioFunctionality functionality,
JerrySzczurak	20:cf211a3b3d9e	6039	VL53L0X_InterruptPolarity polarity )
JerrySzczurak	20:cf211a3b3d9e	6040	{
JerrySzczurak	20:cf211a3b3d9e	6041	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6042	uint8_t data;
JerrySzczurak	20:cf211a3b3d9e	6043
JerrySzczurak	20:cf211a3b3d9e	6044	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6045
JerrySzczurak	20:cf211a3b3d9e	6046	if ( pin != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6047	status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
JerrySzczurak	20:cf211a3b3d9e	6048	} else if ( device_mode == VL53L0X_DEVICEMODE_GPIO_DRIVE ) {
JerrySzczurak	20:cf211a3b3d9e	6049	if ( polarity == VL53L0X_INTERRUPTPOLARITY_LOW )
JerrySzczurak	20:cf211a3b3d9e	6050	data = 0x10;
JerrySzczurak	20:cf211a3b3d9e	6051	else
JerrySzczurak	20:cf211a3b3d9e	6052	data = 1;
JerrySzczurak	20:cf211a3b3d9e	6053
JerrySzczurak	21:627b65069e6d	6054	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	6055	VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, data );
JerrySzczurak	20:cf211a3b3d9e	6056
JerrySzczurak	20:cf211a3b3d9e	6057	} else if ( device_mode == VL53L0X_DEVICEMODE_GPIO_OSC ) {
JerrySzczurak	20:cf211a3b3d9e	6058
JerrySzczurak	21:627b65069e6d	6059	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	21:627b65069e6d	6060	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	21:627b65069e6d	6061
JerrySzczurak	21:627b65069e6d	6062	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	21:627b65069e6d	6063	status \|= vl53l0x_write_byte( dev, 0x80, 0x01 );
JerrySzczurak	21:627b65069e6d	6064	status \|= vl53l0x_write_byte( dev, 0x85, 0x02 );
JerrySzczurak	21:627b65069e6d	6065
JerrySzczurak	21:627b65069e6d	6066	status \|= vl53l0x_write_byte( dev, 0xff, 0x04 );
JerrySzczurak	21:627b65069e6d	6067	status \|= vl53l0x_write_byte( dev, 0xcd, 0x00 );
JerrySzczurak	21:627b65069e6d	6068	status \|= vl53l0x_write_byte( dev, 0xcc, 0x11 );
JerrySzczurak	21:627b65069e6d	6069
JerrySzczurak	21:627b65069e6d	6070	status \|= vl53l0x_write_byte( dev, 0xff, 0x07 );
JerrySzczurak	21:627b65069e6d	6071	status \|= vl53l0x_write_byte( dev, 0xbe, 0x00 );
JerrySzczurak	21:627b65069e6d	6072
JerrySzczurak	21:627b65069e6d	6073	status \|= vl53l0x_write_byte( dev, 0xff, 0x06 );
JerrySzczurak	21:627b65069e6d	6074	status \|= vl53l0x_write_byte( dev, 0xcc, 0x09 );
JerrySzczurak	21:627b65069e6d	6075
JerrySzczurak	21:627b65069e6d	6076	status \|= vl53l0x_write_byte( dev, 0xff, 0x00 );
JerrySzczurak	21:627b65069e6d	6077	status \|= vl53l0x_write_byte( dev, 0xff, 0x01 );
JerrySzczurak	21:627b65069e6d	6078	status \|= vl53l0x_write_byte( dev, 0x00, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6079
JerrySzczurak	20:cf211a3b3d9e	6080	} else {
JerrySzczurak	20:cf211a3b3d9e	6081
JerrySzczurak	20:cf211a3b3d9e	6082	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6083	switch ( functionality ) {
JerrySzczurak	20:cf211a3b3d9e	6084	case VL53L0X_GPIOFUNCTIONALITY_OFF:
JerrySzczurak	20:cf211a3b3d9e	6085	data = 0x00;
JerrySzczurak	20:cf211a3b3d9e	6086	break;
JerrySzczurak	20:cf211a3b3d9e	6087	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW:
JerrySzczurak	20:cf211a3b3d9e	6088	data = 0x01;
JerrySzczurak	20:cf211a3b3d9e	6089	break;
JerrySzczurak	20:cf211a3b3d9e	6090	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH:
JerrySzczurak	20:cf211a3b3d9e	6091	data = 0x02;
JerrySzczurak	20:cf211a3b3d9e	6092	break;
JerrySzczurak	20:cf211a3b3d9e	6093	case VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT:
JerrySzczurak	20:cf211a3b3d9e	6094	data = 0x03;
JerrySzczurak	20:cf211a3b3d9e	6095	break;
JerrySzczurak	20:cf211a3b3d9e	6096	case VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY:
JerrySzczurak	20:cf211a3b3d9e	6097	data = 0x04;
JerrySzczurak	20:cf211a3b3d9e	6098	break;
JerrySzczurak	20:cf211a3b3d9e	6099	default:
JerrySzczurak	20:cf211a3b3d9e	6100	status =
JerrySzczurak	20:cf211a3b3d9e	6101	VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
JerrySzczurak	20:cf211a3b3d9e	6102	}
JerrySzczurak	20:cf211a3b3d9e	6103	}
JerrySzczurak	20:cf211a3b3d9e	6104
JerrySzczurak	20:cf211a3b3d9e	6105	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	21:627b65069e6d	6106	status = vl53l0x_write_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	6107	VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, data );
JerrySzczurak	20:cf211a3b3d9e	6108
JerrySzczurak	20:cf211a3b3d9e	6109	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6110	if ( polarity == VL53L0X_INTERRUPTPOLARITY_LOW )
JerrySzczurak	20:cf211a3b3d9e	6111	data = 0;
JerrySzczurak	20:cf211a3b3d9e	6112	else
JerrySzczurak	20:cf211a3b3d9e	6113	data = ( uint8_t )( 1 << 4 );
JerrySzczurak	20:cf211a3b3d9e	6114
JerrySzczurak	21:627b65069e6d	6115	status = vl53l0x_update_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	6116	VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH, 0xEF, data );
JerrySzczurak	20:cf211a3b3d9e	6117	}
JerrySzczurak	20:cf211a3b3d9e	6118
JerrySzczurak	20:cf211a3b3d9e	6119	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6120	VL53L0X_SETDEVICESPECIFICPARAMETER( dev,
JerrySzczurak	20:cf211a3b3d9e	6121	Pin0GpioFunctionality, functionality );
JerrySzczurak	20:cf211a3b3d9e	6122
JerrySzczurak	20:cf211a3b3d9e	6123	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6124	status = vl53l0x_clear_interrupt_mask( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	6125
JerrySzczurak	20:cf211a3b3d9e	6126	}
JerrySzczurak	20:cf211a3b3d9e	6127
JerrySzczurak	20:cf211a3b3d9e	6128	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6129	return status;
JerrySzczurak	20:cf211a3b3d9e	6130	}
JerrySzczurak	20:cf211a3b3d9e	6131
JerrySzczurak	20:cf211a3b3d9e	6132
JerrySzczurak	20:cf211a3b3d9e	6133	VL53L0X_Error VL53L0X::vl53l0x_get_gpio_config( VL53L0X_DEV dev, uint8_t pin,
JerrySzczurak	20:cf211a3b3d9e	6134	VL53L0X_DeviceModes *p_device_mode,
JerrySzczurak	20:cf211a3b3d9e	6135	VL53L0X_GpioFunctionality *p_functionality,
JerrySzczurak	20:cf211a3b3d9e	6136	VL53L0X_InterruptPolarity *p_polarity )
JerrySzczurak	20:cf211a3b3d9e	6137	{
JerrySzczurak	20:cf211a3b3d9e	6138	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6139	VL53L0X_GpioFunctionality gpio_functionality;
JerrySzczurak	20:cf211a3b3d9e	6140	uint8_t data;
JerrySzczurak	20:cf211a3b3d9e	6141
JerrySzczurak	20:cf211a3b3d9e	6142	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6143
JerrySzczurak	20:cf211a3b3d9e	6144	/* pDeviceMode not managed by Ewok it return the current mode */
JerrySzczurak	20:cf211a3b3d9e	6145
JerrySzczurak	20:cf211a3b3d9e	6146	status = vl53l0x_get_device_mode( dev, p_device_mode );
JerrySzczurak	20:cf211a3b3d9e	6147
JerrySzczurak	20:cf211a3b3d9e	6148	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6149	if ( pin != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6150	status = VL53L0X_ERROR_GPIO_NOT_EXISTING;
JerrySzczurak	20:cf211a3b3d9e	6151	} else {
JerrySzczurak	21:627b65069e6d	6152	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	6153	VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO, &data );
JerrySzczurak	20:cf211a3b3d9e	6154	}
JerrySzczurak	20:cf211a3b3d9e	6155	}
JerrySzczurak	20:cf211a3b3d9e	6156
JerrySzczurak	20:cf211a3b3d9e	6157	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6158	switch ( data & 0x07 ) {
JerrySzczurak	20:cf211a3b3d9e	6159	case 0x00:
JerrySzczurak	20:cf211a3b3d9e	6160	gpio_functionality = VL53L0X_GPIOFUNCTIONALITY_OFF;
JerrySzczurak	20:cf211a3b3d9e	6161	break;
JerrySzczurak	20:cf211a3b3d9e	6162	case 0x01:
JerrySzczurak	20:cf211a3b3d9e	6163	gpio_functionality =
JerrySzczurak	20:cf211a3b3d9e	6164	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW;
JerrySzczurak	20:cf211a3b3d9e	6165	break;
JerrySzczurak	20:cf211a3b3d9e	6166	case 0x02:
JerrySzczurak	20:cf211a3b3d9e	6167	gpio_functionality =
JerrySzczurak	20:cf211a3b3d9e	6168	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH;
JerrySzczurak	20:cf211a3b3d9e	6169	break;
JerrySzczurak	20:cf211a3b3d9e	6170	case 0x03:
JerrySzczurak	20:cf211a3b3d9e	6171	gpio_functionality =
JerrySzczurak	20:cf211a3b3d9e	6172	VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT;
JerrySzczurak	20:cf211a3b3d9e	6173	break;
JerrySzczurak	20:cf211a3b3d9e	6174	case 0x04:
JerrySzczurak	20:cf211a3b3d9e	6175	gpio_functionality =
JerrySzczurak	20:cf211a3b3d9e	6176	VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY;
JerrySzczurak	20:cf211a3b3d9e	6177	break;
JerrySzczurak	20:cf211a3b3d9e	6178	default:
JerrySzczurak	20:cf211a3b3d9e	6179	status = VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED;
JerrySzczurak	20:cf211a3b3d9e	6180	}
JerrySzczurak	20:cf211a3b3d9e	6181	}
JerrySzczurak	20:cf211a3b3d9e	6182
JerrySzczurak	20:cf211a3b3d9e	6183	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	21:627b65069e6d	6184	status = vl53l0x_read_byte( dev, VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH,
JerrySzczurak	20:cf211a3b3d9e	6185	&data );
JerrySzczurak	20:cf211a3b3d9e	6186
JerrySzczurak	20:cf211a3b3d9e	6187	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6188	if ( ( data & ( uint8_t )( 1 << 4 ) ) == 0 )
JerrySzczurak	20:cf211a3b3d9e	6189	*p_polarity = VL53L0X_INTERRUPTPOLARITY_LOW;
JerrySzczurak	20:cf211a3b3d9e	6190	else
JerrySzczurak	20:cf211a3b3d9e	6191	*p_polarity = VL53L0X_INTERRUPTPOLARITY_HIGH;
JerrySzczurak	20:cf211a3b3d9e	6192	}
JerrySzczurak	20:cf211a3b3d9e	6193
JerrySzczurak	20:cf211a3b3d9e	6194	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6195	*p_functionality = gpio_functionality;
JerrySzczurak	20:cf211a3b3d9e	6196	VL53L0X_SETDEVICESPECIFICPARAMETER( dev, Pin0GpioFunctionality,
JerrySzczurak	20:cf211a3b3d9e	6197	gpio_functionality );
JerrySzczurak	20:cf211a3b3d9e	6198	}
JerrySzczurak	20:cf211a3b3d9e	6199
JerrySzczurak	20:cf211a3b3d9e	6200	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6201	return status;
JerrySzczurak	20:cf211a3b3d9e	6202	}
JerrySzczurak	20:cf211a3b3d9e	6203
JerrySzczurak	20:cf211a3b3d9e	6204	VL53L0X_Error VL53L0X::vl53l0x_get_histogram_measurement_data( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6205	VL53L0X_HistogramMeasurementData_t *p_histogram_measurement_data )
JerrySzczurak	20:cf211a3b3d9e	6206	{
JerrySzczurak	20:cf211a3b3d9e	6207	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	6208	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6209
JerrySzczurak	20:cf211a3b3d9e	6210	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6211	return status;
JerrySzczurak	20:cf211a3b3d9e	6212	}
JerrySzczurak	20:cf211a3b3d9e	6213
JerrySzczurak	20:cf211a3b3d9e	6214	VL53L0X_Error VL53L0X::vl53l0x_get_histogram_mode( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6215	VL53L0X_HistogramModes *p_histogram_mode )
JerrySzczurak	20:cf211a3b3d9e	6216	{
JerrySzczurak	20:cf211a3b3d9e	6217	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	6218	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6219
JerrySzczurak	20:cf211a3b3d9e	6220	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	6221
JerrySzczurak	20:cf211a3b3d9e	6222	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6223	return status;
JerrySzczurak	20:cf211a3b3d9e	6224	}
JerrySzczurak	20:cf211a3b3d9e	6225
JerrySzczurak	20:cf211a3b3d9e	6226	VL53L0X_Error VL53L0X::vl53l0x_set_histogram_mode( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6227	VL53L0X_HistogramModes histogram_mode )
JerrySzczurak	20:cf211a3b3d9e	6228	{
JerrySzczurak	20:cf211a3b3d9e	6229	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	6230	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6231
JerrySzczurak	20:cf211a3b3d9e	6232	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	6233
JerrySzczurak	20:cf211a3b3d9e	6234	LOG_FUNCTION_END( Status );
JerrySzczurak	20:cf211a3b3d9e	6235	return status;
JerrySzczurak	20:cf211a3b3d9e	6236	}
JerrySzczurak	20:cf211a3b3d9e	6237
JerrySzczurak	20:cf211a3b3d9e	6238	VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_current( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	6239	FixPoint1616_t *p_limit_check_current )
JerrySzczurak	20:cf211a3b3d9e	6240	{
JerrySzczurak	20:cf211a3b3d9e	6241	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6242	VL53L0X_RangingMeasurementData_t last_range_data_buffer;
JerrySzczurak	20:cf211a3b3d9e	6243
JerrySzczurak	20:cf211a3b3d9e	6244	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6245
JerrySzczurak	20:cf211a3b3d9e	6246	if ( limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS ) {
JerrySzczurak	20:cf211a3b3d9e	6247	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6248	} else {
JerrySzczurak	20:cf211a3b3d9e	6249	switch ( limit_check_id ) {
JerrySzczurak	20:cf211a3b3d9e	6250	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	6251	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6252	*p_limit_check_current = PALDevDataGet( dev, SigmaEstimate );
JerrySzczurak	20:cf211a3b3d9e	6253
JerrySzczurak	20:cf211a3b3d9e	6254	break;
JerrySzczurak	20:cf211a3b3d9e	6255
JerrySzczurak	20:cf211a3b3d9e	6256	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
JerrySzczurak	20:cf211a3b3d9e	6257	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6258	last_range_data_buffer = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6259	LastRangeMeasure );
JerrySzczurak	20:cf211a3b3d9e	6260	*p_limit_check_current =
JerrySzczurak	20:cf211a3b3d9e	6261	last_range_data_buffer.SignalRateRtnMegaCps;
JerrySzczurak	20:cf211a3b3d9e	6262
JerrySzczurak	20:cf211a3b3d9e	6263	break;
JerrySzczurak	20:cf211a3b3d9e	6264
JerrySzczurak	20:cf211a3b3d9e	6265	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
JerrySzczurak	20:cf211a3b3d9e	6266	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6267	*p_limit_check_current = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6268	LastSignalRefMcps );
JerrySzczurak	20:cf211a3b3d9e	6269
JerrySzczurak	20:cf211a3b3d9e	6270	break;
JerrySzczurak	20:cf211a3b3d9e	6271
JerrySzczurak	20:cf211a3b3d9e	6272	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
JerrySzczurak	20:cf211a3b3d9e	6273	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6274	last_range_data_buffer = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6275	LastRangeMeasure );
JerrySzczurak	20:cf211a3b3d9e	6276	*p_limit_check_current =
JerrySzczurak	20:cf211a3b3d9e	6277	last_range_data_buffer.SignalRateRtnMegaCps;
JerrySzczurak	20:cf211a3b3d9e	6278
JerrySzczurak	20:cf211a3b3d9e	6279	break;
JerrySzczurak	20:cf211a3b3d9e	6280
JerrySzczurak	20:cf211a3b3d9e	6281	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
JerrySzczurak	20:cf211a3b3d9e	6282	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6283	last_range_data_buffer = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6284	LastRangeMeasure );
JerrySzczurak	20:cf211a3b3d9e	6285	*p_limit_check_current =
JerrySzczurak	20:cf211a3b3d9e	6286	last_range_data_buffer.SignalRateRtnMegaCps;
JerrySzczurak	20:cf211a3b3d9e	6287
JerrySzczurak	20:cf211a3b3d9e	6288	break;
JerrySzczurak	20:cf211a3b3d9e	6289
JerrySzczurak	20:cf211a3b3d9e	6290	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
JerrySzczurak	20:cf211a3b3d9e	6291	/* Need to run a ranging to have the latest values */
JerrySzczurak	20:cf211a3b3d9e	6292	last_range_data_buffer = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6293	LastRangeMeasure );
JerrySzczurak	20:cf211a3b3d9e	6294	*p_limit_check_current =
JerrySzczurak	20:cf211a3b3d9e	6295	last_range_data_buffer.SignalRateRtnMegaCps;
JerrySzczurak	20:cf211a3b3d9e	6296
JerrySzczurak	20:cf211a3b3d9e	6297	break;
JerrySzczurak	20:cf211a3b3d9e	6298
JerrySzczurak	20:cf211a3b3d9e	6299	default:
JerrySzczurak	20:cf211a3b3d9e	6300	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6301	}
JerrySzczurak	20:cf211a3b3d9e	6302	}
JerrySzczurak	20:cf211a3b3d9e	6303
JerrySzczurak	20:cf211a3b3d9e	6304	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6305	return status;
JerrySzczurak	20:cf211a3b3d9e	6306
JerrySzczurak	20:cf211a3b3d9e	6307	}
JerrySzczurak	20:cf211a3b3d9e	6308
JerrySzczurak	20:cf211a3b3d9e	6309	VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_info( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	6310	char *p_limit_check_string )
JerrySzczurak	20:cf211a3b3d9e	6311	{
JerrySzczurak	20:cf211a3b3d9e	6312	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6313
JerrySzczurak	20:cf211a3b3d9e	6314	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6315
JerrySzczurak	20:cf211a3b3d9e	6316	status = wrapped_vl53l0x_get_limit_check_info( dev, limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	6317	p_limit_check_string );
JerrySzczurak	20:cf211a3b3d9e	6318
JerrySzczurak	20:cf211a3b3d9e	6319	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6320	return status;
JerrySzczurak	20:cf211a3b3d9e	6321	}
JerrySzczurak	20:cf211a3b3d9e	6322
JerrySzczurak	20:cf211a3b3d9e	6323	VL53L0X_Error VL53L0X::vl53l0x_get_limit_check_status( VL53L0X_DEV dev, uint16_t limit_check_id,
JerrySzczurak	20:cf211a3b3d9e	6324	uint8_t *p_limit_check_status )
JerrySzczurak	20:cf211a3b3d9e	6325	{
JerrySzczurak	20:cf211a3b3d9e	6326	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6327	uint8_t temp8;
JerrySzczurak	20:cf211a3b3d9e	6328
JerrySzczurak	20:cf211a3b3d9e	6329	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6330
JerrySzczurak	20:cf211a3b3d9e	6331	if ( limit_check_id >= VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS ) {
JerrySzczurak	20:cf211a3b3d9e	6332	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6333	} else {
JerrySzczurak	20:cf211a3b3d9e	6334
JerrySzczurak	20:cf211a3b3d9e	6335	VL53L0X_GETARRAYPARAMETERFIELD( dev, LimitChecksStatus,
JerrySzczurak	20:cf211a3b3d9e	6336	limit_check_id, temp8 );
JerrySzczurak	20:cf211a3b3d9e	6337
JerrySzczurak	20:cf211a3b3d9e	6338	*p_limit_check_status = temp8;
JerrySzczurak	20:cf211a3b3d9e	6339
JerrySzczurak	20:cf211a3b3d9e	6340	}
JerrySzczurak	20:cf211a3b3d9e	6341
JerrySzczurak	20:cf211a3b3d9e	6342	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6343	return status;
JerrySzczurak	20:cf211a3b3d9e	6344	}
JerrySzczurak	20:cf211a3b3d9e	6345
JerrySzczurak	20:cf211a3b3d9e	6346	VL53L0X_Error VL53L0X::vl53l0x_set_linearity_corrective_gain( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6347	int16_t linearity_corrective_gain )
JerrySzczurak	20:cf211a3b3d9e	6348	{
JerrySzczurak	20:cf211a3b3d9e	6349	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6350	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6351
JerrySzczurak	20:cf211a3b3d9e	6352	if ( ( linearity_corrective_gain < 0 ) \|\| ( linearity_corrective_gain > 1000 ) )
JerrySzczurak	20:cf211a3b3d9e	6353	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6354	else {
JerrySzczurak	20:cf211a3b3d9e	6355	PALDevDataSet( dev, LinearityCorrectiveGain,
JerrySzczurak	20:cf211a3b3d9e	6356	linearity_corrective_gain );
JerrySzczurak	20:cf211a3b3d9e	6357
JerrySzczurak	20:cf211a3b3d9e	6358	if ( linearity_corrective_gain != 1000 ) {
JerrySzczurak	20:cf211a3b3d9e	6359	/* Disable FW Xtalk */
JerrySzczurak	21:627b65069e6d	6360	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	6361	VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, 0 );
JerrySzczurak	20:cf211a3b3d9e	6362	}
JerrySzczurak	20:cf211a3b3d9e	6363	}
JerrySzczurak	20:cf211a3b3d9e	6364
JerrySzczurak	20:cf211a3b3d9e	6365	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6366	return status;
JerrySzczurak	20:cf211a3b3d9e	6367	}
JerrySzczurak	20:cf211a3b3d9e	6368
JerrySzczurak	20:cf211a3b3d9e	6369	VL53L0X_Error VL53L0X::vl53l0x_get_linearity_corrective_gain( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6370	uint16_t *p_linearity_corrective_gain )
JerrySzczurak	20:cf211a3b3d9e	6371	{
JerrySzczurak	20:cf211a3b3d9e	6372	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6373	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6374
JerrySzczurak	20:cf211a3b3d9e	6375	*p_linearity_corrective_gain = PALDevDataGet( dev, LinearityCorrectiveGain );
JerrySzczurak	20:cf211a3b3d9e	6376
JerrySzczurak	20:cf211a3b3d9e	6377	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6378	return status;
JerrySzczurak	20:cf211a3b3d9e	6379	}
JerrySzczurak	20:cf211a3b3d9e	6380
JerrySzczurak	20:cf211a3b3d9e	6381	VL53L0X_Error VL53L0X::vl53l0x_get_max_number_of_roi_zones( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6382	uint8_t *p_max_number_of_roi_zones )
JerrySzczurak	20:cf211a3b3d9e	6383	{
JerrySzczurak	20:cf211a3b3d9e	6384	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6385
JerrySzczurak	20:cf211a3b3d9e	6386	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6387
JerrySzczurak	20:cf211a3b3d9e	6388	*p_max_number_of_roi_zones = 1;
JerrySzczurak	20:cf211a3b3d9e	6389
JerrySzczurak	20:cf211a3b3d9e	6390	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6391	return status;
JerrySzczurak	20:cf211a3b3d9e	6392	}
JerrySzczurak	20:cf211a3b3d9e	6393
JerrySzczurak	20:cf211a3b3d9e	6394	VL53L0X_Error VL53L0X::vl53l0x_get_measurement_ref_signal( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6395	FixPoint1616_t *p_measurement_ref_signal )
JerrySzczurak	20:cf211a3b3d9e	6396	{
JerrySzczurak	20:cf211a3b3d9e	6397	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6398	uint8_t signal_ref_clip_limit_check_enable = 0;
JerrySzczurak	20:cf211a3b3d9e	6399	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6400
JerrySzczurak	20:cf211a3b3d9e	6401	status = vl53l0x_get_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	6402	VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP,
JerrySzczurak	20:cf211a3b3d9e	6403	&signal_ref_clip_limit_check_enable );
JerrySzczurak	20:cf211a3b3d9e	6404	if ( signal_ref_clip_limit_check_enable != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6405	*p_measurement_ref_signal = PALDevDataGet( dev, LastSignalRefMcps );
JerrySzczurak	20:cf211a3b3d9e	6406	} else {
JerrySzczurak	20:cf211a3b3d9e	6407	status = VL53L0X_ERROR_INVALID_COMMAND;
JerrySzczurak	20:cf211a3b3d9e	6408	}
JerrySzczurak	20:cf211a3b3d9e	6409	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6410
JerrySzczurak	20:cf211a3b3d9e	6411	return status;
JerrySzczurak	20:cf211a3b3d9e	6412	}
JerrySzczurak	20:cf211a3b3d9e	6413
JerrySzczurak	20:cf211a3b3d9e	6414
JerrySzczurak	20:cf211a3b3d9e	6415	VL53L0X_Error VL53L0X::vl53l0x_get_number_of_limit_check( uint16_t *p_number_of_limit_check )
JerrySzczurak	20:cf211a3b3d9e	6416	{
JerrySzczurak	20:cf211a3b3d9e	6417	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6418	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6419
JerrySzczurak	20:cf211a3b3d9e	6420	*p_number_of_limit_check = VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS;
JerrySzczurak	20:cf211a3b3d9e	6421
JerrySzczurak	20:cf211a3b3d9e	6422	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6423	return status;
JerrySzczurak	20:cf211a3b3d9e	6424	}
JerrySzczurak	20:cf211a3b3d9e	6425
JerrySzczurak	20:cf211a3b3d9e	6426	VL53L0X_Error VL53L0X::vl53l0x_get_number_of_roi_zones( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6427	uint8_t *p_number_of_roi_zones )
JerrySzczurak	20:cf211a3b3d9e	6428	{
JerrySzczurak	20:cf211a3b3d9e	6429	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6430
JerrySzczurak	20:cf211a3b3d9e	6431	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6432
JerrySzczurak	20:cf211a3b3d9e	6433	*p_number_of_roi_zones = 1;
JerrySzczurak	20:cf211a3b3d9e	6434
JerrySzczurak	20:cf211a3b3d9e	6435	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6436	return status;
JerrySzczurak	20:cf211a3b3d9e	6437	}
JerrySzczurak	20:cf211a3b3d9e	6438
JerrySzczurak	20:cf211a3b3d9e	6439	VL53L0X_Error VL53L0X::vl53l0x_set_number_of_roi_zones( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6440	uint8_t number_of_roi_zones )
JerrySzczurak	20:cf211a3b3d9e	6441	{
JerrySzczurak	20:cf211a3b3d9e	6442	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6443
JerrySzczurak	20:cf211a3b3d9e	6444	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6445
JerrySzczurak	20:cf211a3b3d9e	6446	if ( number_of_roi_zones != 1 )
JerrySzczurak	20:cf211a3b3d9e	6447	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6448
JerrySzczurak	20:cf211a3b3d9e	6449
JerrySzczurak	20:cf211a3b3d9e	6450	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6451	return status;
JerrySzczurak	20:cf211a3b3d9e	6452	}
JerrySzczurak	20:cf211a3b3d9e	6453
JerrySzczurak	20:cf211a3b3d9e	6454	VL53L0X_Error VL53L0X::vl53l0x_get_number_of_sequence_steps( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6455	uint8_t *p_number_of_sequence_steps )
JerrySzczurak	20:cf211a3b3d9e	6456	{
JerrySzczurak	20:cf211a3b3d9e	6457	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6458	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6459
JerrySzczurak	20:cf211a3b3d9e	6460	*p_number_of_sequence_steps = VL53L0X_SEQUENCESTEP_NUMBER_OF_CHECKS;
JerrySzczurak	20:cf211a3b3d9e	6461
JerrySzczurak	20:cf211a3b3d9e	6462	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6463	return status;
JerrySzczurak	20:cf211a3b3d9e	6464	}
JerrySzczurak	20:cf211a3b3d9e	6465
JerrySzczurak	20:cf211a3b3d9e	6466	VL53L0X_Error VL53L0X::vl53l0x_get_pal_error_string( VL53L0X_Error pal_error_code,
JerrySzczurak	20:cf211a3b3d9e	6467	char *p_pal_error_string )
JerrySzczurak	20:cf211a3b3d9e	6468	{
JerrySzczurak	20:cf211a3b3d9e	6469	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6470	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6471
JerrySzczurak	20:cf211a3b3d9e	6472	status = wrapped_vl53l0x_get_pal_error_string( pal_error_code, p_pal_error_string );
JerrySzczurak	20:cf211a3b3d9e	6473
JerrySzczurak	20:cf211a3b3d9e	6474	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6475	return status;
JerrySzczurak	20:cf211a3b3d9e	6476	}
JerrySzczurak	20:cf211a3b3d9e	6477
JerrySzczurak	20:cf211a3b3d9e	6478	VL53L0X_Error VL53L0X::vl53l0x_get_pal_spec_version( VL53L0X_Version_t *p_pal_spec_version )
JerrySzczurak	20:cf211a3b3d9e	6479	{
JerrySzczurak	20:cf211a3b3d9e	6480	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6481
JerrySzczurak	20:cf211a3b3d9e	6482	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6483
JerrySzczurak	20:cf211a3b3d9e	6484	p_pal_spec_version->major = VL53L0X_SPECIFICATION_VER_MAJOR;
JerrySzczurak	20:cf211a3b3d9e	6485	p_pal_spec_version->minor = VL53L0X_SPECIFICATION_VER_MINOR;
JerrySzczurak	20:cf211a3b3d9e	6486	p_pal_spec_version->build = VL53L0X_SPECIFICATION_VER_SUB;
JerrySzczurak	20:cf211a3b3d9e	6487
JerrySzczurak	20:cf211a3b3d9e	6488	p_pal_spec_version->revision = VL53L0X_SPECIFICATION_VER_REVISION;
JerrySzczurak	20:cf211a3b3d9e	6489
JerrySzczurak	20:cf211a3b3d9e	6490	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6491	return status;
JerrySzczurak	20:cf211a3b3d9e	6492	}
JerrySzczurak	20:cf211a3b3d9e	6493
JerrySzczurak	20:cf211a3b3d9e	6494	VL53L0X_Error VL53L0X::vl53l0x_get_pal_state( VL53L0X_DEV dev, VL53L0X_State *p_pal_state )
JerrySzczurak	20:cf211a3b3d9e	6495	{
JerrySzczurak	20:cf211a3b3d9e	6496	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6497	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6498
JerrySzczurak	20:cf211a3b3d9e	6499	*p_pal_state = PALDevDataGet( dev, PalState );
JerrySzczurak	20:cf211a3b3d9e	6500
JerrySzczurak	20:cf211a3b3d9e	6501	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6502	return status;
JerrySzczurak	20:cf211a3b3d9e	6503	}
JerrySzczurak	20:cf211a3b3d9e	6504
JerrySzczurak	20:cf211a3b3d9e	6505	VL53L0X_Error VL53L0X::vl53l0x_get_pal_state_string( VL53L0X_State pal_state_code,
JerrySzczurak	20:cf211a3b3d9e	6506	char *p_pal_state_string )
JerrySzczurak	20:cf211a3b3d9e	6507	{
JerrySzczurak	20:cf211a3b3d9e	6508	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6509	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6510
JerrySzczurak	20:cf211a3b3d9e	6511	status = wrapped_vl53l0x_get_pal_state_string( pal_state_code, p_pal_state_string );
JerrySzczurak	20:cf211a3b3d9e	6512
JerrySzczurak	20:cf211a3b3d9e	6513	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6514	return status;
JerrySzczurak	20:cf211a3b3d9e	6515	}
JerrySzczurak	20:cf211a3b3d9e	6516
JerrySzczurak	20:cf211a3b3d9e	6517	VL53L0X_Error VL53L0X::vl53l0x_get_power_mode( VL53L0X_DEV dev, VL53L0X_PowerModes *p_power_mode )
JerrySzczurak	20:cf211a3b3d9e	6518	{
JerrySzczurak	20:cf211a3b3d9e	6519	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6520	uint8_t byte;
JerrySzczurak	20:cf211a3b3d9e	6521	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6522
JerrySzczurak	20:cf211a3b3d9e	6523	/* Only level1 of Power mode exists */
JerrySzczurak	21:627b65069e6d	6524	status = vl53l0x_read_byte( dev, 0x80, &byte );
JerrySzczurak	20:cf211a3b3d9e	6525
JerrySzczurak	20:cf211a3b3d9e	6526	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6527	if ( byte == 1 ) {
JerrySzczurak	20:cf211a3b3d9e	6528	PALDevDataSet( dev, PowerMode,
JerrySzczurak	20:cf211a3b3d9e	6529	VL53L0X_POWERMODE_IDLE_LEVEL1 );
JerrySzczurak	20:cf211a3b3d9e	6530	} else {
JerrySzczurak	20:cf211a3b3d9e	6531	PALDevDataSet( dev, PowerMode,
JerrySzczurak	20:cf211a3b3d9e	6532	VL53L0X_POWERMODE_STANDBY_LEVEL1 );
JerrySzczurak	20:cf211a3b3d9e	6533	}
JerrySzczurak	20:cf211a3b3d9e	6534	}
JerrySzczurak	20:cf211a3b3d9e	6535
JerrySzczurak	20:cf211a3b3d9e	6536	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6537	return status;
JerrySzczurak	20:cf211a3b3d9e	6538	}
JerrySzczurak	20:cf211a3b3d9e	6539
JerrySzczurak	20:cf211a3b3d9e	6540	VL53L0X_Error VL53L0X::vl53l0x_set_power_mode( VL53L0X_DEV dev, VL53L0X_PowerModes power_mode )
JerrySzczurak	20:cf211a3b3d9e	6541	{
JerrySzczurak	20:cf211a3b3d9e	6542	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6543	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6544
JerrySzczurak	20:cf211a3b3d9e	6545	/* Only level1 of Power mode exists */
JerrySzczurak	20:cf211a3b3d9e	6546	if ( ( power_mode != VL53L0X_POWERMODE_STANDBY_LEVEL1 )
JerrySzczurak	20:cf211a3b3d9e	6547	&& ( power_mode != VL53L0X_POWERMODE_IDLE_LEVEL1 ) ) {
JerrySzczurak	20:cf211a3b3d9e	6548	status = VL53L0X_ERROR_MODE_NOT_SUPPORTED;
JerrySzczurak	20:cf211a3b3d9e	6549	} else if ( power_mode == VL53L0X_POWERMODE_STANDBY_LEVEL1 ) {
JerrySzczurak	20:cf211a3b3d9e	6550	/* set the standby level1 of power mode */
JerrySzczurak	21:627b65069e6d	6551	status = vl53l0x_write_byte( dev, 0x80, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6552	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6553	/* Set PAL State to standby */
JerrySzczurak	20:cf211a3b3d9e	6554	PALDevDataSet( dev, PalState, VL53L0X_STATE_STANDBY );
JerrySzczurak	20:cf211a3b3d9e	6555	PALDevDataSet( dev, PowerMode,
JerrySzczurak	20:cf211a3b3d9e	6556	VL53L0X_POWERMODE_STANDBY_LEVEL1 );
JerrySzczurak	20:cf211a3b3d9e	6557	}
JerrySzczurak	20:cf211a3b3d9e	6558
JerrySzczurak	20:cf211a3b3d9e	6559	} else {
JerrySzczurak	20:cf211a3b3d9e	6560	/* VL53L0X_POWERMODE_IDLE_LEVEL1 */
JerrySzczurak	21:627b65069e6d	6561	status = vl53l0x_write_byte( dev, 0x80, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6562	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6563	status = vl53l0x_static_init( dev );
JerrySzczurak	20:cf211a3b3d9e	6564
JerrySzczurak	20:cf211a3b3d9e	6565	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6566	PALDevDataSet( dev, PowerMode,
JerrySzczurak	20:cf211a3b3d9e	6567	VL53L0X_POWERMODE_IDLE_LEVEL1 );
JerrySzczurak	20:cf211a3b3d9e	6568
JerrySzczurak	20:cf211a3b3d9e	6569	}
JerrySzczurak	20:cf211a3b3d9e	6570
JerrySzczurak	20:cf211a3b3d9e	6571	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6572	return status;
JerrySzczurak	20:cf211a3b3d9e	6573	}
JerrySzczurak	20:cf211a3b3d9e	6574
JerrySzczurak	20:cf211a3b3d9e	6575	VL53L0X_Error VL53L0X::vl53l0x_get_product_revision( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6576	uint8_t p_product_revision_major, uint8_t p_product_revision_minor )
JerrySzczurak	20:cf211a3b3d9e	6577	{
JerrySzczurak	20:cf211a3b3d9e	6578	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6579	uint8_t revision_id;
JerrySzczurak	20:cf211a3b3d9e	6580
JerrySzczurak	20:cf211a3b3d9e	6581	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6582
JerrySzczurak	21:627b65069e6d	6583	status = vl53l0x_read_byte( dev, VL53L0X_REG_IDENTIFICATION_REVISION_ID,
JerrySzczurak	20:cf211a3b3d9e	6584	&revision_id );
JerrySzczurak	20:cf211a3b3d9e	6585	*p_product_revision_major = 1;
JerrySzczurak	20:cf211a3b3d9e	6586	*p_product_revision_minor = ( revision_id & 0xF0 ) >> 4;
JerrySzczurak	20:cf211a3b3d9e	6587
JerrySzczurak	20:cf211a3b3d9e	6588	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6589	return status;
JerrySzczurak	20:cf211a3b3d9e	6590
JerrySzczurak	20:cf211a3b3d9e	6591	}
JerrySzczurak	20:cf211a3b3d9e	6592
JerrySzczurak	20:cf211a3b3d9e	6593	VL53L0X_Error VL53L0X::vl53l0x_get_range_status_string( uint8_t range_status,
JerrySzczurak	20:cf211a3b3d9e	6594	char *p_range_status_string )
JerrySzczurak	20:cf211a3b3d9e	6595	{
JerrySzczurak	20:cf211a3b3d9e	6596	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6597	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6598
JerrySzczurak	20:cf211a3b3d9e	6599	status = wrapped_vl53l0x_get_range_status_string( range_status,
JerrySzczurak	20:cf211a3b3d9e	6600	p_range_status_string );
JerrySzczurak	20:cf211a3b3d9e	6601
JerrySzczurak	20:cf211a3b3d9e	6602	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6603	return status;
JerrySzczurak	20:cf211a3b3d9e	6604	}
JerrySzczurak	20:cf211a3b3d9e	6605
JerrySzczurak	20:cf211a3b3d9e	6606	VL53L0X_Error VL53L0X::vl53l0x_get_ref_calibration( VL53L0X_DEV dev, uint8_t *p_vhv_settings,
JerrySzczurak	20:cf211a3b3d9e	6607	uint8_t *p_phase_cal )
JerrySzczurak	20:cf211a3b3d9e	6608	{
JerrySzczurak	20:cf211a3b3d9e	6609	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6610	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6611
JerrySzczurak	20:cf211a3b3d9e	6612	status = wrapped_vl53l0x_get_ref_calibration( dev, p_vhv_settings, p_phase_cal );
JerrySzczurak	20:cf211a3b3d9e	6613
JerrySzczurak	20:cf211a3b3d9e	6614	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6615	return status;
JerrySzczurak	20:cf211a3b3d9e	6616	}
JerrySzczurak	20:cf211a3b3d9e	6617
JerrySzczurak	20:cf211a3b3d9e	6618	VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6619	VL53L0X_SequenceStepId sequence_step_id, uint8_t *p_sequence_step_enabled )
JerrySzczurak	20:cf211a3b3d9e	6620	{
JerrySzczurak	20:cf211a3b3d9e	6621	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6622	uint8_t SequenceConfig = 0;
JerrySzczurak	20:cf211a3b3d9e	6623	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6624
JerrySzczurak	21:627b65069e6d	6625	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG,
JerrySzczurak	20:cf211a3b3d9e	6626	&SequenceConfig );
JerrySzczurak	20:cf211a3b3d9e	6627
JerrySzczurak	20:cf211a3b3d9e	6628	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6629	status = sequence_step_enabled( dev, sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	6630	SequenceConfig, p_sequence_step_enabled );
JerrySzczurak	20:cf211a3b3d9e	6631	}
JerrySzczurak	20:cf211a3b3d9e	6632
JerrySzczurak	20:cf211a3b3d9e	6633	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6634	return status;
JerrySzczurak	20:cf211a3b3d9e	6635	}
JerrySzczurak	20:cf211a3b3d9e	6636
JerrySzczurak	20:cf211a3b3d9e	6637	VL53L0X_Error VL53L0X::vl53l0x_set_sequence_step_timeout( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6638	VL53L0X_SequenceStepId sequence_step_id, FixPoint1616_t time_out_milli_secs )
JerrySzczurak	20:cf211a3b3d9e	6639	{
JerrySzczurak	20:cf211a3b3d9e	6640	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6641	VL53L0X_Error status1 = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6642	uint32_t TimeoutMicroSeconds = ( ( time_out_milli_secs * 1000 ) + 0x8000 )
JerrySzczurak	20:cf211a3b3d9e	6643	>> 16;
JerrySzczurak	20:cf211a3b3d9e	6644	uint32_t MeasurementTimingBudgetMicroSeconds;
JerrySzczurak	20:cf211a3b3d9e	6645	FixPoint1616_t OldTimeOutMicroSeconds;
JerrySzczurak	20:cf211a3b3d9e	6646
JerrySzczurak	20:cf211a3b3d9e	6647	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6648
JerrySzczurak	20:cf211a3b3d9e	6649	/* Read back the current value in case we need to revert back to this.
JerrySzczurak	20:cf211a3b3d9e	6650	*/
JerrySzczurak	20:cf211a3b3d9e	6651	status = get_sequence_step_timeout( dev, sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	6652	&OldTimeOutMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6653
JerrySzczurak	20:cf211a3b3d9e	6654	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6655	status = set_sequence_step_timeout( dev, sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	6656	TimeoutMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6657	}
JerrySzczurak	20:cf211a3b3d9e	6658
JerrySzczurak	20:cf211a3b3d9e	6659	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6660	VL53L0X_GETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	6661	MeasurementTimingBudgetMicroSeconds,
JerrySzczurak	20:cf211a3b3d9e	6662	MeasurementTimingBudgetMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6663
JerrySzczurak	20:cf211a3b3d9e	6664	/* At this point we don't know if the requested value is valid,
JerrySzczurak	20:cf211a3b3d9e	6665	therefore proceed to update the entire timing budget and
JerrySzczurak	20:cf211a3b3d9e	6666	if this fails, revert back to the previous value.
JerrySzczurak	20:cf211a3b3d9e	6667	*/
JerrySzczurak	20:cf211a3b3d9e	6668	status = vl53l0x_set_measurement_timing_budget_micro_seconds( dev,
JerrySzczurak	20:cf211a3b3d9e	6669	MeasurementTimingBudgetMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6670
JerrySzczurak	20:cf211a3b3d9e	6671	if ( status != VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6672	status1 = set_sequence_step_timeout( dev, sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	6673	OldTimeOutMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6674
JerrySzczurak	20:cf211a3b3d9e	6675	if ( status1 == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6676	status1 =
JerrySzczurak	20:cf211a3b3d9e	6677	vl53l0x_set_measurement_timing_budget_micro_seconds(
JerrySzczurak	20:cf211a3b3d9e	6678	dev,
JerrySzczurak	20:cf211a3b3d9e	6679	MeasurementTimingBudgetMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	6680	}
JerrySzczurak	20:cf211a3b3d9e	6681
JerrySzczurak	20:cf211a3b3d9e	6682	status = status1;
JerrySzczurak	20:cf211a3b3d9e	6683	}
JerrySzczurak	20:cf211a3b3d9e	6684	}
JerrySzczurak	20:cf211a3b3d9e	6685
JerrySzczurak	20:cf211a3b3d9e	6686	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6687
JerrySzczurak	20:cf211a3b3d9e	6688	return status;
JerrySzczurak	20:cf211a3b3d9e	6689	}
JerrySzczurak	20:cf211a3b3d9e	6690
JerrySzczurak	20:cf211a3b3d9e	6691	VL53L0X_Error VL53L0X::vl53l0x_get_sequence_step_timeout( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6692	VL53L0X_SequenceStepId sequence_step_id, FixPoint1616_t *p_time_out_milli_secs )
JerrySzczurak	20:cf211a3b3d9e	6693	{
JerrySzczurak	20:cf211a3b3d9e	6694	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6695	uint32_t timeout_micro_seconds;
JerrySzczurak	20:cf211a3b3d9e	6696	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6697
JerrySzczurak	20:cf211a3b3d9e	6698	status = get_sequence_step_timeout( dev, sequence_step_id,
JerrySzczurak	20:cf211a3b3d9e	6699	&timeout_micro_seconds );
JerrySzczurak	20:cf211a3b3d9e	6700	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6701	timeout_micro_seconds <<= 8;
JerrySzczurak	20:cf211a3b3d9e	6702	*p_time_out_milli_secs = ( timeout_micro_seconds + 500 ) / 1000;
JerrySzczurak	20:cf211a3b3d9e	6703	*p_time_out_milli_secs <<= 8;
JerrySzczurak	20:cf211a3b3d9e	6704	}
JerrySzczurak	20:cf211a3b3d9e	6705
JerrySzczurak	20:cf211a3b3d9e	6706	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6707	return status;
JerrySzczurak	20:cf211a3b3d9e	6708	}
JerrySzczurak	20:cf211a3b3d9e	6709
JerrySzczurak	20:cf211a3b3d9e	6710	VL53L0X_Error VL53L0X::vl53l0x_set_spad_ambient_damper_factor( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6711	uint16_t spad_ambient_damper_factor )
JerrySzczurak	20:cf211a3b3d9e	6712	{
JerrySzczurak	20:cf211a3b3d9e	6713	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6714	uint8_t byte;
JerrySzczurak	20:cf211a3b3d9e	6715	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6716
JerrySzczurak	20:cf211a3b3d9e	6717	byte = ( uint8_t )( spad_ambient_damper_factor & 0x00FF );
JerrySzczurak	20:cf211a3b3d9e	6718
JerrySzczurak	21:627b65069e6d	6719	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	21:627b65069e6d	6720	status \|= vl53l0x_write_byte( dev, 0x42, byte );
JerrySzczurak	21:627b65069e6d	6721	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6722
JerrySzczurak	20:cf211a3b3d9e	6723	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6724	return status;
JerrySzczurak	20:cf211a3b3d9e	6725	}
JerrySzczurak	20:cf211a3b3d9e	6726
JerrySzczurak	20:cf211a3b3d9e	6727
JerrySzczurak	20:cf211a3b3d9e	6728	VL53L0X_Error VL53L0X::vl53l0x_get_spad_ambient_damper_factor( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6729	uint16_t *p_spad_ambient_damper_factor )
JerrySzczurak	20:cf211a3b3d9e	6730	{
JerrySzczurak	20:cf211a3b3d9e	6731	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6732	uint8_t Byte;
JerrySzczurak	20:cf211a3b3d9e	6733	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6734
JerrySzczurak	21:627b65069e6d	6735	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	21:627b65069e6d	6736	status \|= vl53l0x_read_byte( dev, 0x42, &Byte );
JerrySzczurak	21:627b65069e6d	6737	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6738	*p_spad_ambient_damper_factor = ( uint16_t )Byte;
JerrySzczurak	20:cf211a3b3d9e	6739
JerrySzczurak	20:cf211a3b3d9e	6740	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6741	return status;
JerrySzczurak	20:cf211a3b3d9e	6742	}
JerrySzczurak	20:cf211a3b3d9e	6743
JerrySzczurak	20:cf211a3b3d9e	6744	VL53L0X_Error VL53L0X::vl53l0x_set_spad_ambient_damper_threshold( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6745	uint16_t spad_ambient_damper_threshold )
JerrySzczurak	20:cf211a3b3d9e	6746	{
JerrySzczurak	20:cf211a3b3d9e	6747	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6748	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6749
JerrySzczurak	21:627b65069e6d	6750	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	21:627b65069e6d	6751	status \|= vl53l0x_write_word( dev, 0x40, spad_ambient_damper_threshold );
JerrySzczurak	21:627b65069e6d	6752	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6753
JerrySzczurak	20:cf211a3b3d9e	6754	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6755	return status;
JerrySzczurak	20:cf211a3b3d9e	6756	}
JerrySzczurak	20:cf211a3b3d9e	6757
JerrySzczurak	20:cf211a3b3d9e	6758	VL53L0X_Error VL53L0X::vl53l0x_get_spad_ambient_damper_threshold( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6759	uint16_t *p_spad_ambient_damper_threshold )
JerrySzczurak	20:cf211a3b3d9e	6760	{
JerrySzczurak	20:cf211a3b3d9e	6761	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6762	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6763
JerrySzczurak	21:627b65069e6d	6764	status = vl53l0x_write_byte( dev, 0xFF, 0x01 );
JerrySzczurak	21:627b65069e6d	6765	status \|= vl53l0x_read_word( dev, 0x40, p_spad_ambient_damper_threshold );
JerrySzczurak	21:627b65069e6d	6766	status \|= vl53l0x_write_byte( dev, 0xFF, 0x00 );
JerrySzczurak	20:cf211a3b3d9e	6767
JerrySzczurak	20:cf211a3b3d9e	6768	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6769	return status;
JerrySzczurak	20:cf211a3b3d9e	6770	}
JerrySzczurak	20:cf211a3b3d9e	6771
JerrySzczurak	20:cf211a3b3d9e	6772	VL53L0X_Error VL53L0X::vl53l0x_get_upper_limit_milli_meter( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6773	uint16_t *p_upper_limit_milli_meter )
JerrySzczurak	20:cf211a3b3d9e	6774	{
JerrySzczurak	20:cf211a3b3d9e	6775	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	6776	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6777
JerrySzczurak	20:cf211a3b3d9e	6778	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	6779
JerrySzczurak	20:cf211a3b3d9e	6780	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6781	return status;
JerrySzczurak	20:cf211a3b3d9e	6782	}
JerrySzczurak	20:cf211a3b3d9e	6783
JerrySzczurak	20:cf211a3b3d9e	6784	VL53L0X_Error VL53L0X::vl53l0x_set_tuning_setting_buffer( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6785	uint8_t *p_tuning_setting_buffer, uint8_t use_internal_tuning_settings )
JerrySzczurak	20:cf211a3b3d9e	6786	{
JerrySzczurak	20:cf211a3b3d9e	6787	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6788
JerrySzczurak	20:cf211a3b3d9e	6789	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6790
JerrySzczurak	20:cf211a3b3d9e	6791	if ( use_internal_tuning_settings == 1 ) {
JerrySzczurak	20:cf211a3b3d9e	6792	/* Force use internal settings */
JerrySzczurak	20:cf211a3b3d9e	6793	PALDevDataSet( dev, UseInternalTuningSettings, 1 );
JerrySzczurak	20:cf211a3b3d9e	6794	} else {
JerrySzczurak	20:cf211a3b3d9e	6795
JerrySzczurak	20:cf211a3b3d9e	6796	/* check that the first byte is not 0 */
JerrySzczurak	20:cf211a3b3d9e	6797	if ( *p_tuning_setting_buffer != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6798	PALDevDataSet( dev, pTuningSettingsPointer,
JerrySzczurak	20:cf211a3b3d9e	6799	p_tuning_setting_buffer );
JerrySzczurak	20:cf211a3b3d9e	6800	PALDevDataSet( dev, UseInternalTuningSettings, 0 );
JerrySzczurak	20:cf211a3b3d9e	6801
JerrySzczurak	20:cf211a3b3d9e	6802	} else {
JerrySzczurak	20:cf211a3b3d9e	6803	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6804	}
JerrySzczurak	20:cf211a3b3d9e	6805	}
JerrySzczurak	20:cf211a3b3d9e	6806
JerrySzczurak	20:cf211a3b3d9e	6807	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6808	return status;
JerrySzczurak	20:cf211a3b3d9e	6809	}
JerrySzczurak	20:cf211a3b3d9e	6810
JerrySzczurak	20:cf211a3b3d9e	6811	VL53L0X_Error VL53L0X::vl53l0x_get_tuning_setting_buffer( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6812	uint8_t *pp_tuning_setting_buffer, uint8_t p_use_internal_tuning_settings )
JerrySzczurak	20:cf211a3b3d9e	6813	{
JerrySzczurak	20:cf211a3b3d9e	6814	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6815
JerrySzczurak	20:cf211a3b3d9e	6816	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6817
JerrySzczurak	20:cf211a3b3d9e	6818	*pp_tuning_setting_buffer = PALDevDataGet( dev, pTuningSettingsPointer );
JerrySzczurak	20:cf211a3b3d9e	6819	*p_use_internal_tuning_settings = PALDevDataGet( dev,
JerrySzczurak	20:cf211a3b3d9e	6820	UseInternalTuningSettings );
JerrySzczurak	20:cf211a3b3d9e	6821
JerrySzczurak	20:cf211a3b3d9e	6822	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6823	return status;
JerrySzczurak	20:cf211a3b3d9e	6824	}
JerrySzczurak	20:cf211a3b3d9e	6825
JerrySzczurak	20:cf211a3b3d9e	6826	VL53L0X_Error VL53L0X::vl53l0x_get_version( VL53L0X_Version_t *p_version )
JerrySzczurak	20:cf211a3b3d9e	6827	{
JerrySzczurak	20:cf211a3b3d9e	6828	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6829	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6830
JerrySzczurak	20:cf211a3b3d9e	6831	p_version->major = VL53L0X_IMPLEMENTATION_VER_MAJOR;
JerrySzczurak	20:cf211a3b3d9e	6832	p_version->minor = VL53L0X_IMPLEMENTATION_VER_MINOR;
JerrySzczurak	20:cf211a3b3d9e	6833	p_version->build = VL53L0X_IMPLEMENTATION_VER_SUB;
JerrySzczurak	20:cf211a3b3d9e	6834
JerrySzczurak	20:cf211a3b3d9e	6835	p_version->revision = VL53L0X_IMPLEMENTATION_VER_REVISION;
JerrySzczurak	20:cf211a3b3d9e	6836
JerrySzczurak	20:cf211a3b3d9e	6837	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6838	return status;
JerrySzczurak	20:cf211a3b3d9e	6839	}
JerrySzczurak	20:cf211a3b3d9e	6840
JerrySzczurak	20:cf211a3b3d9e	6841	VL53L0X_Error VL53L0X::vl53l0x_lock_sequence_access( VL53L0X_DEV dev )
JerrySzczurak	20:cf211a3b3d9e	6842	{
JerrySzczurak	20:cf211a3b3d9e	6843	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6844
JerrySzczurak	20:cf211a3b3d9e	6845	return status;
JerrySzczurak	20:cf211a3b3d9e	6846	}
JerrySzczurak	20:cf211a3b3d9e	6847
JerrySzczurak	20:cf211a3b3d9e	6848	VL53L0X_Error VL53L0X::vl53l0x_unlock_sequence_access( VL53L0X_DEV dev )
JerrySzczurak	20:cf211a3b3d9e	6849	{
JerrySzczurak	20:cf211a3b3d9e	6850	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6851
JerrySzczurak	20:cf211a3b3d9e	6852	return status;
JerrySzczurak	20:cf211a3b3d9e	6853	}
JerrySzczurak	20:cf211a3b3d9e	6854
JerrySzczurak	20:cf211a3b3d9e	6855	VL53L0X_Error VL53L0X::vl53l0x_perform_offset_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6856	FixPoint1616_t cal_distance_milli_meter,
JerrySzczurak	20:cf211a3b3d9e	6857	int32_t *p_offset_micro_meter )
JerrySzczurak	20:cf211a3b3d9e	6858	{
JerrySzczurak	20:cf211a3b3d9e	6859	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6860	uint16_t sum_ranging = 0;
JerrySzczurak	20:cf211a3b3d9e	6861	FixPoint1616_t total_count = 0;
JerrySzczurak	20:cf211a3b3d9e	6862	VL53L0X_RangingMeasurementData_t ranging_measurement_data;
JerrySzczurak	20:cf211a3b3d9e	6863	FixPoint1616_t stored_mean_range;
JerrySzczurak	20:cf211a3b3d9e	6864	uint32_t stored_mean_range_as_int;
JerrySzczurak	20:cf211a3b3d9e	6865	uint32_t cal_distance_as_int_mm;
JerrySzczurak	20:cf211a3b3d9e	6866	uint8_t sequence_step_enabled;
JerrySzczurak	20:cf211a3b3d9e	6867	int meas = 0;
JerrySzczurak	20:cf211a3b3d9e	6868
JerrySzczurak	20:cf211a3b3d9e	6869	if ( cal_distance_milli_meter <= 0 )
JerrySzczurak	20:cf211a3b3d9e	6870	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	6871
JerrySzczurak	20:cf211a3b3d9e	6872	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6873	status = wrapped_vl53l0x_set_offset_calibration_data_micro_meter( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	6874
JerrySzczurak	20:cf211a3b3d9e	6875
JerrySzczurak	20:cf211a3b3d9e	6876	/* Get the value of the TCC */
JerrySzczurak	20:cf211a3b3d9e	6877	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6878	status = vl53l0x_get_sequence_step_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	6879	VL53L0X_SEQUENCESTEP_TCC, &sequence_step_enabled );
JerrySzczurak	20:cf211a3b3d9e	6880
JerrySzczurak	20:cf211a3b3d9e	6881
JerrySzczurak	20:cf211a3b3d9e	6882	/* Disable the TCC */
JerrySzczurak	20:cf211a3b3d9e	6883	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6884	status = vl53l0x_set_sequence_step_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	6885	VL53L0X_SEQUENCESTEP_TCC, 0 );
JerrySzczurak	20:cf211a3b3d9e	6886
JerrySzczurak	20:cf211a3b3d9e	6887
JerrySzczurak	20:cf211a3b3d9e	6888	/* Disable the RIT */
JerrySzczurak	20:cf211a3b3d9e	6889	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6890	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	6891	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0 );
JerrySzczurak	20:cf211a3b3d9e	6892
JerrySzczurak	20:cf211a3b3d9e	6893	/* Perform 50 measurements and compute the averages */
JerrySzczurak	20:cf211a3b3d9e	6894	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6895	sum_ranging = 0;
JerrySzczurak	20:cf211a3b3d9e	6896	total_count = 0;
JerrySzczurak	20:cf211a3b3d9e	6897	for ( meas = 0; meas < 50; meas++ ) {
JerrySzczurak	20:cf211a3b3d9e	6898	status = vl53l0x_perform_single_ranging_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	6899	&ranging_measurement_data );
JerrySzczurak	20:cf211a3b3d9e	6900
JerrySzczurak	20:cf211a3b3d9e	6901	if ( status != VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	6902	break;
JerrySzczurak	20:cf211a3b3d9e	6903
JerrySzczurak	20:cf211a3b3d9e	6904	/* The range is valid when RangeStatus = 0 */
JerrySzczurak	20:cf211a3b3d9e	6905	if ( ranging_measurement_data.RangeStatus == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6906	sum_ranging = sum_ranging +
JerrySzczurak	20:cf211a3b3d9e	6907	ranging_measurement_data.RangeMilliMeter;
JerrySzczurak	20:cf211a3b3d9e	6908	total_count = total_count + 1;
JerrySzczurak	20:cf211a3b3d9e	6909	}
JerrySzczurak	20:cf211a3b3d9e	6910	}
JerrySzczurak	20:cf211a3b3d9e	6911
JerrySzczurak	20:cf211a3b3d9e	6912	/* no valid values found */
JerrySzczurak	20:cf211a3b3d9e	6913	if ( total_count == 0 )
JerrySzczurak	20:cf211a3b3d9e	6914	status = VL53L0X_ERROR_RANGE_ERROR;
JerrySzczurak	20:cf211a3b3d9e	6915	}
JerrySzczurak	20:cf211a3b3d9e	6916
JerrySzczurak	20:cf211a3b3d9e	6917
JerrySzczurak	20:cf211a3b3d9e	6918	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6919	/* FixPoint1616_t / uint16_t = FixPoint1616_t */
JerrySzczurak	20:cf211a3b3d9e	6920	stored_mean_range = ( FixPoint1616_t )( ( uint32_t )( sum_ranging << 16 )
JerrySzczurak	20:cf211a3b3d9e	6921	/ total_count );
JerrySzczurak	20:cf211a3b3d9e	6922
JerrySzczurak	20:cf211a3b3d9e	6923	stored_mean_range_as_int = ( stored_mean_range + 0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	6924
JerrySzczurak	20:cf211a3b3d9e	6925	/* Round Cal Distance to Whole Number.
JerrySzczurak	20:cf211a3b3d9e	6926	* Note that the cal distance is in mm, therefore no resolution
JerrySzczurak	20:cf211a3b3d9e	6927	* is lost.*/
JerrySzczurak	20:cf211a3b3d9e	6928	cal_distance_as_int_mm = ( cal_distance_milli_meter + 0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	6929
JerrySzczurak	20:cf211a3b3d9e	6930	*p_offset_micro_meter = ( cal_distance_as_int_mm -
JerrySzczurak	20:cf211a3b3d9e	6931	stored_mean_range_as_int ) * 1000;
JerrySzczurak	20:cf211a3b3d9e	6932
JerrySzczurak	20:cf211a3b3d9e	6933	/* Apply the calculated offset */
JerrySzczurak	20:cf211a3b3d9e	6934	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6935	VL53L0X_SETPARAMETERFIELD( dev, RangeOffsetMicroMeters,
JerrySzczurak	20:cf211a3b3d9e	6936	*p_offset_micro_meter );
JerrySzczurak	20:cf211a3b3d9e	6937	status = vl53l0x_set_offset_calibration_data_micro_meter( dev,
JerrySzczurak	20:cf211a3b3d9e	6938	*p_offset_micro_meter );
JerrySzczurak	20:cf211a3b3d9e	6939	}
JerrySzczurak	20:cf211a3b3d9e	6940
JerrySzczurak	20:cf211a3b3d9e	6941	}
JerrySzczurak	20:cf211a3b3d9e	6942
JerrySzczurak	20:cf211a3b3d9e	6943	/* Restore the TCC */
JerrySzczurak	20:cf211a3b3d9e	6944	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6945	if ( sequence_step_enabled != 0 )
JerrySzczurak	20:cf211a3b3d9e	6946	status = vl53l0x_set_sequence_step_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	6947	VL53L0X_SEQUENCESTEP_TCC, 1 );
JerrySzczurak	20:cf211a3b3d9e	6948	}
JerrySzczurak	20:cf211a3b3d9e	6949
JerrySzczurak	20:cf211a3b3d9e	6950	return status;
JerrySzczurak	20:cf211a3b3d9e	6951	}
JerrySzczurak	20:cf211a3b3d9e	6952
JerrySzczurak	20:cf211a3b3d9e	6953	VL53L0X_Error VL53L0X::vl53l0x_set_x_talk_compensation_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6954	uint8_t x_talk_compensation_enable )
JerrySzczurak	20:cf211a3b3d9e	6955	{
JerrySzczurak	20:cf211a3b3d9e	6956	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6957	FixPoint1616_t temp_fix1616;
JerrySzczurak	20:cf211a3b3d9e	6958	uint16_t linearity_corrective_gain;
JerrySzczurak	20:cf211a3b3d9e	6959
JerrySzczurak	20:cf211a3b3d9e	6960	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	6961
JerrySzczurak	20:cf211a3b3d9e	6962	linearity_corrective_gain = PALDevDataGet( dev, LinearityCorrectiveGain );
JerrySzczurak	20:cf211a3b3d9e	6963
JerrySzczurak	20:cf211a3b3d9e	6964	if ( ( x_talk_compensation_enable == 0 )
JerrySzczurak	20:cf211a3b3d9e	6965	\|\| ( linearity_corrective_gain != 1000 ) ) {
JerrySzczurak	20:cf211a3b3d9e	6966	temp_fix1616 = 0;
JerrySzczurak	20:cf211a3b3d9e	6967	} else {
JerrySzczurak	20:cf211a3b3d9e	6968	VL53L0X_GETPARAMETERFIELD( dev, XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	6969	temp_fix1616 );
JerrySzczurak	20:cf211a3b3d9e	6970	}
JerrySzczurak	20:cf211a3b3d9e	6971
JerrySzczurak	20:cf211a3b3d9e	6972	/* the following register has a format 3.13 */
JerrySzczurak	21:627b65069e6d	6973	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	6974	VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS,
JerrySzczurak	20:cf211a3b3d9e	6975	VL53L0X_FIXPOINT1616TOFIXPOINT313( temp_fix1616 ) );
JerrySzczurak	20:cf211a3b3d9e	6976
JerrySzczurak	20:cf211a3b3d9e	6977	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	6978	if ( x_talk_compensation_enable == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	6979	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationEnable,
JerrySzczurak	20:cf211a3b3d9e	6980	0 );
JerrySzczurak	20:cf211a3b3d9e	6981	} else {
JerrySzczurak	20:cf211a3b3d9e	6982	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationEnable,
JerrySzczurak	20:cf211a3b3d9e	6983	1 );
JerrySzczurak	20:cf211a3b3d9e	6984	}
JerrySzczurak	20:cf211a3b3d9e	6985	}
JerrySzczurak	20:cf211a3b3d9e	6986
JerrySzczurak	20:cf211a3b3d9e	6987	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	6988	return status;
JerrySzczurak	20:cf211a3b3d9e	6989	}
JerrySzczurak	20:cf211a3b3d9e	6990
JerrySzczurak	20:cf211a3b3d9e	6991
JerrySzczurak	20:cf211a3b3d9e	6992	VL53L0X_Error VL53L0X::vl53l0x_perform_xtalk_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	6993	FixPoint1616_t xtalk_cal_distance,
JerrySzczurak	20:cf211a3b3d9e	6994	FixPoint1616_t *p_xtalk_compensation_rate_mega_cps )
JerrySzczurak	20:cf211a3b3d9e	6995	{
JerrySzczurak	20:cf211a3b3d9e	6996	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	6997	uint16_t sum_ranging = 0;
JerrySzczurak	20:cf211a3b3d9e	6998	uint16_t sum_spads = 0;
JerrySzczurak	20:cf211a3b3d9e	6999	FixPoint1616_t sum_signal_rate = 0;
JerrySzczurak	20:cf211a3b3d9e	7000	FixPoint1616_t total_count = 0;
JerrySzczurak	20:cf211a3b3d9e	7001	uint8_t xtalk_meas = 0;
JerrySzczurak	20:cf211a3b3d9e	7002	VL53L0X_RangingMeasurementData_t ranging_measurement_data;
JerrySzczurak	20:cf211a3b3d9e	7003	FixPoint1616_t x_talk_stored_mean_signal_rate;
JerrySzczurak	20:cf211a3b3d9e	7004	FixPoint1616_t x_talk_stored_mean_range;
JerrySzczurak	20:cf211a3b3d9e	7005	FixPoint1616_t x_talk_stored_mean_rtn_spads;
JerrySzczurak	20:cf211a3b3d9e	7006	uint32_t signal_x_talk_total_per_spad;
JerrySzczurak	20:cf211a3b3d9e	7007	uint32_t x_talk_stored_mean_rtn_spads_as_int;
JerrySzczurak	20:cf211a3b3d9e	7008	uint32_t x_talk_cal_distance_as_int;
JerrySzczurak	20:cf211a3b3d9e	7009	FixPoint1616_t x_talk_compensation_rate_mega_cps;
JerrySzczurak	20:cf211a3b3d9e	7010
JerrySzczurak	20:cf211a3b3d9e	7011	if ( xtalk_cal_distance <= 0 )
JerrySzczurak	20:cf211a3b3d9e	7012	status = VL53L0X_ERROR_INVALID_PARAMS;
JerrySzczurak	20:cf211a3b3d9e	7013
JerrySzczurak	20:cf211a3b3d9e	7014	/* Disable the XTalk compensation */
JerrySzczurak	20:cf211a3b3d9e	7015	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7016	status = vl53l0x_set_x_talk_compensation_enable( dev, 0 );
JerrySzczurak	20:cf211a3b3d9e	7017
JerrySzczurak	20:cf211a3b3d9e	7018	/* Disable the RIT */
JerrySzczurak	20:cf211a3b3d9e	7019	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7020	status = vl53l0x_set_limit_check_enable( dev,
JerrySzczurak	20:cf211a3b3d9e	7021	VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD, 0 );
JerrySzczurak	20:cf211a3b3d9e	7022	}
JerrySzczurak	20:cf211a3b3d9e	7023
JerrySzczurak	20:cf211a3b3d9e	7024	/* Perform 50 measurements and compute the averages */
JerrySzczurak	20:cf211a3b3d9e	7025	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7026	sum_ranging = 0;
JerrySzczurak	20:cf211a3b3d9e	7027	sum_spads = 0;
JerrySzczurak	20:cf211a3b3d9e	7028	sum_signal_rate = 0;
JerrySzczurak	20:cf211a3b3d9e	7029	total_count = 0;
JerrySzczurak	20:cf211a3b3d9e	7030	for ( xtalk_meas = 0; xtalk_meas < 50; xtalk_meas++ ) {
JerrySzczurak	20:cf211a3b3d9e	7031	status = vl53l0x_perform_single_ranging_measurement( dev,
JerrySzczurak	20:cf211a3b3d9e	7032	&ranging_measurement_data );
JerrySzczurak	20:cf211a3b3d9e	7033
JerrySzczurak	20:cf211a3b3d9e	7034	if ( status != VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7035	break;
JerrySzczurak	20:cf211a3b3d9e	7036
JerrySzczurak	20:cf211a3b3d9e	7037	/* The range is valid when RangeStatus = 0 */
JerrySzczurak	20:cf211a3b3d9e	7038	if ( ranging_measurement_data.RangeStatus == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	7039	sum_ranging = sum_ranging +
JerrySzczurak	20:cf211a3b3d9e	7040	ranging_measurement_data.RangeMilliMeter;
JerrySzczurak	20:cf211a3b3d9e	7041	sum_signal_rate = sum_signal_rate +
JerrySzczurak	20:cf211a3b3d9e	7042	ranging_measurement_data.SignalRateRtnMegaCps;
JerrySzczurak	20:cf211a3b3d9e	7043	sum_spads = sum_spads +
JerrySzczurak	20:cf211a3b3d9e	7044	ranging_measurement_data.EffectiveSpadRtnCount
JerrySzczurak	20:cf211a3b3d9e	7045	/ 256;
JerrySzczurak	20:cf211a3b3d9e	7046	total_count = total_count + 1;
JerrySzczurak	20:cf211a3b3d9e	7047	}
JerrySzczurak	20:cf211a3b3d9e	7048	}
JerrySzczurak	20:cf211a3b3d9e	7049
JerrySzczurak	20:cf211a3b3d9e	7050	/* no valid values found */
JerrySzczurak	20:cf211a3b3d9e	7051	if ( total_count == 0 )
JerrySzczurak	20:cf211a3b3d9e	7052	status = VL53L0X_ERROR_RANGE_ERROR;
JerrySzczurak	20:cf211a3b3d9e	7053
JerrySzczurak	20:cf211a3b3d9e	7054	}
JerrySzczurak	20:cf211a3b3d9e	7055
JerrySzczurak	20:cf211a3b3d9e	7056
JerrySzczurak	20:cf211a3b3d9e	7057	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7058	/* FixPoint1616_t / uint16_t = FixPoint1616_t */
JerrySzczurak	20:cf211a3b3d9e	7059	x_talk_stored_mean_signal_rate = sum_signal_rate / total_count;
JerrySzczurak	20:cf211a3b3d9e	7060	x_talk_stored_mean_range = ( FixPoint1616_t )( ( uint32_t )(
JerrySzczurak	20:cf211a3b3d9e	7061	sum_ranging << 16 ) / total_count );
JerrySzczurak	20:cf211a3b3d9e	7062	x_talk_stored_mean_rtn_spads = ( FixPoint1616_t )( ( uint32_t )(
JerrySzczurak	20:cf211a3b3d9e	7063	sum_spads << 16 ) / total_count );
JerrySzczurak	20:cf211a3b3d9e	7064
JerrySzczurak	20:cf211a3b3d9e	7065	/* Round Mean Spads to Whole Number.
JerrySzczurak	20:cf211a3b3d9e	7066	* Typically the calculated mean SPAD count is a whole number
JerrySzczurak	20:cf211a3b3d9e	7067	* or very close to a whole
JerrySzczurak	20:cf211a3b3d9e	7068	* number, therefore any truncation will not result in a
JerrySzczurak	20:cf211a3b3d9e	7069	* significant loss in accuracy.
JerrySzczurak	20:cf211a3b3d9e	7070	* Also, for a grey target at a typical distance of around
JerrySzczurak	20:cf211a3b3d9e	7071	* 400mm, around 220 SPADs will
JerrySzczurak	20:cf211a3b3d9e	7072	* be enabled, therefore, any truncation will result in a loss
JerrySzczurak	20:cf211a3b3d9e	7073	* of accuracy of less than
JerrySzczurak	20:cf211a3b3d9e	7074	* 0.5%.
JerrySzczurak	20:cf211a3b3d9e	7075	*/
JerrySzczurak	20:cf211a3b3d9e	7076	x_talk_stored_mean_rtn_spads_as_int = ( x_talk_stored_mean_rtn_spads +
JerrySzczurak	20:cf211a3b3d9e	7077	0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	7078
JerrySzczurak	20:cf211a3b3d9e	7079	/* Round Cal Distance to Whole Number.
JerrySzczurak	20:cf211a3b3d9e	7080	* Note that the cal distance is in mm, therefore no resolution
JerrySzczurak	20:cf211a3b3d9e	7081	* is lost.*/
JerrySzczurak	20:cf211a3b3d9e	7082	x_talk_cal_distance_as_int = ( xtalk_cal_distance + 0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	7083
JerrySzczurak	20:cf211a3b3d9e	7084	if ( x_talk_stored_mean_rtn_spads_as_int == 0 \|\|
JerrySzczurak	20:cf211a3b3d9e	7085	x_talk_cal_distance_as_int == 0 \|\|
JerrySzczurak	20:cf211a3b3d9e	7086	x_talk_stored_mean_range >= xtalk_cal_distance ) {
JerrySzczurak	20:cf211a3b3d9e	7087	x_talk_compensation_rate_mega_cps = 0;
JerrySzczurak	20:cf211a3b3d9e	7088	} else {
JerrySzczurak	20:cf211a3b3d9e	7089	/* Round Cal Distance to Whole Number.
JerrySzczurak	20:cf211a3b3d9e	7090	Note that the cal distance is in mm, therefore no
JerrySzczurak	20:cf211a3b3d9e	7091	resolution is lost.*/
JerrySzczurak	20:cf211a3b3d9e	7092	x_talk_cal_distance_as_int = ( xtalk_cal_distance +
JerrySzczurak	20:cf211a3b3d9e	7093	0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	7094
JerrySzczurak	20:cf211a3b3d9e	7095	/* Apply division by mean spad count early in the
JerrySzczurak	20:cf211a3b3d9e	7096	* calculation to keep the numbers small.
JerrySzczurak	20:cf211a3b3d9e	7097	* This ensures we can maintain a 32bit calculation.
JerrySzczurak	20:cf211a3b3d9e	7098	* Fixed1616 / int := Fixed1616 */
JerrySzczurak	20:cf211a3b3d9e	7099	signal_x_talk_total_per_spad = ( x_talk_stored_mean_signal_rate ) /
JerrySzczurak	20:cf211a3b3d9e	7100	x_talk_stored_mean_rtn_spads_as_int;
JerrySzczurak	20:cf211a3b3d9e	7101
JerrySzczurak	20:cf211a3b3d9e	7102	/* Complete the calculation for total Signal XTalk per
JerrySzczurak	20:cf211a3b3d9e	7103	* SPAD
JerrySzczurak	20:cf211a3b3d9e	7104	* Fixed1616 * (Fixed1616 - Fixed1616/int) :=
JerrySzczurak	20:cf211a3b3d9e	7105	* (2^16 * Fixed1616)
JerrySzczurak	20:cf211a3b3d9e	7106	*/
JerrySzczurak	20:cf211a3b3d9e	7107	signal_x_talk_total_per_spad *= ( ( 1 << 16 ) -
JerrySzczurak	20:cf211a3b3d9e	7108	( x_talk_stored_mean_range / x_talk_cal_distance_as_int ) );
JerrySzczurak	20:cf211a3b3d9e	7109
JerrySzczurak	20:cf211a3b3d9e	7110	/* Round from 2^16 * Fixed1616, to Fixed1616. */
JerrySzczurak	20:cf211a3b3d9e	7111	x_talk_compensation_rate_mega_cps = ( signal_x_talk_total_per_spad
JerrySzczurak	20:cf211a3b3d9e	7112	+ 0x8000 ) >> 16;
JerrySzczurak	20:cf211a3b3d9e	7113	}
JerrySzczurak	20:cf211a3b3d9e	7114
JerrySzczurak	20:cf211a3b3d9e	7115	*p_xtalk_compensation_rate_mega_cps = x_talk_compensation_rate_mega_cps;
JerrySzczurak	20:cf211a3b3d9e	7116
JerrySzczurak	20:cf211a3b3d9e	7117	/* Enable the XTalk compensation */
JerrySzczurak	20:cf211a3b3d9e	7118	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7119	status = vl53l0x_set_x_talk_compensation_enable( dev, 1 );
JerrySzczurak	20:cf211a3b3d9e	7120
JerrySzczurak	20:cf211a3b3d9e	7121	/* Enable the XTalk compensation */
JerrySzczurak	20:cf211a3b3d9e	7122	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7123	status = vl53l0x_set_x_talk_compensation_rate_mega_cps( dev,
JerrySzczurak	20:cf211a3b3d9e	7124	x_talk_compensation_rate_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	7125
JerrySzczurak	20:cf211a3b3d9e	7126	}
JerrySzczurak	20:cf211a3b3d9e	7127
JerrySzczurak	20:cf211a3b3d9e	7128	return status;
JerrySzczurak	20:cf211a3b3d9e	7129	}
JerrySzczurak	20:cf211a3b3d9e	7130
JerrySzczurak	20:cf211a3b3d9e	7131	VL53L0X_Error VL53L0X::vl53l0x_set_x_talk_compensation_rate_mega_cps( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7132	FixPoint1616_t x_talk_compensation_rate_mega_cps )
JerrySzczurak	20:cf211a3b3d9e	7133	{
JerrySzczurak	20:cf211a3b3d9e	7134	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7135	uint8_t temp8;
JerrySzczurak	20:cf211a3b3d9e	7136	uint16_t linearity_corrective_gain;
JerrySzczurak	20:cf211a3b3d9e	7137	uint16_t data;
JerrySzczurak	20:cf211a3b3d9e	7138	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7139
JerrySzczurak	20:cf211a3b3d9e	7140	VL53L0X_GETPARAMETERFIELD( dev, XTalkCompensationEnable, temp8 );
JerrySzczurak	20:cf211a3b3d9e	7141	linearity_corrective_gain = PALDevDataGet( dev, LinearityCorrectiveGain );
JerrySzczurak	20:cf211a3b3d9e	7142
JerrySzczurak	20:cf211a3b3d9e	7143	if ( temp8 == 0 ) { /* disabled write only internal value */
JerrySzczurak	20:cf211a3b3d9e	7144	VL53L0X_SETPARAMETERFIELD( dev, XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	7145	x_talk_compensation_rate_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	7146	} else {
JerrySzczurak	20:cf211a3b3d9e	7147	/* the following register has a format 3.13 */
JerrySzczurak	20:cf211a3b3d9e	7148	if ( linearity_corrective_gain == 1000 ) {
JerrySzczurak	20:cf211a3b3d9e	7149	data = VL53L0X_FIXPOINT1616TOFIXPOINT313(
JerrySzczurak	20:cf211a3b3d9e	7150	x_talk_compensation_rate_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	7151	} else {
JerrySzczurak	20:cf211a3b3d9e	7152	data = 0;
JerrySzczurak	20:cf211a3b3d9e	7153	}
JerrySzczurak	20:cf211a3b3d9e	7154
JerrySzczurak	21:627b65069e6d	7155	status = vl53l0x_write_word( dev,
JerrySzczurak	20:cf211a3b3d9e	7156	VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS, data );
JerrySzczurak	20:cf211a3b3d9e	7157
JerrySzczurak	20:cf211a3b3d9e	7158	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7159	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	7160	XTalkCompensationRateMegaCps,
JerrySzczurak	20:cf211a3b3d9e	7161	x_talk_compensation_rate_mega_cps );
JerrySzczurak	20:cf211a3b3d9e	7162	}
JerrySzczurak	20:cf211a3b3d9e	7163	}
JerrySzczurak	20:cf211a3b3d9e	7164
JerrySzczurak	20:cf211a3b3d9e	7165	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7166	return status;
JerrySzczurak	20:cf211a3b3d9e	7167	}
JerrySzczurak	20:cf211a3b3d9e	7168
JerrySzczurak	20:cf211a3b3d9e	7169	VL53L0X_Error VL53L0X::vl53l0x_perform_xtalk_measurement( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7170	uint32_t timeout_ms, FixPoint1616_t *p_xtalk_per_spad,
JerrySzczurak	20:cf211a3b3d9e	7171	uint8_t *p_ambient_too_high )
JerrySzczurak	20:cf211a3b3d9e	7172	{
JerrySzczurak	20:cf211a3b3d9e	7173	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	7174	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7175
JerrySzczurak	20:cf211a3b3d9e	7176	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	7177
JerrySzczurak	20:cf211a3b3d9e	7178	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7179	return status;
JerrySzczurak	20:cf211a3b3d9e	7180	}
JerrySzczurak	20:cf211a3b3d9e	7181
JerrySzczurak	20:cf211a3b3d9e	7182	VL53L0X_Error VL53L0X::vl53l0x_reset_device( VL53L0X_DEV dev )
JerrySzczurak	20:cf211a3b3d9e	7183	{
JerrySzczurak	20:cf211a3b3d9e	7184	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7185	uint8_t byte;
JerrySzczurak	20:cf211a3b3d9e	7186	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7187
JerrySzczurak	20:cf211a3b3d9e	7188	/* Set reset bit */
JerrySzczurak	21:627b65069e6d	7189	status = vl53l0x_write_byte( dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
JerrySzczurak	20:cf211a3b3d9e	7190	0x00 );
JerrySzczurak	20:cf211a3b3d9e	7191
JerrySzczurak	20:cf211a3b3d9e	7192	/* Wait for some time */
JerrySzczurak	20:cf211a3b3d9e	7193	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7194	do {
JerrySzczurak	21:627b65069e6d	7195	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	7196	VL53L0X_REG_IDENTIFICATION_MODEL_ID, &byte );
JerrySzczurak	20:cf211a3b3d9e	7197	} while ( byte != 0x00 );
JerrySzczurak	20:cf211a3b3d9e	7198	}
JerrySzczurak	20:cf211a3b3d9e	7199
JerrySzczurak	21:627b65069e6d	7200	vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	7201
JerrySzczurak	20:cf211a3b3d9e	7202	/* Release reset */
JerrySzczurak	21:627b65069e6d	7203	status = vl53l0x_write_byte( dev, VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N,
JerrySzczurak	20:cf211a3b3d9e	7204	0x01 );
JerrySzczurak	20:cf211a3b3d9e	7205
JerrySzczurak	20:cf211a3b3d9e	7206	/* Wait until correct boot-up of the device */
JerrySzczurak	20:cf211a3b3d9e	7207	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7208	do {
JerrySzczurak	21:627b65069e6d	7209	status = vl53l0x_read_byte( dev,
JerrySzczurak	20:cf211a3b3d9e	7210	VL53L0X_REG_IDENTIFICATION_MODEL_ID, &byte );
JerrySzczurak	20:cf211a3b3d9e	7211	} while ( byte == 0x00 );
JerrySzczurak	20:cf211a3b3d9e	7212	}
JerrySzczurak	20:cf211a3b3d9e	7213
JerrySzczurak	21:627b65069e6d	7214	vl53l0x_polling_delay( dev );
JerrySzczurak	20:cf211a3b3d9e	7215
JerrySzczurak	20:cf211a3b3d9e	7216	/* Set PAL State to VL53L0X_STATE_POWERDOWN */
JerrySzczurak	20:cf211a3b3d9e	7217	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7218	PALDevDataSet( dev, PalState, VL53L0X_STATE_POWERDOWN );
JerrySzczurak	20:cf211a3b3d9e	7219
JerrySzczurak	20:cf211a3b3d9e	7220
JerrySzczurak	20:cf211a3b3d9e	7221	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7222	return status;
JerrySzczurak	20:cf211a3b3d9e	7223	}
JerrySzczurak	20:cf211a3b3d9e	7224
JerrySzczurak	20:cf211a3b3d9e	7225	VL53L0X_Error VL53L0X::VL53L0X_reverse_bytes( uint8_t *data, uint32_t size )
JerrySzczurak	20:cf211a3b3d9e	7226	{
JerrySzczurak	20:cf211a3b3d9e	7227	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7228	uint8_t temp_data;
JerrySzczurak	20:cf211a3b3d9e	7229	uint32_t mirror_index;
JerrySzczurak	20:cf211a3b3d9e	7230	uint32_t middle = size / 2;
JerrySzczurak	20:cf211a3b3d9e	7231	uint32_t index;
JerrySzczurak	20:cf211a3b3d9e	7232
JerrySzczurak	20:cf211a3b3d9e	7233	for ( index = 0; index < middle; index++ ) {
JerrySzczurak	20:cf211a3b3d9e	7234	mirror_index = size - index - 1;
JerrySzczurak	20:cf211a3b3d9e	7235	temp_data = data[index];
JerrySzczurak	20:cf211a3b3d9e	7236	data[index] = data[mirror_index];
JerrySzczurak	20:cf211a3b3d9e	7237	data[mirror_index] = temp_data;
JerrySzczurak	20:cf211a3b3d9e	7238	}
JerrySzczurak	20:cf211a3b3d9e	7239	return status;
JerrySzczurak	20:cf211a3b3d9e	7240	}
JerrySzczurak	20:cf211a3b3d9e	7241
JerrySzczurak	20:cf211a3b3d9e	7242	VL53L0X_Error VL53L0X::vl53l0x_set_ref_calibration( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7243	uint8_t vhv_settings, uint8_t phase_cal )
JerrySzczurak	20:cf211a3b3d9e	7244	{
JerrySzczurak	20:cf211a3b3d9e	7245	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7246	uint8_t p_vhv_settings;
JerrySzczurak	20:cf211a3b3d9e	7247	uint8_t p_phase_cal;
JerrySzczurak	20:cf211a3b3d9e	7248
JerrySzczurak	20:cf211a3b3d9e	7249	status = vl53l0x_ref_calibration_io( dev, 0,
JerrySzczurak	20:cf211a3b3d9e	7250	vhv_settings, phase_cal,
JerrySzczurak	20:cf211a3b3d9e	7251	&p_vhv_settings, &p_phase_cal,
JerrySzczurak	20:cf211a3b3d9e	7252	1, 1 );
JerrySzczurak	20:cf211a3b3d9e	7253
JerrySzczurak	20:cf211a3b3d9e	7254	return status;
JerrySzczurak	20:cf211a3b3d9e	7255	}
JerrySzczurak	20:cf211a3b3d9e	7256
JerrySzczurak	20:cf211a3b3d9e	7257	VL53L0X_Error VL53L0X::VL53L0X_SetDeviceParameters( VL53L0X_DEV Dev,
JerrySzczurak	20:cf211a3b3d9e	7258	const VL53L0X_DeviceParameters_t *pDeviceParameters )
JerrySzczurak	20:cf211a3b3d9e	7259	{
JerrySzczurak	20:cf211a3b3d9e	7260	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7261	int i;
JerrySzczurak	20:cf211a3b3d9e	7262	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7263	Status = vl53l0x_set_device_mode( Dev, pDeviceParameters->DeviceMode );
JerrySzczurak	20:cf211a3b3d9e	7264
JerrySzczurak	20:cf211a3b3d9e	7265	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7266	Status = vl53l0x_set_inter_measurement_period_milli_seconds( Dev,
JerrySzczurak	20:cf211a3b3d9e	7267	pDeviceParameters->InterMeasurementPeriodMilliSeconds );
JerrySzczurak	20:cf211a3b3d9e	7268
JerrySzczurak	20:cf211a3b3d9e	7269
JerrySzczurak	20:cf211a3b3d9e	7270	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7271	Status = vl53l0x_set_x_talk_compensation_rate_mega_cps( Dev,
JerrySzczurak	20:cf211a3b3d9e	7272	pDeviceParameters->XTalkCompensationRateMegaCps );
JerrySzczurak	20:cf211a3b3d9e	7273
JerrySzczurak	20:cf211a3b3d9e	7274
JerrySzczurak	20:cf211a3b3d9e	7275	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7276	Status = vl53l0x_set_offset_calibration_data_micro_meter( Dev,
JerrySzczurak	20:cf211a3b3d9e	7277	pDeviceParameters->RangeOffsetMicroMeters );
JerrySzczurak	20:cf211a3b3d9e	7278
JerrySzczurak	20:cf211a3b3d9e	7279
JerrySzczurak	20:cf211a3b3d9e	7280	for ( i = 0; i < VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS; i++ ) {
JerrySzczurak	20:cf211a3b3d9e	7281	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7282	Status \|= vl53l0x_set_limit_check_enable( Dev, i,
JerrySzczurak	20:cf211a3b3d9e	7283	pDeviceParameters->LimitChecksEnable[i] );
JerrySzczurak	20:cf211a3b3d9e	7284	else
JerrySzczurak	20:cf211a3b3d9e	7285	break;
JerrySzczurak	20:cf211a3b3d9e	7286
JerrySzczurak	20:cf211a3b3d9e	7287	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7288	Status \|= vl53l0x_set_limit_check_value( Dev, i,
JerrySzczurak	20:cf211a3b3d9e	7289	pDeviceParameters->LimitChecksValue[i] );
JerrySzczurak	20:cf211a3b3d9e	7290	else
JerrySzczurak	20:cf211a3b3d9e	7291	break;
JerrySzczurak	20:cf211a3b3d9e	7292
JerrySzczurak	20:cf211a3b3d9e	7293	}
JerrySzczurak	20:cf211a3b3d9e	7294
JerrySzczurak	20:cf211a3b3d9e	7295	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7296	Status = vl53l0x_set_wrap_around_check_enable( Dev,
JerrySzczurak	20:cf211a3b3d9e	7297	pDeviceParameters->WrapAroundCheckEnable );
JerrySzczurak	20:cf211a3b3d9e	7298
JerrySzczurak	20:cf211a3b3d9e	7299	if ( Status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7300	Status = vl53l0x_set_measurement_timing_budget_micro_seconds( Dev,
JerrySzczurak	20:cf211a3b3d9e	7301	pDeviceParameters->MeasurementTimingBudgetMicroSeconds );
JerrySzczurak	20:cf211a3b3d9e	7302
JerrySzczurak	20:cf211a3b3d9e	7303
JerrySzczurak	20:cf211a3b3d9e	7304	LOG_FUNCTION_END( Status );
JerrySzczurak	20:cf211a3b3d9e	7305	return Status;
JerrySzczurak	20:cf211a3b3d9e	7306	}
JerrySzczurak	20:cf211a3b3d9e	7307
JerrySzczurak	20:cf211a3b3d9e	7308	VL53L0X_Error VL53L0X::vl53l0x_set_inter_measurement_period_milli_seconds( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7309	uint32_t inter_measurement_period_milli_seconds )
JerrySzczurak	20:cf211a3b3d9e	7310	{
JerrySzczurak	20:cf211a3b3d9e	7311	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7312	uint16_t osc_calibrate_val;
JerrySzczurak	20:cf211a3b3d9e	7313	uint32_t im_period_milli_seconds;
JerrySzczurak	20:cf211a3b3d9e	7314
JerrySzczurak	20:cf211a3b3d9e	7315	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7316
JerrySzczurak	21:627b65069e6d	7317	status = vl53l0x_read_word( dev, VL53L0X_REG_OSC_CALIBRATE_VAL,
JerrySzczurak	20:cf211a3b3d9e	7318	&osc_calibrate_val );
JerrySzczurak	20:cf211a3b3d9e	7319
JerrySzczurak	20:cf211a3b3d9e	7320	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7321	if ( osc_calibrate_val != 0 ) {
JerrySzczurak	20:cf211a3b3d9e	7322	im_period_milli_seconds =
JerrySzczurak	20:cf211a3b3d9e	7323	inter_measurement_period_milli_seconds
JerrySzczurak	20:cf211a3b3d9e	7324	* osc_calibrate_val;
JerrySzczurak	20:cf211a3b3d9e	7325	} else {
JerrySzczurak	20:cf211a3b3d9e	7326	im_period_milli_seconds =
JerrySzczurak	20:cf211a3b3d9e	7327	inter_measurement_period_milli_seconds;
JerrySzczurak	20:cf211a3b3d9e	7328	}
JerrySzczurak	21:627b65069e6d	7329	status = vl53l0x_write_dword( dev,
JerrySzczurak	20:cf211a3b3d9e	7330	VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD,
JerrySzczurak	20:cf211a3b3d9e	7331	im_period_milli_seconds );
JerrySzczurak	20:cf211a3b3d9e	7332	}
JerrySzczurak	20:cf211a3b3d9e	7333
JerrySzczurak	20:cf211a3b3d9e	7334	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7335	VL53L0X_SETPARAMETERFIELD( dev,
JerrySzczurak	20:cf211a3b3d9e	7336	InterMeasurementPeriodMilliSeconds,
JerrySzczurak	20:cf211a3b3d9e	7337	inter_measurement_period_milli_seconds );
JerrySzczurak	20:cf211a3b3d9e	7338	}
JerrySzczurak	20:cf211a3b3d9e	7339
JerrySzczurak	20:cf211a3b3d9e	7340	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7341	return status;
JerrySzczurak	20:cf211a3b3d9e	7342	}
JerrySzczurak	20:cf211a3b3d9e	7343
JerrySzczurak	20:cf211a3b3d9e	7344	VL53L0X_Error VL53L0X::vl53l0x_set_wrap_around_check_enable( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7345	uint8_t wrap_around_check_enable )
JerrySzczurak	20:cf211a3b3d9e	7346	{
JerrySzczurak	20:cf211a3b3d9e	7347	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7348	uint8_t data;
JerrySzczurak	20:cf211a3b3d9e	7349	uint8_t wrap_around_check_enable_int;
JerrySzczurak	20:cf211a3b3d9e	7350
JerrySzczurak	20:cf211a3b3d9e	7351	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7352
JerrySzczurak	21:627b65069e6d	7353	status = vl53l0x_read_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, &data );
JerrySzczurak	20:cf211a3b3d9e	7354	if ( wrap_around_check_enable == 0 ) {
JerrySzczurak	20:cf211a3b3d9e	7355	/* Disable wraparound */
JerrySzczurak	20:cf211a3b3d9e	7356	data = data & 0x7F;
JerrySzczurak	20:cf211a3b3d9e	7357	wrap_around_check_enable_int = 0;
JerrySzczurak	20:cf211a3b3d9e	7358	} else {
JerrySzczurak	20:cf211a3b3d9e	7359	/Enable wraparound /
JerrySzczurak	20:cf211a3b3d9e	7360	data = data \| 0x80;
JerrySzczurak	20:cf211a3b3d9e	7361	wrap_around_check_enable_int = 1;
JerrySzczurak	20:cf211a3b3d9e	7362	}
JerrySzczurak	20:cf211a3b3d9e	7363
JerrySzczurak	21:627b65069e6d	7364	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG, data );
JerrySzczurak	20:cf211a3b3d9e	7365
JerrySzczurak	20:cf211a3b3d9e	7366	if ( status == VL53L0X_ERROR_NONE ) {
JerrySzczurak	20:cf211a3b3d9e	7367	PALDevDataSet( dev, SequenceConfig, data );
JerrySzczurak	20:cf211a3b3d9e	7368	VL53L0X_SETPARAMETERFIELD( dev, WrapAroundCheckEnable,
JerrySzczurak	20:cf211a3b3d9e	7369	wrap_around_check_enable_int );
JerrySzczurak	20:cf211a3b3d9e	7370	}
JerrySzczurak	20:cf211a3b3d9e	7371
JerrySzczurak	20:cf211a3b3d9e	7372	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7373	return status;
JerrySzczurak	20:cf211a3b3d9e	7374	}
JerrySzczurak	20:cf211a3b3d9e	7375
JerrySzczurak	20:cf211a3b3d9e	7376	VL53L0X_Error VL53L0X::vl53l0x_set_group_param_hold( VL53L0X_DEV dev, uint8_t group_param_hold )
JerrySzczurak	20:cf211a3b3d9e	7377	{
JerrySzczurak	20:cf211a3b3d9e	7378	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	7379	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7380
JerrySzczurak	20:cf211a3b3d9e	7381	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	7382
JerrySzczurak	20:cf211a3b3d9e	7383	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7384	return status;
JerrySzczurak	20:cf211a3b3d9e	7385	}
JerrySzczurak	20:cf211a3b3d9e	7386
JerrySzczurak	20:cf211a3b3d9e	7387	VL53L0X_Error VL53L0X::vl53l0x_set_range_fraction_enable( VL53L0X_DEV dev, uint8_t enable )
JerrySzczurak	20:cf211a3b3d9e	7388	{
JerrySzczurak	20:cf211a3b3d9e	7389	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7390
JerrySzczurak	20:cf211a3b3d9e	7391	LOG_FUNCTION_START( "%d", ( int )Enable );
JerrySzczurak	20:cf211a3b3d9e	7392
JerrySzczurak	21:627b65069e6d	7393	status = vl53l0x_write_byte( dev, VL53L0X_REG_SYSTEM_RANGE_CONFIG, enable );
JerrySzczurak	20:cf211a3b3d9e	7394
JerrySzczurak	20:cf211a3b3d9e	7395	if ( status == VL53L0X_ERROR_NONE )
JerrySzczurak	20:cf211a3b3d9e	7396	PALDevDataSet( dev, RangeFractionalEnable, enable );
JerrySzczurak	20:cf211a3b3d9e	7397
JerrySzczurak	20:cf211a3b3d9e	7398	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7399	return status;
JerrySzczurak	20:cf211a3b3d9e	7400	}
JerrySzczurak	20:cf211a3b3d9e	7401
JerrySzczurak	20:cf211a3b3d9e	7402	VL53L0X_Error VL53L0X::vl53l0x_set_reference_spads( VL53L0X_DEV dev, uint32_t count,
JerrySzczurak	20:cf211a3b3d9e	7403	uint8_t is_aperture_spads )
JerrySzczurak	20:cf211a3b3d9e	7404	{
JerrySzczurak	20:cf211a3b3d9e	7405	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7406	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7407
JerrySzczurak	20:cf211a3b3d9e	7408	status = wrapped_vl53l0x_set_reference_spads( dev, count, is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	7409
JerrySzczurak	20:cf211a3b3d9e	7410	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7411
JerrySzczurak	20:cf211a3b3d9e	7412	return status;
JerrySzczurak	20:cf211a3b3d9e	7413	}
JerrySzczurak	20:cf211a3b3d9e	7414
JerrySzczurak	20:cf211a3b3d9e	7415	VL53L0X_Error VL53L0X::vl53l0x_get_reference_spads( VL53L0X_DEV dev, uint32_t *p_spad_count,
JerrySzczurak	20:cf211a3b3d9e	7416	uint8_t *p_is_aperture_spads )
JerrySzczurak	20:cf211a3b3d9e	7417	{
JerrySzczurak	20:cf211a3b3d9e	7418	VL53L0X_Error status = VL53L0X_ERROR_NONE;
JerrySzczurak	20:cf211a3b3d9e	7419	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7420
JerrySzczurak	20:cf211a3b3d9e	7421	status = wrapped_vl53l0x_get_reference_spads( dev, p_spad_count, p_is_aperture_spads );
JerrySzczurak	20:cf211a3b3d9e	7422
JerrySzczurak	20:cf211a3b3d9e	7423	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7424
JerrySzczurak	20:cf211a3b3d9e	7425	return status;
JerrySzczurak	20:cf211a3b3d9e	7426	}
JerrySzczurak	20:cf211a3b3d9e	7427
JerrySzczurak	20:cf211a3b3d9e	7428	VL53L0X_Error VL53L0X::wrapped_vl53l0x_wait_device_booted( VL53L0X_DEV dev )
JerrySzczurak	20:cf211a3b3d9e	7429	{
JerrySzczurak	20:cf211a3b3d9e	7430	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	7431	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7432
JerrySzczurak	20:cf211a3b3d9e	7433	/* not implemented on VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	7434
JerrySzczurak	20:cf211a3b3d9e	7435	LOG_FUNCTION_END( status );
JerrySzczurak	20:cf211a3b3d9e	7436	return status;
JerrySzczurak	20:cf211a3b3d9e	7437	}
JerrySzczurak	20:cf211a3b3d9e	7438
JerrySzczurak	20:cf211a3b3d9e	7439	VL53L0X_Error VL53L0X::vl53l0x_wait_device_ready_for_new_measurement( VL53L0X_DEV dev,
JerrySzczurak	20:cf211a3b3d9e	7440	uint32_t max_loop )
JerrySzczurak	20:cf211a3b3d9e	7441	{
JerrySzczurak	20:cf211a3b3d9e	7442	VL53L0X_Error status = VL53L0X_ERROR_NOT_IMPLEMENTED;
JerrySzczurak	20:cf211a3b3d9e	7443	LOG_FUNCTION_START( "" );
JerrySzczurak	20:cf211a3b3d9e	7444
JerrySzczurak	20:cf211a3b3d9e	7445	/* not implemented for VL53L0X */
JerrySzczurak	20:cf211a3b3d9e	7446
JerrySzczurak	20:cf211a3b3d9e	7447	LOG_FUNCTION_END( satus );
JerrySzczurak	20:cf211a3b3d9e	7448	return status;
JerrySzczurak	20:cf211a3b3d9e	7449	}
johnAlexander	0:c523920bcc09	7450	/******************************************************************************/
johnAlexander	0:c523920bcc09	7451

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	26 Jun 2017
Imports:	10
Forks:	0
Commits:	22
Dependents:	2
Dependencies:	2
Followers:	64

Components/VL53L0X/vl53l0x_class.cpp@21:627b65069e6d, 2017-06-28 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning