TCS3472_I2C.cpp

00001 #include "TCS3472_I2C.h"
00002 
00003 TCS3472_I2C::TCS3472_I2C( PinName sda, PinName scl ) : i2c( sda, scl ){   
00004     i2c.frequency(100000);
00005     enablePowerAndRGBC();
00006 }
00007 
00008 TCS3472_I2C::~TCS3472_I2C(){
00009     
00010 }
00011 
00012 int TCS3472_I2C::writeSingleRegister( char address, char data ){
00013     char tx[2] = { address | 160, data }; //0d160 = 0b10100000
00014     int ack = i2c.write( SLAVE_ADDRESS << 1, tx, 2 );
00015     return ack;
00016 }
00017 
00018 int TCS3472_I2C::writeMultipleRegisters( char address, char* data, int quantity ){
00019     char tx[ quantity + 1 ];
00020     tx[0] = address | 160;
00021     for ( int i = 1; i <= quantity; i++ ){
00022         tx[ i ] = data[ i - 1 ];
00023     }
00024     int ack = i2c.write( SLAVE_ADDRESS << 1, tx, quantity + 1 );
00025     return ack;
00026 }
00027 
00028 char TCS3472_I2C::readSingleRegister( char address ){
00029     char output = 255;
00030     char command = address | 160; //0d160 = 0b10100000
00031     i2c.write( SLAVE_ADDRESS << 1, &command, 1, true );
00032     i2c.read( SLAVE_ADDRESS << 1, &output, 1 );
00033     return output;
00034 }
00035 
00036 int TCS3472_I2C::readMultipleRegisters( char address, char* output, int quantity ){
00037     char command = address | 160; //0d160 = 0b10100000
00038     i2c.write( SLAVE_ADDRESS << 1, &command, 1, true );
00039     int ack = i2c.read( SLAVE_ADDRESS << 1, output, quantity );
00040     return ack;
00041 }
00042 
00043 void TCS3472_I2C::getAllColors( int* readings ){
00044     char buffer[8] = { 0 };
00045 
00046     readMultipleRegisters( CDATA, buffer, 8 );
00047 
00048     readings[0] = (int)buffer[1] << 8 | (int)buffer[0];
00049     readings[1] = (int)buffer[3] << 8 | (int)buffer[2];
00050     readings[2] = (int)buffer[5] << 8 | (int)buffer[4];
00051     readings[3] = (int)buffer[7] << 8 | (int)buffer[6];
00052 }
00053 
00054 int TCS3472_I2C::getClearData(){
00055     char buffer[2] = { 0 };
00056     readMultipleRegisters( CDATA, buffer, 2 );
00057     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00058     return reading;
00059 }
00060 
00061 int TCS3472_I2C::getRedData(){
00062     char buffer[2] = { 0 };
00063     readMultipleRegisters( RDATA, buffer, 2 );
00064     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00065     return reading;
00066 }
00067 
00068 int TCS3472_I2C::getGreenData(){
00069     char buffer[2] = { 0 };
00070     readMultipleRegisters( GDATA, buffer, 2 );
00071     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00072     return reading;
00073 }
00074 
00075 int TCS3472_I2C::getBlueData(){
00076     char buffer[2] = { 0 };
00077     readMultipleRegisters( BDATA, buffer, 2 );
00078     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00079     return reading;
00080 }
00081 
00082 int TCS3472_I2C::enablePower(){
00083     char enable_old = readSingleRegister( ENABLE );
00084     char enable_new = enable_old | 1; // sets PON (bit 0) to 1
00085     int ack = writeSingleRegister( ENABLE, enable_new );
00086     return ack;
00087 }
00088 
00089 int TCS3472_I2C::disablePower(){
00090     char enable_old = readSingleRegister( ENABLE );
00091     char enable_new = enable_old & 254; // sets PON (bit 0) to 0
00092     int ack = writeSingleRegister( ENABLE, enable_new );
00093     return ack;
00094 }
00095 
00096 bool TCS3472_I2C::isPowerEnabled(){
00097     char enable = readSingleRegister( ENABLE );
00098     char pon = enable << 7;
00099     pon = pon >> 7; // gets PON (bit 0) from ENABLE register byte
00100     return (bool)pon;
00101 }
00102 
00103 int TCS3472_I2C::enableRGBC(){
00104     char enable_old = readSingleRegister( ENABLE );
00105     char enable_new = enable_old | 2; // sets AEN (bit 1) to 1
00106     int ack = writeSingleRegister( ENABLE, enable_new );
00107     return ack;
00108 }
00109 
00110 int TCS3472_I2C::disableRGBC(){
00111     char enable_old = readSingleRegister( ENABLE );
00112     char enable_new = enable_old & 253; // sets AEN (bit 1) to 0
00113     int ack = writeSingleRegister( ENABLE, enable_new );
00114     return ack;
00115 }
00116 
00117 bool TCS3472_I2C::isRGBCEnabled(){
00118     char enable = readSingleRegister( ENABLE );
00119     char aen = enable << 6;
00120     aen = aen >> 7; // gets AEN (bit 1) from ENABLE register byte
00121     return (bool)aen;
00122 }
00123 
00124 int TCS3472_I2C::enablePowerAndRGBC(){
00125     char enable_old = readSingleRegister( ENABLE );
00126     char enable_new = enable_old | 3; // sets PON (bit 0) and AEN (bit 1) to 1
00127     int ack = writeSingleRegister( ENABLE, enable_new );
00128     return ack;
00129 }
00130 
00131 int TCS3472_I2C::disablePowerAndRGBC(){
00132     char enable_old = readSingleRegister( ENABLE );
00133     char enable_new = enable_old & 252; // sets PON (bit 0) and AEN (bit 1) to 0
00134     int ack = writeSingleRegister( ENABLE, enable_new );
00135     return ack;
00136 }
00137 
00138 int TCS3472_I2C::enableWait(){
00139     char enable_old = readSingleRegister( ENABLE );
00140     char enable_new = enable_old | 8; // sets WEN (bit 3) to 1
00141     int ack = writeSingleRegister( ENABLE, enable_new );
00142     return ack;
00143 }
00144 
00145 int TCS3472_I2C::disableWait(){
00146     char enable_old = readSingleRegister( ENABLE );
00147     char enable_new = enable_old & 247; // sets WEN (bit 3) to 0
00148     int ack = writeSingleRegister( ENABLE, enable_new );
00149     return ack;
00150 }
00151 
00152 bool TCS3472_I2C::isWaitEnabled(){ 
00153     char enable = readSingleRegister( ENABLE );
00154     char wen = enable << 4;
00155     wen = wen >> 7; // gets WEN (bit 3) from ENABLE register byte
00156     return (bool)wen;
00157 }
00158 
00159 int TCS3472_I2C::enableInterrupt(){
00160     char enable_old = readSingleRegister( ENABLE );
00161     char enable_new = enable_old | 16; // sets AIEN (bit 4) to 1
00162     int ack = writeSingleRegister( ENABLE, enable_new );
00163     return ack;
00164 }
00165 
00166 int TCS3472_I2C::disableInterrupt(){
00167     char enable_old = readSingleRegister( ENABLE );
00168     char enable_new = enable_old & 239; // sets AIEN (bit 4) to 0
00169     int ack = writeSingleRegister( ENABLE, enable_new );
00170     return ack;
00171 }
00172 
00173 bool TCS3472_I2C::isInterruptEnabled(){
00174     char enable = readSingleRegister( ENABLE );
00175     char aien = enable << 3;
00176     aien = aien >> 7; // gets AIEN (bit 4) from ENABLE register byte
00177     return (bool)aien;
00178 }
00179 
00180 int TCS3472_I2C::setIntegrationTime( const float itime ){
00181     char atime = 256 - roundTowardsZero( itime / 2.4 ); // rounding ensures nearest value of atime is used
00182     int ack = writeSingleRegister( ATIME, atime );
00183     return ack;
00184 }
00185 
00186 float TCS3472_I2C::readIntegrationTime(){
00187     float itime = 0;
00188     char atime = readSingleRegister( ATIME );
00189     itime = 2.4 * ( 256 - atime );
00190     return itime;
00191 }
00192 
00193 int TCS3472_I2C::setWaitTime( const float time ){
00194     int ack = 1;
00195     char wtime = 0;
00196     if ( time >= 2.39 && time <= 614.4 ){ // 2.39 instead of 2.4 to allow for float accuracy errors
00197         ack = writeSingleRegister( CONFIG, 0 ); // sets WLONG to 0
00198         wtime = 256 - roundTowardsZero( time / 2.4 );
00199     }
00200     else if ( time > 614.4 && time <= 7400.1 ){ // 7400.1 instead of 7400 to allow for float accuracy errors
00201         ack = writeSingleRegister( CONFIG, 2 ); // sets WLONG to 1
00202         wtime = 256 - roundTowardsZero( time / 28.8 );
00203     } 
00204     ack = ack || writeSingleRegister( WTIME, wtime );
00205     return ack;
00206 }
00207 
00208 float TCS3472_I2C::readWaitTime(){
00209     float time = 0;
00210     char wtime = readSingleRegister( WTIME );
00211     char config = readSingleRegister( CONFIG );
00212     int wlong = ( config << 6 ) >> 7; // gets WLONG (bit 1) from CONFIG register byte
00213     if ( wlong == 0 ){
00214         time = 2.4 * ( 256 - wtime );
00215     }
00216     else if ( wlong == 1 ){
00217         time = 28.8 * ( 256 - wtime ); // 28.8 = 2.4 * 12
00218     }
00219     return time;
00220 }
00221 
00222 char TCS3472_I2C::readEnableRegister(){
00223     return readSingleRegister( ENABLE );
00224 }
00225 
00226 int TCS3472_I2C::readLowInterruptThreshold(){
00227     char buffer[2] = { 0 };
00228     readMultipleRegisters( AILTL, buffer, 2 );
00229     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00230     return reading;
00231 }
00232 
00233 int TCS3472_I2C::readHighInterruptThreshold(){
00234     char buffer[2] = { 0 };
00235     readMultipleRegisters( AIHTL, buffer, 2 );
00236     int reading = (int)buffer[1] << 8 | (int)buffer[0];
00237     return reading;
00238 }
00239 
00240 int TCS3472_I2C::setLowInterruptThreshold( const int threshold ){
00241     char threshold_bytes[2];
00242     threshold_bytes[0] = threshold; // take lowest 8 bits of threshold
00243     threshold_bytes[1] = threshold >> 8; // take highest 8 bits of threshold
00244     int ack = writeMultipleRegisters( AILTL, threshold_bytes, 2 );
00245     return ack;
00246 }
00247 
00248 int TCS3472_I2C::setHighInterruptThreshold( const int threshold ){
00249     char threshold_bytes[2];
00250     threshold_bytes[0] = threshold;
00251     threshold_bytes[1] = threshold >> 8;
00252     int ack = writeMultipleRegisters( AIHTL, threshold_bytes, 2 );
00253     return ack;
00254 }
00255 
00256 int TCS3472_I2C::readInterruptPersistence(){
00257     char pers = readSingleRegister( PERS );
00258     char persistence_bits = ( pers << 4 ) >> 4; // discard bits 4 to 7, keep only bits 0 to 3
00259     int persistence = -1;
00260     switch (persistence_bits){
00261         case 0:
00262             persistence = 0;
00263             break;
00264         case 1:
00265             persistence = 1;
00266             break;
00267         case 2:
00268             persistence = 2;
00269             break;
00270         case 3:
00271             persistence = 3;
00272             break;
00273         case 4:
00274             persistence = 5;
00275             break;
00276         case 5:
00277             persistence = 10;
00278             break;
00279         case 6:
00280             persistence = 15;
00281             break;
00282         case 7:
00283             persistence = 20;
00284             break;
00285         case 8:
00286             persistence = 25;
00287             break;
00288         case 9:
00289             persistence = 30;
00290             break;
00291         case 10:
00292             persistence = 35;
00293             break;
00294         case 11:
00295             persistence = 40;
00296             break;
00297         case 12:
00298             persistence = 45;
00299             break;
00300         case 13:
00301             persistence = 50;
00302             break;
00303         case 14:
00304             persistence = 55;
00305             break;
00306         case 15:
00307             persistence = 60;
00308             break;
00309         default:
00310             break;
00311     }
00312     return persistence;
00313 }
00314 
00315 int TCS3472_I2C::setInterruptPersistence( const int persistence ){
00316     char pers_byte;
00317     int ack = 0;
00318     switch (persistence){
00319         case 0:
00320             pers_byte = 0;
00321             break;
00322         case 1:
00323             pers_byte = 1;
00324             break;
00325         case 2:
00326             pers_byte = 2;
00327             break;
00328         case 3:
00329             pers_byte = 3;
00330             break;
00331         case 5:
00332             pers_byte = 4;
00333             break;
00334         case 10:
00335             pers_byte = 5;
00336             break;
00337         case 15:
00338             pers_byte = 6;
00339             break;
00340         case 20:
00341             pers_byte = 7;
00342             break;
00343         case 25:
00344             pers_byte = 8;
00345             break;
00346         case 30:
00347             pers_byte = 9;
00348             break;
00349         case 35:
00350             pers_byte = 10;
00351             break;
00352         case 40:
00353             pers_byte = 11;
00354             break;
00355         case 45:
00356             pers_byte = 12;
00357             break;
00358         case 50:
00359             pers_byte = 13;
00360             break;
00361         case 55:
00362             pers_byte = 14;
00363             break;
00364         case 60:
00365             pers_byte = 15;
00366             break;
00367         default:
00368             ack = 2; // 2 used to indicate invalid entry
00369             break;
00370     }
00371     if ( ack != 2 ){
00372         ack = writeSingleRegister( PERS, pers_byte );
00373     }
00374     return ack;
00375 }
00376 
00377 int TCS3472_I2C::clearInterrupt(){
00378     char tx = 230;
00379     int ack = i2c.write( SLAVE_ADDRESS << 1, &tx, 1 );
00380     return ack;
00381 }
00382 
00383 int TCS3472_I2C::readRGBCGain(){
00384     char control = readSingleRegister( CONTROL );
00385     char gain_bits = ( control << 6 ) >> 6; // discard  bits 2 to 7, keep only bits 0 & 1
00386     int gain;
00387     switch (gain_bits) {
00388         case 0:
00389             gain = 1;
00390             break;
00391         case 1:
00392             gain = 4;
00393             break;
00394         case 2:
00395             gain = 16;
00396             break;
00397         case 3:
00398             gain = 60;
00399             break;
00400         default:
00401             gain = 0;
00402             break;
00403     }
00404     return gain;
00405 }
00406 
00407 int TCS3472_I2C::setRGBCGain( const int gain ){
00408     char control;
00409     int ack = 0;
00410     switch (gain){
00411         case 1:
00412             control = 0;
00413             break;
00414         case 4:
00415             control = 1;
00416             break;
00417         case 16:
00418             control = 2;
00419             break;
00420         case 60:
00421             control = 3;
00422             break;
00423         default:
00424             ack = 2; // 2 used to indicate invalid entry
00425             break;
00426     }
00427     if ( ack != 2 ){
00428         ack = writeSingleRegister( CONTROL, control );
00429     }
00430     return ack;
00431 }
00432 
00433 char TCS3472_I2C::getDeviceID(){
00434     return readSingleRegister( ID );
00435 }
00436 
00437 char TCS3472_I2C::readStatusRegister(){
00438     return readSingleRegister( STATUS );
00439 }
00440 
00441 float TCS3472_I2C::roundTowardsZero( const float value ){
00442     float result = 0;
00443     if ( ( value >= 0 && ( value - (int)value ) < 0.5 ) || ( value < 0 && ( abs(value) - (int)abs(value) ) >= 0.5 ) ){
00444         result = floor(value);
00445     }
00446     else{
00447         result = ceil(value);
00448     }
00449     return result;
00450 }