### Retrieve Orientation Quaternions with MPU-9250

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

The getQ() function returns a pointer to the current quaternion array [q0, q1, q2, q3] calculated by the sensor fusion filters. This example demonstrates initializing the MPU-9250 sensor and retrieving the orientation data within the main loop.

```cpp
#include "quaternionFilters.h"
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();
  myIMU.initAK8963(myIMU.factoryMagCalibration);
  myIMU.getAres();
  myIMU.getGres();
  myIMU.getMres();
}

void loop() {
  if (myIMU.readByte(MPU9250_ADDRESS_AD0, INT_STATUS) & 0x01) {
    myIMU.readAccelData(myIMU.accelCount);
    myIMU.readGyroData(myIMU.gyroCount);
    myIMU.readMagData(myIMU.magCount);

    myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes;
    myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes;
    myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes;
    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.updateTime();
  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);

  const float *q = getQ();

  Serial.print("Quaternion: q0="); Serial.print(q[0], 4);
  Serial.print(" q1="); Serial.print(q[1], 4);
  Serial.print(" q2="); Serial.print(q[2], 4);
  Serial.print(" q3="); Serial.println(q[3], 4);

  delay(100);
}
```

--------------------------------

### Initialize AK8963 Magnetometer

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Initializes the AK8963 magnetometer by powering it up, reading factory calibration values from the fuse ROM, and configuring measurement modes. It requires the MPU9250 library and returns calibration values essential for accurate magnetic field readings.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  myIMU.initMPU9250();

  // Verify magnetometer connection
  byte d = myIMU.readByte(AK8963_ADDRESS, WHO_AM_I_AK8963);
  if (d == 0x48) {
    Serial.println("AK8963 magnetometer found!");

    // Initialize magnetometer and get factory calibration
    myIMU.initAK8963(myIMU.factoryMagCalibration);

    Serial.println("Factory Magnetometer Calibration Values:");
    Serial.print("X-Axis sensitivity adjustment: ");
    Serial.println(myIMU.factoryMagCalibration[0], 2);
    Serial.print("Y-Axis sensitivity adjustment: ");
    Serial.println(myIMU.factoryMagCalibration[1], 2);
    Serial.print("Z-Axis sensitivity adjustment: ");
    Serial.println(myIMU.factoryMagCalibration[2], 2);

    myIMU.getMres();  // Set magnetometer resolution
  }
}
```

--------------------------------

### Initialize MPU-9250 via SPI

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Configures the MPU-9250 object for SPI communication. Requires the chip select pin and SPI port, and includes a hardware kick to ensure proper SPI mode initialization.

```cpp
#include <SPI.h>
#include "MPU9250.h"

#define SPIspeed 1000000  // 1MHz max for MPU-9250
#define SPIport SPI
#define CSpin 2

// Create MPU9250 object with CS pin, SPI port, and clock speed
MPU9250 myIMU(CSpin, SPIport, SPIspeed);

void setup() {
  Serial.begin(38400);
  SPIport.begin();

  // Kick the hardware to ensure SPI is in correct mode
  myIMU.kickHardware();

  // Verify connection
  byte c = myIMU.readByte(0, WHO_AM_I_MPU9250);  // Address ignored for SPI
  if (c == 0x71) {
    Serial.println("MPU9250 is online via SPI!");
  }
}
```

--------------------------------

### Initialize MPU-9250 via I2C

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Configures the MPU-9250 object for I2C communication using the Wire library. It verifies the connection by reading the WHO_AM_I register to ensure the device is responsive.

```cpp
#include <Wire.h>
#include "MPU9250.h"

#define I2Cclock 400000
#define I2Cport Wire
#define MPU9250_ADDRESS MPU9250_ADDRESS_AD0  // 0x68 when AD0 is low

