MPU-6050 (I2C) Library

Can someone help me port this library?
aster
Posts: 120
Joined: Thu Mar 30, 2017 2:41 pm
Location: bella italy
Contact:

Re: MPU-6050 (I2C) Library

Post by aster » Mon Oct 09, 2017 1:51 pm

I meant to use it with only a device, so i could remove all these start/stop!

anyway i spent the last 3 hours trying the spi interface but it is still not working
the problem is in the comunication with the magnetometer AK8963. the library is good when using the i2c but the spi part is bad written
if someone fix it please write here!

stevestrong
Posts: 2067
Joined: Mon Oct 19, 2015 12:06 am
Location: Munich, Germany
Contact:

Re: MPU-6050 (I2C) Library

Post by stevestrong » Mon Oct 09, 2017 2:04 pm

I cannot see any example code you did try when using SPI. Please post here.
Otherwise we cannot know what and why is not working.

aster
Posts: 120
Joined: Thu Mar 30, 2017 2:41 pm
Location: bella italy
Contact:

Re: MPU-6050 (I2C) Library

Post by aster » Mon Oct 09, 2017 2:18 pm

i used the example inside the library: https://github.com/sparkfun/SparkFun_MP ... RS_SPI.ino (change who i am from 0x71 to 0x73)
and it didn't work
so i started to modify it cutting all the not necessary pieces but i wasn't able to have it working anyway

Code: Select all

/* MPU9250 Basic Example Code
  by: Kris Winer
  date: April 1, 2014
  license: Beerware - Use this code however you'd like. If you
  find it useful you can buy me a beer some time.
  Modified by Brent Wilkins January 9, 2016

  Demonstrate basic MPU-9250 functionality including parameterizing the register
  addresses, initializing the sensor, getting properly scaled accelerometer,
  gyroscope, and magnetometer data out. Added display functions to allow display
  to on breadboard monitor. Addition of 9 DoF sensor fusion using open source
  Madgwick and Mahony filter algorithms. Sketch runs on the 3.3 V 8 MHz Pro Mini.

*/

#include "quaternionFilters.h"
#include "MPU9250.h"
#include "Streaming.h"

#define AHRS true         // Set to false for basic data read
#define SERIAL_DEBUG false  // Set to true to get Serial output for debugging

MPU9250 myIMU = MPU9250(10); // Using digital pin to for chip select in demo

