Diff: BMC050.cpp

Revision:

1:b022f8d7884d

Parent:

0:8de5e2fd5c48

Child:

2:93141eb80862

--- a/BMC050.cpp	Sun Jul 20 13:16:25 2014 +0000
+++ b/BMC050.cpp	Sun Sep 07 07:15:37 2014 +0000
@@ -7,7 +7,7 @@
  *  http://www.page.sannet.ne.jp/kenjia/index.html
  *  http://mbed.org/users/kenjiArai/
  *      Created: July      19th, 2014 
- *      Revised: July      20th, 2014
+ *      Revised: September  7th, 2014
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
@@ -36,29 +36,33 @@
     //      -> Need to go "Normal mode" via "Sleep mode"
     // step 1/start 
     mag_addr = mag_parameter->addr;
-    dbf[0] = BMC050_M_POWER_MODE;
-    dbf[1] = 0x01;  // Power control bit on
-    i2c_write_n_bytes(mag_addr, dbf, 2);
-    dbf[0] = BMC050_M_OPERATION;
-    dbf[1] = 0;
-    i2c_write_n_bytes(mag_addr, dbf, 2);
+    if (mag_addr != BMC050_MAG_NOT_USED_ADDR) {
+        dbf[0] = BMC050_M_POWER_MODE;
+        dbf[1] = 0x01;  // Power control bit on
+        i2c.write(mag_addr, dbf, 2);
+        dbf[0] = BMC050_M_OPERATION;
+        dbf[1] = 0;
+        i2c.write(mag_addr, dbf, 2);
+    }
     /////////////// Accelerometer configuration ////////////////
     // Check acc chip is available of not
     // step 1/start
     acc_addr = acc_parameter->addr;
     dbf[0] = BMC050_A_WHO_AM_I; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
+    i2c.write(acc_addr, dbf, 1); 
+    i2c.read(acc_addr, dbf, 1);
     if (dbf[0] == I_AM_BMC050_ACC){ acc_ready = 1;
     } else {                        acc_ready = 0; }
     /////////////// Magnetometer Configuration /////////////////
     // after power-on, mag chip is keeping "Suspend mode"!!
     //      -> Need to go "Normal mode" via "Sleep mode"
     // step 2 
-    i2c_write_n_bytes(mag_addr, dbf, 2);
-    dbf[0] = BMC050_M_OPERATION;
-    dbf[1] = 0;
-    i2c_write_n_bytes(mag_addr, dbf, 2);
+    if (mag_addr != BMC050_MAG_NOT_USED_ADDR) {
+        i2c.write(mag_addr, dbf, 2);
+        dbf[0] = BMC050_M_OPERATION;
+        dbf[1] = 0;
+        i2c.write(mag_addr, dbf, 2);
+    }
     /////////////// Accelerometer configuration ////////////////
     // step 2/last
     if ( acc_ready == 1){
@@ -82,7 +86,7 @@
             fs_factor_acc = 256;
             dbf[1] = BMC050_FS_2G;
         }          
-        i2c_write_n_bytes(acc_addr, dbf, 2);
+        i2c.write(acc_addr, dbf, 2);
         // set bandwidth
         dbf[1] = acc_parameter->bandwith;
         if (dbf[1] == BMC050_NOT_FILTERED){
@@ -91,25 +95,27 @@
         } else {
             dbf[0] = BMC050_A_BANDWIDTH;
         }
-        i2c_write_n_bytes(acc_addr, dbf, 2);
+        i2c.write(acc_addr, dbf, 2);
     }
     /////////////// Magnetometer Configuration /////////////////
     // Check mag chip is available of not
     // step 3/last
