Revision 0:4b56d28cc7e9, committed 2015-12-02

Comitter:

quicksand

Date:

Wed Dec 02 11:39:52 2015 +0000

Child:

1:acabcc8fed83

Commit message:

This library demonstrates how to use the sensors on the QW Shield.

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LinearTempSensor.cpp	Wed Dec 02 11:39:52 2015 +0000
@@ -0,0 +1,92 @@
+/* mbed Linear Temperature Sensor library
+ * Supports Microchip MCP9700/9701, National Semiconductor LM35
+ *
+ * Written by Todotani, Nov 22 2010
+ */
+
+#include "LinearTempSensor.h"
+
+LinearTempSensor::LinearTempSensor(PinName ain, int N, SensorType type):
+        // Initialize private variables using Initialization Lists
+        // _ain(ain) is equivalent to _ain = new AnalogIn(ain)
+        // _sample(N) is equivalent to _sample = N
+        _ain(ain), _samples(N), _type(type) {
+    sampleBuffer = (float *)malloc(sizeof(float) * _samples);
+    sampleCount = 0;
+    index       = 0;
+    Vref        = 3300;
+    bufferNotFilled = true;
+
+    // Set constants to calculate temperature from sensor value
+    switch (_type) {
+        case LM35:
+            V0 = 0.0f;
+            Tc = 10.0f;
+            break;
+      case MCP9701:
+            V0 = 400.0f;
+            Tc = 19.5f;
+            break;
+      case MCP9700:
+       default:
+            V0 = 500.0f;
+            Tc = 10.0f;
+    }
+    
+    for (int i = 0; i < _samples; i++)
+        sampleBuffer[i] = 0.0f;
+}
+
+
+LinearTempSensor::~LinearTempSensor() {
+    free(sampleBuffer);
+}
+
+
+float LinearTempSensor::Sense() {
+    float val;
+
+    val = _ain * Vref;
+    sampleBuffer[index] = val;
+    //printf("Index:%d  ", index);    // Debug print
+    if ( ++index >= _samples )
+        index = 0;
+
+    if ( bufferNotFilled && (sampleCount == _samples) ) {
+        bufferNotFilled = false;
+    }
+    //printf("flag:%d  ", bufferNotFilled);   // Debug print
+    sampleCount++;
+
+    return val;
+}
+
+
+float LinearTempSensor::GetAverageTemp() {
+    float sum = 0;
+    int i, numberOfsumples;
+
+    if (sampleCount == 0)
+        return 0;
+
+    if (bufferNotFilled) {
+        // In case number of samples less than buffer lenght
+        for (i = 0; i < sampleCount; i++) {
+            sum += sampleBuffer[i];
+        }
+        numberOfsumples = sampleCount;
+    } else {
+        // In case buffer is filled
+        for (i = 0; i < _samples; i++) {
+            sum += sampleBuffer[i];
+        }
+        numberOfsumples = _samples;
+    }
+
+    return ((sum / numberOfsumples) - V0) / Tc;    //  Temp = (Vout - V0) / Tc
+}
+
+
+float LinearTempSensor::GetLatestTemp() {
+    return (sampleBuffer[(sampleCount-1)%_samples] - V0) / Tc;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LinearTempSensor.h	Wed Dec 02 11:39:52 2015 +0000
@@ -0,0 +1,73 @@
+/* mbed Linear Temperature Sensor library
+ * Supports Microchip MCP9700/9701, National Semiconductor LM35
+ *
+ * Written by Todotani, Nov 22 2010
+ */
+ 
+#ifndef MBED_LINEARTEMPSENSOR_H
+#define MBED_LINEARTEMPSENSOR_H
+
+#include "mbed.h"
+
+/** Linear Temperature Sensor class.
+ * Sample and store sensor acuired value in N (default=10) times and
+ * calculate avarage temperature from sampled data
+ * Supports Microchip MCP9700/9701, National Semiconductor LM35
+ * @author Todotani
+ */
+class LinearTempSensor {
+public:
+    /** Sensor Type Definitions  */
+    enum SensorType {
+        MCP9700,    /**< Microchip MCP9700 (Default)  */
+        MCP9701,    /**< Microchip MCP9701 */
+        LM35        /**< National Semiconductor LM35 */
+    };
+    
+    /** Create a Temperature Sensor instanse
+     *
+     * @param ain       PinName of analog input
+     * @param N         Number of samples to calculate average temperature (default = 10)
+     * @param type      Sensor type (default = MCP9700)
+     */
+    LinearTempSensor(PinName ain, int N = 10, SensorType type = MCP9700);
+    
+    /** Sample (read) sensor data and store to buffer
+     *
+     * @param None
+     * @return Sensor-acuired value (mV)
+     */
+     float Sense();
+     
+    /** Calculate average temperature from sample buffer
+     *
+     * @param None
+     * @return Average temperature from N times of sumple (Centigrade)
+     */
+     float GetAverageTemp();
+     
+    /** Calculate temperature from the latest sample
+     *
+     * @param None
+     * @return Temperature from the latest sampled data (Centigrade)
+     */
+     float GetLatestTemp();
+
+     ~LinearTempSensor();
+
+private:
+    AnalogIn    _ain;
+    int         _samples;
+    SensorType  _type;
+    
+    float       *sampleBuffer;      // Buffer to store sensor acuired data
+    bool        bufferNotFilled;    // Flag shows that buffer have not filled
+    uint32_t    sampleCount;
+    uint32_t    index;
+
+    float   V0;                      // Sensor read value in case 0 degree
+    float   Tc;                      // Tmperature coefficient (temprature inclease) in each degree
+    float   Vref;                    // Reference volgate for ADC
+};
+
+#endif
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VCNL4010.cpp	Wed Dec 02 11:39:52 2015 +0000
@@ -0,0 +1,287 @@
+/*
+Copyright (c) 2012 Vishay GmbH, www.vishay.com
+author: DS, version 1.21
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include "VCNL4010.h"
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0::VCNL40x0(PinName sda, PinName scl, unsigned char addr) : _i2c(sda, scl), _addr(addr) {
+   // _i2c.frequency(1000000);                                // set I2C frequency to 1MHz
+}
+
+VCNL40x0::~VCNL40x0() {
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetCommandRegister (unsigned char Command) {
+
+    _send[0] = REGISTER_COMMAND;                            // VCNL40x0 Configuration reister
+    _send[1] = Command;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadCommandRegister (unsigned char *Command) {
+
+    _send[0] = REGISTER_COMMAND;                            // VCNL40x0 Configuration register
+    _i2c.write(VCNL40x0_ADDRESS,_send, 1);                  // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1,_receive, 1);              // Read 1 byte on I2C
+
+    *Command = (unsigned char)(_receive[0]);
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadID (unsigned char *ID) {
+
+    _send[0] = REGISTER_ID;                                 // VCNL40x0 product ID revision register
+    _i2c.write(VCNL40x0_ADDRESS, _send, 1);                 // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1, _receive, 1);             // Read 1 byte on I2C
+
+    *ID = (unsigned char)(_receive[0]);
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetCurrent (unsigned char Current) {
+
+    _send[0] = REGISTER_PROX_CURRENT;                       // VCNL40x0 IR LED Current register
+    _send[1] = Current;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadCurrent (unsigned char *Current) {
+
+    _send[0] = REGISTER_PROX_CURRENT;                       // VCNL40x0 IR LED current register
+    _i2c.write(VCNL40x0_ADDRESS,_send, 1);                  // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1,_receive, 1);              // Read 1 byte on I2C
+
+    *Current = (unsigned char)(_receive[0]);
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetProximityRate (unsigned char ProximityRate) {
+
+    _send[0] = REGISTER_PROX_RATE;                          // VCNL40x0 Proximity rate register
+    _send[1] = ProximityRate;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetAmbiConfiguration (unsigned char AmbiConfiguration) {
+
+    _send[0] = REGISTER_AMBI_PARAMETER;                     // VCNL40x0 Ambilight configuration
+    _send[1] = AmbiConfiguration;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetInterruptControl (unsigned char InterruptControl) {
+
+    _send[0] = REGISTER_INTERRUPT_CONTROL;                  // VCNL40x0 Interrupt Control register
+    _send[1] = InterruptControl;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadInterruptControl (unsigned char *InterruptControl) {
+
+    _send[0] = REGISTER_INTERRUPT_CONTROL;                  // VCNL40x0 Interrupt Control register
+    _i2c.write(VCNL40x0_ADDRESS,_send, 1);                  // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1,_receive, 1);              // Read 1 byte on I2C
+
+    *InterruptControl = (unsigned char)(_receive[0]);
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetInterruptStatus (unsigned char InterruptStatus) {
+
+    _send[0] = REGISTER_INTERRUPT_STATUS;                   // VCNL40x0 Interrupt Status register
+    _send[1] = InterruptStatus;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetModulatorTimingAdjustment (unsigned char ModulatorTimingAdjustment) {
+
+    _send[0] = REGISTER_PROX_TIMING;                        // VCNL40x0 Modulator Timing Adjustment register
+    _send[1] = ModulatorTimingAdjustment;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadInterruptStatus (unsigned char *InterruptStatus) {
+
+    _send[0] = REGISTER_INTERRUPT_STATUS;                   // VCNL40x0 Interrupt Status register
+    _i2c.write(VCNL40x0_ADDRESS,_send, 1);                  // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1,_receive, 1);              // Read 1 byte on I2C
+
+    *InterruptStatus = (unsigned char)(_receive[0]);
+
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadProxiValue (unsigned int *ProxiValue) {
+
+    _send[0] = REGISTER_PROX_VALUE;                         // VCNL40x0 Proximity Value register
+    _i2c.write(VCNL40x0_ADDRESS, _send, 1);                 // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1, _receive, 2);             // Read 2 bytes on I2C
+    *ProxiValue = ((unsigned int)_receive[0] << 8 | (unsigned char)_receive[1]);
+
+    return VCNL40x0_ERROR_OK;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadAmbiValue (unsigned int *AmbiValue) {
+
+    _send[0] = REGISTER_AMBI_VALUE;                          // VCNL40x0 Ambient Light Value register
+    _i2c.write(VCNL40x0_ADDRESS, _send, 1);                  // Write 1 byte on I2C
+    _i2c.read(VCNL40x0_ADDRESS+1, _receive, 2);              // Read 2 bytes on I2C
+    *AmbiValue = ((unsigned int)_receive[0] << 8 | (unsigned char)_receive[1]);
+
+    return VCNL40x0_ERROR_OK;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetLowThreshold (unsigned int LowThreshold) {
+
+    unsigned char LoByte=0, HiByte=0;
+    
+    LoByte = (unsigned char)(LowThreshold & 0x00ff);
+    HiByte = (unsigned char)((LowThreshold & 0xff00)>>8);
+    
+    _send[0] = REGISTER_INTERRUPT_LOW_THRES;                // VCNL40x0 Low Threshold Register, Hi Byte
+    _send[1] = HiByte;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+    
+    _send[0] = REGISTER_INTERRUPT_LOW_THRES+1;              // VCNL40x0 Low Threshold Register, Lo Byte
+    _send[1] = LoByte;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::SetHighThreshold (unsigned int HighThreshold) {
+
+    unsigned char LoByte=0, HiByte=0;
+    
+    LoByte = (unsigned char)(HighThreshold & 0x00ff);
+    HiByte = (unsigned char)((HighThreshold & 0xff00)>>8);
+    
+    _send[0] = REGISTER_INTERRUPT_HIGH_THRES;               // VCNL40x0 High Threshold Register, Hi Byte
+    _send[1] = HiByte;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+    
+    _send[0] = REGISTER_INTERRUPT_HIGH_THRES+1;             // VCNL40x0 High Threshold Register, Lo Byte
+    _send[1] = LoByte;
+    _i2c.write(VCNL40x0_ADDRESS,_send, 2);                  // Write 2 bytes on I2C
+
+    return VCNL40x0_ERROR_OK;
+
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadProxiOnDemand (unsigned int *ProxiValue) {
+
+    unsigned char Command=0;
+
+    // enable prox value on demand
+    SetCommandRegister (COMMAND_PROX_ENABLE | COMMAND_PROX_ON_DEMAND);
+ 
+    // wait on prox data ready bit
+    do {
+        ReadCommandRegister (&Command);                     // read command register
+    } while (!(Command & COMMAND_MASK_PROX_DATA_READY));
+
+    ReadProxiValue (ProxiValue);                            // read prox value
+
+    SetCommandRegister (COMMAND_ALL_DISABLE);               // stop prox value on demand
+    
+    return VCNL40x0_ERROR_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+VCNL40x0Error_e VCNL40x0::ReadAmbiOnDemand (unsigned int *AmbiValue) {
+
+    unsigned char Command=0;
+
+    // enable ambi value on demand
+    SetCommandRegister (COMMAND_PROX_ENABLE | COMMAND_AMBI_ON_DEMAND);
+
+    // wait on ambi data ready bit
+    do {
+        ReadCommandRegister (&Command);                     // read command register
+    } while (!(Command & COMMAND_MASK_AMBI_DATA_READY));
+
+    ReadAmbiValue (AmbiValue);                              // read ambi value    
+
+    SetCommandRegister (COMMAND_ALL_DISABLE);               // stop ambi value on demand    
+
+    return VCNL40x0_ERROR_OK;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/VCNL4010.h	Wed Dec 02 11:39:52 2015 +0000
@@ -0,0 +1,188 @@
+/*
+Copyright (c) 2012 Vishay GmbH, www.vishay.com
+author: DS, version 1.2
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#ifndef VCNL40x0_H
+#define VCNL40x0_H
+
+#include "mbed.h"
+
+// Library for the Vishay Proximity/Ambient Light Sensor VCNL4010/4020
+// The VCNL4x00 is a I2C digital Proximity and Ambient Light Sensor in a small SMD package
+
+#define VCNL40x0_ADDRESS               (0x26) // 001 0011 shifted left 1 bit = 0x26
+
+// registers 
+#define REGISTER_COMMAND               (0x80)
+#define REGISTER_ID                    (0x81)
+#define REGISTER_PROX_RATE             (0x82)
+#define REGISTER_PROX_CURRENT          (0x83)
+#define REGISTER_AMBI_PARAMETER        (0x84)
+#define REGISTER_AMBI_VALUE            (0x85)
+#define REGISTER_PROX_VALUE            (0x87)
+#define REGISTER_INTERRUPT_CONTROL     (0x89)
+#define REGISTER_INTERRUPT_LOW_THRES   (0x8a)
+#define REGISTER_INTERRUPT_HIGH_THRES  (0x8c)
+#define REGISTER_INTERRUPT_STATUS      (0x8e)
+#define REGISTER_PROX_TIMING           (0x8f)
+#define REGISTER_AMBI_IR_LIGHT_LEVEL   (0x90)   // This register is not intended to be use by customer
+
+// Bits in Command register (0x80)
+#define COMMAND_ALL_DISABLE            (0x00)
+#define COMMAND_SELFTIMED_MODE_ENABLE  (0x01)
+#define COMMAND_PROX_ENABLE            (0x02)
+#define COMMAND_AMBI_ENABLE            (0x04)
+#define COMMAND_PROX_ON_DEMAND         (0x08)
+#define COMMAND_AMBI_ON_DEMAND         (0x10)
+#define COMMAND_MASK_PROX_DATA_READY   (0x20)
+#define COMMAND_MASK_AMBI_DATA_READY   (0x40)
+#define COMMAND_MASK_LOCK              (0x80)
+
+// Bits in Product ID Revision Register (0x81)
+#define PRODUCT_MASK_REVISION_ID       (0x0f)
+#define PRODUCT_MASK_PRODUCT_ID        (0xf0)
+
+// Bits in Prox Measurement Rate register (0x82)
+#define PROX_MEASUREMENT_RATE_2        (0x00)   // DEFAULT
+#define PROX_MEASUREMENT_RATE_4        (0x01)
+#define PROX_MEASUREMENT_RATE_8        (0x02)
+#define PROX_MEASUREMENT_RATE_16       (0x03)
+#define PROX_MEASUREMENT_RATE_31       (0x04)
+#define PROX_MEASUREMENT_RATE_62       (0x05)
+#define PROX_MEASUREMENT_RATE_125      (0x06)
+#define PROX_MEASUREMENT_RATE_250      (0x07)
+#define PROX_MASK_MEASUREMENT_RATE     (0x07)
+
+// Bits in Procimity LED current setting (0x83)
+#define PROX_MASK_LED_CURRENT          (0x3f)   // DEFAULT = 2
+#define PROX_MASK_FUSE_PROG_ID         (0xc0)
+
+// Bits in Ambient Light Parameter register (0x84)
+#define AMBI_PARA_AVERAGE_1            (0x00)
+#define AMBI_PARA_AVERAGE_2            (0x01)
+#define AMBI_PARA_AVERAGE_4            (0x02)
+#define AMBI_PARA_AVERAGE_8            (0x03)
+#define AMBI_PARA_AVERAGE_16           (0x04)
+#define AMBI_PARA_AVERAGE_32           (0x05)   // DEFAULT
+#define AMBI_PARA_AVERAGE_64           (0x06)
+#define AMBI_PARA_AVERAGE_128          (0x07)
+#define AMBI_MASK_PARA_AVERAGE         (0x07)
+
+#define AMBI_PARA_AUTO_OFFSET_ENABLE   (0x08)   // DEFAULT enable
+#define AMBI_MASK_PARA_AUTO_OFFSET     (0x08)
+
+#define AMBI_PARA_MEAS_RATE_1          (0x00)
+#define AMBI_PARA_MEAS_RATE_2          (0x10)   // DEFAULT
+#define AMBI_PARA_MEAS_RATE_3          (0x20)
+#define AMBI_PARA_MEAS_RATE_4          (0x30)
+#define AMBI_PARA_MEAS_RATE_5          (0x40)
+#define AMBI_PARA_MEAS_RATE_6          (0x50)
+#define AMBI_PARA_MEAS_RATE_8          (0x60)
+#define AMBI_PARA_MEAS_RATE_10         (0x70)
+#define AMBI_MASK_PARA_MEAS_RATE       (0x70)
+
+#define AMBI_PARA_CONT_CONV_ENABLE     (0x80)
+#define AMBI_MASK_PARA_CONT_CONV       (0x80)   // DEFAULT disable
+
+// Bits in Interrupt Control Register (x89)
+#define INTERRUPT_THRES_SEL_PROX       (0x00)
+#define INTERRUPT_THRES_SEL_ALS        (0x01)
+
+#define INTERRUPT_THRES_ENABLE         (0x02)
+
+#define INTERRUPT_ALS_READY_ENABLE     (0x04)
+
+#define INTERRUPT_PROX_READY_ENABLE    (0x08)
+
+#define INTERRUPT_COUNT_EXCEED_1       (0x00)   // DEFAULT
+#define INTERRUPT_COUNT_EXCEED_2       (0x20)
+#define INTERRUPT_COUNT_EXCEED_4       (0x40)
+#define INTERRUPT_COUNT_EXCEED_8       (0x60)
+#define INTERRUPT_COUNT_EXCEED_16      (0x80)
+#define INTERRUPT_COUNT_EXCEED_32      (0xa0)
+#define INTERRUPT_COUNT_EXCEED_64      (0xc0)
+#define INTERRUPT_COUNT_EXCEED_128     (0xe0)
+#define INTERRUPT_MASK_COUNT_EXCEED    (0xe0) 
+
+// Bits in Interrupt Status Register (x8e)
+#define INTERRUPT_STATUS_THRES_HI      (0x01)
+#define INTERRUPT_STATUS_THRES_LO      (0x02)
+#define INTERRUPT_STATUS_ALS_READY     (0x04)
+#define INTERRUPT_STATUS_PROX_READY    (0x08)
+#define INTERRUPT_MASK_STATUS_THRES_HI (0x01)
+#define INTERRUPT_MASK_THRES_LO        (0x02)
+#define INTERRUPT_MASK_ALS_READY       (0x04)
+#define INTERRUPT_MASK_PROX_READY      (0x08)
+
+typedef enum {
+    VCNL40x0_ERROR_OK = 0,               // Everything executed normally
+    VCNL40x0_ERROR_I2CINIT,              // Unable to initialise I2C
+    VCNL40x0_ERROR_I2CBUSY,              // I2C already in use
+    VCNL40x0_ERROR_LAST
+} VCNL40x0Error_e;
+
+
+class VCNL40x0 {
+public:
+// Creates an instance of the class.
+// Connect module at I2C address addr using I2C port pins sda and scl.
+
+    VCNL40x0 (PinName sda, PinName scl, unsigned char addr);
+
+// Destroys instance
+
+    ~VCNL40x0();
+
+// public functions
+
+    VCNL40x0Error_e Init (void);
+    
+    VCNL40x0Error_e SetCommandRegister (unsigned char Command);
+    VCNL40x0Error_e SetCurrent (unsigned char CurrentValue);
+    VCNL40x0Error_e SetProximityRate (unsigned char ProximityRate);
+    VCNL40x0Error_e SetAmbiConfiguration (unsigned char AmbiConfiguration);
+    VCNL40x0Error_e SetLowThreshold (unsigned int LowThreshold);
+    VCNL40x0Error_e SetHighThreshold (unsigned int HighThreshold);
+    VCNL40x0Error_e SetInterruptControl (unsigned char InterruptControl);
+    VCNL40x0Error_e SetInterruptStatus (unsigned char InterruptStatus);
+    VCNL40x0Error_e SetModulatorTimingAdjustment (unsigned char ModulatorTimingAdjustment);
+
+    VCNL40x0Error_e ReadID (unsigned char *ID);
+    VCNL40x0Error_e ReadCurrent (unsigned char *CurrentValue);
+    VCNL40x0Error_e ReadCommandRegister (unsigned char *Command);
+    VCNL40x0Error_e ReadProxiValue (unsigned int *ProxiValue);
+    VCNL40x0Error_e ReadAmbiValue (unsigned int *AmbiValue);
+    VCNL40x0Error_e ReadInterruptStatus (unsigned char *InterruptStatus);
+    VCNL40x0Error_e ReadInterruptControl (unsigned char *InterruptControl);
+    
+    VCNL40x0Error_e ReadProxiOnDemand (unsigned int *ProxiValue);
+    VCNL40x0Error_e ReadAmbiOnDemand (unsigned int *AmbiValue);
+ 
+private:
+    I2C _i2c;
+    int _addr;
+    char _send[3];
+    char _receive[2];
+    
+};
+
+#endif