// Create MPU9250 object with I2C address, Wire port, and clock speed
MPU9250 myIMU(MPU9250_ADDRESS, I2Cport, I2Cclock);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  // Verify connection by reading WHO_AM_I register
  byte c = myIMU.readByte(MPU9250_ADDRESS, WHO_AM_I_MPU9250);
  Serial.print("MPU9250 I AM 0x");
  Serial.print(c, HEX);
  Serial.print(" I should be 0x71");

  if (c == 0x71) {
    Serial.println(" - MPU9250 is online!");
  }
}
```

--------------------------------

### Calibrate and Initialize MPU-9250

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Performs sensor calibration to calculate gyro and accelerometer biases, followed by initialization of the sensor for active data collection. This process sets sample rates and resolution scales.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  // First calibrate the sensor (device must be stationary)
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  Serial.println("Calibration complete");
  Serial.print("Gyro bias X: "); Serial.print(myIMU.gyroBias[0]);
  Serial.print(" Y: "); Serial.print(myIMU.gyroBias[1]);
  Serial.print(" Z: "); Serial.println(myIMU.gyroBias[2]);

  // Initialize the MPU9250 for active data mode
  myIMU.initMPU9250();
  Serial.println("MPU9250 initialized for active data mode");

  // Get resolution values for converting raw data
  myIMU.getAres();  // Sets aRes based on Ascale setting
  myIMU.getGres();  // Sets gRes based on Gscale setting
}
```

--------------------------------

### Implement Full 9-DOF AHRS Sensor Fusion

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Demonstrates the complete workflow for initializing the MPU-9250, calibrating sensors, and calculating orientation angles using the Mahony quaternion filter. The code reads raw accelerometer, gyroscope, and magnetometer data, updates the filter, and outputs Euler angles via serial communication.

```cpp
#include "quaternionFilters.h"
#include "MPU9250.h"

#define I2Cclock 400000
#define MPU9250_ADDRESS MPU9250_ADDRESS_AD0

MPU9250 myIMU(MPU9250_ADDRESS, Wire, I2Cclock);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  byte c = myIMU.readByte(MPU9250_ADDRESS, WHO_AM_I_MPU9250);
  if (c != 0x71) {
    Serial.println("MPU9250 not found!");
    while(1);
  }

  myIMU.MPU9250SelfTest(myIMU.selfTest);
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();

  byte d = myIMU.readByte(AK8963_ADDRESS, WHO_AM_I_AK8963);
  if (d != 0x48) {
    Serial.println("AK8963 not found!");
    while(1);
  }
  myIMU.initAK8963(myIMU.factoryMagCalibration);

  myIMU.getAres();
  myIMU.getGres();
  myIMU.getMres();
}

void loop() {
  if (myIMU.readByte(MPU9250_ADDRESS, INT_STATUS) & 0x01) {
    myIMU.readAccelData(myIMU.accelCount);
    myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes;
    myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes;
    myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes;

    myIMU.readGyroData(myIMU.gyroCount);
    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);
    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];
  }

  myIMU.updateTime();
  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);

  static uint32_t lastPrint = 0;
  if (millis() - lastPrint > 500) {
    lastPrint = millis();
    const float *q = getQ();
    myIMU.yaw   = atan2(2.0f * (q[1]*q[2] + q[0]*q[3]), q[0]*q[0] + q[1]*q[1] - q[2]*q[2] - q[3]*q[3]);
    myIMU.pitch = -asin(2.0f * (q[1]*q[3] - q[0]*q[2]));
    myIMU.roll  = atan2(2.0f * (q[0]*q[1] + q[2]*q[3]), q[0]*q[0] - q[1]*q[1] - q[2]*q[2] + q[3]*q[3]);
    
    Serial.print("Yaw: "); Serial.print(myIMU.yaw * RAD_TO_DEG, 1);
    Serial.print("  Pitch: "); Serial.print(myIMU.pitch * RAD_TO_DEG, 1);
    Serial.print("  Roll: "); Serial.println(myIMU.roll * RAD_TO_DEG, 1);
  }
}
```

--------------------------------

