Revision 0:84fb42fedc5b, committed 2015-07-07

Comitter:

julientiron

Date:

Tue Jul 07 20:36:43 2015 +0000

Commit message:

add I2C internal pull up

Changed in this revision

diff -r 000000000000 -r 84fb42fedc5b VL6180x.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180x.cpp	Tue Jul 07 20:36:43 2015 +0000
@@ -0,0 +1,239 @@
+/******************************************************************************
+ * SFE_VL6180x.cpp
+ * Library for VL6180x time of flight range finder.
+ * Casey Kuhns @ SparkFun Electronics
+ * 10/29/2014
+ * https://github.com/sparkfun/
+ * 
+ * The VL6180x by ST micro is a time of flight range finder that
+ * uses pulsed IR light to determine distances from object at close
+ * range.  The average range of a sensor is between 0-200mm
+ * 
+ * In this file are the functions in the VL6180x class
+ * 
+ * Resources:
+ * This library uses the Arduino Wire.h to complete I2C transactions.
+ * 
+ * Development environment specifics:
+ *  IDE: Arduino 1.0.5
+ *  Hardware Platform: Arduino Pro 3.3V/8MHz
+ *  VL6180x Breakout Version: 1.0
+ * 
+ * 
+ * This code is beerware. If you see me (or any other SparkFun employee) at the
+ * local pub, and you've found our code helpful, please buy us a round!
+ * 
+ * Distributed as-is; no warranty is given.
+ ******************************************************************************/
+
+
+#include "VL6180x.h"
+
+VL6180x::VL6180x(PinName sda, PinName scl, uint8_t addr) : m_i2c(sda, scl), m_addr(addr) {}
+int VL6180x::VL6180xInit(void){
+  uint8_t data; //for temp data storage
+
+  data = VL6180x_getRegister(VL6180X_SYSTEM_FRESH_OUT_OF_RESET);
+  wait_ms(50);
+  if(data != 1) return VL6180x_FAILURE_RESET;
+
+  //Required by datasheet
+  //http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
+  VL6180x_setRegister(0x0207, 0x01);
+  VL6180x_setRegister(0x0208, 0x01);
+  VL6180x_setRegister(0x0096, 0x00);
+  VL6180x_setRegister(0x0097, 0xfd);
+  VL6180x_setRegister(0x00e3, 0x00);
+  VL6180x_setRegister(0x00e4, 0x04);
+  VL6180x_setRegister(0x00e5, 0x02);
+  VL6180x_setRegister(0x00e6, 0x01);
+  VL6180x_setRegister(0x00e7, 0x03);
+  VL6180x_setRegister(0x00f5, 0x02);
+  VL6180x_setRegister(0x00d9, 0x05);
+  VL6180x_setRegister(0x00db, 0xce);
+  VL6180x_setRegister(0x00dc, 0x03);
+  VL6180x_setRegister(0x00dd, 0xf8);
+  VL6180x_setRegister(0x009f, 0x00);
+  VL6180x_setRegister(0x00a3, 0x3c);
+  VL6180x_setRegister(0x00b7, 0x00);
+  VL6180x_setRegister(0x00bb, 0x3c);
+  VL6180x_setRegister(0x00b2, 0x09);
+  VL6180x_setRegister(0x00ca, 0x09);  
+  VL6180x_setRegister(0x0198, 0x01);
+  VL6180x_setRegister(0x01b0, 0x17);
+  VL6180x_setRegister(0x01ad, 0x00);
+  VL6180x_setRegister(0x00ff, 0x05);
+  VL6180x_setRegister(0x0100, 0x05);
+  VL6180x_setRegister(0x0199, 0x05);
+  VL6180x_setRegister(0x01a6, 0x1b);
+  VL6180x_setRegister(0x01ac, 0x3e);
+  VL6180x_setRegister(0x01a7, 0x1f);
+  VL6180x_setRegister(0x0030, 0x00);
+
+  return 0;
+}
+VL6180x::~VL6180x(void) {
+};
+
+void VL6180x::VL6180xDefautSettings(void){
+  //Recommended settings from datasheet
+  //http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
+
+  //Enable Interrupts on Conversion Complete (any source)
+  VL6180x_setRegister(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, (4 << 3)|(4) ); // Set GPIO1 high when sample complete
+
+
+  VL6180x_setRegister(VL6180X_SYSTEM_MODE_GPIO1, 0x10); // Set GPIO1 high when sample complete
+  VL6180x_setRegister(VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD, 0x30); //Set Avg sample period
+  VL6180x_setRegister(VL6180X_SYSALS_ANALOGUE_GAIN, 0x46); // Set the ALS gain
+  VL6180x_setRegister(VL6180X_SYSRANGE_VHV_REPEAT_RATE, 0xFF); // Set auto calibration period (Max = 255)/(OFF = 0)
+  VL6180x_setRegister(VL6180X_SYSALS_INTEGRATION_PERIOD, 0x63); // Set ALS integration time to 100ms
+  VL6180x_setRegister(VL6180X_SYSRANGE_VHV_RECALIBRATE, 0x01); // perform a single temperature calibration
+  //Optional settings from datasheet
+  //http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
+  VL6180x_setRegister(VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09); // Set default ranging inter-measurement period to 100ms
+  VL6180x_setRegister(VL6180X_SYSALS_INTERMEASUREMENT_PERIOD, 0x0A); // Set default ALS inter-measurement period to 100ms
+  VL6180x_setRegister(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, 0x24); // Configures interrupt on ‘New Sample Ready threshold event’ 
+  //Additional settings defaults from community
+  VL6180x_setRegister(VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME, 0x32);
+  VL6180x_setRegister(VL6180X_SYSRANGE_RANGE_CHECK_ENABLES, 0x10 | 0x01);
+  VL6180x_setRegister16bit(VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, 0x7B );
+  VL6180x_setRegister16bit(VL6180X_SYSALS_INTEGRATION_PERIOD, 0x64);
+
+  VL6180x_setRegister(VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD,0x30);
+  VL6180x_setRegister(VL6180X_SYSALS_ANALOGUE_GAIN,0x40);
+  VL6180x_setRegister(VL6180X_FIRMWARE_RESULT_SCALER,0x01);
+}
+void VL6180x::getIdentification(struct VL6180xIdentification *temp){
+
+  temp->idModel =  VL6180x_getRegister(VL6180X_IDENTIFICATION_MODEL_ID);
+  temp->idModelRevMajor = VL6180x_getRegister(VL6180X_IDENTIFICATION_MODEL_REV_MAJOR);
+  temp->idModelRevMinor = VL6180x_getRegister(VL6180X_IDENTIFICATION_MODEL_REV_MINOR);
+  temp->idModuleRevMajor = VL6180x_getRegister(VL6180X_IDENTIFICATION_MODULE_REV_MAJOR);
+  temp->idModuleRevMinor = VL6180x_getRegister(VL6180X_IDENTIFICATION_MODULE_REV_MINOR);
+
+  temp->idDate = VL6180x_getRegister16bit(VL6180X_IDENTIFICATION_DATE);
+  temp->idTime = VL6180x_getRegister16bit(VL6180X_IDENTIFICATION_TIME);
+}
+
+
+uint8_t VL6180x::changeAddress(uint8_t old_address, uint8_t new_address){
+  
+  //NOTICE:  IT APPEARS THAT CHANGING THE ADDRESS IS NOT STORED IN NON-VOLATILE MEMORY
+  // POWER CYCLING THE DEVICE REVERTS ADDRESS BACK TO 0X29
+ 
+  if( old_address == new_address) return old_address;
+  if( new_address > 127) return old_address;
+   
+   VL6180x_setRegister(VL6180X_I2C_SLAVE_DEVICE_ADDRESS, new_address);
+   
+   return VL6180x_getRegister(VL6180X_I2C_SLAVE_DEVICE_ADDRESS); 
+}
+  
+
+
+uint8_t VL6180x::getDistance() {
+  uint8_t distance;
+  VL6180x_setRegister(VL6180X_SYSRANGE_START, 0x01); //Start Single shot mode
+  wait_ms(10);
+  distance = VL6180x_getRegister(VL6180X_RESULT_RANGE_VAL);
+  VL6180x_setRegister(VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07);
+  return distance;
+}
+
+float VL6180x::getAmbientLight(vl6180x_als_gain VL6180X_ALS_GAIN)
+{
+  //First load in Gain we are using, do it everytime incase someone changes it on us.
+  //Note: Upper nibble shoudl be set to 0x4 i.e. for ALS gain of 1.0 write 0x46
+  VL6180x_setRegister(VL6180X_SYSALS_ANALOGUE_GAIN, (0x40 | VL6180X_ALS_GAIN)); // Set the ALS gain
+
+  //Start ALS Measurement 
+  VL6180x_setRegister(VL6180X_SYSALS_START, 0x01);
+
+    wait_ms(100); //give it time... 
+
+  VL6180x_setRegister(VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07);
+
+  //Retrieve the Raw ALS value from the sensoe
+  unsigned int alsRaw = VL6180x_getRegister16bit(VL6180X_RESULT_ALS_VAL);
+  
+  //Get Integration Period for calculation, we do this everytime incase someone changes it on us.
+  unsigned int alsIntegrationPeriodRaw = VL6180x_getRegister16bit(VL6180X_SYSALS_INTEGRATION_PERIOD);
+  
+  float alsIntegrationPeriod = 100.0 / alsIntegrationPeriodRaw ;
+
+  //Calculate actual LUX from Appnotes
+
+  float alsGain = 0.0;
+  
+  switch (VL6180X_ALS_GAIN){
+    case GAIN_20: alsGain = 20.0; break;
+    case GAIN_10: alsGain = 10.32; break;
+    case GAIN_5: alsGain = 5.21; break;
+    case GAIN_2_5: alsGain = 2.60; break;
+    case GAIN_1_67: alsGain = 1.72; break;
+    case GAIN_1_25: alsGain = 1.28; break;
+    case GAIN_1: alsGain = 1.01; break;
+    case GAIN_40: alsGain = 40.0; break;
+  }
+
+//Calculate LUX from formula in AppNotes
+  
+  float alsCalculated = (float)0.32 * ((float)alsRaw / alsGain) * alsIntegrationPeriod;
+
+  return alsCalculated;
+}
+
+// --- Private Functions --- //
+
+uint8_t VL6180x::VL6180x_getRegister(uint16_t registerAddr)
+{
+  uint8_t data;
+  char data_write[2];
+  char data_read[1];
+  data_write[0] = (registerAddr >> 8) & 0xFF; //MSB of register address 
+  data_write[1] = registerAddr & 0xFF; //LSB of register address 
+  m_i2c.write(m_addr, data_write, 2,0); 
+  m_i2c.read(m_addr,data_read,1,1);
+  //Read Data from selected register
+  data=data_read[0];
+  return data;
+}
+
+uint16_t VL6180x::VL6180x_getRegister16bit(uint16_t registerAddr)
+{
+  uint8_t data_low;
+  uint8_t data_high;
+  uint16_t data;
+
+  char data_write[2];
+  char data_read[2];
+  data_write[0] = (registerAddr >> 8) & 0xFF; //MSB of register address 
+  data_write[1] = registerAddr & 0xFF; //LSB of register address 
+  m_i2c.write(m_addr, data_write, 2,0); 
+  m_i2c.read(m_addr,data_read,2,1);
+  data_high = data_read[0]; //Read Data from selected register
+  data_low = data_read[1]; //Read Data from selected register
+  data = (data_high << 8)|data_low;
+
+  return data;
+}
+
+void VL6180x::VL6180x_setRegister(uint16_t registerAddr, uint8_t data)
+{
+    char data_write[3];
+    data_write[0] = (registerAddr >> 8) & 0xFF; //MSB of register address 
+    data_write[1] = registerAddr & 0xFF; //LSB of register address 
+    data_write[2] = data & 0xFF; 
+    m_i2c.write(m_addr, data_write, 3); 
+}
+
+void VL6180x::VL6180x_setRegister16bit(uint16_t registerAddr, uint16_t data)
+{
+    char data_write[4];
+    data_write[0] = (registerAddr >> 8) & 0xFF; //MSB of register address 
+    data_write[1] = registerAddr & 0xFF; //LSB of register address 
+    data_write[2] = (data >> 8) & 0xFF;
+    data_write[3] = data & 0xFF; 
+    m_i2c.write(m_addr, data_write, 4); 
+}

