Vijayaraghavan Narayanan
vlx lib
Diff: ranging_driver.cpp
- Revision:
- 0:bc9f26b5dadf
diff -r 000000000000 -r bc9f26b5dadf ranging_driver.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ranging_driver.cpp Sun Feb 08 14:26:51 2015 +0000
@@ -0,0 +1,686 @@
+/*******************************************************************************
+################################################################################
+# (C) STMicroelectronics 2014
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License version 2 and only version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+#------------------------------------------------------------------------------
+# Imaging Division
+################################################################################
+********************************************************************************/
+
+// Ranging_Driver.c
+
+/*
+'''
+Application-level functions used for configuration and operation during ranging.
+'''
+*/
+
+
+// ST libraries
+#include "ranging_driver.h"
+#include "utilities.h"
+#include "platform.h"
+#include "debug.h"
+//----------------------------ECE_FACTOR-------------------------------------------------
+// global variable declarations
+//-----------------------------------------------------------------------------
+//double_t ece_factor = ECE_FACTOR; // user set ECE margin (< 1.00 for maximum detection, > 1.00 for minimizing red glow)
+uint32_t ece_factor_m = ECE_FACTOR_M;
+uint32_t ece_factor_d = ECE_FACTOR_D;
+
+//-----------------------------------------------------------------------------
+// function definitions
+//-----------------------------------------------------------------------------
+
+sensor_error range_set_dynamic_config(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error range_set_systemMode(uint8_t device_base_address, int32_t mode)
+{
+ uint8_t startRegVal;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&mode);
+ switch (mode)
+ {
+ case RANGE_START_SINGLESHOT:
+ i2c_write_byte(SYSRANGE_START, mode, device_base_address);
+ break;
+ case RANGE_START_CONTINUOUS:
+ // ensure mode bit is set!
+ startRegVal = i2c_read_byte(SYSRANGE_START, device_base_address);
+ startRegVal |= 0x03;
+ i2c_write_byte(SYSRANGE_START, startRegVal, device_base_address);
+ break;
+ case RANGE_STOP:
+ // ensure mode bit is left unaffected!
+ startRegVal = i2c_read_byte(SYSRANGE_START, device_base_address);
+ startRegVal |= 0x01;
+ // set the bit, as it is a toggle state, not a 0=Off, 1=ON!
+ i2c_write_byte(SYSRANGE_START, startRegVal, device_base_address);
+ break;
+ default:
+ ret = COMMON_INVALID_PARAMS;
+ }
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_systemMode(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_START, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_result(uint8_t device_base_address)
+{
+ return i2c_read_byte(RESULT_RANGE_VAL, device_base_address);
+}
+
+uint32_t range_get_signal_rate(uint8_t device_base_address)
+{
+ uint32_t rawVal = (uint32_t)i2c_read_word(RESULT_RANGE_SIGNAL_RATE, device_base_address);
+
+ return rawVal;
+}
+
+sensor_error range_get_full_result(uint8_t device_base_address)
+{
+/*
+ return_list = []
+
+# I2C base address is 8-bit indexing
+ I2C_base_address = Utilities.device['reg_bank_go2']['I2C_SLAVE_DEVICE_ADDRESS'].read()
+ I2C_base_address *= 2 # convert from 7-bit to 8-bit address
+
+# make the indexing easy, read from index 0x60, but we only want data from 0x62!
+# reading from indices 0x60-0x84
+# common.Set_System_Group_Parameter_Hold()
+ regs = Utilities.device.comms['read'](I2C_base_address, 0x60, 0x25)
+ conv_threshold = Utilities.device['reg_bank_go2']['USER_CONV_CTRL_RETURN_THRESHOLD_FINE'].read() * 256
+# common.Clear_System_Group_Parameter_Hold()
+
+ result_range_val = regs[2] # address 0x62
+ result_range_stray = regs[3]
+ result_range_raw = regs[4]
+# no results at 0x65
+ result_range_return_rate = (regs[6] << 8) + regs[7]
+ result_range_reference_rate = (regs[8] << 8) + regs[9]
+# indices 0x6A, 0x6B empty
+ result_range_Return_VCSEL_count = (regs[0x0C] << 24) + (regs[0x0D] << 16) + (regs[0x0E] << 8) + regs[0x0F]
+ result_range_Reference_VCSEL_count = (regs[0x10] << 24) + (regs[0x11] << 16) + (regs[0x12] << 8) + regs[0x13]
+ result_range_Return_AMB_count = (regs[0x14] << 24) + (regs[0x15] << 16) + (regs[0x16] << 8) + regs[0x17]
+ result_range_Reference_AMB_count = (regs[0x18] << 24) + (regs[0x19] << 16) + (regs[0x1A] << 8) + regs[0x1B]
+ result_range_Return_Conv_time = (regs[0x1C] << 24) + (regs[0x1D] << 16) + (regs[0x1E] << 8) + regs[0x1F]
+ result_range_Reference_Conv_time = (regs[0x20] << 24) + (regs[0x21] << 16) + (regs[0x22] << 8) + regs[0x23]
+
+ return_list.append( result_range_val )
+ return_list.append( result_range_stray )
+ return_list.append( result_range_raw )
+ return_list.append( result_range_return_rate )
+ return_list.append( result_range_reference_rate )
+ return_list.append( result_range_Return_VCSEL_count )
+ return_list.append( result_range_Reference_VCSEL_count )
+ return_list.append( result_range_Return_AMB_count )
+ return_list.append( result_range_Reference_AMB_count )
+ return_list.append( result_range_Return_Conv_time )
+ return_list.append( result_range_Reference_Conv_time )
+ return_list.append( conv_threshold )
+ return return_list
+
+*/
+ return SENSOR_ERROR_NONE;
+
+}
+
+sensor_error range_set_high_threshold(uint8_t device_base_address, uint8_t threshold)
+{
+ //threshold type is uint8_t. no need to check parameter since from 0-255
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&threshold);
+ i2c_write_byte(SYSRANGE_THRESH_HIGH, threshold, device_base_address);
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+uint8_t range_get_high_threshold(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_THRESH_HIGH, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_low_threshold(uint8_t device_base_address, uint8_t threshold)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ //threshold type is uint8_t. no need to check parameter since from 0-255
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&threshold);
+ i2c_write_byte(SYSRANGE_THRESH_LOW, threshold, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_low_threshold(uint8_t device_base_address)
+{
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_THRESH_LOW, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_interMeasurement_period(uint8_t device_base_address, uint16_t intermeasurement_period)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&intermeasurement_period);
+ if (intermeasurement_period > 255*10)
+ {
+ // Clipping value to max of 2.55s
+ intermeasurement_period = 255*10;
+ }
+ i2c_write_byte(SYSRANGE_INTERMEASUREMENT_PERIOD, (uint8_t)(intermeasurement_period/10), device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint16_t range_get_interMeasurement_period(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_INTERMEASUREMENT_PERIOD, device_base_address);
+ ret *=10; //return in ms
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_max_convergence_time(uint8_t device_base_address, int32_t max_convergence_time)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&max_convergence_time);
+ i2c_write_byte(SYSRANGE_MAX_CONVERGENCE_TIME, max_convergence_time, device_base_address);
+ range_set_early_convergence_estimate_threshold(device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_max_convergence_time(uint8_t device_base_address)
+{
+ return i2c_read_byte(SYSRANGE_MAX_CONVERGENCE_TIME, device_base_address);
+}
+
+sensor_error range_set_crosstalk_compensation_rate(uint8_t device_base_address, int32_t crosstalk_compensation_rate)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&crosstalk_compensation_rate);
+ i2c_write_word(SYSRANGE_CROSSTALK_COMPENSATION_RATE, crosstalk_compensation_rate, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+int32_t range_get_crosstalk_compensation_rate(uint8_t device_base_address)
+{
+ uint32_t ret=0;
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_word(SYSRANGE_CROSSTALK_COMPENSATION_RATE, device_base_address);
+ LOG_FUNCTION_END(NULL);
+
+ return ret;
+}
+
+sensor_error range_set_crosstalk_compensation_range(uint8_t device_base_address, int32_t crosstalk_compensation_range)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&crosstalk_compensation_range);
+ i2c_write_byte(SYSRANGE_CROSSTALK_COMPENSATION_RANGE, crosstalk_compensation_range, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_crosstalk_compensation_range(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_CROSSTALK_COMPENSATION_RANGE, device_base_address);
+ LOG_FUNCTION_END(NULL);
+
+ return ret;
+}
+
+sensor_error range_set_crosstalk_valid_height(uint8_t device_base_address, int32_t crosstalk_valid_height)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&crosstalk_valid_height);
+ i2c_write_byte(SYSRANGE_CROSSTALK_VALID_HEIGHT, crosstalk_valid_height, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_crosstalk_valid_height(uint8_t device_base_address)
+{
+ uint8_t ret;
+ LOG_FUNCTION_START((void*)&device_base_address);
+ ret = i2c_read_byte(SYSRANGE_CROSSTALK_VALID_HEIGHT, device_base_address);
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_early_convergence_estimate_threshold(uint8_t device_base_address)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ uint32_t cMicroSecPerMilliSec = 1000;
+ uint32_t cEceSampleTime_us = 500;
+ uint32_t maxConv_ms = (uint32_t)range_get_max_convergence_time(device_base_address);
+ uint32_t convergTime_us = maxConv_ms * cMicroSecPerMilliSec - range_get_vernier_ave_total_time(device_base_address);
+ uint32_t fineThresh = range_get_converg_ctrl_rtn_thresh_fine(device_base_address);
+ uint32_t eceThresh = ece_factor_m * cEceSampleTime_us * fineThresh/(convergTime_us * ece_factor_d);
+ LOG_FUNCTION_START((void*)&device_base_address,);
+
+ i2c_write_word(SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, (uint16_t)eceThresh, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_early_convergence_estimate_threshold(uint8_t device_base_address)
+{
+ uint8_t ret;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ ret = i2c_read_word(SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint32_t range_get_vernier_ave_total_time(uint8_t device_base_address)
+{
+ uint32_t cFwOverhead_us = 24;
+ uint32_t cVernVcpSetupTime_us = 70;
+ uint32_t cPLL2_StartupDelay_us = 200;
+ uint8_t cVernMeasMask = 0x07;
+ uint32_t vernSamples;
+ uint32_t vernSamplePeriod;
+ uint32_t singleVernTime_us;
+ uint32_t totalVernAveTime_us;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ // Calculate Vernier average time
+ vernSamples = (uint32_t)(i2c_read_byte(VERNIER_MEASUREMENTS, device_base_address) & cVernMeasMask);
+ vernSamplePeriod = (uint32_t)i2c_read_byte(VERNIER_RIPPLE_AVE_SAMPLE_PERIOD, device_base_address);
+ singleVernTime_us = cFwOverhead_us + cVernVcpSetupTime_us + (vernSamplePeriod * 10);
+ totalVernAveTime_us = (vernSamples + 1) * singleVernTime_us + cPLL2_StartupDelay_us;
+
+ LOG_FUNCTION_END(totalVernAveTime_us);
+
+ return totalVernAveTime_us;
+}
+
+uint32_t range_get_converg_ctrl_rtn_thresh_fine(uint8_t device_base_address)
+{
+ //uint32_t cBitMask = 0x00FFFFFFF;
+ uint32_t cFineThreshLsb = 256;
+ uint32_t rawValue;
+ uint32_t realValue;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ rawValue = i2c_read_uint32(USER_CONV_CTRL_RETURN_THRESHOLD_FINE, device_base_address);
+ realValue = rawValue * cFineThreshLsb;
+
+ LOG_FUNCTION_END(realValue);
+
+ return realValue;
+}
+
+sensor_error range_set_ignore_valid_height(uint8_t device_base_address, int32_t ignore_valid_height)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&ignore_valid_height);
+
+ i2c_write_byte(SYSRANGE_RANGE_IGNORE_VALID_HEIGHT, ignore_valid_height, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_ignore_valid_height(uint8_t device_base_address)
+{
+ uint8_t ret;
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ ret = i2c_read_byte(SYSRANGE_RANGE_IGNORE_VALID_HEIGHT, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_range_ignore_threshold(uint8_t device_base_address, uint32_t range_ignore_threshold)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&range_ignore_threshold);
+ i2c_write_word(SYSRANGE_RANGE_IGNORE_THRESHOLD,
+ (uint16_t)range_ignore_threshold,
+ device_base_address);
+
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint32_t range_get_range_ignore_threshold(uint8_t device_base_address)
+{
+ uint16_t ignoreThreshRegVal = i2c_read_word(SYSRANGE_RANGE_IGNORE_THRESHOLD, device_base_address);
+ return ignoreThreshRegVal;
+}
+
+sensor_error range_set_emitter_block_threshold(uint8_t device_base_address, int32_t emitter_block_threshold)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&emitter_block_threshold);
+ i2c_write_word(SYSRANGE_EMITTER_BLOCK_THRESHOLD, emitter_block_threshold, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_emitter_block_threshold(uint8_t device_base_address)
+{
+ return i2c_read_word(SYSRANGE_EMITTER_BLOCK_THRESHOLD, device_base_address);
+}
+#ifndef __KERNEL__
+sensor_error range_set_snr_thresh(uint8_t device_base_address, float_t snrThresh)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&snrThresh);
+
+ const float cRegFractionLsb = 0.0625f;
+ const float cRegWholeLsb = 1.0f;
+ const float cReciprocalMax = 16.0f - cRegFractionLsb;
+ const float cSnrMin = 1.0f/cReciprocalMax;
+
+ uint8_t snrThresRegVal;
+
+ // Taking the reciprocal into account the allowable SNR range is 0.0625...16.0.
+ if(snrThresh < cSnrMin)
+ {
+ snrThresh = cSnrMin;
+ }
+
+ float snrthreshMult = 1.0f/snrThresh;
+ snrThresRegVal = (uint8_t)encodeTo4_4_Format(snrthreshMult);
+ i2c_write_byte(SYSRANGE_MAX_AMBIENT_LEVEL_MULT, (uint8_t)snrThresRegVal, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+
+float range_get_snr_thresh(uint8_t device_base_address)
+{
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ uint8_t snrthreshMult = i2c_read_byte(SYSRANGE_MAX_AMBIENT_LEVEL_MULT, device_base_address);
+ float snrThresh = 1.0f/decodeFrom4_4_Format((uint32_t)snrthreshMult);
+
+ LOG_FUNCTION_END(snrThresh);
+
+ return snrThresh;
+}
+#endif
+sensor_error range_set_range_check_enables(uint8_t device_base_address, int32_t range_check_enables)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&range_check_enables);
+
+ i2c_write_byte(SYSRANGE_RANGE_CHECK_ENABLES, range_check_enables, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_range_check_enables(uint8_t device_base_address)
+{
+ return i2c_read_byte(SYSRANGE_RANGE_CHECK_ENABLES, device_base_address);
+}
+
+sensor_error range_set_vhv_recalibrate(uint8_t device_base_address, int32_t VHV_Recalibrate)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&VHV_Recalibrate);
+
+ i2c_write_byte(SYSRANGE_VHV_RECALIBRATE, VHV_Recalibrate, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_vhv_recalibrate(uint8_t device_base_address)
+{
+ return i2c_read_byte(SYSRANGE_VHV_RECALIBRATE, device_base_address);
+}
+
+sensor_error range_set_vhv_repeat_rate(uint8_t device_base_address, int32_t VHV_repeat_rate)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address, (void*)&VHV_repeat_rate);
+
+ i2c_write_byte(SYSRANGE_VHV_REPEAT_RATE, VHV_repeat_rate, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_vhv_repeat_rate(uint8_t device_base_address)
+{
+ return i2c_read_byte(SYSRANGE_VHV_REPEAT_RATE, device_base_address);
+}
+
+int32_t range_get_result_status(uint8_t device_base_address)
+{
+ return i2c_read_byte(RESULT_RANGE_STATUS, device_base_address);
+}
+
+bool_t range_get_device_ready(uint8_t device_base_address)
+{
+ if (i2c_read_byte(RESULT_RANGE_STATUS, device_base_address) & RANGE_DEVICE_READY)
+ {
+ return TRUE;
+ }
+ return FALSE;
+}
+
+uint8_t range_get_result_error_codes(uint8_t device_base_address)
+{
+ return (i2c_read_byte(RESULT_RANGE_STATUS, device_base_address) & RANGE_ERROR_CODE) >> 4;
+}
+
+sensor_error range_set_ece_factor(uint8_t device_base_address, uint32_t ECE_Factor_M, uint32_t ECE_Factor_D)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&ECE_Factor_M, (void*)&ECE_Factor_D);
+
+ ece_factor_m = ECE_Factor_M;
+ ece_factor_d = ECE_Factor_D;
+ range_set_early_convergence_estimate_threshold(device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_get_ece_factor(uint32_t *pece_factor_m, uint32_t *pece_factor_d)
+{
+ *pece_factor_m = ece_factor_m;
+ *pece_factor_d = ece_factor_d;
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error range_set_system_interrupt_config_gpio(uint8_t device_base_address, uint8_t Ranging_GPIO_interrupt_config)
+{
+ uint8_t reg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&Ranging_GPIO_interrupt_config);
+ switch (Ranging_GPIO_interrupt_config)
+ {
+ case CONFIG_GPIO_INTERRUPT_DISABLED:
+ case CONFIG_GPIO_INTERRUPT_LEVEL_LOW:
+ case CONFIG_GPIO_INTERRUPT_LEVEL_HIGH:
+ case CONFIG_GPIO_INTERRUPT_OUT_OF_WINDOW:
+ case CONFIG_GPIO_INTERRUPT_NEW_SAMPLE_READY:
+ reg = i2c_read_byte(SYSTEM_INTERRUPT_CONFIG_GPIO, device_base_address);
+ reg &= 0x38; // preserve only the ALS part of reg
+ i2c_write_byte(SYSTEM_INTERRUPT_CONFIG_GPIO,
+ (reg | Ranging_GPIO_interrupt_config),
+ device_base_address);
+ break;
+ default :
+ ret = COMMON_INVALID_PARAMS;
+ break;
+ }
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_system_interrupt_config_gpio(uint8_t device_base_address)
+{
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ // expose only bits [2:0]
+
+ ret = (i2c_read_byte(SYSTEM_INTERRUPT_CONFIG_GPIO, device_base_address) & 0x07);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error range_set_system_interrupt_clear(uint8_t device_base_address)
+{
+ sensor_error ret = SENSOR_ERROR_NONE;
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_write_byte(SYSTEM_INTERRUPT_CLEAR, INTERRUPT_CLEAR_RANGING, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t range_get_result_interrupt_status_gpio(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ ret = (i2c_read_byte(RESULT_INTERRUPT_STATUS_GPIO, device_base_address) & 0x07);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_history_buffer_range_mode_enable(uint8_t device_base_address)
+{
+ uint8_t mode;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ mode = i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address);
+ mode = mode & 0xFD; // clear bit 1 to set to range mode
+ mode = mode | 0x01; // set bit 0 to enable history buffer
+ i2c_write_byte(SYSTEM_HISTORY_CTRL, mode, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return ret;
+}
+
+
+uint32_t range_get_upper_limit(uint8_t device_base_address)
+{
+ const uint32_t cScalerMax1X = 255;
+ uint32_t upperLim = cScalerMax1X;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ LOG_FUNCTION_END(upperLim);
+
+ return upperLim;
+}
+
+
+uint32_t range_get_lower_limit(uint8_t device_base_address)
+{
+ uint32_t lowerLimit = 0;
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ LOG_FUNCTION_END(lowerLimit);
+
+ return lowerLimit;
+}
+