### Calibrate Magnetometer for MPU-9250 (Arduino)

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Performs magnetometer calibration by sampling data during a figure-8 motion for about 15 seconds. It calculates hard-iron (bias) and soft-iron (scale) correction values for accurate heading. Requires the MPU9250 library and Wire library.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  myIMU.initMPU9250();
  myIMU.initAK8963(myIMU.factoryMagCalibration);
  myIMU.getMres();

  Serial.println("Starting magnetometer calibration in 4 seconds...");
  Serial.println("Wave device in a figure-8 pattern for 15 seconds");

  // Perform mag calibration - user must move device in figure-8
  // Function blocks for ~19 seconds (4s prep + 15s sampling)
  myIMU.magCalMPU9250(myIMU.magBias, myIMU.magScale);

  Serial.println("Magnetometer calibration complete!");
  Serial.println("Mag biases (mG):");
  Serial.print("  X: "); Serial.println(myIMU.magBias[0]);
  Serial.print("  Y: "); Serial.println(myIMU.magBias[1]);
  Serial.print("  Z: "); Serial.println(myIMU.magBias[2]);

  Serial.println("Mag scale factors:");
  Serial.print("  X: "); Serial.println(myIMU.magScale[0]);
  Serial.print("  Y: "); Serial.println(myIMU.magScale[1]);
  Serial.print("  Z: "); Serial.println(myIMU.magScale[2]);
}

```

--------------------------------

### Read Magnetometer Data

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Reads raw 16-bit magnetometer data from the AK8963. It applies resolution (mRes), factory calibration, and bias correction to output data in milliGauss.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.initMPU9250();
  myIMU.initAK8963(myIMU.factoryMagCalibration);
  myIMU.getMres();  // Get magnetometer resolution (default MFS_16BITS)
}

void loop() {
  // Read raw magnetometer data
  myIMU.readMagData(myIMU.magCount);

  // Convert to milliGauss with factory calibration and bias correction
  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];

  Serial.print("Mag X: "); Serial.print(myIMU.mx);
  Serial.print(" mG  Y: "); Serial.print(myIMU.my);
  Serial.print(" mG  Z: "); Serial.print(myIMU.mz);
  Serial.println(" mG");

  delay(125);  // Magnetometer updates at 8Hz in default mode
}
```

--------------------------------

### Run MPU-9250 Self-Test (Arduino)

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Performs the built-in self-test for both accelerometer and gyroscope. It returns the percentage deviation from factory trim values for all six axes. Deviations within +/-14% are considered passing. Requires the MPU9250 library and Wire library.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  Serial.println("Running MPU9250 Self Test...");

  // Perform self test - results stored in selfTest array
  myIMU.MPU9250SelfTest(myIMU.selfTest);

  Serial.println("Accelerometer Self Test (% deviation from factory):");
  Serial.print("  X-axis: "); Serial.print(myIMU.selfTest[0], 1);
  Serial.println(abs(myIMU.selfTest[0]) < 14 ? "% PASS" : "% FAIL");
  Serial.print("  Y-axis: "); Serial.print(myIMU.selfTest[1], 1);
  Serial.println(abs(myIMU.selfTest[1]) < 14 ? "% PASS" : "% FAIL");
  Serial.print("  Z-axis: "); Serial.print(myIMU.selfTest[2], 1);
  Serial.println(abs(myIMU.selfTest[2]) < 14 ? "% PASS" : "% FAIL");

  Serial.println("Gyroscope Self Test (% deviation from factory):");
  Serial.print("  X-axis: "); Serial.print(myIMU.selfTest[3], 1);
  Serial.println(abs(myIMU.selfTest[3]) < 14 ? "% PASS" : "% FAIL");
  Serial.print("  Y-axis: "); Serial.print(myIMU.selfTest[4], 1);
  Serial.println(abs(myIMU.selfTest[4]) < 14 ? "% PASS" : "% FAIL");
  Serial.print("  Z-axis: "); Serial.print(myIMU.selfTest[5], 1);
  Serial.println(abs(myIMU.selfTest[5]) < 14 ? "% PASS" : "% FAIL");
}

```

--------------------------------

### Madgwick AHRS Filter Implementation in Arduino

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Implements Sebastian Madgwick's efficient AHRS algorithm to fuse accelerometer, gyroscope, and magnetometer data for quaternion-based orientation estimation. Requires the quaternionFilters and MPU9250 libraries. Outputs Euler angles (Yaw, Pitch, Roll) after processing sensor data.

```cpp
#include "quaternionFilters.h"
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();
  myIMU.initAK8963(myIMU.factoryMagCalibration);
  myIMU.getAres();
  myIMU.getGres();
  myIMU.getMres();
}