-    dbf[0] = BMC050_M_WHO_AM_I; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    if (dbf[0] == I_AM_BMC050_MAG){ mag_ready = 1;
-    } else {                        mag_ready = 0; }
-    if ( mag_ready == 1){
-        // set output data rate
-        dbf[0] = BMC050_M_OPERATION;
-        dbf[1] = mag_parameter->data_rate;
-        i2c_write_n_bytes(mag_addr, dbf, 2);
+    if (mag_addr != BMC050_MAG_NOT_USED_ADDR) {
+        dbf[0] = BMC050_M_WHO_AM_I; 
+        i2c.write(mag_addr, dbf, 1); 
+        i2c.read(mag_addr, dbf, 1);
+        if (dbf[0] == I_AM_BMC050_MAG){ mag_ready = 1;
+        } else {                        mag_ready = 0; }
+        if ( mag_ready == 1){
+            // set output data rate
+            dbf[0] = BMC050_M_OPERATION;
+            dbf[1] = mag_parameter->data_rate;
+            i2c.write(mag_addr, dbf, 2);
+        }
     }      
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
 void BMC050::read_data_acc(float *dt) {
 char data[6];
 
@@ -117,40 +123,37 @@
         dt[0] = dt[1] = dt[2] = 0;
         return;  
     }
-    // X
+    // X,Y &Z
     dbf[0] = BMC050_A_OUT_X_L; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[0] = dbf[0];
-    dbf[0] = BMC050_A_OUT_X_H         ; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[1] = dbf[0];
-    // Y
-    dbf[0] = BMC050_A_OUT_Y_L; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[2] = dbf[0];
-    dbf[0] = BMC050_A_OUT_Y_H; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[3] = dbf[0];
-    // Z
-    dbf[0] = BMC050_A_OUT_Z_L; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[4] = dbf[0];
-    dbf[0] = BMC050_A_OUT_Z_H; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
-    data[5] = dbf[0];
+    i2c.write(acc_addr, dbf, 1, true); 
+    i2c.read(acc_addr, data, 6, false);
     // change data type
     dt[0] = float((short(data[1] << 8 | data[0] & 0xc0))>> 6) * GRAVITY / fs_factor_acc;
     dt[1] = float((short(data[3] << 8 | data[2] & 0xc0))>> 6) * GRAVITY / fs_factor_acc;
     dt[2] = float((short(data[5] << 8 | data[4] & 0xc0))>> 6) * GRAVITY / fs_factor_acc;
 }
 
-/////////////// Magnetometer ///////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
+void BMC050::read_mg_acc(float *dt) {
+char data[6];
+
+    if (acc_ready == 0){
+        dt[0] = 0;
+        dt[1] = 0;
+        dt[2] = 0;
+        return;  
+    }
+    // X,Y &Z
+    dbf[0] = BMC050_A_OUT_X_L; 
+    i2c.write(acc_addr, dbf, 1, true); 
+    i2c.read(acc_addr, data, 6, false);
+    // change data type
+    dt[0] = float((short(data[1] << 8 | data[0] & 0xc0))>> 6) / fs_factor_acc;
+    dt[1] = float((short(data[3] << 8 | data[2] & 0xc0))>> 6) / fs_factor_acc;
+    dt[2] = float((short(data[5] << 8 | data[4] & 0xc0))>> 6) / fs_factor_acc;
+}
+
+/////////////// Magnetometer ////////////////////
 void BMC050::read_data_mag(float *dt) {
 char data[6];
 
@@ -158,69 +161,46 @@
         dt[0] = dt[1] = dt[2] = 0;
         return;  
     }
-    // X
+    // X,Y &Z
     dbf[0] = BMC050_M_OUT_X_L; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[0] = dbf[0];
