MAX44000.cpp

00001 /*
00002  * File description here
00003  */
00004 #include "MAX44000.h"
00005 
00006 /* some definitions here */
00007 #define REG_INT_STATUS  0x00
00008 #define REG_MAIN_CONFIG 0x01
00009 #define REG_RECV_CONFIG 0x02
00010 #define REG_TRNS_CONFIG 0x03
00011 
00012 /* ADC DATA */
00013 #define REG_ADC_MSB    0x04
00014 #define REG_ADC_LSB    0x05
00015 #define REG_ADC_BYTE   0x16
00016 
00017 /* THRESHOLD SET */
00018 #define REG_ALS_UMSB   0x06
00019 #define REG_ALS_ULSB   0x07
00020 #define REG_ALS_LMSB   0x08
00021 #define REG_ALS_LLSB   0x09
00022 #define REG_THR_PT     0x0A
00023 #define REG_PRXTHR_IND 0x0B
00024 #define REG_PRX_THR    0x0C
00025 #define REG_TRM_GAING  0x0F
00026 #define REG_TRM_GAINIR 0x10
00027     
00028 MAX44000::MAX44000(PinName sda, PinName scl, int addr) : m_i2c(sda, scl), m_addr(addr<<1) {
00029     // activate the peripheral
00030     uint8_t conf = 0 ;
00031     conf = \
00032           0x20 /* Use factory-programmed gains for green and IR channels. */
00033         | 0x10 /* ALS and PROX are interleaved ontinuously. */
00034         ;
00035     setMainConfig(conf) ;
00036 }
00037 
00038 MAX44000::~MAX44000() { }
00039 
00040 void MAX44000::readRegs(int addr, uint8_t * data, int len) {
00041     char t[1] = {addr} ;
00042     m_i2c.write(m_addr, t, 1, true) ;
00043     m_i2c.read(m_addr, (char*)data, len) ;
00044 }
00045 
00046 void MAX44000::writeRegs(uint8_t * data, int len) {
00047    m_i2c.write(m_addr, (char *)data, len) ;
00048 }
00049 
00050 void MAX44000::getIntStatus(uint8_t *data)
00051 {
00052     readRegs(REG_INT_STATUS, data, 1) ;
00053 }
00054 
00055 void MAX44000::getMainConfig(uint8_t *conf)
00056 {
00057     readRegs(REG_MAIN_CONFIG, conf, 1) ;
00058 }
00059 
00060 void MAX44000::setMainConfig(uint8_t newConf)
00061 {
00062     uint8_t data[2] ;
00063     data[0] = REG_MAIN_CONFIG ;
00064     data[1] = newConf ;
00065     writeRegs(data, 2) ;
00066 }
00067 
00068 void MAX44000::getRxConfig(uint8_t *conf)
00069 {
00070     readRegs(REG_RECV_CONFIG, conf, 1) ;
00071 }
00072 
00073 void MAX44000::setRxConfig(uint8_t newConf)
00074 {
00075     uint8_t data[2] ;
00076     data[0] = REG_RECV_CONFIG ;
00077     data[1] = newConf ;
00078     writeRegs(data, 2) ;    
00079 }
00080 
00081 void MAX44000::getTxConfig(uint8_t *conf)
00082 {
00083     readRegs(REG_TRNS_CONFIG, conf, 1) ;
00084 }
00085 
00086 void MAX44000::setTxConfig(uint8_t newConf)
00087 {
00088     uint8_t data[2] ;
00089     data[0] = REG_TRNS_CONFIG ;
00090     data[1] = newConf ;
00091     writeRegs(data, 2) ;    
00092 }   
00093 
00094 void MAX44000::getALS(uint8_t *ofl, uint16_t *value) 
00095 {
00096     uint8_t data[2] ;
00097 //    readRegs(REG_ADC_MSB, data, 2) ;
00098     readRegs(REG_ADC_MSB, data, 1) ;
00099     readRegs(REG_ADC_LSB, &data[1], 1) ;
00100     *value = ((data[0] & 0x3F)<<8) | data[1] ;
00101     *ofl = (data[0] >> 6) & 0x01 ; // overflow
00102 }
00103 
00104 void MAX44000::getProx(uint8_t *value) 
00105 {
00106     readRegs(REG_ADC_BYTE, value, 1) ;
00107 }
00108 
00109 void MAX44000::getADC(uint8_t *ofl, uint16_t *als, uint8_t *prox)
00110 {
00111     getALS(ofl, als) ;
00112     getProx(prox) ;
00113 }
00114 
00115 void MAX44000::getUPTHR(uint16_t *thr)
00116 {
00117     readRegs(REG_ALS_UMSB, (uint8_t*)thr, 2) ;
00118     *thr &= 0x3FFF ;
00119 }
00120 
00121 void MAX44000::setUPTHR(uint16_t newThr)
00122 {
00123     uint8_t data[3] ;
00124     data[0] = REG_ALS_UMSB ;
00125     data[1] = (newThr >> 8) & 0x3F ;
00126     data[2] = (newThr & 0xFF) ;
00127     writeRegs(data, 3) ;
00128 }
00129 
00130 void MAX44000::getLOTHR(uint16_t *thr)
00131 {
00132     readRegs(REG_ALS_LMSB, (uint8_t*)thr, 2) ;
00133     *thr &= 0x3FFF ;
00134 }
00135 
00136 void MAX44000::setLOTHR(uint16_t newThr)
00137 {
00138     uint8_t data[3] ;
00139     data[0] = REG_ALS_LMSB ;
00140     data[1] = (newThr >> 8) & 0x3F ;
00141     data[2] = (newThr & 0xFF) ;
00142     writeRegs(data, 3) ;
00143 }
00144 
00145 void MAX44000::getTHRPT(uint8_t *data)
00146 {
00147     readRegs(REG_THR_PT, data, 1) ;
00148 }
00149 
00150 void MAX44000::setTHRPT(uint8_t newData)
00151 {
00152     uint8_t data[2] ;
00153     data[0] = REG_THR_PT ;
00154     data[1] = newData ;
00155     writeRegs(data, 2) ;
00156 }
00157 
00158 void MAX44000::getPRXTHR_IND(uint8_t *value)
00159 {
00160     uint8_t data ;
00161     readRegs(REG_PRXTHR_IND, &data, 1) ;
00162     *value = (data >> 6) & 0x01 ;
00163 }
00164 
00165 void MAX44000::setPRXTHR_IND(uint8_t newValue)
00166 {
00167     uint8_t data[2] ;
00168     data[0] = REG_PRXTHR_IND ;
00169     data[1] = (newValue & 0x01) << 6 ;
00170     writeRegs(data, 2) ;
00171 }
00172 
00173 void MAX44000::getPRX_THR(uint8_t *data)
00174 {
00175     readRegs(REG_PRX_THR, data, 1) ;
00176 }
00177 
00178 void MAX44000::setPRX_THR(uint8_t newValue)
00179 {
00180     uint8_t data[2] ;
00181     data[0] = REG_PRX_THR ;
00182     data[1] = newValue ;
00183     writeRegs(data, 2) ;
00184 }
00185 
00186 void MAX44000::getTRM_GAING(uint8_t *data)
00187 {
00188     readRegs(REG_TRM_GAING, data, 1) ;
00189 }
00190 
00191 void MAX44000::setTRM_GAING(uint8_t newValue)
00192 {
00193     uint8_t data[2] ;
00194     data[0] = REG_TRM_GAING ;
00195     data[1] = newValue ;
00196     writeRegs(data, 2) ;
00197 }
00198 
00199 void MAX44000::getTRM_GAINIR(uint8_t *data)
00200 {
00201     readRegs(REG_TRM_GAINIR, data, 1) ;
00202 }
00203 
00204 void MAX44000::setTRM_GAINIR(uint8_t newValue)
00205 {
00206     uint8_t data[2] ;
00207     data[0] = REG_TRM_GAINIR ;
00208     data[1] = newValue ;
00209     writeRegs(data, 2) ;
00210 }