How to set sensitivity of MPU6050 to 16g - and convert accel data to g units

[ossvale]

Hello,
I am using this great library to build a flight computer for rocket models. Everything works fine but I need to use the max sensitivity up to 16g because my rocket can be up to this high acceleration (even more sometimes): how can I set it in this library?
And when I get the acceleration values I am not sure which units it is reading, I think they are values in the range -32000 to 32000. How can I convert them to g or m/s2 ?
Thank you!
Valerio

[ZHomeSlice]

This is a cool project.
There are 2 things to consider First is that the 6-degree of freedom uses gravity to help create the Quaternion values of the embedded DMP (Digital Motion Processing) firmware loaded into the package. We will need to remove the Accelerometers from this to allow for the Eular values to ignore the acceleration of the rocket in the quaternion calculations. There is a 3-degree of freedom mode that requires alterations to the firmware. This will allow the accelerometers (I hope but I have not tried) to function separately from the eDMP firmware.

Also with your request of using 16g accelerometers, we must remove the use of the accelerometer form the eDMP firmware. The eDMP requires specific gyro rates and acceleration rates when in the 6-degree of freedom mode. We need to make several modification to the eDMP firmware

// Change eDMP to 3 Axis Low Power Quaternions it defaulted to 6 Axis Low Power Quaternions
#define CFG_8 (2718)
#define CFG_LP_QUAT (2712)
uint8_t regs1[4] = {0xA3,0xA3,0xA3,0xA3};
// write the above values to the eDMP memory location: (CFG_8, 4, regs1);
uint8_t regs2[4] = {0xC0,0xC2,0xC4,0xC6};
// write the above values to the eDMP memory location: (CFG_LP_QUAT, 4, regs2);

The above information is compatible with Jeff's version of the eDMP firmware.

Now the gyro is the only influence for orientation.
Changing the Acceleration to +-16g from +-2g
This is simple :)

0x1C bits 2,3 Accel Full Scale Select: 2g (00), 4g (01), 8g (10), 16g (11)
Changing the register address 0x1C Bits 2 & 3 (2 bits) must be changed to 11
now converting the -32,768 to 32,767 Raw value to +-16g
It's just shifting bits using division.
unsigned int 0 to 65535 equals signed int +-32,768 / 2048 = (float)+-16 g

to get the data you will need to read from the following registers
ACCEL_X_OUT 0x3B (uint16_t) Value // accelerometer x-axis data.
ACCEL_Y_OUT 0x3D (uint16_t) Value // accelerometer y-axis data.
ACCEL_Z_OUT 0x3F (uint16_t) Value // accelerometer z-axis data.

The value will be an unsigned integer and just convert it to a signed integer

unsigned int a; // what the readWord() function returns
int b = (int) a; // cast it to a signed integer
float c;
c = ((float) b) / 2048.0f; // and just divide it.

should work
Z

P.S. I have a library: Simple_MPU6050 which may help you achieve the above changes. This is a parallel library that achieves the exact same results just in a different way. I have been able to modify my library as I know it better than Jeff's.

[ossvale]

Thank you for your answer Homer,
I must say that I am not so good with programming and your explanation is a little beyond my knowledge...
But I had a look at your library and installed it: it works perfectly also with my Teensy 4.1 (the microcontroller I use for this project) .
The only thing that I cannot see is the calibration OFFSETS in the serial output, because I see:
// X Accel Y Accel Z Accel X Gyro Y Gyro Z Gyro
#define OFFSETS l, �, x, Z, �, �
(just symbols)

The example "Simple_MPU6050_Example" does everything I need (yaw/pitch/bend, accel and gyro x/y/z) except it uses +-2g as sensitivity.
Can you help me with the exact code to use in that example with 16g sensitivity?
If I can reach that sensitivity I can integrate your example in my code that is using also an altimeter, a GPS unit and writes all the telemetry data to SDcard. After that I want my project to send also all the telemetry via radio, but that's another step.

This is your example, of course you know it... :-)

Thank you!

Valerio