void setup() {

  Serial.begin(115200);
  myIMU.begin();

  Serial << "is in i2c mode? " << myIMU.isInI2cMode() << newl;

  Serial.println("Testing MPU9250::readBytesSPI...");
  byte c = 0;
  myIMU.readBytes(MPU9250_ADDRESS, WHO_AM_I_MPU9250, 1, &c);
  Serial.println(c, HEX); //should be 0x73

  if (c == 0x73) {
    Serial.println(F("MPU9250 is online..."));

    // Start by performing self test and reporting values
    myIMU.MPU9250SelfTest(myIMU.selfTest);
    Serial.print(F("x-axis self test: acceleration trim within : "));
    Serial.print(myIMU.selfTest[0], 1); Serial.println("% of factory value");
    Serial.print(F("y-axis self test: acceleration trim within : "));
    Serial.print(myIMU.selfTest[1], 1); Serial.println("% of factory value");
    Serial.print(F("z-axis self test: acceleration trim within : "));
    Serial.print(myIMU.selfTest[2], 1); Serial.println("% of factory value");
    Serial.print(F("x-axis self test: gyration trim within : "));
    Serial.print(myIMU.selfTest[3], 1); Serial.println("% of factory value");
    Serial.print(F("y-axis self test: gyration trim within : "));
    Serial.print(myIMU.selfTest[4], 1); Serial.println("% of factory value");
    Serial.print(F("z-axis self test: gyration trim within : "));
    Serial.print(myIMU.selfTest[5], 1); Serial.println("% of factory value");

    // Calibrate gyro and accelerometers, load biases in bias registers
    myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);


    myIMU.initMPU9250();
    // Initialize device for active mode read of acclerometer, gyroscope, and
    // temperature
    Serial.println("MPU9250 initialized for active data mode....");

    //now lets work with the magnetometer
    myIMU.ak8963WhoAmI_SPI();
    // Set slave address of AK8963 and set AK8963 for read
    //myIMU.writeByteSPI(I2C_SLV0_ADDR, AK8963_ADDRESS);
    // Set address to start read from
    //myIMU.writeByteSPI(I2C_SLV0_REG, WHO_AM_I_AK8963);

    
    byte fd = 0;
    myIMU.readBytes(AK8963_ADDRESS, WHO_AM_I_AK8963, 1, &fd);
    Serial.println(fd, HEX);

    // Read the WHO_AM_I register of the magnetometer, this is a good test of
    // communication
    byte d = myIMU.readByte(AK8963_ADDRESS, WHO_AM_I_AK8963);
    Serial.print("AK8963 ");
    Serial.print("I AM 0x");
    Serial.print(d, HEX);
    Serial.print(" I should be 0x");
    Serial.println(0x48, HEX);
    /*










            if (d != 0x48)
            {
              // Communication failed, stop here
              Serial.println(F("Communication failed, abort!"));
              Serial.flush();
              abort();
            }

            // Get magnetometer calibration from AK8963 ROM
            myIMU.initAK8963(myIMU.factoryMagCalibration);
            // Initialize device for active mode read of magnetometer
            Serial.println("AK8963 initialized for active data mode....");

          #ifdef SERIAL_DEBUG
            //  Serial.println("Calibration values: ");
            Serial.print("X-Axis factory sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[0], 2);
            Serial.print("Y-Axis factory sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[1], 2);
            Serial.print("Z-Axis factory sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[2], 2);
          #endif  // SERIAL_DEBUG


            // Get sensor resolutions, only need to do this once
            myIMU.getAres();
            myIMU.getGres();
            myIMU.getMres();

            // The next call delays for 4 seconds, and then records about 15 seconds of
            // data to calculate bias and scale.
            myIMU.magCalMPU9250(myIMU.magBias, myIMU.magScale);
            Serial.println("AK8963 mag biases (mG)");
            Serial.println(myIMU.magBias[0]);
            Serial.println(myIMU.magBias[1]);
            Serial.println(myIMU.magBias[2]);

            Serial.println("AK8963 mag scale (mG)");
            Serial.println(myIMU.magScale[0]);
            Serial.println(myIMU.magScale[1]);
            Serial.println(myIMU.magScale[2]);
            delay(2000); // Add delay to see results before serial spew of data

          #ifdef SERIAL_DEBUG
            Serial.println("Magnetometer:");
            Serial.print("X-Axis sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[0], 2);
            Serial.print("Y-Axis sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[1], 2);
            Serial.print("Z-Axis sensitivity adjustment value ");
            Serial.println(myIMU.factoryMagCalibration[2], 2);
          #endif  // SERIAL_DEBUG

          } // if (c == 0x71)
          else
          {
            Serial.print("Could not connect to MPU9250: 0x");
            Serial.println(c, HEX);

            // Communication failed, stop here
            Serial.println(F("Communication failed, abort!"));
            Serial.flush();
            abort();
          }
    */
  }
}