void loop() {
  if (myIMU.readByte(MPU9250_ADDRESS_AD0, INT_STATUS) & 0x01) {
    // Read all sensor data
    myIMU.readAccelData(myIMU.accelCount);
    myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes;
    myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes;
    myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes;

    myIMU.readGyroData(myIMU.gyroCount);
    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);
    myIMU.mx = (float)myIMU.magCount[0] * myIMU.mRes * myIMU.factoryMagCalibration[0];
    myIMU.my = (float)myIMU.magCount[1] * myIMU.mRes * myIMU.factoryMagCalibration[1];
    myIMU.mz = (float)myIMU.magCount[2] * myIMU.mRes * myIMU.factoryMagCalibration[2];
  }

  // Calculate delta time for filter
  myIMU.updateTime();

  // Apply Madgwick filter (gyro rates must be in rad/s)
  // Note: Sensor axes may need remapping depending on mounting orientation
  MadgwickQuaternionUpdate(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);

  // Get quaternion and convert to Euler angles
  const float *q = getQ();
  myIMU.yaw   = atan2(2.0f * (q[1] * q[2] + q[0] * q[3]),
                      q[0] * q[0] + q[1] * q[1] - q[2] * q[2] - q[3] * q[3]);
  myIMU.pitch = -asin(2.0f * (q[1] * q[3] - q[0] * q[2]));
  myIMU.roll  = atan2(2.0f * (q[0] * q[1] + q[2] * q[3]),
                      q[0] * q[0] - q[1] * q[1] - q[2] * q[2] + q[3] * q[3]);

  // Convert to degrees and apply magnetic declination
  myIMU.yaw   *= RAD_TO_DEG;
  myIMU.pitch *= RAD_TO_DEG;
  myIMU.roll  *= RAD_TO_DEG;
  myIMU.yaw   -= 8.5;  // Adjust for local magnetic declination

  Serial.print("Yaw: "); Serial.print(myIMU.yaw, 2);
  Serial.print(" Pitch: "); Serial.print(myIMU.pitch, 2);
  Serial.print(" Roll: "); Serial.println(myIMU.roll, 2);
}
```

--------------------------------

### Read Accelerometer Data

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Reads raw 16-bit accelerometer data from the MPU-9250 and converts it to g-force values. It utilizes the accelerometer resolution (aRes) and supports configurable scales from +/-2g to +/-16g.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();
  myIMU.getAres();  // Get resolution for current scale setting (default AFS_2G)
}

void loop() {
  // Check if new data is available
  if (myIMU.readByte(MPU9250_ADDRESS_AD0, INT_STATUS) & 0x01) {
    // Read raw accelerometer data into accelCount array
    myIMU.readAccelData(myIMU.accelCount);

    // Convert to actual g values using resolution
    myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes;
    myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes;
    myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes;

    // Print acceleration in milli-g's
    Serial.print("Accel X: "); Serial.print(1000 * myIMU.ax);
    Serial.print(" mg  Y: "); Serial.print(1000 * myIMU.ay);
    Serial.print(" mg  Z: "); Serial.print(1000 * myIMU.az);
    Serial.println(" mg");
  }
  delay(100);
}
```

--------------------------------

### Calibrate Gyroscope and Accelerometer for MPU-9250 (Arduino)

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Performs gyroscope and accelerometer calibration by collecting stationary samples. It calculates bias values, loads them into hardware registers, and returns them. The device must remain still during calibration. Requires the MPU9250 library and Wire library.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();

  Serial.println("Keep the sensor stationary for calibration...");
  delay(2000);

  // Perform calibration - populates gyroBias and accelBias arrays
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);

  Serial.println("Calibration complete!");
  Serial.println("Accelerometer biases (mg):");
  Serial.print("  X: "); Serial.println(1000 * myIMU.accelBias[0]);
  Serial.print("  Y: "); Serial.println(1000 * myIMU.accelBias[1]);
  Serial.print("  Z: "); Serial.println(1000 * myIMU.accelBias[2]);

  Serial.println("Gyroscope biases (deg/s):");
  Serial.print("  X: "); Serial.println(myIMU.gyroBias[0], 1);
  Serial.print("  Y: "); Serial.println(myIMU.gyroBias[1], 1);
  Serial.print("  Z: "); Serial.println(myIMU.gyroBias[2], 1);

  myIMU.initMPU9250();
}
```

--------------------------------

### Read Temperature Data from MPU-9250 (Arduino)

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Reads raw 16-bit temperature data from the MPU-9250's internal sensor. The raw value can be converted to Celsius using a specific formula. Requires the MPU9250 library and Wire library.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.initMPU9250();
}

void loop() {
  // Read raw temperature data
  myIMU.tempCount = myIMU.readTempData();

  // Convert to Celsius
  myIMU.temperature = ((float)myIMU.tempCount) / 333.87 + 21.0;

  Serial.print("Temperature: ");
  Serial.print(myIMU.temperature, 1);
  Serial.println(" C");

  delay(1000);
}
```