-    dbf[0] = BMC050_M_OUT_X_H         ; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[1] = dbf[0];
-    // Y
-    dbf[0] = BMC050_M_OUT_Y_L; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[2] = dbf[0];
-    dbf[0] = BMC050_M_OUT_Y_H; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[3] = dbf[0];
-    // Z
-    dbf[0] = BMC050_M_OUT_Z_L; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[4] = dbf[0];
-    dbf[0] = BMC050_M_OUT_Z_H; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
-    data[5] = dbf[0];
+    i2c.write(mag_addr, dbf, 1, true); 
+    i2c.read(mag_addr, data, 6, false);
     // change data type
     dt[0] = float((short(data[1] << 8 | data[0] & 0xf8))>> 3);
     dt[1] = float((short(data[3] << 8 | data[2] & 0xf8))>> 3);
     dt[2] = float((short(data[5] << 8 | data[4] & 0xfe))>> 1);
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
 float BMC050::read_temp() {
     dbf[0] = BMC050_A_OUT_TEMP; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
+    i2c.write(acc_addr, dbf, 1); 
+    i2c.read(acc_addr, dbf, 1);
     return ((float)dbf[0] * 0.5 + 24.0);
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
 uint8_t BMC050::read_id_acc() {
     dbf[0] = BMC050_A_WHO_AM_I; 
-    i2c_write_n_bytes(acc_addr, dbf, 1); 
-    i2c_read_n_bytes(acc_addr, dbf, 1);
+    i2c.write(acc_addr, dbf, 1); 
+    i2c.read(acc_addr, dbf, 1);
     return (uint8_t)dbf[0];
 }
 
-/////////////// Magnetometer ///////////////////////////////////////////////////////
+/////////////// Magnetometer ////////////////////
 uint8_t BMC050::read_id_mag() {
     dbf[0] = BMC050_M_WHO_AM_I; 
-    i2c_write_n_bytes(mag_addr, dbf, 1); 
-    i2c_read_n_bytes(mag_addr, dbf, 1);
+    i2c.write(mag_addr, dbf, 1); 
+    i2c.read(mag_addr, dbf, 1);
     return (uint8_t)dbf[0];
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
 uint8_t BMC050::data_ready_acc() {
     if (acc_ready == 1){
         dbf[0] = BMC050_A_OUT_X_L; 
-        i2c_write_n_bytes(acc_addr, dbf, 1); 
-        i2c_read_n_bytes(acc_addr, dbf, 1);
+        i2c.write(acc_addr, dbf, 1); 
+        i2c.read(acc_addr, dbf, 1);
         if (!(dbf[0] & 0x01)){
             return 0;
         }
@@ -228,12 +208,12 @@
     return 1;
 }
 
-/////////////// Magnetometer ///////////////////////////////////////////////////////
+/////////////// Magnetometer ////////////////////
 uint8_t BMC050::data_ready_mag() {
     if (mag_ready == 1){
         dbf[0] = BMC050_M_HALL_L; 
-        i2c_write_n_bytes(mag_addr, dbf, 1); 
-        i2c_read_n_bytes(mag_addr, dbf, 1);
+        i2c.write(mag_addr, dbf, 1); 
+        i2c.read(mag_addr, dbf, 1);
         if (!(dbf[0] & 0x01)){
             return 0;
         }
@@ -241,53 +221,49 @@
     return 1;
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Accelerometer ///////////////////
 uint8_t BMC050::read_reg_acc(uint8_t addr) {
     if (acc_ready == 1){
         dbf[0] = addr; 
-        i2c_write_n_bytes(acc_addr, dbf, 1); 
-        i2c_read_n_bytes(acc_addr, dbf, 1);
-    } else {
-        dbf[0] = 0xff;
-    }
-    return (uint8_t)dbf[0];
-}
-
-/////////////// Magnetometer ///////////////////////////////////////////////////////
-uint8_t BMC050::read_reg_mag(uint8_t addr) {
-    if (mag_ready == 1){
-        dbf[0] = addr; 
-        i2c_write_n_bytes(mag_addr, dbf, 1); 
-        i2c_read_n_bytes(mag_addr, dbf, 1);
+        i2c.write(acc_addr, dbf, 1); 
+        i2c.read(acc_addr, dbf, 1);
     } else {
         dbf[0] = 0xff;
     }
     return (uint8_t)dbf[0];
 }
 
-/////////////// Accelerometer //////////////////////////////////////////////////////
+/////////////// Magnetometer ////////////////////
+uint8_t BMC050::read_reg_mag(uint8_t addr) {
+    if (mag_ready == 1){
+        dbf[0] = addr; 
+        i2c.write(mag_addr, dbf, 1); 
+        i2c.read(mag_addr, dbf, 1);
+    } else {
+        dbf[0] = 0xff;
+    }
+    return (uint8_t)dbf[0];
+}
+
+/////////////// Accelerometer ///////////////////
 void BMC050::write_reg_acc(uint8_t addr, uint8_t data) {
     if (acc_ready == 1){
         dbf[0] = addr;
         dbf[1] = data; 
-        i2c_write_n_bytes(acc_addr, dbf, 2); 
+        i2c.write(acc_addr, dbf, 2); 
     }
 }
 
-/////////////// Magnetometer ///////////////////////////////////////////////////////
+/////////////// Magnetometer ////////////////////
 void BMC050::write_reg_mag(uint8_t addr, uint8_t data) {
     if (mag_ready == 1){
         dbf[0] = addr;
         dbf[1] = data; 
-        i2c_write_n_bytes(mag_addr, dbf, 2); 
+        i2c.write(mag_addr, dbf, 2); 
     }
 }
 
-/////////////// Low level interface ////////////////////////////////////////////////
-void BMC050::i2c_read_n_bytes (int addr, char* dbf, int n) {
-    i2c.read(addr, dbf, n);
+/////////////// Common //////////////////////////
+void BMC050::frequency(int hz) {
+    i2c.frequency(hz);
 }
-
-void BMC050::i2c_write_n_bytes (int addr, char* dbf, int n) {
-    i2c.write(addr, dbf, n);
-}