void loop()
{ /*
    // TODO: Fix these comments not interrupt pin used
    // If intPin goes high, all data registers have new data
    // On interrupt, check if data ready interrupt
    if (myIMU.readByte(MPU9250_ADDRESS, INT_STATUS) & 0x01)
    {
     myIMU.readAccelData(myIMU.accelCount);  // Read the x/y/z adc values

     // Now we'll calculate the accleration value into actual g's
     // This depends on scale being set
     myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes; // - myIMU.accelBias[0];
     myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes; // - myIMU.accelBias[1];
     myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes; // - myIMU.accelBias[2];

     myIMU.readGyroData(myIMU.gyroCount);  // Read the x/y/z adc values

     // Calculate the gyro value into actual degrees per second
     // This depends on scale being set
     myIMU.gx = (float)myIMU.gyroCount[0] * myIMU.gRes;
     myIMU.gy = (float)myIMU.gyroCount[1] * myIMU.gRes;
     myIMU.gz = (float)myIMU.gyroCount[2] * myIMU.gRes;

     myIMU.readMagData(myIMU.magCount);  // Read the x/y/z adc values

     // Calculate the magnetometer values in milliGauss
     // Include factory calibration per data sheet and user environmental
     // corrections
     // Get actual magnetometer value, this depends on scale being set
     myIMU.mx = (float)myIMU.magCount[0] * myIMU.mRes
                  myIMU.factoryMagCalibration[0] - myIMU.magBias[0];
     myIMU.my = (float)myIMU.magCount[1] * myIMU.mRes
                  myIMU.factoryMagCalibration[1] - myIMU.magBias[1];
     myIMU.mz = (float)myIMU.magCount[2] * myIMU.mRes
                  myIMU.factoryMagCalibration[2] - myIMU.magBias[2];
    } // if (readByte(MPU9250_ADDRESS, INT_STATUS) & 0x01)

    // Must be called before updating quaternions!
    myIMU.updateTime();

    // Sensors x (y)-axis of the accelerometer is aligned with the y (x)-axis of
    // the magnetometer; the magnetometer z-axis (+ down) is opposite to z-axis
    // (+ up) of accelerometer and gyro! We have to make some allowance for this
    // orientationmismatch in feeding the output to the quaternion filter. For the
    // MPU-9250, we have chosen a magnetic rotation that keeps the sensor forward
    // along the x-axis just like in the LSM9DS0 sensor. This rotation can be
    // modified to allow any convenient orientation convention. This is ok by
    // aircraft orientation standards! Pass gyro rate as rad/s
    MahonyQuaternionUpdate(myIMU.ax, myIMU.ay, myIMU.az, myIMU.gx * DEG_TO_RAD,
                          myIMU.gy * DEG_TO_RAD, myIMU.gz * DEG_TO_RAD, myIMU.my,
                          myIMU.mx, myIMU.mz, myIMU.deltat);

    if (!AHRS)
    {
     myIMU.delt_t = millis() - myIMU.count;
     if (myIMU.delt_t > 500)
     {
    #ifdef SERIAL_DEBUG
       // Print acceleration values in milligs!
       Serial.print("X-acceleration: "); Serial.print(1000 * myIMU.ax);
       Serial.print(" mg ");
       Serial.print("Y-acceleration: "); Serial.print(1000 * myIMU.ay);
       Serial.print(" mg ");
       Serial.print("Z-acceleration: "); Serial.print(1000 * myIMU.az);
       Serial.println(" mg ");

       // Print gyro values in degree/sec
       Serial.print("X-gyro rate: "); Serial.print(myIMU.gx, 3);
       Serial.print(" degrees/sec ");
       Serial.print("Y-gyro rate: "); Serial.print(myIMU.gy, 3);
       Serial.print(" degrees/sec ");
       Serial.print("Z-gyro rate: "); Serial.print(myIMU.gz, 3);
       Serial.println(" degrees/sec");

       // Print mag values in degree/sec
       Serial.print("X-mag field: "); Serial.print(myIMU.mx);
       Serial.print(" mG ");
       Serial.print("Y-mag field: "); Serial.print(myIMU.my);
       Serial.print(" mG ");
       Serial.print("Z-mag field: "); Serial.print(myIMU.mz);
       Serial.println(" mG");

       myIMU.tempCount = myIMU.readTempData();  // Read the adc values
       // Temperature in degrees Centigrade
       myIMU.temperature = ((float) myIMU.tempCount) / 333.87 + 21.0;
       // Print temperature in degrees Centigrade
       Serial.print("Temperature is ");  Serial.print(myIMU.temperature, 1);
       Serial.println(" degrees C");
    #endif  // SERIAL_DEBUG


       myIMU.count = millis();
     } // if (myIMU.delt_t > 500)
    } // if (!AHRS)
    else
    {
     // Serial print and/or display at 0.5 s rate independent of data rates
     myIMU.delt_t = millis() - myIMU.count;

     // update LCD once per half-second independent of read rate
     if (myIMU.delt_t > 500)
     {
    #ifdef SERIAL_DEBUG
       Serial.print("ax = ");  Serial.print((int)1000 * myIMU.ax);
       Serial.print(" ay = "); Serial.print((int)1000 * myIMU.ay);
       Serial.print(" az = "); Serial.print((int)1000 * myIMU.az);
       Serial.println(" mg");

       Serial.print("gx = ");  Serial.print(myIMU.gx, 2);
       Serial.print(" gy = "); Serial.print(myIMU.gy, 2);
       Serial.print(" gz = "); Serial.print(myIMU.gz, 2);
       Serial.println(" deg/s");

       Serial.print("mx = ");  Serial.print((int)myIMU.mx);
       Serial.print(" my = "); Serial.print((int)myIMU.my);
       Serial.print(" mz = "); Serial.print((int)myIMU.mz);
       Serial.println(" mG");

       Serial.print("q0 = ");  Serial.print(*getQ());
       Serial.print(" qx = "); Serial.print(*(getQ() + 1));
       Serial.print(" qy = "); Serial.print(*(getQ() + 2));
       Serial.print(" qz = "); Serial.println(*(getQ() + 3));
    #endif  // SERIAL_DEBUG

       // Define output variables from updated quaternion---these are Tait-Bryan
       // angles, commonly used in aircraft orientation. In this coordinate system,
       // the positive z-axis is down toward Earth. Yaw is the angle between Sensor
       // x-axis and Earth magnetic North (or true North if corrected for local
       // declination, looking down on the sensor positive yaw is counterclockwise.
       // Pitch is angle between sensor x-axis and Earth ground plane, toward the
       // Earth is positive, up toward the sky is negative. Roll is angle between
       // sensor y-axis and Earth ground plane, y-axis up is positive roll. These
       // arise from the definition of the homogeneous rotation matrix constructed
       // from quaternions. Tait-Bryan angles as well as Euler angles are
       // non-commutative; that is, the get the correct orientation the rotations
       // must be applied in the correct order which for this configuration is yaw,
       // pitch, and then roll.
       // For more see
       // http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles
       // which has additional links.
       myIMU.yaw   = atan2(2.0f * (*(getQ() + 1) * *(getQ() + 2) + *getQ()
                                   * *(getQ() + 3)), *getQ() * *getQ() + * (getQ() + 1)
                           * *(getQ() + 1) - * (getQ() + 2) * *(getQ() + 2) - * (getQ() + 3)
                           * *(getQ() + 3));
       myIMU.pitch = -asin(2.0f * (*(getQ() + 1) * *(getQ() + 3) - *getQ()
                                   * *(getQ() + 2)));
       myIMU.roll  = atan2(2.0f * (*getQ() * *(getQ() + 1) + * (getQ() + 2)
                                   * *(getQ() + 3)), *getQ() * *getQ() - * (getQ() + 1)
                           * *(getQ() + 1) - * (getQ() + 2) * *(getQ() + 2) + * (getQ() + 3)
                           * *(getQ() + 3));
       myIMU.pitch *= RAD_TO_DEG;
       myIMU.yaw   *= RAD_TO_DEG;

       // Declination of SparkFun Electronics (40°05'26.6"N 105°11'05.9"W) is
       // 	8° 30' E  ± 0° 21' (or 8.5°) on 2016-07-19
       // - http://www.ngdc.noaa.gov/geomag-web/#declination
       myIMU.yaw  -= 8.5;
       myIMU.roll *= RAD_TO_DEG;

    #ifdef SERIAL_DEBUG
       Serial.print("Yaw, Pitch, Roll: ");
       Serial.print(myIMU.yaw, 2);
       Serial.print(", ");
       Serial.print(myIMU.pitch, 2);
       Serial.print(", ");
       Serial.println(myIMU.roll, 2);

       Serial.print("rate = ");
       Serial.print((float)myIMU.sumCount / myIMU.sum, 2);
       Serial.println(" Hz");
    #endif  // SERIAL_DEBUG

       // With these settings the filter is updating at a ~145 Hz rate using the
       // Madgwick scheme and >200 Hz using the Mahony scheme even though the
       // display refreshes at only 2 Hz. The filter update rate is determined
       // mostly by the mathematical steps in the respective algorithms, the
       // processor speed (8 MHz for the 3.3V Pro Mini), and the magnetometer ODR:
       // an ODR of 10 Hz for the magnetometer produce the above rates, maximum
       // magnetometer ODR of 100 Hz produces filter update rates of 36 - 145 and
       // ~38 Hz for the Madgwick and Mahony schemes, respectively. This is
       // presumably because the magnetometer read takes longer than the gyro or
       // accelerometer reads. This filter update rate should be fast enough to
       // maintain accurate platform orientation for stabilization control of a
       // fast-moving robot or quadcopter. Compare to the update rate of 200 Hz
       // produced by the on-board Digital Motion Processor of Invensense's MPU6050
       // 6 DoF and MPU9150 9DoF sensors. The 3.3 V 8 MHz Pro Mini is doing pretty
       // well!


       myIMU.count = millis();
       myIMU.sumCount = 0;
       myIMU.sum = 0;
     } // if (myIMU.delt_t > 500)
    } // if (AHRS)
  */
}

stevestrong
Posts: 2067
Joined: Mon Oct 19, 2015 12:06 am
Location: Munich, Germany
Contact:

Re: MPU-6050 (I2C) Library

Post by stevestrong » Mon Oct 09, 2017 3:45 pm

I still cannot see where do you use the SPI port.
And what exactly is not working? Have you connected the MPU chip to SPI port pins?

aster
Posts: 120
Joined: Thu Mar 30, 2017 2:41 pm
Location: bella italy
Contact:

Re: MPU-6050 (I2C) Library

Post by aster » Mon Oct 09, 2017 5:07 pm

i use spi every time i call "readBytes"
anyway the problem is with the library itself not with the spi communication

Post Reply