--------------------------------

### Mahony AHRS Filter Implementation in Arduino

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Implements the Mahony complementary filter for AHRS, utilizing proportional-integral feedback on orientation error for faster processing than Madgwick. Suitable for real-time control applications. Requires the quaternionFilters and MPU9250 libraries. Outputs filter update rate.

```cpp
#include "quaternionFilters.h"
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();
  myIMU.initAK8963(myIMU.factoryMagCalibration);
  myIMU.getAres();
  myIMU.getGres();
  myIMU.getMres();
}

void loop() {
  if (myIMU.readByte(MPU9250_ADDRESS_AD0, INT_STATUS) & 0x01) {
    myIMU.readAccelData(myIMU.accelCount);
    myIMU.ax = (float)myIMU.accelCount[0] * myIMU.aRes;
    myIMU.ay = (float)myIMU.accelCount[1] * myIMU.aRes;
    myIMU.az = (float)myIMU.accelCount[2] * myIMU.aRes;

    myIMU.readGyroData(myIMU.gyroCount);
    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);
    myIMU.mx = (float)myIMU.magCount[0] * myIMU.mRes * myIMU.factoryMagCalibration[0];
    myIMU.my = (float)myIMU.magCount[1] * myIMU.mRes * myIMU.factoryMagCalibration[1];
    myIMU.mz = (float)myIMU.magCount[2] * myIMU.mRes * myIMU.factoryMagCalibration[2];
  }

  myIMU.updateTime();

  // Apply faster Mahony filter
  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);

  // Print filter update rate
  static uint32_t count = 0;
  static float sum = 0;
  sum += myIMU.deltat;
  count++;

  if (millis() % 500 == 0) {
    Serial.print("Filter rate: ");
    Serial.print((float)count / sum, 2);
    Serial.println(" Hz");
    count = 0;
    sum = 0;
  }
}
```

--------------------------------

### Read Gyroscope Data

Source: https://context7.com/sparkfun/sparkfun_mpu-9250_breakout_arduino_library/llms.txt

Reads raw 16-bit gyroscope data from the MPU-9250 and converts it to degrees per second. The output depends on the configured scale, ranging from +/-250 to +/-2000 degrees/sec.

```cpp
#include "MPU9250.h"

MPU9250 myIMU(MPU9250_ADDRESS_AD0, Wire, 400000);

void setup() {
  Serial.begin(38400);
  Wire.begin();
  myIMU.calibrateMPU9250(myIMU.gyroBias, myIMU.accelBias);
  myIMU.initMPU9250();
  myIMU.getGres();  // Get resolution for current scale setting (default GFS_250DPS)
}

void loop() {
  if (myIMU.readByte(MPU9250_ADDRESS_AD0, INT_STATUS) & 0x01) {
    // Read raw gyroscope data
    myIMU.readGyroData(myIMU.gyroCount);

    // Convert to degrees per second
    myIMU.gx = (float)myIMU.gyroCount[0] * myIMU.gRes;
    myIMU.gy = (float)myIMU.gyroCount[1] * myIMU.gRes;
    myIMU.gz = (float)myIMU.gyroCount[2] * myIMU.gRes;

    Serial.print("Gyro X: "); Serial.print(myIMU.gx, 3);
    Serial.print(" deg/s  Y: "); Serial.print(myIMU.gy, 3);
    Serial.print(" deg/s  Z: "); Serial.print(myIMU.gz, 3);
    Serial.println(" deg/s");
  }
  delay(100);
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.