Esta versión v6 pasa a ser el nuevo master. Funciona correctamente

Dependencies:   ADXL345 Display1602 MSCFileSystem SDFileSystem mbed FATFileSystem

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers BMA180.cpp Source File

BMA180.cpp

00001 /**
00002  * @author Jose L. Escalona (virtualmech)
00003  */
00004 
00005 #include "BMA180.h"
00006 
00007 BMA180::BMA180(PinName mosi, PinName miso, PinName sck, PinName cs) : spi_(mosi, miso, sck), nCS_(cs) 
00008     {
00009     nCS_ = 1;
00010 
00011     wait_us(500);
00012     
00013     char readVersion, readID;
00014     char byte;
00015     // Setup the spi for 8 bit data, high steady state clock,
00016     // second edge capture, with a 10MHz clock rate
00017 
00018     spi_.frequency(10000000);        // 10 mHz page 59 of the BMA180 datasheet
00019     spi_.format(8,3);                // Not conform !!! page 58 of the BMA180 datasheet)
00020     wait_ms(100);
00021     readID = read_reg(BMA180_ID);
00022     readVersion = read_reg(VERSION);
00023     
00024     /*pc.printf("\n\r");
00025     if (readID == 3) {
00026         pc.printf("Connected to BMA180\n\r");
00027         pc.printf("BMA180 Version %d\n\r", readVersion);
00028     } else
00029         pc.printf("Sorry not connected to BMA180 !!!\n\r", readID);*/
00030 
00031     soft_reset();   // to copy EEprom into volatile area
00032 
00033     //---------------------------
00034     byte = read_reg(CTRL_REG0);             // Unlock image writing
00035     byte |= 0x10;                           // Set bit 4
00036     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00037     
00038     //------------------------
00039     byte= read_reg(DIS_I2C);                // read
00040     byte |= 0x01;                           // set bit0 to 1, SPI only
00041     write_reg(DIS_I2C, byte);               // Set spi, disable i2c, page 31
00042     
00043     
00044     //  SET RANGO  //
00045     
00046     byte= read_reg(RANGE);                  // read
00047     byte &= 0xF1;                           // set to 0 all 3 bits related to range
00048     byte |= 0x02;                           // Rango +- 1.5g
00049     write_reg(RANGE, byte);                 // Set RANGO, page 27
00050     
00051     //  SET FILTER BAND WITH  //
00052     
00053     byte= read_reg(FILTER_BW);              // read
00054     byte &= 0x0F;                           // set to 0 all 4 bits related to filter
00055     byte |= 0x70;                           // Filtro 1200 Hz (luego resulta ser un filtro de 472 Hz por ultra-low noise, ver p. 28 de datas sheet)
00056     write_reg(FILTER_BW, byte);             // Set BW, page 27
00057     
00058     //  SET NOISE Y POWER  (mode_config)//
00059     
00060     byte= read_reg(NOISE_POWER);            // read
00061     byte &= 0xFC;                           // set to 0 all 2 bits related to mode configuration
00062     byte |= 0x01;                           // Ultra low noise
00063     write_reg(NOISE_POWER, byte);           // Set mode_config, page 28
00064     
00065     //-------------------------
00066     //byte = read_reg(CTRL_REG3);
00067     //byte |= 0x02;                           // set bit 1 enable interrupt
00068     //byte |= 0x40;                           // set bit 6 slope mode
00069     //byte |= 0x80;                           // set bit 7 slope alert
00070     //write_reg(CTRL_REG3,byte);              //
00071     //pc.printf("Enable interrupt bis is set ");
00072     
00073     
00074     
00075     //------------------------------
00076     byte = read_reg(CTRL_REG0);             // Lock image writing
00077     byte &= 0xEF;                           // REset  bit 4
00078     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00079     //-------------------------------------------------------------------------------------
00080     //pc.printf("\n\rBMA init done    \n\r");
00081 
00082 }
00083 
00084 void BMA180::soft_reset(void) {
00085     // Write a soft reset
00086     // to copy EEprom into volatile area, see mid page 22
00087     write_reg(RESET, 0xB6);             // page 48
00088     wait_ms(10);                        // wait 10 ms, see page 49
00089     //pc.printf("Soft reset, EEPROM copied    \n\r");
00090 }
00091 
00092 void BMA180::ReadAccels_BMA180(int* Acc) {
00093     char x_lsb, x_msb;
00094     char y_lsb, y_msb;
00095     char z_lsb, z_msb;
00096     signed short ax, ay, az;
00097 
00098     //------------X----------------
00099     x_lsb = read_reg(ACCXLSB);
00100     x_msb = read_reg(ACCXMSB);
00101     ax = (x_msb << 8) |  x_lsb ;   // combineer msb en lsb
00102     ax = ax >> 2;                  // Get rid of two non-value bits in LSB
00103     //------------Y----------------
00104     y_lsb = read_reg(ACCYLSB);
00105     y_msb = read_reg(ACCYMSB);
00106     ay = (y_msb << 8) | y_lsb;     // combineer msb en lsb
00107     ay = ay >> 2;                  // Get rid of two non-value bits in LSB
00108     //------------Z----------------
00109     z_lsb = read_reg(ACCZLSB);
00110     z_msb = read_reg(ACCZMSB);
00111     az = (z_msb << 8) |  z_lsb;    //  combineer msb en lsb
00112     az = az >> 2;                  // Get rid of two non-value bits in LSB
00113 
00114     Acc[0] = ax;
00115     Acc[1] = ay;
00116     Acc[2] = az;
00117 }
00118 
00119 //-----------------READ OUT the X-Y-Z values---------------
00120 
00121 void BMA180::write_reg(uint8_t address, char data) {
00122     address &= 0x7F;                        //Force a write (bit 7=0)
00123     nCS_ = 0;                                   //Select SPI device
00124     wait_us(2);
00125     spi_.write(address);                     //Send register location
00126     wait_us(2);
00127     spi_.write(data);                        //Send value to record into register
00128     wait_us(2);
00129     nCS_ = 1;
00130     wait_us(2);
00131 }
00132 
00133 char BMA180::read_reg(uint8_t address) {
00134     char byte;
00135     address |= 0x80;                        //Force a read (bit 7=1)
00136     nCS_ = 0;
00137     wait_us(2);                             //Select SPI device
00138     spi_.write(address);                     //Send register location
00139     wait_us(2);
00140     byte=spi_.write(0xFF);                   //Get the data
00141     wait_us(2);
00142     nCS_ = 1;
00143     wait_us(2);
00144     return byte;
00145 }
00146 
00147 void BMA180::disable_int(void) {
00148     char byte;
00149     byte = read_reg(CTRL_REG0);             // Unlock image writing
00150     byte |= 0x10;                           // Set bit 4
00151     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00152     //-------------------------
00153     byte = read_reg(CTRL_REG3);
00154     byte &= 0xFD;                           // REset bit 1 enable interrupt
00155     write_reg(CTRL_REG3,byte);              //
00156     //pc.printf("\n\rDisable interrupt bis is set ");
00157     //------------------------------
00158     byte = read_reg(CTRL_REG0);             // Lock image writing
00159     byte &= 0xEF;                           // REset  bit 4
00160     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00161     //pc.printf("\n\rMBA180 in now switched off ");
00162 }
00163 
00164 void BMA180::AcelerometroSleep(void)      //OJO, NO ESTOY SEGURO DE QUE ESTA FUNCION ESTÉ BIEN IMPLEMENTADA
00165 {
00166     char byte;
00167      
00168     byte = read_reg(0x0D);
00169     byte &= 0xFD;
00170     byte |= 0x02;
00171     write_reg(0x0D, byte);
00172 }  
00173 void BMA180::AcelerometroWakeUp(void)     //OJO, NO ESTOY SEGURO DE QUE ESTA FUNCION ESTÉ BIEN IMPLEMENTADA
00174 {
00175     char byte;
00176      
00177     byte = read_reg(0x0D);
00178     byte &= 0xFD;
00179     write_reg(0x0D, byte);
00180 }    
00181 
00182 void BMA180::AcelerometroLeeOffsets(int * offSet)              //Lee los valores de los 3 offsets: x, y, z 
00183 {
00184     char x_lsb, x_msb;
00185     char y_lsb, y_msb;
00186     char z_lsb, z_msb;
00187     signed short offx, offy, offz;  
00188      
00189     offx = 0;
00190     offy = 0;
00191     offz = 0; 
00192      
00193     x_msb = read_reg(0x38);
00194     y_msb = read_reg(0x39);
00195     z_msb = read_reg(0x3A);
00196     
00197     x_lsb = read_reg(0x35);
00198     y_lsb = read_reg(0x36) << 4;
00199     z_lsb = read_reg(0x36);
00200 
00201     //------------X----------------
00202     offx = (x_msb << 8) |  x_lsb ;   // combineer msb en lsb
00203     offx = offx >> 4;                  // Get rid of 4 non-value bits in LSB
00204     //------------Y----------------
00205     offy = (y_msb << 8) | y_lsb;     // combineer msb en lsb
00206     offy = offy >> 4;                  // Get rid of 4 non-value bits in LSB
00207     //------------Z----------------
00208     offz = (z_msb << 8) |  z_lsb;    //  combineer msb en lsb
00209     offz = offz >> 4;                  // Get rid of 4 non-value bits in LSB
00210 
00211     offSet[0] = offx;
00212     offSet[1] = offy;
00213     offSet[2] = offz;
00214 }
00215 
00216 
00217 void BMA180::AcelerometroEscribeOffsets (char * offSet)              //Escribe los valores de los 3 offsets: x, y, z 
00218 {
00219     ////////////////////////// 
00220     // Unlock image writing //
00221     //////////////////////////
00222 
00223     char byte;
00224     byte = read_reg(CTRL_REG0);             // Unlock image writing
00225     byte |= 0x10;                           // Set bit 4
00226     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00227 
00228     char x_lsb, x_msb;
00229     char y_lsb, y_msb;
00230     char z_lsb, z_msb;
00231     char reg_x, reg_yz; 
00232     
00233      
00234     x_msb = offSet[0];
00235     y_msb = offSet[1];
00236     z_msb = offSet[2];
00237     
00238     x_lsb = offSet[3];
00239     y_lsb = offSet[4];
00240     z_lsb = offSet[5];
00241      
00242      
00243     // offset_finetuning to 11
00244     char fine_tu;
00245     fine_tu = read_reg(0x22);
00246     fine_tu &= 0xFC;
00247     fine_tu |= 0x01;
00248     write_reg(0x22,fine_tu);
00249     
00250     ///////////////////////////////
00251     /// ESTABLECE EL OFFSET EN X //
00252     ///////////////////////////////
00253     
00254     //Enable offset X
00255     fine_tu = read_reg(0x0E);
00256     fine_tu &= 0x7F;
00257     fine_tu |= 0x80;
00258     write_reg(0x0E,fine_tu);
00259     
00260     write_reg(0x38,x_msb);
00261     
00262     //Set X
00263     reg_x = read_reg(0x35);
00264     reg_x &= 0x0F;
00265     x_lsb = x_lsb << 4;
00266     reg_x |= x_lsb;
00267     write_reg(0x35,reg_x);
00268     
00269     //Disable offset X y Enable Y
00270     fine_tu &= 0x7F;
00271     fine_tu |= 0x40;
00272     write_reg(0x0E,fine_tu);
00273     
00274     ///////////////////////////////
00275     /// ESTABLECE EL OFFSET EN Y //
00276     ///////////////////////////////
00277     
00278     write_reg(0x39,y_msb);
00279     
00280     reg_yz = read_reg(0x36);
00281     reg_yz &= 0xF0;
00282     reg_yz |= y_lsb;
00283     write_reg(0x36,reg_yz);
00284     
00285     //Disable offset Y y Enable Z
00286     fine_tu &= 0xBF;
00287     fine_tu |= 0x20;
00288     write_reg(0x0E,fine_tu);
00289     
00290     ///////////////////////////////
00291     /// ESTABLECE EL OFFSET EN Z //
00292     ///////////////////////////////
00293     
00294     write_reg(0x3A,z_msb);
00295     
00296     reg_yz &= 0x0F;
00297     reg_yz |= z_lsb << 4;
00298     write_reg(0x36,reg_yz);
00299     
00300     //Disable offset Z
00301     fine_tu &= 0xDF;
00302     write_reg(0x0E,fine_tu);
00303     
00304     // offset_finetuning to 01
00305     fine_tu = read_reg(0x22);
00306     fine_tu &= 0xFC;
00307     fine_tu |= 0x01;
00308     write_reg(0x22,fine_tu);
00309     
00310     //////////////////////// 
00311     // Lock image writing //
00312     ////////////////////////
00313     
00314     byte = read_reg(CTRL_REG0);             // Lock image writing
00315     byte &= 0xEF;                           // REset  bit 4
00316     write_reg(CTRL_REG0,byte);              // Have to set ee_w to
00317 }