HeptaAccel.cpp

00001 #include "HeptaAccel.h"
00002 #include "mbed.h"
00003 
00004 HeptaAccel::HeptaAccel(PinName sda, PinName scl, int aaddr ) : accel(sda,scl),addr(aaddr)
00005 {
00006     _cmd[0] = 0x2A;//CTL_REG
00007     _cmd[1] = 0x01;//ACTIVE
00008     accel.write(addr, _cmd, 2);
00009     accel.start();
00010     accel.write(addr);
00011     accel.stop(); 
00012 }
00013 
00014 void HeptaAccel::setup()
00015 {
00016     _cmd[0] = 0x2A;
00017     _cmd[1] = 0x01;
00018     accel.frequency(100000);
00019     accel.write(addr, _cmd, 2);
00020     accel.start();
00021     accel.write(addr);
00022     accel.stop();
00023 }
00024 
00025 void HeptaAccel::sensing(float *ax,float *ay,float *az)
00026 {
00027     int16_t acc;
00028     accel.start();//start
00029     accel.write(addr);//write address
00030     accel.write(0x01);//X-axis_MSB_REG
00031     accel.start();//restart, switch from write to read
00032     accel.write(addr|0x01);//read address
00033     _xmsb = accel.read(0);//read from selected register with NACK
00034     accel.stop();
00035     accel.start();
00036     accel.write(addr);
00037     accel.write(0x02);//X-axis_LSB_REG
00038     accel.start();
00039     accel.write(addr|0x01);
00040     _xlsb = accel.read(0);
00041     accel.stop();
00042     acc = (_xmsb << 6) | (_xlsb >> 2);
00043     if (acc > UINT14_MAX/2)
00044     {
00045         acc -= UINT14_MAX;
00046     }
00047     *ax = acc/4096.0*9.81;
00048     
00049     accel.start();
00050     accel.write(addr);
00051     accel.write(0x03);
00052     accel.start();
00053     accel.write(addr|0x01);
00054     _ymsb = accel.read(0);
00055     accel.stop();
00056     accel.start();
00057     accel.write(addr);
00058     accel.write(0x04);
00059     accel.start();
00060     accel.write(addr|0x01);
00061     _ylsb = accel.read(0);
00062     accel.stop();
00063     acc = (_ymsb << 6) | (_ylsb >> 2);
00064     if (acc > UINT14_MAX/2)
00065     {
00066         acc -= UINT14_MAX;
00067     }
00068     *ay = acc/4096.0*9.81;   
00069         
00070     accel.start();
00071     accel.write(addr);
00072     accel.write(0x05);
00073     accel.start();
00074     accel.write(addr|0x01);
00075     _zmsb = accel.read(0);
00076     accel.stop();
00077     accel.start();
00078     accel.write(addr);
00079     accel.write(0x06);
00080     accel.start();
00081     accel.write(addr|0x01);
00082     _zlsb = accel.read(0);
00083     accel.stop();
00084     acc = (_zmsb << 6) | (_zlsb >> 2);
00085     if (acc > UINT14_MAX/2)
00086     {
00087         acc -= UINT14_MAX;
00088     }   
00089     *az = acc/4096.0*9.81;  
00090 }
00091     
00092 float HeptaAccel::x()
00093 {  
00094     int16_t acc;
00095     float ax;
00096     accel.start();
00097     accel.write(addr);
00098     accel.write(0x01);
00099     accel.start();
00100     accel.write(addr|0x01);
00101     _xmsb = accel.read(0);
00102     accel.stop();
00103     accel.start();
00104     accel.write(addr);
00105     accel.write(0x02);
00106     accel.start();
00107     accel.write(addr|0x01);
00108     _xlsb = accel.read(0);
00109     accel.stop();  
00110     acc = (_xmsb << 6) | (_xlsb >> 2);
00111     if (acc > UINT14_MAX/2)
00112     {
00113         acc -= UINT14_MAX;
00114     }
00115     ax = acc/4096.0*9.81;
00116     return(ax);
00117 }
00118     
00119 float HeptaAccel::y()
00120 {
00121     int16_t acc;
00122     float ay;
00123     accel.start();
00124     accel.write(addr);
00125     accel.write(0x03);
00126     accel.start();
00127     accel.write(addr|0x01);
00128     _ymsb = accel.read(0);
00129     accel.stop();
00130     accel.start();
00131     accel.write(addr);
00132     accel.write(0x04);
00133     accel.start();
00134     accel.write(addr|0x01);
00135     _ylsb = accel.read(0);
00136     accel.stop();
00137     acc = (_ymsb << 6) | (_ylsb >> 2);
00138     if (acc > UINT14_MAX/2)
00139     {
00140         acc -= UINT14_MAX;
00141     }   
00142     ay = acc/4096.0*9.81;
00143     return(ay);
00144 }
00145     
00146 float HeptaAccel::z()
00147 {
00148     int16_t acc;
00149     float az;
00150     accel.start();
00151     accel.write(addr);
00152     accel.write(0x2C);
00153     accel.start();
00154     accel.write(addr|0x01);
00155     _zmsb = accel.read(0);
00156     accel.stop();
00157     accel.start();
00158     accel.write(addr);
00159     accel.write(0x2D);
00160     accel.start();
00161     accel.write(addr|0x01);
00162     _zlsb = accel.read(0);
00163     accel.stop();
00164     acc = (_zmsb << 6) | (_zlsb >> 2);
00165     if (acc > UINT14_MAX/2)
00166     {
00167         acc -= UINT14_MAX;
00168     }   
00169     az = acc/4096.0*9.81;
00170     return(az);
00171 }
00172     
00173 void HeptaAccel::sensing_u16(char* ax_u16,char* ay_u16,char* az_u16, int *dsize)
00174 {
00175     char a1[8]={0x00},a2[8]={0x00};
00176     accel.start();
00177     accel.write(addr);
00178     accel.write(0x01);
00179     accel.start();
00180     accel.write(addr|0x01);
00181     _xmsb = accel.read(0);
00182     accel.stop();
00183     accel.start();
00184     accel.write(addr);
00185     accel.write(0x02);
00186     accel.start();
00187     accel.write(addr|0x01);
00188     _xlsb = accel.read(0);
00189     accel.stop();  
00190     sprintf( a1, "%02X", ((_xmsb)) & 0xFF);
00191     sprintf( a2, "%02X", ((_xlsb)) & 0xFF);
00192     ax_u16[0]=a1[0];
00193     ax_u16[1]=a1[1];
00194     ax_u16[2]=a2[0];
00195     ax_u16[3]=a2[1];
00196         
00197     accel.start();
00198     accel.write(addr);
00199     accel.write(0x03);
00200     accel.start();
00201     accel.write(addr|0x01);
00202     _ymsb = accel.read(0);
00203     accel.stop();
00204     accel.start();
00205     accel.write(addr);
00206     accel.write(0x04);
00207     accel.start();
00208     accel.write(addr|0x01);
00209     _ylsb = accel.read(0);
00210     accel.stop();  
00211     sprintf( a1, "%02X", ((_ymsb)) & 0xFF);
00212     sprintf( a2, "%02X", ((_ylsb)) & 0xFF);
00213     ay_u16[0]=a1[0];
00214     ay_u16[1]=a1[1];
00215     ay_u16[2]=a2[0];
00216     ay_u16[3]=a2[1];
00217         
00218     accel.start();
00219     accel.write(addr);
00220     accel.write(0x05);
00221     accel.start();
00222     accel.write(addr|0x01);
00223     _zmsb = accel.read(0);
00224     accel.stop();
00225     accel.start();
00226     accel.write(addr);
00227     accel.write(0x06);
00228     accel.start();
00229     accel.write(addr|0x01);
00230     _zlsb = accel.read(0);
00231     accel.stop();  
00232     sprintf( a1, "%02X", ((_zmsb)) & 0xFF);
00233     sprintf( a2, "%02X", ((_zlsb)) & 0xFF);
00234     az_u16[0]=a1[0];
00235     az_u16[1]=a1[1];
00236     az_u16[2]=a2[0];
00237     az_u16[3]=a2[1];
00238     *dsize = 4;
00239 }
00240         
00241 void HeptaAccel::x_u16(char* a_u16, int *dsize)
00242 {
00243     char a1[8]={0x00},a2[8]={0x00};
00244     accel.start();
00245     accel.write(addr);
00246     accel.write(0x01);
00247     accel.start();
00248     accel.write(addr|0x01);
00249     _xmsb = accel.read(0);
00250     accel.stop();
00251     accel.start();
00252     accel.write(addr);
00253     accel.write(0x02);
00254     accel.start();
00255     accel.write(addr|0x01);
00256     _xlsb = accel.read(0);
00257     accel.stop();  
00258     sprintf( a1, "%02X", ((_xmsb)) & 0xFF);
00259     sprintf( a2, "%02X", ((_xlsb)) & 0xFF);
00260     a_u16[0]=a1[0];
00261     a_u16[1]=a1[1];
00262     a_u16[2]=a2[0];
00263     a_u16[3]=a2[1];
00264     *dsize = 4;
00265 }
00266     
00267 void HeptaAccel::y_u16(char* a_u16, int *dsize)
00268 {
00269     char a1[8]={0x00},a2[8]={0x00};
00270     accel.start();
00271     accel.write(addr);
00272     accel.write(0x03);
00273     accel.start();
00274     accel.write(addr|0x01);
00275     _ymsb = accel.read(0);
00276     accel.stop();
00277     accel.start();
00278     accel.write(addr);
00279     accel.write(0x04);
00280     accel.start();
00281     accel.write(addr|0x01);
00282     _ylsb = accel.read(0);
00283     accel.stop();  
00284     sprintf( a1, "%02X", ((_ymsb)) & 0xFF);
00285     sprintf( a2, "%02X", ((_ylsb)) & 0xFF);
00286     a_u16[0]=a1[0];
00287     a_u16[1]=a1[1];
00288     a_u16[2]=a2[0];
00289     a_u16[3]=a2[1];
00290     *dsize = 4;
00291 }
00292      
00293 void HeptaAccel::z_u16(char* a_u16, int *dsize)
00294 {
00295     char a1[8]={0x00},a2[8]={0x00};
00296     accel.start();
00297     accel.write(addr);
00298     accel.write(0x05);
00299     accel.start();
00300     accel.write(addr|0x01);
00301     _zmsb = accel.read(0);
00302     accel.stop();
00303     accel.start();
00304     accel.write(addr);
00305     accel.write(0x06);
00306     accel.start();
00307     accel.write(addr|0x01);
00308     _zlsb = accel.read(0);
00309     accel.stop();  
00310     sprintf( a1, "%02X", ((_zmsb)) & 0xFF);
00311     sprintf( a2, "%02X", ((_zlsb)) & 0xFF);
00312     a_u16[0]=a1[0];
00313     a_u16[1]=a1[1];
00314     a_u16[2]=a2[0];
00315     a_u16[3]=a2[1];
00316     *dsize = 4;
00317 }