`/* ============================================
Simple_MPU6050 device library code is placed under the MIT license
Copyright (c) 2021 Homer Creutz

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

*/

//#include "MPU_ReadMacros.h"
//#inc;ude "MPU_WriteMacros.h"
#include "Simple_MPU6050.h"
#define MPU6050_ADDRESS_AD0_LOW 0x68 // address pin low (GND), default for InvenSense evaluation board
#define MPU6050_ADDRESS_AD0_HIGH 0x69 // address pin high (VCC)
#define MPU6050_DEFAULT_ADDRESS MPU6050_ADDRESS_AD0_LOW

Simple_MPU6050 mpu;
/* _________________________________________________________/
// X Accel Y Accel Z Accel X Gyro Y Gyro Z Gyro
//#define OFFSETS -5260, 6596, 7866, -45, 5, -9 // My Last offsets.
// You will want to use your own as these are only for my specific MPU6050.
/ _________________________________________________________*/

//***************************************************************************************
//****************** Print Functions **********************
//***************************************************************************************

#define spamtimer(t) for (static uint32_t SpamTimer; (uint32_t)(millis() - SpamTimer) >= (t); SpamTimer = millis()) // (BLACK BOX) Ya, don't complain that I used "for(;;){}" instead of "if(){}" for my Blink Without Delay Timer macro. It works nicely!!!

/* printfloatx() is a helper Macro used with the Serial class to simplify my code and provide enhanced viewing of Float and interger values:
usage: printfloatx(Name,Variable,Spaces,Precision,EndTxt);
Name and EndTxt are just char arrays
Variable is any numerical value byte, int, long and float
Spaces is the number of spaces the floating point number could possibly take up including +- and decimal point.
Precision is the number of digits after the decimal point set to zero for intergers
*/
#define printfloatx(Name,Variable,Spaces,Precision,EndTxt) print(Name); {char S[(Spaces + Precision + 3)];Serial.print(F(" ")); Serial.print(dtostrf((float)Variable,Spaces,Precision ,S));}Serial.print(EndTxt);//Name,Variable,Spaces,Precision,EndTxt

void PrintValues(int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
float ypr[3] = { 0, 0, 0 };
float xyz[3] = { 0, 0, 0 };
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.GetYawPitchRoll(ypr, &q, &gravity);
mpu.ConvertToDegrees(ypr, xyz);
Serial.printfloatx(F("Yaw") , xyz[0], 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("Pitch"), xyz[1], 9, 4, F(", "));
Serial.printfloatx(F("Roll") , xyz[2], 9, 4, F("\n"));
}
}

void ChartValues(int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
float ypr[3] = { 0, 0, 0 };
float xyz[3] = { 0, 0, 0 };
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.GetYawPitchRoll(ypr, &q, &gravity);
mpu.ConvertToDegrees(ypr, xyz);
Serial.printfloatx("", xyz[0], 9, 4, F(",")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx("", xyz[1], 9, 4, F(","));
Serial.printfloatx("", xyz[2], 9, 4, F("\n"));
}
}

//Gyro, Accel and Quaternion
void PrintAllValues(int16_t *gyro, int16_t *accel, int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
float ypr[3] = { 0, 0, 0 };
float xyz[3] = { 0, 0, 0 };
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.GetYawPitchRoll(ypr, &q, &gravity);
mpu.ConvertToDegrees(ypr, xyz);
Serial.printfloatx(F("Yaw") , xyz[0], 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("Pitch"), xyz[1], 9, 4, F(", "));
Serial.printfloatx(F("Roll") , xyz[2], 9, 4, F(", "));
Serial.printfloatx(F("ax") , accel[0], 5, 0, F(", "));
Serial.printfloatx(F("ay") , accel[1], 5, 0, F(", "));
Serial.printfloatx(F("az") , accel[2], 5, 0, F(", "));
Serial.printfloatx(F("gx") , gyro[0], 5, 0, F(", "));
Serial.printfloatx(F("gy") , gyro[1], 5, 0, F(", "));
Serial.printfloatx(F("gz") , gyro[2], 5, 0, F("\n"));
Serial.println();
}
}

void ChartAllValues(int16_t *gyro, int16_t *accel, int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
float ypr[3] = { 0, 0, 0 };
float xyz[3] = { 0, 0, 0 };
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.GetYawPitchRoll(ypr, &q, &gravity);
mpu.ConvertToDegrees(ypr, xyz);
Serial.printfloatx("", xyz[0], 9, 4, F(",")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx("", xyz[1], 9, 4, F(","));
Serial.printfloatx("", xyz[2], 9, 4, F(", "));
Serial.printfloatx("", accel[0], 5, 0, F(","));
Serial.printfloatx("", accel[1], 5, 0, F(","));
Serial.printfloatx("", accel[2], 5, 0, F(","));
Serial.printfloatx("", gyro[0], 5, 0, F(","));
Serial.printfloatx("", gyro[1], 5, 0, F(","));
Serial.printfloatx("", gyro[2], 5, 0, F("\n"));
}
}

void PrintQuaternion(int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
Serial.printfloatx(F("quat w") , q.w, 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("x") , q.x, 9, 4, F(", "));
Serial.printfloatx(F("y") , q.y, 9, 4, F(", "));
Serial.printfloatx(F("z") , q.z, 9, 4, F("\n"));
}
}

void PrintEuler(int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
float euler[3]; // [psi, theta, phi] Euler angle container
float eulerDEG[3]; // [psi, theta, phi] Euler angle container
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetEuler(euler, &q);
mpu.ConvertToDegrees(euler, eulerDEG);
Serial.printfloatx(F("euler ") , eulerDEG[0], 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("") , eulerDEG[1], 9, 4, F(", "));
Serial.printfloatx(F("") , eulerDEG[2], 9, 4, F("\n"));
}
}

void PrintRealAccel(int16_t *accel, int32_t *quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
VectorInt16 aa, aaReal;
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.SetAccel(&aa, accel);
mpu.GetLinearAccel(&aaReal, &aa, &gravity);
Serial.printfloatx(F("aReal x") , aaReal.x , 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("y") , aaReal.y , 9, 4, F(", "));
Serial.printfloatx(F("z") , aaReal.z, 9, 4, F("\n"));
}
}

void PrintWorldAccel(int16_t accel, int32_t quat, uint16_t SpamDelay = 100) {
Quaternion q;
VectorFloat gravity;
VectorInt16 aa, aaReal, aaWorld;
spamtimer(SpamDelay) {// non blocking delay before printing again. This skips the following code when delay time (ms) hasn't been met
mpu.GetQuaternion(&q, quat);
mpu.GetGravity(&gravity, &q);
mpu.SetAccel(&aa, accel);
mpu.GetLinearAccel(&aaReal, &aa, &gravity);
mpu.GetLinearAccelInWorld(&aaWorld, &aaReal, &q);
Serial.printfloatx(F("aWorld x") , aaWorld.x , 9, 4, F(", ")); //printfloatx is a Helper Macro that works with Serial.print that I created (See #define above)
Serial.printfloatx(F("y") , aaWorld.y, 9, 4, F(", "));
Serial.printfloatx(F("z") , aaWorld.z, 9, 4, F("\n"));
}
}
//*************************************************************************************
//****************** Callback Function **********************
//***************************************************************************************

void print_Values (int16_t *gyro, int16_t *accel, int32_t *quat) {
uint8_t Spam_Delay = 100; // Built in Blink without delay timer preventing Serial.print SPAM

// PrintValues(quat, Spam_Delay);
// ChartValues(quat, Spam_Delay);
PrintAllValues(gyro, accel, quat, Spam_Delay);
// ChartAllValues(gyro, accel, quat, Spam_Delay);
// PrintQuaternion(quat, Spam_Delay);
// PrintEuler(quat, Spam_Delay);
// PrintRealAccel(accel, quat, Spam_Delay);
// PrintWorldAccel(accel, quat, Spam_Delay);
}

//***************************************************************************************
//****************** Setup and Loop **********************
//***************************************************************************************

void setup() {
// initialize serial communication
Serial.begin(115200);
while (!Serial); // wait for Leonardo enumeration, others continue immediately
Serial.println(F("Start:"));
mpu.Set_DMP_Output_Rate_Hz(100); // Set the DMP output rate from 200Hz to 5 Minutes.
//mpu.Set_DMP_Output_Rate_Seconds(10); // Set the DMP output rate in Seconds
//mpu.Set_DMP_Output_Rate_Minutes(5); // Set the DMP output rate in Minute
#ifdef OFFSETS
Serial.println(F("Using Offsets"));
mpu.SetAddress(MPU6050_DEFAULT_ADDRESS);
mpu.load_DMP_Image(OFFSETS); // Does it all for you

#else
Serial.println(F(" Since no offsets are defined we are going to calibrate this specific MPU6050,\n"
" Start by having the MPU6050 placed stationary on a flat surface to get a proper accelerometer calibration\n"
" Place the new offsets on the #define OFFSETS... line at top of program for super quick startup\n\n"
" \t\t\t[Press Any Key]"));
while (Serial.available() && Serial.read()); // empty buffer
while (!Serial.available()); // wait for data
while (Serial.available() && Serial.read()); // empty buffer again
mpu.SetAddress(MPU6050_DEFAULT_ADDRESS);
mpu.CalibrateMPU();
mpu.load_DMP_Image();// Does it all for you with Calibration
#endif
mpu.on_FIFO(print_Values);
}

void loop() {
// mpu.dmp_read_fifo(ture);// Must be in loop Interrupt pin must be connected
mpu.dmp_read_fifo(false);// Must be in loop No Interrupt pin required at the expense of polling the i2c buss
}`

[ZHomeSlice]

Let's move our discussion over to the simple_mpu6050 Github site if you choose to use my library further. I'm sure Jeff would appreciate it. I've opened an issue Here: ZHomeSlice/Simple_MPU6050#26
to further our discussions.
See you there @ossvale

Thanks, Jeff, I Have a solution for ossval and when I get a bit of time I'll implement it into your MPU6050 library. :)