diff -r 000000000000 -r 84fb42fedc5b VL6180x.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VL6180x.h	Tue Jul 07 20:36:43 2015 +0000
@@ -0,0 +1,319 @@
+/**
+* @file VL6180x.h
+ * @brief Library for VL6180x time of flight range finder.
+ * Casey Kuhns @ SparkFun Electronics
+ * 10/29/2014
+ * https://github.com/sparkfun/
+ * 
+ * The VL6180x by ST micro is a time of flight range finder that
+ * uses pulsed IR light to determine distances from object at close
+ * range.  The average range of a sensor is between 0-200mm
+ * 
+ * In this file are the function prototypes in the VL6180x class
+ * 
+ * Resources:
+ * This library uses the Arduino Wire.h to complete I2C transactions.
+ * 
+ * Development environment specifics:
+ *  IDE: Arduino 1.0.5
+ *  Hardware Platform: Arduino Pro 3.3V/8MHz
+ *  VL6180x Breakout Version: 1.0
+ * 
+ * Some settings and initial values come from code written by Kris Winer
+ * VL6180X_t3 Basic Example Code
+ * by: Kris Winer
+ * date: September 1, 2014
+ * license: Beerware - Use this code however you'd like. If you 
+ * find it useful you can buy me a beer some time.
+ * 
+ * This code is beerware. If you see me (or any other SparkFun employee) at the
+ * local pub, and you've found our code helpful, please buy us a round!
+ * 
+ * Distributed as-is; no warranty is given.
+*/
+#include "mbed.h"
+#ifndef VL6180x_h
+#define VL6180x_h
+
+#define VL6180x_FAILURE_RESET  -1
+
+#define VL6180X_IDENTIFICATION_MODEL_ID              0x0000
+#define VL6180X_IDENTIFICATION_MODEL_REV_MAJOR       0x0001
+#define VL6180X_IDENTIFICATION_MODEL_REV_MINOR       0x0002
+#define VL6180X_IDENTIFICATION_MODULE_REV_MAJOR      0x0003
+#define VL6180X_IDENTIFICATION_MODULE_REV_MINOR      0x0004
+#define VL6180X_IDENTIFICATION_DATE                  0x0006 //16bit value
+#define VL6180X_IDENTIFICATION_TIME                  0x0008 //16bit value
+
+#define VL6180X_SYSTEM_MODE_GPIO0                    0x0010
+#define VL6180X_SYSTEM_MODE_GPIO1                    0x0011
+#define VL6180X_SYSTEM_HISTORY_CTRL                  0x0012
+#define VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO         0x0014
+#define VL6180X_SYSTEM_INTERRUPT_CLEAR               0x0015
+#define VL6180X_SYSTEM_FRESH_OUT_OF_RESET            0x0016
+#define VL6180X_SYSTEM_GROUPED_PARAMETER_HOLD        0x0017
+
+#define VL6180X_SYSRANGE_START                       0x0018
+#define VL6180X_SYSRANGE_THRESH_HIGH                 0x0019
+#define VL6180X_SYSRANGE_THRESH_LOW                  0x001A
+#define VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD     0x001B
+#define VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME        0x001C
+#define VL6180X_SYSRANGE_CROSSTALK_COMPENSATION_RATE 0x001E
+#define VL6180X_SYSRANGE_CROSSTALK_VALID_HEIGHT      0x0021
+#define VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE  0x0022
+#define VL6180X_SYSRANGE_PART_TO_PART_RANGE_OFFSET   0x0024
+#define VL6180X_SYSRANGE_RANGE_IGNORE_VALID_HEIGHT   0x0025
+#define VL6180X_SYSRANGE_RANGE_IGNORE_THRESHOLD      0x0026
+#define VL6180X_SYSRANGE_MAX_AMBIENT_LEVEL_MULT      0x002C
+#define VL6180X_SYSRANGE_RANGE_CHECK_ENABLES         0x002D
+#define VL6180X_SYSRANGE_VHV_RECALIBRATE             0x002E
+#define VL6180X_SYSRANGE_VHV_REPEAT_RATE             0x0031
+
+#define VL6180X_SYSALS_START                         0x0038
+#define VL6180X_SYSALS_THRESH_HIGH                   0x003A
+#define VL6180X_SYSALS_THRESH_LOW                    0x003C
+#define VL6180X_SYSALS_INTERMEASUREMENT_PERIOD       0x003E
+#define VL6180X_SYSALS_ANALOGUE_GAIN                 0x003F
+#define VL6180X_SYSALS_INTEGRATION_PERIOD            0x0040
+
+#define VL6180X_RESULT_RANGE_STATUS                  0x004D
+#define VL6180X_RESULT_ALS_STATUS                    0x004E
+#define VL6180X_RESULT_INTERRUPT_STATUS_GPIO         0x004F
+#define VL6180X_RESULT_ALS_VAL                       0x0050
+#define VL6180X_RESULT_HISTORY_BUFFER                0x0052 
+#define VL6180X_RESULT_RANGE_VAL                     0x0062
+#define VL6180X_RESULT_RANGE_RAW                     0x0064
+#define VL6180X_RESULT_RANGE_RETURN_RATE             0x0066
+#define VL6180X_RESULT_RANGE_REFERENCE_RATE          0x0068
+#define VL6180X_RESULT_RANGE_RETURN_SIGNAL_COUNT     0x006C
+#define VL6180X_RESULT_RANGE_REFERENCE_SIGNAL_COUNT  0x0070
+#define VL6180X_RESULT_RANGE_RETURN_AMB_COUNT        0x0074
+#define VL6180X_RESULT_RANGE_REFERENCE_AMB_COUNT     0x0078
+#define VL6180X_RESULT_RANGE_RETURN_CONV_TIME        0x007C
+#define VL6180X_RESULT_RANGE_REFERENCE_CONV_TIME     0x0080
+
+#define VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD      0x010A
+#define VL6180X_FIRMWARE_BOOTUP                      0x0119
+#define VL6180X_FIRMWARE_RESULT_SCALER               0x0120
+#define VL6180X_I2C_SLAVE_DEVICE_ADDRESS             0x0212
+#define VL6180X_INTERLEAVED_MODE_ENABLE              0x02A3
+
+/**
+* gain settings for ALS
+*Data sheet shows gain values as binary list
+*/
+enum vl6180x_als_gain { 
+
+GAIN_20 = 0, // Actual ALS Gain of 20
+GAIN_10,     // Actual ALS Gain of 10.32
+GAIN_5,      // Actual ALS Gain of 5.21
+GAIN_2_5,    // Actual ALS Gain of 2.60
+GAIN_1_67,   // Actual ALS Gain of 1.72
+GAIN_1_25,   // Actual ALS Gain of 1.28
+GAIN_1 ,     // Actual ALS Gain of 1.01
+GAIN_40,     // Actual ALS Gain of 40
+
+};
+/**
+* VL6180xIdentification
+* @brief structure to hold module identification
+*
+* @param idModel Model number
+* @param idModelRevMajor Major revision
+* @param idModelRevMinor Minor revision
+* @param idModuleRevMajor Module Major revision
+* @param idModuleRevMinor Module Minor revision
+* @param idDate Date of manufacture
+* @param idTime Seconds after midnight manufacture
+*/
+struct VL6180xIdentification {
+  uint8_t idModel;
+  uint8_t idModelRevMajor;
+  uint8_t idModelRevMinor;
+  uint8_t idModuleRevMajor;
+  uint8_t idModuleRevMinor;
+  uint16_t idDate;
+  uint16_t idTime;
+};
+/**
+* VL6180x tof/als sensor example
+*
+* @code
+#include "mbed.h"
+#include <VL6180x.h>
+
+const float GAIN_1    = 1.01;  // Actual ALS Gain of 1.01
+const float GAIN_1_25 = 1.28;  // Actual ALS Gain of 1.28
+const float GAIN_1_67 = 1.72;  // Actual ALS Gain of 1.72
+const float GAIN_2_5  = 2.6;   // Actual ALS Gain of 2.60
+const float GAIN_5    = 5.21;  // Actual ALS Gain of 5.21
+const float GAIN_10   = 10.32; // Actual ALS Gain of 10.32
+const float GAIN_20   = 20;    // Actual ALS Gain of 20
+const float GAIN_40   = 40;    // Actual ALS Gain of 40
+
+
+#define VL6180X_ADDRESS 0x29
+
+VL6180xIdentification identification;
+// mbed uses 8bit addresses shift address by 1 bit left
+VL6180x sensor(D14, D15, VL6180X_ADDRESS<<1);
+
+void printIdentification(struct VL6180xIdentification *temp){
+  printf("Model ID = ");
+  printf("%d\n",temp->idModel);
+
+  printf("Model Rev = ");
+  printf("%d",temp->idModelRevMajor);
+  printf(".");
+  printf("%d\n",temp->idModelRevMinor);
+
+  printf("Module Rev = ");
+  printf("%d",temp->idModuleRevMajor);
+  printf(".");
+  printf("%d\n",temp->idModuleRevMinor);  
+
+  printf("Manufacture Date = ");
+  printf("%d",((temp->idDate >> 3) & 0x001F));
+  printf("/");
+  printf("%d",((temp->idDate >> 8) & 0x000F));
+  printf("/1");
+  printf("%d\n",((temp->idDate >> 12) & 0x000F));
+  printf(" Phase: ");
+  printf("%d\n",(temp->idDate & 0x0007));
+
+  printf("Manufacture Time (s)= ");
+  printf("%d\n",(temp->idTime * 2));
+  printf("\n\n");
+}
+int main() {
+
+  wait_ms(100); // delay .1s
+
+  sensor.getIdentification(&identification); // Retrieve manufacture info from device memory
+  printIdentification(&identification); // Helper function to print all the Module information
+
+  if(sensor.VL6180xInit() != 0){
+        printf("FAILED TO INITALIZE\n"); //Initialize device and check for errors
+  }; 
+
+  sensor.VL6180xDefautSettings(); //Load default settings to get started.
+  
+    wait_ms(1000); // delay 1s
+
+    
+    
+    while(1) {
+  //Get Ambient Light level and report in LUX
+      printf("Ambient Light Level (Lux) = ");
+  
+  //Input GAIN for light levels, 
+  // GAIN_20     // Actual ALS Gain of 20
+  // GAIN_10     // Actual ALS Gain of 10.32
+  // GAIN_5      // Actual ALS Gain of 5.21
+  // GAIN_2_5    // Actual ALS Gain of 2.60
+  // GAIN_1_67   // Actual ALS Gain of 1.72
+  // GAIN_1_25   // Actual ALS Gain of 1.28
+  // GAIN_1      // Actual ALS Gain of 1.01
+  // GAIN_40     // Actual ALS Gain of 40
+  
+      printf("%f\n",sensor.getAmbientLight(GAIN_1) );
+
+  //Get Distance and report in mm
+      printf("Distance measured (mm) = ");
+      printf("%d\n", sensor.getDistance() ); 
+
+      wait_ms(500);  
+    }
+}
+* @endcode
+*/
+class VL6180x
+{
+public: 
+/**
+* VL6180x constructor
+*
+* @param sda SDA pin
+* @param sdl SCL pin
+* @param addr addr of the I2C peripheral
+*/
+  VL6180x(PinName sda, PinName scl, uint8_t addr);
+/**
+* VL6180x destructor
+*/
+  ~VL6180x();
+/**
+* Send mandatory settings as stated in ST datasheet.
+* http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf (Section 1.3)
+* @returns 0 if ok 
+* @returns -1 on error*/
+  int VL6180xInit(void);
+/**
+* Use default settings from ST data sheet section 9.
+*
+* http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/DM00122600.pdf
+*/
+  void VL6180xDefautSettings(void);
+/**
+* Get Range distance in (mm)
+* @returns TOF distance in mm  
+*/
+  uint8_t getDistance();
+/**
+* Get ALS level in Lux
+* @param vl6180x_als_gain gain setting for sensor
+* @param sdl SCL pin
+* @param addr addr of the I2C peripheral
+* @returns light level in Lux 
+*/
+  float getAmbientLight(vl6180x_als_gain VL6180X_ALS_GAIN);
+/**
+* Load structure provided by the user with identification info
+* Structure example:
+* struct VL6180xIdentification
+*/
+  void getIdentification(struct VL6180xIdentification *temp);
+
+/**
+* Change the default address of the device to allow multiple
+* sensors on the bus.  Can use up to 127 sensors. New address
+* is saved in non-volatile device memory.
+* @param old_address current address
+* @param new_address desired new address
+* @returns new address
+*/
+  uint8_t changeAddress(uint8_t old_address, uint8_t new_address);
+
+
+private:
+  //Store address given when the class is initialized.
+  //This value can be changed by the changeAddress() function
+  I2C m_i2c;
+  int m_addr;
+/**
+* read 8 bit register
+* @param registerAddr address for register
+* @returns contents of register
+*/
+  uint8_t VL6180x_getRegister(uint16_t registerAddr);
+/**
+* read 16 bit register
+* @param registerAddr address for register
+* @param returns contents of register
+*/
+uint16_t VL6180x_getRegister16bit(uint16_t registerAddr);
+/**
+* write 8 bit register
+* @param registerAddr address for register
+* @returns ERROR
+*/
+  void VL6180x_setRegister(uint16_t registerAddr, uint8_t data);
+/**
+* write 16 bit register
+* @param registerAddr address for register
+* @returns ERROR
+*/
+  void VL6180x_setRegister16bit(uint16_t registerAddr, uint16_t data);
+};
+
+#endif