Vijayaraghavan Narayanan
vlx lib
Diff: common_driver.cpp
- Revision:
- 0:bc9f26b5dadf
diff -r 000000000000 -r bc9f26b5dadf common_driver.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/common_driver.cpp Sun Feb 08 14:26:51 2015 +0000
@@ -0,0 +1,890 @@
+/*******************************************************************************
+################################################################################
+# (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
+################################################################################
+********************************************************************************/
+
+/*
+ '''
+ Application-level methods used for generic, system or identification operations.
+ '''
+*/
+
+//-----------------------------------------------------------------------------
+// module imports
+//-----------------------------------------------------------------------------
+#include "debug.h"
+#include "common_driver.h"
+#include "ranging_driver.h"
+
+//-----------------------------------------------------------------------------
+// global variable declarations
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// method definitions
+//-----------------------------------------------------------------------------
+
+sensor_error common_initialise(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_initialise(device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error common_set_static_config(uint8_t device_base_address)
+{
+ int8_t reset;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ reset = i2c_read_byte(0x016, device_base_address);
+ if (reset==1)
+ {
+ // check to see has it be Initialised already
+ //REGISTER_TUNING_SR03_270514_CustomerView.txt
+
+ // Mandatory : private registers
+ i2c_write_byte(0x0207, 0x01, device_base_address);
+ i2c_write_byte(0x0208, 0x01, device_base_address);
+ i2c_write_byte(0x0096, 0x00, device_base_address);
+ i2c_write_byte(0x0097, 0xfd, device_base_address);
+ i2c_write_byte(0x00e3, 0x00, device_base_address);
+ i2c_write_byte(0x00e4, 0x04, device_base_address);
+ i2c_write_byte(0x00e5, 0x02, device_base_address);
+ i2c_write_byte(0x00e6, 0x01, device_base_address);
+ i2c_write_byte(0x00e7, 0x03, device_base_address);
+ i2c_write_byte(0x00f5, 0x02, device_base_address);
+ i2c_write_byte(0x00d9, 0x05, device_base_address);
+ i2c_write_byte(0x00db, 0xce, device_base_address);
+ i2c_write_byte(0x00dc, 0x03, device_base_address);
+ i2c_write_byte(0x00dd, 0xf8, device_base_address);
+ i2c_write_byte(0x009f, 0x00, device_base_address);
+ i2c_write_byte(0x00a3, 0x3c, device_base_address);
+ i2c_write_byte(0x00b7, 0x00, device_base_address);
+ i2c_write_byte(0x00bb, 0x3c, device_base_address);
+ i2c_write_byte(0x00b2, 0x09, device_base_address);
+ i2c_write_byte(0x00ca, 0x09, device_base_address);
+ i2c_write_byte(0x0198, 0x01, device_base_address);
+ i2c_write_byte(0x01b0, 0x17, device_base_address);
+ i2c_write_byte(0x01ad, 0x00, device_base_address);
+ i2c_write_byte(0x00ff, 0x05, device_base_address);
+ i2c_write_byte(0x0100, 0x05, device_base_address);
+ i2c_write_byte(0x0199, 0x05, device_base_address);
+ i2c_write_byte(0x01a6, 0x1b, device_base_address);
+ i2c_write_byte(0x01ac, 0x3e, device_base_address);
+ i2c_write_byte(0x01a7, 0x1f, device_base_address);
+ i2c_write_byte(0x0030, 0x00, device_base_address);
+
+ // Recommended : Public registers - See data sheet for more detail
+ i2c_write_byte(0x0011, 0x10, device_base_address); // Enables polling for ¡®New Sample ready¡¯ when measurement completes
+ i2c_write_byte(0x010a, 0x30, device_base_address); // Set the averaging sample period (compromise between lower noise and increased execution time)
+ i2c_write_byte(0x003f, 0x46, device_base_address); // Sets the light and dark gain (upper nibble). Dark gain should not be changed.
+ i2c_write_byte(0x0031, 0xFF, device_base_address); // sets the # of range measurements after which auto calibration of system is performed
+ i2c_write_byte(0x0040, 0x63, device_base_address); // Set ALS integration time to 100ms
+ i2c_write_byte(0x002e, 0x01, device_base_address); // perform a single temperature calibration of the ranging sensor
+
+ // Optional: Public registers - See data sheet for more detail
+ i2c_write_byte(0x001b, 0x09, device_base_address); // Set default ranging inter-measurement period to 100ms
+ i2c_write_byte(0x003e, 0x31, device_base_address); // Set default ALS inter-measurement period to 500ms
+ i2c_write_byte(0x0014, 0x24, device_base_address); // Configures interrupt on ¡®New sample ready¡¯
+
+ // extra stuff
+ i2c_write_byte(0x016, 0x00, device_base_address); // change fresh out of set status to 0
+
+ }
+
+ // VHV automatically run on parts that are NVM-programmed, ie customer parts!
+
+ range_set_max_convergence_time(device_base_address, 50); // Calculate ece value on initialisation (use max conv)
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error common_get_identification(uint8_t device_base_address)
+{
+/*
+ return_list = []
+
+ # I2C base address is 8-bit indexing
+ I2C_base_address = I2C_ReadReg_CCI(I2C_SLAVE_DEVICE_ADDRESS, I2C_ADDR);
+ I2C_base_address *= 2 # convert from 7-bit to 8-bit address
+
+ # reading from indices 0x00-0x0B
+ regs = Utilities.device.comms['read'](I2C_base_address, 0x00, 0x0C)
+
+ identification_model_id = regs[0x00]
+ identification_model_rev_major = regs[0x01]
+ identification_model_rev_minor = regs[0x02]
+ identification_module_rev_major = regs[0x03]
+ identification_module_rev_minor = regs[0x04]
+ identification_nvm_revision_id = regs[0x05] & 0x0F
+ identification_mask_revision_id = (regs[0x05] & 0xF0) >> 4
+ identification_month = regs[0x06] & 0x0F
+ identification_year = (regs[0x06] & 0xF0) >> 4
+ identification_phase = regs[0x07] & 0x0F
+ identification_day = (regs[0x07] & 0xF0) >> 4
+ identification_time = (regs[0x08] << 8) + regs[0x09]
+ identification_code = regs[0x0A]
+ firmware_revision_id = regs[0x0B]
+
+ return_list.append( identification_model_id )
+ return_list.append( identification_model_rev_major )
+ return_list.append( identification_model_rev_minor )
+ return_list.append( identification_module_rev_major )
+ return_list.append( identification_module_rev_minor )
+ return_list.append( identification_nvm_revision_id )
+ return_list.append( identification_mask_revision_id )
+ return_list.append( identification_month )
+ return_list.append( identification_year )
+ return_list.append( identification_phase )
+ return_list.append( identification_day )
+ return_list.append( identification_time )
+ return_list.append( identification_code )
+ return_list.append( firmware_revision_id )
+ return return_list
+*/
+ return SENSOR_ERROR_NONE;
+}
+
+
+sensor_error common_set_i2c_base_address(uint8_t device_base_address, uint32_t new_i2c_base_address)
+{
+ //# reduce 8-bit address to a 7-bit address
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&new_i2c_base_address);
+
+ i2c_write_byte(I2C_SLAVE_DEVICE_ADDRESS, (new_i2c_base_address >> 1), device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error common_set_i2c_pad_voltage(uint8_t device_base_address, uint8_t pad_voltage)
+{
+ uint8_t padConfigReg;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&pad_voltage);
+
+ padConfigReg = i2c_read_byte(PAD_I2C_CONFIG, device_base_address);
+ if (pad_voltage == I2C_1v2_PAD_VOLTAGE)
+ {
+ i2c_write_byte(PAD_I2C_CONFIG, (padConfigReg & 0xFE), device_base_address); // clear bit 0
+ }
+
+ if (pad_voltage == I2C_2v8_PAD_VOLTAGE)
+ {
+ i2c_write_byte(PAD_I2C_CONFIG, (padConfigReg & 0x01), device_base_address); // set bit 0
+ }
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+uint8_t common_get_i2c_pad_voltage(uint8_t device_base_address)
+{
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (!(i2c_read_byte(PAD_I2C_CONFIG, device_base_address) & 0xFE)) // test that bit 0 is clear!
+ {
+ ret = I2C_1v2_PAD_VOLTAGE;
+ }
+ else if (i2c_read_byte(PAD_I2C_CONFIG, device_base_address) & 0x01) // test that bit 0 is set!
+ {
+ ret = I2C_2v8_PAD_VOLTAGE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_system_mode_gpio0(uint8_t device_base_address, uint8_t mode, uint8_t select, uint8_t polarity)
+{
+ uint8_t gpioModeReg;
+ uint8_t gpio_select;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&mode, (void*)&select, (void*)&polarity);
+
+ switch (select)
+ {
+ case GPIOx_SELECT_OFF :
+ case GPIOx_SELECT_MEASURE_READY :
+ case GPIOx_SELECT_DISABLED :
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT :
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ gpioModeReg = gpioModeReg & 0x21; // preserve only the mode & polarity bits from the register contents!
+ gpio_select = select << 1; // move up 1 bit, to make mask for bits 1-4
+
+ i2c_write_byte(SYSTEM_MODE_GPIO0,
+ (gpioModeReg | gpio_select),
+ device_base_address);
+ break;
+ default :
+ ret = COMMON_INVALID_PARAMS;
+ break;
+ }
+
+ if ((mode == GPIOx_MODE_SELECT_RANGING) || (mode == GPIOx_MODE_SELECT_ALS))
+ {
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ i2c_write_byte(SYSTEM_MODE_GPIO0,
+ (gpioModeReg | mode),
+ device_base_address);
+ }
+ else
+ {
+ ret = COMMON_INVALID_PARAMS;
+ }
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ if (polarity == GPIOx_POLARITY_SELECT_OFF)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO0,
+ (gpioModeReg & GPIOx_POLARITY_SELECT_CLEARED),
+ device_base_address);
+ }
+ else if (polarity == GPIOx_POLARITY_SELECT_ON)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO0,
+ (gpioModeReg | GPIOx_POLARITY_SELECT),
+ device_base_address);
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio0_mode(uint8_t device_base_address, uint8_t mode)
+{
+ uint8_t gpioModeReg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&mode);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ if ((mode == GPIOx_MODE_SELECT_RANGING) || (mode == GPIOx_MODE_SELECT_ALS))
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO0, (gpioModeReg | mode), device_base_address);
+ }
+ else
+ {
+ ret = COMMON_INVALID_PARAMS;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_gpio0_mode(uint8_t device_base_address)
+{
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address) & GPIOx_MODE_SELECT)
+ {
+ ret = 1;
+ }
+ else
+ {
+ ret = 0;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio0_select(uint8_t device_base_address, uint8_t select)
+{
+ uint8_t gpio_select;
+ uint8_t gpioModeReg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&select);
+
+ switch (select)
+ {
+ case GPIOx_SELECT_OFF:
+ case GPIOx_SELECT_MEASURE_READY:
+ case GPIOx_SELECT_THRESHOLD_OUTPUT:
+ case GPIOx_SELECT_BLANK_IN:
+ case GPIOx_SELECT_BLANK_OUT:
+ case GPIOx_SELECT_START_STOP:
+ case GPIOx_SELECT_DISABLED:
+ case GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT:
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT:
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ gpio_select = select << 1; // move up 1 bit, to make mask for bits 1-4
+ i2c_write_byte(SYSTEM_MODE_GPIO0, (gpioModeReg | gpio_select), device_base_address);
+ break;
+ default :
+ ret = COMMON_INVALID_PARAMS;
+ break;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_gpio0_select(uint8_t device_base_address)
+{
+ uint8_t gpioModeReg;
+ uint8_t gpio_select;
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ gpio_select = (gpioModeReg & 0x1E) >> 1; // mask only bits 1-4
+ switch (gpio_select)
+ {
+ case GPIOx_SELECT_OFF:
+ ret = GPIOx_SELECT_OFF;
+ break;
+ case GPIOx_SELECT_MEASURE_READY:
+ ret = GPIOx_SELECT_MEASURE_READY;
+ break;
+ case GPIOx_SELECT_THRESHOLD_OUTPUT:
+ ret = GPIOx_SELECT_THRESHOLD_OUTPUT;
+ break;
+ case GPIOx_SELECT_BLANK_IN:
+ ret = GPIOx_SELECT_BLANK_IN;
+ break;
+ case GPIOx_SELECT_BLANK_OUT:
+ ret = GPIOx_SELECT_BLANK_OUT;
+ break;
+ case GPIOx_SELECT_START_STOP:
+ ret = GPIOx_SELECT_START_STOP;
+ break;
+ case GPIOx_SELECT_DISABLED:
+ ret = GPIOx_SELECT_DISABLED;
+ break;
+ case GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT:
+ ret = GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT;
+ break;
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT:
+ ret = GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT;
+ break;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio0_polarity(uint8_t device_base_address, uint8_t polarity)
+{
+ uint8_t gpioModeReg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*) &polarity);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address);
+ if (polarity == GPIOx_POLARITY_SELECT_OFF)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO0,
+ (gpioModeReg & GPIOx_POLARITY_SELECT_CLEARED),
+ device_base_address);
+ }
+ else if (polarity == GPIOx_POLARITY_SELECT_ON)
+ i2c_write_byte(SYSTEM_MODE_GPIO0, (gpioModeReg | GPIOx_POLARITY_SELECT), device_base_address);
+ else
+ ret = COMMON_INVALID_PARAMS;
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+bool_t common_get_gpio0_polarity(uint8_t device_base_address)
+{
+ bool_t ret=FALSE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_MODE_GPIO0, device_base_address) & GPIOx_POLARITY_SELECT)
+ ret = TRUE;
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_system_mode_gpio1(uint8_t device_base_address, uint8_t mode, uint8_t select, uint8_t polarity)
+{
+ uint8_t gpioModeReg;
+ uint8_t gpio_select;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&mode,(void*)&select,(void*)&polarity);
+
+ switch (select)
+ {
+ case GPIOx_SELECT_OFF :
+ case GPIOx_SELECT_MEASURE_READY :
+ case GPIOx_SELECT_DISABLED :
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT :
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+ gpioModeReg = gpioModeReg & 0x21; // preserve only the mode & polarity bits from the register contents!
+ gpio_select = select << 1; // move up 1 bit, to make mask for bits 1-4
+ i2c_write_byte(SYSTEM_MODE_GPIO1, (gpioModeReg | gpio_select), device_base_address);
+ break;
+ default :
+ ret = COMMON_INVALID_PARAMS;
+ break;
+ }
+
+ if ((mode == GPIOx_MODE_SELECT_RANGING) || (mode == GPIOx_MODE_SELECT_ALS))
+ {
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg | mode),
+ device_base_address);
+ }
+ else
+ {
+ ret = COMMON_INVALID_PARAMS;
+ }
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+
+ if (polarity == GPIOx_POLARITY_SELECT_OFF)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg & GPIOx_POLARITY_SELECT_CLEARED),
+ device_base_address);
+ }
+
+ if (polarity == GPIOx_POLARITY_SELECT_ON)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg | GPIOx_POLARITY_SELECT),
+ device_base_address);
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio1_mode(uint8_t device_base_address, uint8_t mode)
+{
+ uint8_t gpioModeReg;
+ sensor_error ret = COMMON_INVALID_PARAMS;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&mode);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+
+ if ((mode == GPIOx_MODE_SELECT_RANGING) || (mode == GPIOx_MODE_SELECT_ALS))
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg | mode),
+ device_base_address);
+ ret = SENSOR_ERROR_NONE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_gpio1_mode(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address) & GPIOx_MODE_SELECT)
+ {
+ ret = 1;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio1_select(uint8_t device_base_address, uint8_t select)
+{
+ uint8_t gpio_select;
+ uint8_t gpioModeReg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&select);
+
+ switch (select)
+ {
+ case GPIOx_SELECT_OFF:
+ case GPIOx_SELECT_MEASURE_READY:
+ case GPIOx_SELECT_THRESHOLD_OUTPUT:
+ case GPIOx_SELECT_BLANK_IN:
+ case GPIOx_SELECT_BLANK_OUT:
+ case GPIOx_SELECT_START_STOP:
+ case GPIOx_SELECT_DISABLED:
+ case GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT:
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT:
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+ gpio_select = select << 1; // move up 1 bit, to make mask for bits 1-4
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg | gpio_select),
+ device_base_address);
+ break;
+ default:
+ ret = COMMON_INVALID_PARAMS;
+ break;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_gpio1_select(uint8_t device_base_address)
+{
+ uint8_t gpio_select;
+ uint8_t gpioModeReg;
+ uint8_t ret=0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+
+ gpio_select = (gpioModeReg & 0x1E) >> 1; // mask only bits 1-4
+
+ switch (gpio_select)
+ {
+ case GPIOx_SELECT_OFF:
+ ret = GPIOx_SELECT_OFF;
+ break;
+ case GPIOx_SELECT_MEASURE_READY:
+ ret = GPIOx_SELECT_MEASURE_READY;
+ break;
+ case GPIOx_SELECT_THRESHOLD_OUTPUT:
+ ret = GPIOx_SELECT_THRESHOLD_OUTPUT;
+ break;
+ case GPIOx_SELECT_BLANK_IN:
+ ret = GPIOx_SELECT_BLANK_IN;
+ break;
+ case GPIOx_SELECT_BLANK_OUT:
+ ret = GPIOx_SELECT_BLANK_OUT;
+ break;
+ case GPIOx_SELECT_START_STOP:
+ ret = GPIOx_SELECT_START_STOP;
+ break;
+ case GPIOx_SELECT_DISABLED:
+ ret = GPIOx_SELECT_DISABLED;
+ break;
+ case GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT:
+ ret = GPIOx_SELECT_COMBINED_THRESHOLD_OUTPUT;
+ break;
+ case GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT:
+ ret = GPIOx_SELECT_GPIO_INTERRUPT_OUTPUT;
+ break;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_gpio1_polarity(uint8_t device_base_address, uint8_t polarity)
+{
+ uint8_t gpioModeReg;
+ sensor_error ret = SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&polarity);
+
+ gpioModeReg = i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address);
+
+ if (polarity == GPIOx_POLARITY_SELECT_OFF)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg & GPIOx_POLARITY_SELECT_CLEARED),
+ device_base_address);
+ }
+ else if (polarity == GPIOx_POLARITY_SELECT_ON)
+ {
+ i2c_write_byte(SYSTEM_MODE_GPIO1,
+ (gpioModeReg | GPIOx_POLARITY_SELECT),
+ device_base_address);
+ }
+ else
+ {
+ ret = COMMON_INVALID_PARAMS;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+bool_t common_get_gpio1_polarity(uint8_t device_base_address)
+{
+ bool_t ret= FALSE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_MODE_GPIO1, device_base_address) & GPIOx_POLARITY_SELECT)
+ {
+ ret = TRUE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_history_buffer_enable(uint8_t device_base_address, uint8_t history_buffer_enable)
+{
+ uint8_t mode;
+ sensor_error ret= COMMON_INVALID_PARAMS;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&history_buffer_enable);
+
+ if ((history_buffer_enable == HISTORY_BUFFER_DISABLE) ||
+ (history_buffer_enable == HISTORY_BUFFER_ENABLE))
+ {
+ mode = i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address);
+ i2c_write_byte(SYSTEM_HISTORY_CTRL,
+ (mode | history_buffer_enable),
+ device_base_address);
+ ret = SENSOR_ERROR_NONE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+bool_t common_get_history_buffer_enable(uint8_t device_base_address)
+{
+ bool_t ret = FALSE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address) & HISTORY_BUFFER_ENABLED)
+ {
+ ret = TRUE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_history_buffer_mode(uint8_t device_base_address, uint8_t history_buffer_mode)
+{
+ uint8_t historyRegVal;
+ uint8_t mode=0;
+ sensor_error ret= SENSOR_ERROR_NONE;
+
+ LOG_FUNCTION_START((void*)&device_base_address,(void*)&history_buffer_mode);
+
+ historyRegVal = i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address);
+
+ if (history_buffer_mode & HISTORY_BUFFER_ALS_MODE)
+ {
+ mode = historyRegVal | 0x02; // set bit 1 to enable ALS mode
+ }
+ else if (history_buffer_mode & HISTORY_BUFFER_RANGING_MODE)
+ {
+ mode = historyRegVal & 0xFD; // clear bit 1
+ }
+ else
+ {
+ ret = COMMON_INVALID_PARAMS;
+ }
+ i2c_write_byte(SYSTEM_HISTORY_CTRL, mode, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_history_buffer_mode(uint8_t device_base_address)
+{
+ int32_t ret = HISTORY_BUFFER_RANGING_MODE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address) & HISTORY_BUFFER_MODE)
+ {
+ ret = HISTORY_BUFFER_ALS_MODE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_history_buffer_clear(uint8_t device_base_address)
+{
+ uint8_t mode;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ mode = i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address);
+ mode = mode | 0x04; // set bit 2 to 1 to clear history buffer
+ i2c_write_byte(SYSTEM_HISTORY_CTRL, mode, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+bool_t common_get_history_buffer_clear(uint8_t device_base_address)
+{
+ bool_t ret = FALSE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+ if (i2c_read_byte(SYSTEM_HISTORY_CTRL, device_base_address) & HISTORY_BUFFER_CLEARED)
+ {
+ ret= TRUE;
+ }
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_system_interrupt_clear_error(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_write_byte(SYSTEM_INTERRUPT_CLEAR, INTERRUPT_CLEAR_ERROR, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+uint8_t common_get_error_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) & 0xC0) >> 6 );
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_clear_system_fresh_out_of_reset(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_write_byte(SYSTEM_FRESH_OUT_OF_RESET, 0x00, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+bool_t common_get_system_fresh_out_of_reset(uint8_t device_base_address)
+{
+ uint8_t cFreshOutOfReset = 0x01;
+ bool_t ret= FALSE;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ if (i2c_read_byte(SYSTEM_FRESH_OUT_OF_RESET, device_base_address) & cFreshOutOfReset)
+ {
+ ret = TRUE;
+ }
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+sensor_error common_set_system_group_parameter_hold(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_write_byte(SYSTEM_GROUPED_PARAMETER_HOLD, 0x01, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+sensor_error common_clear_system_group_parameter_hold(uint8_t device_base_address)
+{
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ i2c_write_byte(SYSTEM_GROUPED_PARAMETER_HOLD, 0x00, device_base_address);
+
+ LOG_FUNCTION_END(NULL);
+
+ return SENSOR_ERROR_NONE;
+}
+
+uint8_t common_get_system_fatal_error_code(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ ret = i2c_read_byte(SYSTEM_FATAL_ERROR_CODE, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+uint8_t common_get_system_fatal_error_status(uint8_t device_base_address)
+{
+ uint8_t ret = 0;
+
+ LOG_FUNCTION_START((void*)&device_base_address);
+
+ ret = i2c_read_byte(SYSTEM_FATAL_ERROR_STATUS, device_base_address);
+
+ LOG_FUNCTION_END(ret);
+
+ return ret;
+}
+
+// ??
+uint8_t common_get_system_health_check(uint8_t device_base_address)
+{
+// return threshold
+ return 1; // temp only, will stub is here!
+}
+