Diff: modules/vl53lx_xtalk.c

Revision:

5:89031b2f5316

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/modules/vl53lx_xtalk.c	Wed Jul 14 12:45:49 2021 +0100
@@ -0,0 +1,1050 @@
+
+// SPDX-License-Identifier: BSD-3-Clause
+/******************************************************************************
+ * Copyright (c) 2020, STMicroelectronics - All Rights Reserved
+
+ This file is part of VL53LX Protected and is dual licensed,
+ either 'STMicroelectronics Proprietary license'
+ or 'BSD 3-clause "New" or "Revised" License' , at your option.
+
+ ******************************************************************************
+
+ 'STMicroelectronics Proprietary license'
+
+ ******************************************************************************
+
+ License terms: STMicroelectronics Proprietary in accordance with licensing
+ terms at www.st.com/sla0081
+
+ ******************************************************************************
+ */
+
+
+
+
+#include <vl53lx_platform_log.h>
+#include <vl53lx_types.h>
+#include "vl53lx_core_support.h"
+#include "vl53lx_error_codes.h"
+
+#include "vl53lx_xtalk.h"
+#include "vl53lx_hist_core.h"
+
+
+
+
+#define LOG_FUNCTION_START(fmt, ...) \
+	_LOG_FUNCTION_START(VL53LX_TRACE_MODULE_HISTOGRAM, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...) \
+	_LOG_FUNCTION_END(VL53LX_TRACE_MODULE_HISTOGRAM, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...) \
+	_LOG_FUNCTION_END_FMT(VL53LX_TRACE_MODULE_HISTOGRAM, \
+	status, fmt, ##__VA_ARGS__)
+
+#define trace_print(level, ...) \
+	_LOG_TRACE_PRINT(VL53LX_TRACE_MODULE_HISTOGRAM, \
+	level, VL53LX_TRACE_FUNCTION_NONE, ##__VA_ARGS__)
+
+
+VL53LX_Error VL53LX_xtalk_calibration_process_data(
+	VL53LX_xtalk_range_results_t		*pxtalk_results,
+	VL53LX_xtalk_histogram_data_t		*pxtalk_shape,
+	VL53LX_xtalk_calibration_results_t	*pxtalk_cal)
+{
+
+
+	VL53LX_Error status = VL53LX_ERROR_NONE;
+
+	VL53LX_xtalk_algo_data_t xtalk_debug;
+	VL53LX_xtalk_algo_data_t *pdebug      = &xtalk_debug;
+	VL53LX_xtalk_range_data_t *pxtalk_data = NULL;
+
+	VL53LX_histogram_bin_data_t avg_bins;
+	VL53LX_histogram_bin_data_t *pavg_bins   = &avg_bins;
+
+	LOG_FUNCTION_START("");
+
+
+
+	memcpy(pavg_bins, &(pxtalk_results->central_histogram_avg),
+		sizeof(VL53LX_histogram_bin_data_t));
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		VL53LX_init_histogram_bin_data_struct(
+			0, 0, &(pdebug->VL53LX_p_056));
+
+	if (status == VL53LX_ERROR_NONE)
+		VL53LX_init_histogram_bin_data_struct(
+			0, 0, &(pdebug->VL53LX_p_057));
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		status = VL53LX_f_039(
+		pxtalk_results,
+		pdebug,
+		&(pxtalk_cal->algo__crosstalk_compensation_x_plane_gradient_kcps
+				),
+		&(pxtalk_cal->algo__crosstalk_compensation_y_plane_gradient_kcps
+				));
+
+
+
+
+
+	if (status != VL53LX_ERROR_NONE)
+		goto ENDFUNC;
+
+	pxtalk_data = &(pxtalk_results->VL53LX_p_003[4]);
+
+	if (pxtalk_data->no_of_samples >  0) {
+
+
+
+		if (status == VL53LX_ERROR_NONE) {
+			memcpy(&(pdebug->VL53LX_p_056),
+			pavg_bins,
+			sizeof(VL53LX_histogram_bin_data_t));
+		}
+
+
+
+		status = VL53LX_f_040(
+		pxtalk_data,
+		pdebug,
+		&(pxtalk_cal->algo__crosstalk_compensation_plane_offset_kcps));
+
+
+
+		if (status == VL53LX_ERROR_NONE)
+			status = VL53LX_f_041(
+			pavg_bins,
+			pdebug,
+			pxtalk_data,
+			pxtalk_results->central_histogram__window_start,
+			pxtalk_results->central_histogram__window_end,
+			&(pxtalk_shape->xtalk_shape));
+
+	} else {
+
+
+
+		pxtalk_cal->algo__crosstalk_compensation_plane_offset_kcps = 0;
+
+
+
+		pdebug->VL53LX_p_058 = 0;
+
+
+	}
+
+
+ENDFUNC:
+
+
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_041(
+		VL53LX_histogram_bin_data_t        *pavg_bins,
+		VL53LX_xtalk_algo_data_t           *pdebug,
+		VL53LX_xtalk_range_data_t          *pxtalk_data,
+		uint8_t                             histogram__window_start,
+		uint8_t                             histogram__window_end,
+		VL53LX_xtalk_histogram_shape_t     *pxtalk_shape)
+{
+
+	VL53LX_Error status        = VL53LX_ERROR_NONE;
+
+
+
+	uint32_t ambient_thresh         = 0;
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		VL53LX_f_029(
+			pavg_bins,
+			pavg_bins->VL53LX_p_028);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		VL53LX_f_043(
+				6,
+				pavg_bins->VL53LX_p_028,
+				&ambient_thresh);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		status = VL53LX_f_044(
+				pavg_bins,
+				ambient_thresh,
+				histogram__window_start,
+				histogram__window_end);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		status =  VL53LX_f_045(
+			pavg_bins,
+			pxtalk_data,
+			pdebug,
+			pxtalk_shape);
+
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+
+}
+
+
+VL53LX_Error VL53LX_f_039(
+	VL53LX_xtalk_range_results_t   *pxtalk_results,
+	VL53LX_xtalk_algo_data_t       *pdebug,
+	int16_t                        *xgradient,
+	int16_t                        *ygradient
+	)
+{
+
+
+
+	VL53LX_Error status        = VL53LX_ERROR_NONE;
+
+	VL53LX_xtalk_range_data_t  *presults_int = NULL;
+
+	int          i                   = 0;
+
+	uint32_t xtalk_per_spad[4];
+	int32_t  VL53LX_p_059         = 0;
+	int32_t  VL53LX_p_060         = 0;
+
+	uint8_t  result_invalid          = 0;
+
+
+	LOG_FUNCTION_START("");
+
+
+
+	*xgradient = 0;
+	*ygradient = 0;
+
+
+
+
+	for (i = 0; i < 4; i++)
+		xtalk_per_spad[i] = 0;
+
+
+
+	for (i = 0; i < 4; i++) {
+
+		if (status == VL53LX_ERROR_NONE) {
+
+			presults_int = &(pxtalk_results->VL53LX_p_003[i]);
+
+
+
+
+			if (presults_int->no_of_samples == 0) {
+
+
+				result_invalid = 1;
+				pdebug->VL53LX_p_061[i] = 0;
+
+
+			} else {
+
+				xtalk_per_spad[i] =
+					presults_int->rate_per_spad_kcps_avg;
+
+
+
+				pdebug->VL53LX_p_061[i] =
+					(uint32_t)xtalk_per_spad[i];
+
+			}
+		}
+
+	}
+
+
+
+	if ((status == VL53LX_ERROR_NONE) && (result_invalid == 0)) {
+
+
+
+		if (status == VL53LX_ERROR_NONE) {
+			VL53LX_p_059 = ((int32_t)xtalk_per_spad[1]
+				- (int32_t)xtalk_per_spad[0]) / (8);
+			VL53LX_p_060 = ((int32_t)xtalk_per_spad[3]
+				- (int32_t)xtalk_per_spad[2]) / (8);
+		}
+
+
+
+
+		if (status == VL53LX_ERROR_NONE) {
+			if (VL53LX_p_059 < -32767) {
+				VL53LX_p_059 = -32767;
+			} else {
+				if (VL53LX_p_059 > 32767)
+					VL53LX_p_059 = 32767;
+			}
+
+			if (VL53LX_p_060 < -32767) {
+				VL53LX_p_060 = -32767;
+			} else {
+				if (VL53LX_p_060 > 32767)
+					VL53LX_p_060 = 32767;
+			}
+
+
+
+			pdebug->VL53LX_p_059 = (int16_t)VL53LX_p_059;
+			pdebug->VL53LX_p_060 = (int16_t)VL53LX_p_060;
+		}
+
+	} else {
+
+
+
+		VL53LX_p_059 = 0;
+		VL53LX_p_060 = 0;
+
+		pdebug->VL53LX_p_059 = 0;
+		pdebug->VL53LX_p_060 = 0;
+	}
+
+
+
+	if (status == VL53LX_ERROR_NONE) {
+		*xgradient = (int16_t)VL53LX_p_059;
+		*ygradient = (int16_t)VL53LX_p_060;
+	}
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_040(
+	VL53LX_xtalk_range_data_t *pxtalk_data,
+	VL53LX_xtalk_algo_data_t  *pdebug,
+	uint32_t                 *xtalk_mean_offset_kcps
+	)
+{
+
+
+	VL53LX_Error status        = VL53LX_ERROR_NONE;
+
+	uint32_t xtalk_per_spad          = 0;
+	uint8_t  result_invalid          = 0;
+
+	LOG_FUNCTION_START("");
+
+	*xtalk_mean_offset_kcps          = 0;
+
+
+	if (pxtalk_data->no_of_samples == 0) {
+
+
+
+		result_invalid = 1;
+
+
+
+		pdebug->VL53LX_p_058 = 0;
+
+	}
+
+
+
+
+	if ((status == VL53LX_ERROR_NONE) && (result_invalid == 0)) {
+
+
+
+		xtalk_per_spad = pxtalk_data->rate_per_spad_kcps_avg >> 2;
+
+
+
+		pdebug->VL53LX_p_058 = xtalk_per_spad;
+
+
+		if (xtalk_per_spad < 0x3FFFF)
+			*xtalk_mean_offset_kcps     = (uint32_t)xtalk_per_spad;
+		else
+			*xtalk_mean_offset_kcps     = 0x3FFFF;
+
+	} else {
+
+
+
+		*xtalk_mean_offset_kcps     = 0;
+	}
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+
+}
+
+
+
+
+VL53LX_Error VL53LX_f_045(
+	VL53LX_histogram_bin_data_t	*phist_data,
+	VL53LX_xtalk_range_data_t      *pxtalk_data,
+	VL53LX_xtalk_algo_data_t       *pdebug,
+	VL53LX_xtalk_histogram_shape_t *pxtalk_histo
+	)
+{
+
+
+	VL53LX_Error status            = VL53LX_ERROR_NONE;
+
+	uint8_t idx;
+	int32_t tmpi32;
+	uint8_t i = 0;
+	uint64_t bin_data[VL53LX_XTALK_HISTO_BINS];
+
+	LOG_FUNCTION_START("");
+
+
+
+
+
+
+	pxtalk_histo->VL53LX_p_020             =
+			phist_data->VL53LX_p_020;
+	pxtalk_histo->cal_config__vcsel_start =
+			phist_data->cal_config__vcsel_start;
+	pxtalk_histo->VL53LX_p_015     =
+			phist_data->VL53LX_p_015;
+	pxtalk_histo->VL53LX_p_019               =
+			phist_data->VL53LX_p_019;
+	pxtalk_histo->time_stamp              =
+			phist_data->time_stamp;
+	pxtalk_histo->vcsel_width             =
+			phist_data->vcsel_width;
+	pxtalk_histo->zero_distance_phase     =
+			phist_data->zero_distance_phase;
+	pxtalk_histo->zone_id                 =
+			phist_data->zone_id;
+	pxtalk_histo->VL53LX_p_021          =
+			VL53LX_XTALK_HISTO_BINS;
+	pxtalk_histo->phasecal_result__reference_phase =
+			phist_data->phasecal_result__reference_phase;
+	pxtalk_histo->phasecal_result__vcsel_start     =
+			phist_data->phasecal_result__vcsel_start;
+
+
+	memcpy(&(pdebug->VL53LX_p_057),
+		phist_data, sizeof(VL53LX_histogram_bin_data_t));
+
+
+
+
+
+	if (pxtalk_data->signal_total_events_avg == 0) {
+		for (i = 0; i < pxtalk_histo->VL53LX_p_021; i++)
+			bin_data[i] = 0;
+		goto FAIL;
+	}
+
+	for (i = 0; i < pxtalk_histo->VL53LX_p_021; i++) {
+		idx = i + phist_data->number_of_ambient_bins;
+		if (phist_data->bin_data[idx] > 0) {
+			bin_data[i] =
+			((uint64_t)phist_data->bin_data[idx] << 10);
+			tmpi32 = pxtalk_data->signal_total_events_avg / 2;
+			bin_data[i] = bin_data[i] + (uint64_t)tmpi32;
+			bin_data[i] = do_division_u(bin_data[i],
+			(uint64_t)pxtalk_data->signal_total_events_avg);
+		} else {
+			bin_data[i] = 0;
+		}
+	}
+
+FAIL:
+
+
+	for (i = 0; i < VL53LX_XTALK_HISTO_BINS; i++)
+		pxtalk_histo->bin_data[i] = (uint32_t)bin_data[i];
+
+
+
+	for (i = 0; i < pxtalk_histo->VL53LX_p_021; i++)
+		pdebug->VL53LX_p_062[i] = pxtalk_histo->bin_data[i];
+
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+
+}
+
+
+VL53LX_Error VL53LX_f_046(
+	VL53LX_customer_nvm_managed_t *pcustomer,
+	VL53LX_dynamic_config_t       *pdyn_cfg,
+	VL53LX_xtalk_histogram_data_t *pxtalk_shape,
+	VL53LX_histogram_bin_data_t   *pip_hist_data,
+	VL53LX_histogram_bin_data_t   *pop_hist_data,
+	VL53LX_histogram_bin_data_t   *pxtalk_count_data)
+{
+
+
+
+	VL53LX_Error status = VL53LX_ERROR_NONE;
+
+
+
+	uint32_t xtalk_rate_kcps = 0;
+
+	LOG_FUNCTION_START("");
+
+
+
+	memcpy(pop_hist_data, pip_hist_data,
+			sizeof(VL53LX_histogram_bin_data_t));
+
+
+
+	status =
+		VL53LX_f_032(
+		pcustomer->algo__crosstalk_compensation_plane_offset_kcps,
+		pcustomer->algo__crosstalk_compensation_x_plane_gradient_kcps,
+		pcustomer->algo__crosstalk_compensation_y_plane_gradient_kcps,
+		0,
+		0,
+		pip_hist_data->result__dss_actual_effective_spads,
+
+		pdyn_cfg->roi_config__user_roi_centre_spad,
+		pdyn_cfg->roi_config__user_roi_requested_global_xy_size,
+		&(xtalk_rate_kcps));
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		status =
+			VL53LX_f_033(
+				pip_hist_data,
+				&(pxtalk_shape->xtalk_shape),
+				xtalk_rate_kcps,
+				pxtalk_count_data);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		status =
+			VL53LX_f_047(
+				pop_hist_data,
+				pxtalk_count_data,
+				pip_hist_data->number_of_ambient_bins);
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_032(
+	uint32_t                       mean_offset,
+	int16_t                        xgradient,
+	int16_t                        ygradient,
+	int8_t                         centre_offset_x,
+	int8_t                         centre_offset_y,
+	uint16_t                       roi_effective_spads,
+	uint8_t                        roi_centre_spad,
+	uint8_t                        roi_xy_size,
+	uint32_t                      *xtalk_rate_kcps
+	)
+{
+
+
+
+	VL53LX_Error status = VL53LX_ERROR_NONE;
+
+	uint8_t row = 0;
+	uint8_t col = 0;
+
+
+
+	int16_t  bound_l_x = 0;
+	int16_t  bound_r_x = 0;
+	int16_t  bound_u_y = 0;
+	int16_t  bound_d_y = 0;
+
+	int64_t xtalk_rate_ll = 0;
+	int64_t xtalk_rate_ur = 0;
+
+	int64_t xtalk_avg = 0;
+
+	LOG_FUNCTION_START("");
+
+	SUPPRESS_UNUSED_WARNING(roi_effective_spads);
+
+
+
+
+
+
+	if (status == VL53LX_ERROR_NONE) {
+		VL53LX_decode_row_col(
+				roi_centre_spad,
+				&row,
+				&col);
+	}
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Row", row);
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Col", col);
+
+
+
+	if (status == VL53LX_ERROR_NONE) {
+		if ((((int16_t)roi_xy_size / 16) & 0x01) == 1)
+			bound_l_x = (int16_t) col -
+			(((int16_t)roi_xy_size / 32) + 1);
+		else
+			bound_l_x = (int16_t) col -
+			((int16_t)roi_xy_size / 32);
+
+		bound_r_x = (int16_t) col + ((int16_t)roi_xy_size / 32);
+
+		if ((((int16_t)roi_xy_size) & 0x01) == 1)
+			bound_d_y = (int16_t) row -
+			((((int16_t)roi_xy_size & 0x0f) / 2) + 1);
+		else
+			bound_d_y = (int16_t) row -
+			(((int16_t)roi_xy_size & 0x0f) / 2);
+
+		bound_u_y = (int16_t) row +
+				(((int16_t)roi_xy_size & 0xf) / 2);
+	}
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Bound_l_x", bound_l_x);
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Bound_r_x", bound_r_x);
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Bound_u_y", bound_u_y);
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"Bound_d_y", bound_d_y);
+
+
+
+
+	if (status == VL53LX_ERROR_NONE) {
+		bound_l_x =  (2 * bound_l_x) - 15 +
+				(2 * (int16_t)centre_offset_x);
+		bound_r_x =  (2 * bound_r_x) - 15 +
+				(2 * (int16_t)centre_offset_x);
+		bound_u_y =  (2 * bound_u_y) - 15 +
+				(2 * (int16_t)centre_offset_y);
+		bound_d_y =  (2 * bound_d_y) - 15 +
+				(2 * (int16_t)centre_offset_y);
+	}
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"Bound_l_x", bound_l_x);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"Bound_r_x", bound_r_x);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"Bound_u_y", bound_u_y);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"Bound_d_y", bound_d_y);
+
+
+
+
+	if (status == VL53LX_ERROR_NONE) {
+		xtalk_rate_ll  = ((int64_t)bound_l_x *
+			((int64_t)xgradient)) + ((int64_t)bound_d_y *
+					((int64_t)ygradient));
+		xtalk_rate_ll  = do_division_s((xtalk_rate_ll + 1), 2);
+		xtalk_rate_ll += ((int64_t)mean_offset * 4);
+
+		xtalk_rate_ur  = ((int64_t)bound_r_x *
+			((int64_t)xgradient)) + ((int64_t)bound_u_y *
+			((int64_t)ygradient));
+		xtalk_rate_ur  = do_division_s((xtalk_rate_ur + 1), 2);
+		xtalk_rate_ur += ((int64_t)mean_offset * 4);
+	}
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"xtalk_rate_ll", xtalk_rate_ll);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"xtalk_rate_ur", xtalk_rate_ur);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		xtalk_avg = do_division_s(
+			((xtalk_rate_ll + xtalk_rate_ur) + 1), 2);
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"xtalk_avg", xtalk_avg);
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		if (xtalk_avg < 0)
+			xtalk_avg = 0;
+
+
+
+
+
+	*xtalk_rate_kcps = (uint32_t) xtalk_avg;
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"xtalk_rate_kcps", xtalk_avg);
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+
+VL53LX_Error VL53LX_f_033(
+	VL53LX_histogram_bin_data_t    *phist_data,
+	VL53LX_xtalk_histogram_shape_t *pxtalk_data,
+	uint32_t                        xtalk_rate_kcps,
+	VL53LX_histogram_bin_data_t    *pxtalkcount_data
+	)
+{
+
+
+	VL53LX_Error status              = VL53LX_ERROR_NONE;
+
+	uint64_t xtalk_events_per_spad = 0;
+	uint64_t xtalk_total_events = 0;
+	uint64_t xtalk_temp_bin = 0;
+
+	uint8_t  i = 0;
+
+	LOG_FUNCTION_START("");
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"pk_duration_internal", phist_data->peak_duration_us);
+
+
+
+	xtalk_events_per_spad = do_division_u((((uint64_t)xtalk_rate_kcps *
+		(uint64_t)phist_data->peak_duration_us) + 500), 1000);
+
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"xtalk_events_per_spad", xtalk_events_per_spad);
+
+
+
+
+	xtalk_total_events = xtalk_events_per_spad *
+		(uint64_t)phist_data->result__dss_actual_effective_spads;
+
+	xtalk_total_events = do_division_u((xtalk_total_events), 256);
+
+	xtalk_total_events = do_division_u((xtalk_total_events + 1024), 2048);
+
+	if (xtalk_total_events > 0xFFFFFFFF)
+		xtalk_total_events = 0xFFFFFFFF;
+
+	trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"xtalk_total_events", xtalk_total_events);
+
+
+
+
+
+
+	for (i = 0; i < pxtalk_data->VL53LX_p_021; i++) {
+		xtalk_temp_bin = (uint64_t)pxtalk_data->bin_data[i] *
+				(uint64_t)xtalk_total_events;
+		xtalk_temp_bin = do_division_u((xtalk_temp_bin + 512), 1024);
+
+		pxtalkcount_data->bin_data[i] = (uint32_t)xtalk_temp_bin;
+
+		trace_print(
+			VL53LX_TRACE_LEVEL_DEBUG,
+			"    %-48s : %10d\n",
+			"bin_data", pxtalkcount_data->bin_data[i]);
+	}
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_047(
+	VL53LX_histogram_bin_data_t	*phist_data,
+	VL53LX_histogram_bin_data_t	*pxtalk_data,
+	uint8_t					xtalk_bin_offset)
+{
+
+
+	VL53LX_Error status = VL53LX_ERROR_NONE;
+
+	uint8_t  i = 0;
+
+	int32_t  temp_bin;
+
+	LOG_FUNCTION_START("");
+
+
+
+
+	if (status == VL53LX_ERROR_NONE)
+		for (i = xtalk_bin_offset;
+				i < pxtalk_data->VL53LX_p_021; i++) {
+
+			temp_bin = (int32_t)phist_data->bin_data[i] -
+			(int32_t)pxtalk_data->bin_data[i - xtalk_bin_offset];
+
+			if (temp_bin < 0)
+				temp_bin = 0;
+
+			phist_data->bin_data[i] = (uint32_t)temp_bin;
+		}
+
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_044(
+	VL53LX_histogram_bin_data_t		*pxtalk_data,
+	uint32_t						amb_threshold,
+	uint8_t						VL53LX_p_019,
+	uint8_t						VL53LX_p_024)
+{
+
+
+	VL53LX_Error status = VL53LX_ERROR_NONE;
+
+	uint8_t i = 0;
+	uint8_t first_bin_int = 0;
+	uint8_t first_bin_inc = 0;
+	uint8_t last_bin_int  = 0;
+	uint8_t realign_bin   = 0;
+	uint8_t realign_index = 0;
+	int32_t realign_bin_data[VL53LX_HISTOGRAM_BUFFER_SIZE];
+
+	LOG_FUNCTION_START("");
+
+
+
+	for (i = 0 ; i < VL53LX_HISTOGRAM_BUFFER_SIZE ; i++)
+		realign_bin_data[i] = 0;
+
+	first_bin_int = VL53LX_p_019;
+	last_bin_int  = VL53LX_p_024;
+
+
+
+
+
+	VL53LX_hist_remove_ambient_bins(pxtalk_data);
+
+
+
+	first_bin_int = (first_bin_int) %
+				pxtalk_data->VL53LX_p_021;
+
+	last_bin_int = (last_bin_int) %
+				pxtalk_data->VL53LX_p_021;
+
+	first_bin_inc = (first_bin_int + 1) % pxtalk_data->VL53LX_p_021;
+
+
+
+	if (first_bin_inc > last_bin_int) {
+
+
+		realign_bin = pxtalk_data->VL53LX_p_021 - first_bin_inc;
+
+
+		first_bin_int = (first_bin_int + realign_bin) %
+				pxtalk_data->VL53LX_p_021;
+		last_bin_int = (last_bin_int + realign_bin) %
+				pxtalk_data->VL53LX_p_021;
+
+
+		pxtalk_data->zero_distance_phase =
+			pxtalk_data->zero_distance_phase +
+			((uint16_t)realign_bin * 2048);
+	}
+
+	if (realign_bin > 0) {
+
+		for (i = 0; i < pxtalk_data->VL53LX_p_021; i++)
+			realign_bin_data[i] = pxtalk_data->bin_data[i];
+
+
+		for (i = 0; i < pxtalk_data->VL53LX_p_021; i++) {
+			realign_index = (pxtalk_data->VL53LX_p_021 -
+				realign_bin + i)
+				% pxtalk_data->VL53LX_p_021;
+
+			pxtalk_data->bin_data[i] =
+				realign_bin_data[realign_index];
+		}
+	}
+
+
+
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"first bin int", first_bin_int);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"last bin int", last_bin_int);
+
+	trace_print(
+		VL53LX_TRACE_LEVEL_DEBUG,
+		"    %-48s : %10d\n",
+		"amb thresh", amb_threshold);
+
+
+
+
+
+	for (i = 0; i < pxtalk_data->VL53LX_p_021; i++) {
+
+		if (first_bin_int <= last_bin_int) {
+			if ((i >= first_bin_int) && (i <= last_bin_int)) {
+				if (pxtalk_data->bin_data[i] <
+						(int32_t)amb_threshold)
+					pxtalk_data->bin_data[i] = 0;
+			} else {
+				pxtalk_data->bin_data[i] = 0;
+			}
+		} else {
+			if ((i >= first_bin_int) || (i <= last_bin_int)) {
+				if (pxtalk_data->bin_data[i] <
+						(int32_t)amb_threshold) {
+					pxtalk_data->bin_data[i] = 0;
+				}
+			} else {
+				pxtalk_data->bin_data[i] = 0;
+			}
+		}
+	}
+
+
+
+
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+VL53LX_Error VL53LX_f_043(
+		uint8_t                      sigma_mult,
+		int32_t                      VL53LX_p_028,
+		uint32_t                    *ambient_noise)
+{
+
+
+
+	VL53LX_Error status              = VL53LX_ERROR_NONE;
+
+	uint32_t ambient_events_per_bin_int = 0;
+
+	LOG_FUNCTION_START("");
+
+	if (VL53LX_p_028 <= 0)
+		ambient_events_per_bin_int = 1;
+	else
+		ambient_events_per_bin_int = (uint32_t)VL53LX_p_028;
+
+	*ambient_noise =  VL53LX_isqrt(ambient_events_per_bin_int);
+
+	*ambient_noise = *ambient_noise * (uint32_t)sigma_mult;
+
+	LOG_FUNCTION_END(status);
+
+	return status;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+