VCNL4010.cpp

00001 #include "mbed.h"
00002 #include "VCNL4010.h"
00003 
00004 /* I2C 7bit address is 0x13 */
00005 /* Register Definitions */
00006 #define REG_COMMAND                  0x80
00007 #define REG_PRODUCT_ID               0x81
00008 #define REG_PROXIMITY_RATE           0x82
00009 #define REG_IR_LED_CURRENT           0x83
00010 #define REG_AMBIENT_LIGHT_PARAMETER  0x84
00011 #define REG_AMBIENT_LIGHT_RESULT_MSB 0x85
00012 #define REG_AMBIENT_LIGHT_RESULT_LSB 0x86
00013 #define REG_PROXIMITY_RESULT_MSB     0x87
00014 #define REG_PROXIMITY_RESULT_LSB     0x88
00015 #define REG_INTERRUPT_CONTROL        0x89
00016 #define REG_LOW_THRESHOLD_MSB        0x8A
00017 #define REG_LOW_THRESHOLD_LSB        0x8B
00018 #define REG_HIGH_THRESHOLD_MSB       0x8C
00019 #define REG_HIGH_THRESHOLD_LSB       0x8D
00020 #define REG_INTERRUPT_STATUS         0x8E
00021 #define REG_PROXIMITY_MOD_TIMING     0x8F
00022 
00023 /* Bits in Register */
00024 /* COMMAND REGISTER (0x80) */
00025 
00026 /* mandatory functions */
00027 VCNL4010::VCNL4010(PinName sda, PinName scl, int addr): m_i2c(sda, scl), m_addr(addr<<1) {
00028     // activate the peripheral
00029 }
00030 
00031 VCNL4010::~VCNL4010()
00032 {
00033 }
00034 
00035 void VCNL4010::readRegs(int addr, uint8_t * data, int len) {
00036     char t[1] = {addr};
00037     m_i2c.write(m_addr, t, 1, true);
00038     m_i2c.read(m_addr, (char *)data, len);
00039 }
00040 
00041 void VCNL4010::writeRegs(uint8_t * data, int len) {
00042     m_i2c.write(m_addr, (char *)data, len);
00043 }
00044 
00045 /* device specific member functions */
00046 uint8_t  VCNL4010::getCommandReg(void) 
00047 {
00048     uint8_t cmd ;
00049     readRegs(REG_COMMAND, &cmd, 1) ;
00050     return( cmd ) ;
00051 }
00052 
00053 void     VCNL4010::setCommandReg(uint8_t cmd) 
00054 {
00055     uint8_t data[2] ;
00056     data[0] = REG_COMMAND ;
00057     data[1] = cmd ;
00058     writeRegs(data, 2) ;
00059 }
00060 
00061 uint8_t  VCNL4010::getProductID(void) 
00062 {
00063     uint8_t id ;
00064     readRegs(REG_PRODUCT_ID, &id, 1) ;
00065     return( id ) ;
00066 }
00067 
00068 uint8_t  VCNL4010::getProxRate(void) 
00069 {
00070     uint8_t rate ;
00071     readRegs(REG_PROXIMITY_RATE, &rate, 1) ;
00072     return( rate ) ;
00073 }
00074 
00075 void     VCNL4010::setProxRate(uint8_t rate) 
00076 {
00077     uint8_t data[2] ;
00078     data[0] = REG_PROXIMITY_RATE ;
00079     data[1] = rate ;
00080     writeRegs(data, 2) ;
00081 }
00082 
00083 uint8_t  VCNL4010::getIrLedCurrent(void) 
00084 {
00085     uint8_t IrLedCur ;
00086     readRegs(REG_IR_LED_CURRENT, &IrLedCur, 1) ;
00087     return( IrLedCur ) ;
00088 }
00089 
00090 void     VCNL4010::setIrLedCurrent(uint8_t IrLedCur) 
00091 {
00092     uint8_t data[2] ;
00093     data[0] = REG_IR_LED_CURRENT ;
00094     data[1] = IrLedCur ;
00095     writeRegs(data, 2) ;
00096 }
00097 
00098 uint8_t  VCNL4010::getAlsParam(void) 
00099 {
00100     uint8_t param ;
00101     readRegs(REG_AMBIENT_LIGHT_PARAMETER, &param, 1) ;
00102     return( param ) ;
00103 }
00104 
00105 void     VCNL4010::setAlsParam(uint8_t param) 
00106 {
00107     uint8_t data[2] ;
00108     data[0] = REG_AMBIENT_LIGHT_PARAMETER ;
00109     data[1] = param ;
00110     writeRegs(data, 2) ;
00111 }
00112 
00113 uint16_t VCNL4010::getAls(void) 
00114 {
00115     uint16_t als ;
00116     uint8_t data[2] ;
00117     readRegs(REG_AMBIENT_LIGHT_RESULT_MSB, data, 2) ;
00118     als = (data[0] << 8) | data[1] ;
00119     return( als ) ;
00120 }
00121 
00122 uint16_t VCNL4010::getProx(void) 
00123 {
00124     uint16_t prox ;
00125     uint8_t data[2] ;
00126     readRegs(REG_PROXIMITY_RESULT_MSB, data, 2) ;
00127     prox = (data[0] << 8) | data[1] ;
00128     return( prox ) ;
00129 }
00130 
00131 uint8_t  VCNL4010::getIntCtrl(void) 
00132 {
00133     uint8_t ctrl ;
00134     readRegs(REG_INTERRUPT_CONTROL, &ctrl, 1) ;
00135     return( ctrl ) ;
00136 }
00137 
00138 void     VCNL4010::setIntCtrl(uint8_t ctrl) 
00139 {
00140     uint8_t data[2] ;
00141     data[0] = REG_INTERRUPT_CONTROL ;
00142     data[1] = ctrl ;
00143     writeRegs(data, 2) ;
00144 }
00145 
00146 uint16_t VCNL4010::getLowThreshold(void) 
00147 {
00148     uint16_t thr ;
00149     uint8_t data[2] ;
00150     readRegs(REG_LOW_THRESHOLD_MSB, data, 2) ;
00151     thr = (data[0] << 8) | data[1] ;
00152     return( thr ) ;
00153 }
00154 
00155 void     VCNL4010::setLowThreshold(uint16_t thr) 
00156 {
00157     uint8_t data[3] ;
00158     data[0] = REG_LOW_THRESHOLD_MSB ;
00159     data[1] = (thr >> 8) & 0xFF ;
00160     data[2] = thr & 0xFF ;
00161     writeRegs(data, 3) ;
00162 }
00163 
00164 uint16_t VCNL4010::getHighThreshold(void) 
00165 {
00166     uint16_t thr ;
00167     uint8_t data[2] ;
00168     readRegs(REG_HIGH_THRESHOLD_MSB, data, 2) ;
00169     thr = (data[0] << 8) | data[1] ;
00170     return( thr ) ;
00171 }
00172 
00173 void     VCNL4010::setHighThreshold(uint16_t thr) 
00174 {
00175     uint8_t data[3] ;
00176     data[0] = REG_HIGH_THRESHOLD_MSB ;
00177     data[1] = (thr >> 8) & 0xFF ;
00178     data[2] = thr & 0xFF ;
00179     writeRegs(data, 3) ;
00180 }
00181 
00182 uint8_t  VCNL4010::getIntStatus(void) 
00183 {
00184     uint8_t status ;
00185     readRegs(REG_INTERRUPT_STATUS, &status, 1) ;
00186     return( status ) ;
00187 }
00188 
00189 void     VCNL4010::setIntStatus(uint8_t status) 
00190 {
00191     uint8_t data[2] ;
00192     data[0] = REG_INTERRUPT_STATUS ;
00193     data[1] = status ;
00194     writeRegs(data, 2) ;
00195 }
00196 
00197 uint8_t  VCNL4010::getProxModTiming(void) 
00198 {
00199     uint8_t timing ;
00200     readRegs(REG_PROXIMITY_MOD_TIMING, &timing, 1) ;
00201     return( timing ) ;
00202 }
00203 
00204 void     VCNL4010::setProxModTiming(uint8_t timing) 
00205 {
00206     uint8_t data[2] ;
00207     data[0] = REG_PROXIMITY_MOD_TIMING ;
00208     data[1] = timing ;
00209     writeRegs(data, 2) ;
00210 }