VCNL4100.cpp

00001 #include "mbed.h"
00002 #include "VCNL4100.h"
00003 
00004 /* I2C protocol
00005  *
00006  * I2C bus timing for Sendign Word Command Format 
00007  * <s> <8bit: Slave Address>W <sa> <8bit: command code> <sa>
00008  * <8bit: Data Byte Low> <sa> <8bit: Data Byte High> <sa> <p>
00009  *
00010  * I2C bus timing for Receiving Word Command Format
00011  * <s> <8bit: Slave Address>W <sa> <8bit: Command Code> <sa>
00012  * <s> <8bit: Slave Address>R <sa> <8bit: Data Byte Low> <ma>
00013  * <8bit: Data Byte High> <ma> <p>
00014  * 
00015  * <s> Start by Master
00016  * <p> Stop by Master
00017  * <ma> ACK by Master
00018  * <sa> ACK by Slave (VCNL4100)
00019  */
00020  
00021 /* Internal Registers */
00022 #define REG_ALS_CONF   0x00
00023 #define REG_ALS_THDH_L 0x01
00024 #define REG_ALS_THDL_L 0x02
00025 #define REG_PS_CONF1   0x03
00026 #define REG_PS_CONF3   0x04
00027 #define REG_PS_THDL    0x06
00028 #define REG_PS_DATA    0x08
00029 #define REG_ASL_DATA   0x09
00030 #define REG_INT_FLAG   0x0B
00031 
00032 VCNL4100::VCNL4100(PinName sda, PinName scl, int addr) :
00033     m_i2c(sda, scl), m_addr(addr<<1) 
00034 {
00035     // activate the peripheral
00036 }
00037 
00038 
00039 VCNL4100::~VCNL4100()
00040 {
00041 }
00042 
00043 void VCNL4100::readRegs(int addr, uint8_t * data, int len) {
00044     char t[1] = {addr};
00045     m_i2c.write(m_addr, t, 1, true);
00046     m_i2c.read(m_addr, (char *)data, len);
00047 }
00048 
00049 void VCNL4100::writeRegs(uint8_t * data, int len) {
00050     m_i2c.write(m_addr, (char *)data, len);
00051 }
00052 
00053 uint8_t  VCNL4100::getAlsConf(void) 
00054 {
00055     uint8_t data[2] ;
00056     readRegs(REG_ALS_CONF, data, 2) ;
00057     return(data[0]) ;
00058 }
00059 
00060 void     VCNL4100::setAlsConf(uint8_t conf) 
00061 {
00062     uint8_t data[3] ;
00063     data[0] = REG_ALS_CONF ;
00064     data[1] = conf ;
00065     data[2] = 0x00 ;
00066     writeRegs(data, 3) ;
00067 }
00068 
00069 uint16_t VCNL4100::getAlsThdh(void) 
00070 {
00071     uint16_t thdh ;
00072     uint8_t data[2] ;
00073     readRegs(REG_ALS_THDH_L, data, 2) ;
00074     thdh = (data[1] << 8) | data[0] ;
00075     return( thdh ) ;
00076 }
00077 
00078 void     VCNL4100::setAlsThdh(uint16_t thdh) 
00079 {
00080     uint8_t data[3] ;
00081     data[0] = REG_ALS_THDH_L ;
00082     data[1] = thdh & 0xFF ;
00083     data[2] = (thdh >> 8) & 0xFF ;
00084     writeRegs(data, 3) ;
00085 }
00086 
00087 uint16_t VCNL4100::getAlsThdl(void) 
00088 {
00089     uint16_t thdl ;
00090     uint8_t data[2] ;
00091     readRegs(REG_ALS_THDL_L, data, 2) ;
00092     thdl = (data[1] << 8) | data[0] ;
00093     return( thdl ) ;
00094 }
00095 
00096 void     VCNL4100::setAlsThdl(uint16_t thdl) 
00097 {
00098     uint8_t data[3] ;
00099     data[0] = REG_ALS_THDL_L ;
00100     data[1] = thdl & 0xFF ;
00101     data[2] = (thdl >> 8) & 0xFF ;
00102     writeRegs(data, 3) ;    
00103 }
00104 
00105 uint16_t VCNL4100::getPsConf12(void) 
00106 {
00107     uint16_t psconf12 ;
00108     uint8_t data[2] ;
00109     readRegs(REG_PS_CONF1, data, 2) ;
00110     psconf12 = (data[1] << 8) | data[0] ;
00111     return( psconf12 ) ;
00112 }
00113 
00114 void     VCNL4100::setPsConf12(uint16_t conf12) 
00115 {
00116     uint8_t data[3] ;
00117     data[0] = REG_PS_CONF1 ;
00118     data[1] = conf12 & 0xFF ;
00119     data[2] = (conf12 >> 8) & 0xFF ;
00120     writeRegs(data, 3) ;
00121 }
00122 
00123 uint8_t  VCNL4100::getPsConf1(void) 
00124 {
00125     uint16_t tmp ;
00126     uint8_t psconf1 ;
00127     tmp = getPsConf12() ;
00128     psconf1 = tmp & 0xFF ;
00129     return( psconf1 ) ;
00130 }
00131 
00132 void     VCNL4100::setPsConf1(uint8_t conf1) 
00133 {
00134     uint16_t tmp ;
00135     uint8_t data[3] ;
00136     data[0] = REG_PS_CONF1 ;
00137     tmp = getPsConf12() ;
00138     data[1] = conf1 ;
00139     data[2] = (tmp >> 8) & 0xFF ; // conf2
00140     writeRegs(data, 3) ;
00141 }
00142 
00143 uint8_t  VCNL4100::getPsConf2(void) 
00144 {
00145     uint16_t tmp ;
00146     uint8_t psconf2 ;
00147     tmp = getPsConf12() ;
00148     psconf2 = (tmp >> 8) & 0xFF ;
00149     return( psconf2 ) ;
00150 }
00151 
00152 void     VCNL4100::setPsConf2(uint8_t conf2) 
00153 {
00154     uint16_t tmp ;
00155     uint8_t data[3] ;
00156     data[0] = REG_PS_CONF1 ;
00157     tmp = getPsConf12() ;
00158     data[1] = tmp & 0xFF ;
00159     data[2] = conf2 ;
00160     writeRegs(data, 3) ;
00161 }
00162 
00163 uint16_t VCNL4100::getPsConf3Spo(void) 
00164 {
00165     uint16_t conf3spo ;
00166     uint8_t data[2] ; /* data[0] = PS_CONF3 ; data[1] = SPO ; */
00167     readRegs(REG_PS_CONF3, data, 2) ;
00168     conf3spo = (data[1] << 8) | data[0] ;
00169     return( conf3spo ) ;
00170 }
00171 
00172 void     VCNL4100::setPsConf3Spo(uint16_t conf3spo) 
00173 {
00174     uint8_t data[3] ;
00175     data[0] = REG_PS_CONF3 ;
00176     data[1] = conf3spo & 0xFF ; /* PS_CONF3 */
00177     data[2] = (conf3spo >> 8) & 0xFF ; /* PS_SPO */
00178     writeRegs(data, 3) ;
00179 }
00180 
00181 uint8_t  VCNL4100::getPsConf3(void) 
00182 {
00183     uint16_t conf3spo ;
00184     uint8_t conf3 ;
00185     conf3spo = getPsConf3Spo() ;
00186     conf3 = conf3spo & 0xFF ;
00187     return( conf3 ) ;
00188 }
00189 
00190 void     VCNL4100::setPsConf3(uint8_t conf3)
00191 {
00192     uint16_t conf3spo ;
00193     uint8_t data[3] ;
00194     conf3spo = getPsConf3Spo() ;
00195     data[0] = REG_PS_CONF3 ;
00196     data[1] = conf3 ;
00197     data[2] = (conf3spo >> 8) & 0xFF ; /* spo */
00198     writeRegs(data, 3) ;
00199 }
00200 
00201 uint8_t  VCNL4100::getSpo(void) 
00202 {
00203     uint16_t conf3spo ;
00204     uint8_t spo ;
00205     conf3spo = getPsConf3Spo() ;
00206     spo = (conf3spo >> 8) & 0xFF ;
00207     return( spo ) ;
00208 }
00209 
00210 void     VCNL4100::setSpo(uint8_t spo) 
00211 {
00212     uint16_t conf3spo ;
00213     uint8_t data[3] ;
00214     conf3spo = getPsConf3Spo() ;
00215     data[0] = REG_PS_CONF3 ;
00216     data[1] = conf3spo & 0xFF ; /* PS_CONF3 */
00217     data[2] = spo ; /* PS_SPO */
00218     writeRegs(data, 3) ;
00219 }
00220 
00221 uint16_t VCNL4100::getPsThd(void) 
00222 {
00223     uint16_t psthd ;
00224     uint8_t data[2] ;
00225     readRegs(REG_PS_THDL, data, 2) ;
00226     psthd = (data[1] << 8) | data[0] ;
00227     return( psthd ) ;
00228 }
00229 
00230 void     VCNL4100::setPsThd(uint16_t psthd) 
00231 {
00232     uint8_t data[3] ;
00233     data[0] = REG_PS_THDL ;
00234     data[1] = psthd & 0xFF ;
00235     data[2] = (psthd >> 8) & 0xFF ;
00236     writeRegs(data, 3) ;
00237 }
00238 
00239 uint8_t VCNL4100::getPsThdl(void)
00240 {
00241     uint16_t thd16 ;
00242     uint8_t thdl ;
00243     thd16 = getPsThd() ;
00244     thdl = thd16 & 0xFF ;
00245     return( thdl ) ;
00246 }
00247 
00248 void VCNL4100::setPsThdl(uint8_t thdl)
00249 {
00250     uint16_t thd16 ;
00251     uint8_t data[3] ;
00252     thd16 = getPsThd() ;
00253     data[0] = REG_PS_THDL ;
00254     data[1] = thdl ;
00255     data[2] = (thd16 >> 8) & 0xFF ;
00256     writeRegs(data, 3) ;
00257 }
00258 
00259 uint8_t VCNL4100::getPsThdh(void)
00260 {
00261     uint16_t thd16 ;
00262     uint8_t thdh ;
00263     thd16 = getPsThd() ;
00264     thdh = (thd16 >> 8) & 0xFF ;
00265     return( thdh ) ;
00266 }
00267 
00268 void VCNL4100::setPsThdh(uint8_t thdh)
00269 {
00270     uint16_t thd16 ;
00271     uint8_t data[3] ;
00272     thd16 = getPsThd() ;
00273     data[0] = REG_PS_THDL ;
00274     data[1] = thd16 & 0xFF ;
00275     data[2] = thdh ;
00276     writeRegs(data, 3) ;
00277 }
00278 
00279 uint8_t  VCNL4100::getPsData(void) 
00280 {
00281     uint8_t data[2] ;
00282     readRegs(REG_PS_DATA, data, 2) ;
00283     return(data[0]) ;
00284 }
00285 
00286 uint16_t VCNL4100::getAlsData(void) 
00287 {
00288     uint16_t alsdata ;
00289     uint8_t data[2] ;
00290     readRegs(REG_ASL_DATA, data, 2) ;
00291     alsdata = (data[1] << 8) | data[0] ;
00292     return( alsdata ) ;
00293 }
00294 
00295 uint8_t  VCNL4100::getIntFlag(void) 
00296 {
00297     uint8_t data[2] ;
00298     readRegs(REG_INT_FLAG, data, 2) ;
00299     return( data[1] ) ;
00300 }