AKM AK9753 IR Sensor IC with I2C I/F

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers AK9753.cpp Source File

AK9753.cpp

00001 #include "mbed.h"
00002 #include "AK9753.h"
00003 
00004 #define REG_WIA1       0x00
00005 #define REG_WIA2       0x01
00006 #define REG_INFO1      0x02
00007 #define REG_INFO2      0x03
00008 #define REG_INTST      0x04
00009 #define REG_ST1        0x05
00010 #define REG_IR1L       0x06
00011 #define REG_IR1H       0x07
00012 #define REG_IR2L       0x08
00013 #define REG_IR2H       0x09
00014 #define REG_IR3L       0x0A
00015 #define REG_IR3H       0x0B
00016 #define REG_IR4L       0x0C
00017 #define REG_IR4H       0x0D
00018 #define REG_TMPL       0x0E
00019 #define REG_TMPH       0x0F
00020 #define REG_ST2        0x10
00021 #define REG_ETH13H_LSB 0x11
00022 #define REG_ETH13H_MSB 0x12
00023 #define REG_ETH13L_LSB 0x13
00024 #define REG_ETH13L_MSB 0x14
00025 #define REG_ETH24H_LSB 0x15
00026 #define REG_ETH24H_MSB 0x16
00027 #define REG_ETH24L_LSB 0x17
00028 #define REG_ETH24L_MSB 0x18
00029 #define REG_EHYS13     0x19
00030 #define REG_EHYS24     0x1A
00031 #define REG_EINTEN     0x1B
00032 #define REG_ECNTL1     0x1C
00033 #define REG_CNTL2      0x1D
00034 
00035 /* EEPROM */
00036 #define REG_EKEY          0x50
00037 #define EEPROM_ETH13H_LSB 0x51
00038 #define EEPROM_ETH13H_MSB 0x52
00039 #define EEPROM_ETH13L_LSB 0x53
00040 #define EEPROM_ETH13L_MSB 0x54
00041 #define EEPROM_ETH24H_LSB 0x55
00042 #define EEPROM_ETH24H_MSB 0x56
00043 #define EEPROM_ETH24L_LSB 0x57
00044 #define EEPROM_ETH24L_MSB 0x58
00045 #define EEPROM_EHYS13     0x59
00046 #define EEPROM_EHYS24     0x5A
00047 #define EEPROM_EINTEN     0x5B
00048 #define EEPROM_ECNTL1     0x5C
00049 
00050 
00051 AK9753::AK9753(PinName sda, PinName scl, int addr) : m_i2c(sda, scl), m_addr(addr<<1) {
00052     // activate the peripheral
00053 }
00054 
00055 AK9753::~AK9753() { }
00056 
00057 int AK9753::readRegs(int addr, uint8_t * data, int len) {
00058     char t[1] = {addr};
00059     int result ;
00060     result = m_i2c.write(m_addr, t, 1, true);
00061     if (result == 0) {
00062         result = m_i2c.read(m_addr, (char *)data, len);
00063     }
00064     return( result ) ;
00065 }
00066 
00067 int AK9753::writeRegs(uint8_t * data, int len) {
00068     int result ;
00069     result = m_i2c.write(m_addr, (char *)data, len);
00070     return( result ) ;
00071 }
00072 
00073 /**
00074  * getCompanyCode
00075  * the code is expected to be 0x48 
00076  */
00077 uint8_t AK9753::getCompanyCode(void) 
00078 {
00079     uint8_t data ;
00080     readRegs(REG_WIA1, &data, 1) ;
00081     return(data) ;
00082 }
00083 
00084 /**
00085  * getDeviceID
00086  * the ID is expected to be 0x13
00087  */
00088 uint8_t AK9753::getDeviceID(void) 
00089 {
00090     uint8_t data ;
00091     readRegs(REG_WIA2, &data, 1) ;
00092     return(data) ;
00093 }
00094 
00095 bool AK9753::dataReady(void) /* returns ST1[0], read ST2 to clear */
00096 {
00097     uint8_t data ;
00098     readRegs(REG_ST1, &data, 1) ;
00099     return((data & 0x01) == 0x01) ;
00100 }
00101 
00102 bool AK9753::dataOverRun(void)
00103 {
00104     uint8_t data ;
00105     readRegs(REG_ST2, &data, 1) ;
00106     return((data & 0x02) == 0x02) ;
00107 }
00108 
00109 uint8_t AK9753::getINTST(void)  /** return REG_INTST */
00110 {
00111     uint8_t data ;
00112     readRegs(REG_INTST, &data, 1) ;
00113     return( data ) ;
00114 }
00115 
00116 uint8_t  AK9753::getST1(void) 
00117 {
00118     uint8_t data ;
00119     readRegs(REG_ST1, &data, 1) ;
00120     return( data ) ;
00121 }
00122 
00123 int16_t AK9753::getRawIR1(void) 
00124 {
00125     uint8_t data[2] ;
00126     int16_t IR ;
00127     readRegs(REG_IR1L, data, 2) ;
00128     IR = (data[1] << 8) | data[0] ;
00129     return( IR ) ;
00130 }
00131 
00132 float AK9753::getIR1(void) 
00133 {
00134     int16_t iValue ;
00135     float fValue ;
00136     iValue = getRawIR1() ;
00137     fValue = 14286.8 * iValue / 32768.0 ;
00138     return( fValue ) ;
00139 }
00140 
00141 int16_t AK9753::getRawIR2(void) 
00142 {    
00143     uint8_t data[2] ;
00144     int16_t IR ;
00145     readRegs(REG_IR2L, data, 2) ;
00146     IR = (data[1] << 8) | data[0] ;
00147     return( IR ) ;
00148 }
00149 
00150 float AK9753::getIR2(void) 
00151 {
00152     int16_t iValue ;
00153     float fValue ;
00154     iValue = getRawIR2() ;
00155     fValue = 14286.8 * iValue / 32768.0 ;
00156     return( fValue ) ;
00157 }
00158 
00159 int16_t AK9753::getRawIR3(void) 
00160 {
00161     uint8_t data[2] ;
00162     int16_t IR ;
00163     readRegs(REG_IR3L, data, 2) ;
00164     IR = (data[1] << 8) | data[0] ;
00165     return( IR ) ;
00166 }
00167 
00168 float AK9753::getIR3(void) 
00169 {
00170     int16_t iValue ;
00171     float fValue ;
00172     iValue = getRawIR3() ;
00173     fValue = 14286.8 * iValue / 32768.0 ;
00174     return( fValue ) ;
00175 }
00176 
00177 int16_t AK9753::getRawIR4(void) 
00178 {
00179     uint8_t data[2] ;
00180     int16_t IR ;
00181     readRegs(REG_IR4L, data, 2) ;
00182     IR = (data[1] << 8) | data[0] ;
00183     return( IR ) ;
00184 }
00185 
00186 float AK9753::getIR4(void) 
00187 {
00188     int16_t iValue ;
00189     float fValue ;
00190     iValue = getRawIR4() ;
00191     fValue = 14286.8 * iValue / 32768.0 ;
00192     return( fValue ) ;
00193 }
00194 
00195 int16_t AK9753::getRawTMP(void) 
00196 {
00197     uint8_t data[2] ;
00198     int16_t temp ;
00199     readRegs(REG_TMPL, data, 2) ;
00200     temp = (data[1] << 8) | data[0] ;
00201     return( temp ) ;
00202 }
00203 
00204 float AK9753::getTMP(void) 
00205 {
00206     int16_t iValue ;
00207     float fValue ;
00208     iValue = getRawTMP() ;
00209     fValue = 26.75 +  (60.0 - 26.75) * iValue / 17792.0 ;
00210     return( fValue ) ;
00211 }
00212 
00213 uint8_t  AK9753::getST2(void) 
00214 {
00215     uint8_t data ;
00216     readRegs(REG_ST2, &data, 1) ;
00217     return( data ) ;
00218 }
00219 
00220 int16_t AK9753::getETH13H(void)
00221 {
00222     int16_t value ;
00223     uint8_t data[2] ;
00224     readRegs(REG_ETH13H_LSB, data, 2) ;
00225     value = (data[1] << 8) | data[0] ;
00226     return( value ) ;
00227 }
00228 
00229 int16_t AK9753::getETH13L(void)
00230 {
00231     int16_t value ;
00232     uint8_t data[2] ;
00233     readRegs(REG_ETH13L_LSB, data, 2) ;
00234     value = (data[1] << 8) | data[0] ;
00235     return( value ) ;
00236 }
00237 
00238 int16_t AK9753::getETH24H(void)
00239 {
00240     int16_t value ;
00241     uint8_t data[2] ;
00242     readRegs(REG_ETH24H_LSB, data, 2) ;
00243     value = (data[1] << 8) | data[0] ;
00244     return( value ) ;
00245 }
00246 
00247 int16_t AK9753::getETH24L(void)
00248 {
00249     int16_t value ;
00250     uint8_t data[2] ;
00251     readRegs(REG_ETH24L_LSB, data, 2) ;
00252     value = (data[1] << 8) | data[0] ;
00253     return( value ) ;
00254 }
00255 
00256 uint8_t AK9753::getEHYS13(void)
00257 {
00258     uint8_t data ;
00259     readRegs(REG_EHYS13, &data, 1) ;
00260     return( data ) ;
00261 }
00262 
00263 uint8_t AK9753::getEHYS24(void)
00264 {
00265     uint8_t data ;
00266     readRegs(REG_EHYS24, &data, 1) ;
00267     return( data ) ;
00268 }
00269 
00270 uint8_t AK9753::getEINTEN(void)
00271 {
00272     uint8_t data ;
00273     readRegs(REG_EINTEN, &data, 1) ;
00274     return( data ) ;   
00275 }
00276 
00277 uint8_t AK9753::getECNTL1(void)
00278 {
00279     uint8_t data ;
00280     readRegs(REG_ECNTL1, &data, 1) ;
00281     return( data ) ;      
00282 }
00283 
00284 uint8_t AK9753::getCNTL2(void)
00285 {
00286     uint8_t data ;
00287     readRegs(REG_CNTL2, &data, 1) ;
00288     return( data ) ;      
00289 }
00290 
00291 void AK9753::setETH13H(int16_t value) 
00292 {
00293     uint8_t data[3] ;
00294     data[0] = REG_ETH13H_LSB ;
00295     data[1] = value & 0xFF ;
00296     data[2] = (value >> 8) & 0xFF ;
00297     writeRegs(data, 3) ;
00298 }
00299 
00300 void AK9753::setETH13L(int16_t value) 
00301 {
00302     uint8_t data[3] ;
00303     data[0] = REG_ETH13L_LSB ;
00304     data[1] = value & 0xFF ;
00305     data[2] = (value >> 8) & 0xFF ;
00306     writeRegs(data, 3) ;
00307 }
00308 
00309 void AK9753::setETH24H(int16_t value) 
00310 {
00311     uint8_t data[3] ;
00312     data[0] = REG_ETH24H_LSB ;
00313     data[1] = value & 0xFF ;
00314     data[2] = (value >> 8) & 0xFF ;
00315     writeRegs(data, 3) ;
00316 }
00317 
00318 void AK9753::setETH24L(int16_t value) 
00319 {
00320     uint8_t data[3] ;
00321     data[0] = REG_ETH24L_LSB ;
00322     data[1] = value & 0xFF ;
00323     data[2] = (value >> 8) & 0xFF ;
00324     writeRegs(data, 3) ;
00325 }
00326 
00327 void AK9753::setEHYS13(uint8_t value) 
00328 {
00329     uint8_t data[2] ;
00330     data[0] = REG_EHYS13 ;
00331     data[1] = value ;
00332     writeRegs(data, 2) ;
00333 }
00334 
00335 void AK9753::setEHYS24(uint8_t value) 
00336 {
00337     uint8_t data[2] ;
00338     data[0] = REG_EHYS24 ;
00339     data[1] = value ;
00340     writeRegs(data, 2) ;    
00341 }
00342 
00343 void AK9753::setEINTEN(uint8_t value) 
00344 {
00345     uint8_t data[2] ;
00346     data[0] = REG_EINTEN ;
00347     data[1] = value ;
00348     writeRegs(data, 2) ; 
00349 }
00350 
00351 void AK9753::setECNTL1(uint8_t value) 
00352 {
00353     uint8_t data[2] ;
00354     data[0] = REG_ECNTL1 ;
00355     data[1] = value ;
00356     writeRegs(data, 2) ; 
00357 }
00358 
00359 void AK9753::software_reset(void) 
00360 {
00361     uint8_t data[2] = { REG_CNTL2, 0xFF } ;
00362     writeRegs(data, 2) ;
00363 }