能不能来个很具体的代码

当然可以，以下是一个使用MPU6050六轴IMU将数据转换为3x3矩阵的C语言代码示例，其中包括了数据校准和滤波的部分，供您参考：

#include <Wire.h>
#include <math.h>

// MPU6050地址
#define MPU6050_ADDR 0x68

// 加速度计和陀螺仪校准参数
float accel_scale_factor[3];
float gyro_scale_factor[3];

// 数据滤波参数
float alpha = 0.5;   // 滤波系数
float accel_filtered[3];
float gyro_filtered[3];

// 归一化加速度计数据
void normalize_accel(float *accel, float *accel_norm)
{
    float accel_norm_sq = accel[0]*accel[0] + accel[1]*accel[1] + accel[2]*accel[2];
    accel_norm[0] = accel[0] / sqrt(accel_norm_sq);
    accel_norm[1] = accel[1] / sqrt(accel_norm_sq);
    accel_norm[2] = accel[2] / sqrt(accel_norm_sq);
}

// 读取MPU6050数据
void read_mpu6050(float *accel_raw, float *gyro_raw)
{
    Wire.beginTransmission(MPU6050_ADDR);
    Wire.write(0x3B);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU6050_ADDR, 14, true);
    accel_raw[0] = Wire.read()<<8 | Wire.read();  // X轴加速度计原始数据
    accel_raw[1] = Wire.read()<<8 | Wire.read();  // Y轴加速度计原始数据
    accel_raw[2] = Wire.read()<<8 | Wire.read();  // Z轴加速度计原始数据
    gyro_raw[0] = Wire.read()<<8 | Wire.read();   // X轴陀螺仪原始数据
    gyro_raw[1] = Wire.read()<<8 | Wire.read();   // Y轴陀螺仪原始数据
    gyro_raw[2] = Wire.read()<<8 | Wire.read();   // Z轴陀螺仪原始数据
}

// 加速度计和陀螺仪校准
void calibrate_mpu6050()
{
    float accel_sum[3] = {0};
    float gyro_sum[3] = {0};
    const int num_samples = 1000;
    for (int i = 0; i < num_samples; i++) {
        float accel_raw[3], gyro_raw[3];
        read_mpu6050(accel_raw, gyro_raw);
        for (int j = 0; j < 3; j++) {
            accel_sum[j] += accel_raw[j];
            gyro_sum[j] += gyro_raw[j];
        }
        delay(2);
    }
    for (int j = 0; j < 3; j++) {
        accel_scale_factor[j] = accel_sum[j] / num_samples;
        gyro_scale_factor[j] = gyro_sum[j] / num_samples;
    }
}

// 数据滤波
void filter_data(float *data_raw, float *data_filtered)
{
    for (int i = 0; i < 3; i++) {
        data_filtered[i] = alpha * data_filtered[i] + (1 - alpha) * (data_raw[i] - accel_scale_factor[i]);
    }
}

// 将数据转换为3x3矩阵
void data_to_matrix(float *accel_filtered, float *gyro_filtered, float (*R)[3])
{
    float accel_norm[3];
    normalize_accel(accel_filtered, accel_norm);

    float delta_theta[3];
    for (int i = 0; i < 3; i++) {
        delta_theta[i] = gyro_filtered[i] - gyro_scale_factor[i];
    }

    float delta_R[3][3];
    delta_R[0][0] = cos(delta_theta[1])*cos(delta_theta[2]);
    delta_R[0][1] = sin(delta_theta[0])*sin(delta_theta[1])*cos(delta_theta[2]) - cos(delta_theta[0])*sin(delta_theta[2]);
    delta_R[0][2] = cos(delta_theta[0])*sin(delta_theta[1])*cos(delta_theta[2]) + sin(delta_theta[0])*sin(delta_theta[2]);
    delta_R[1][0] = cos(delta_theta[1])*sin(delta_theta[2]);
    delta_R[1][1] = sin(delta_theta[0])*sin(delta_theta[1])*sin(delta_theta[2]) + cos(delta_theta[0])*cos(delta_theta[2]);
    delta_R[1][2] = cos(delta_theta[0])*sin(delta_theta[1])*sin(delta_theta[2]) - sin(delta_theta[0])*cos(delta_theta[2]);
    delta_R[2][0] = -sin(delta_theta[1]);
    delta_R[2][1] = sin(delta_theta[0])*cos(delta_theta[1]);
    delta_R[2][2] = cos(delta_theta[0])*cos(delta_theta[1]);

    float b[3];
    b[0] = delta_R[1][2]*accel_norm[2] - delta_R[2][2]*accel_norm[1];
    b[1] = delta_R[2][0]*accel_norm[1] - delta_R[0][2]*accel_norm[2];
    b[2] = delta_R[0][1]*accel_norm[2] - delta_R[1][0]*accel_norm[1];

    float c[3];
    c[0] = accel_norm[1]*b[2] - accel_norm[2]*b[1];
    c[1] = accel_norm[2]*b[0] - accel_norm[0]*b[2];
    c[2] = accel_norm[0]*b[1] - accel_norm[1]*b[0];

    R[0][0] = accel_norm[0]; R[0][1] = b[0]; R[0][2] = c[0];
    R[1][0] = accel_norm[1]; R[1][1] = b[1]; R[1][2] = c[1];
    R[2][0] = accel_norm[2]; R[2][1] = b[2]; R[2][2] = c[2];
}

void setup()
{
    Wire.begin();
    Wire.beginTransmission(MPU6050_ADDR);
    Wire.write(0x6B);  // PWR_MGMT_1寄存器
    Wire.write(0);     // 唤醒MPU6050
    Wire.endTransmission(true);
    calibrate_mpu6050();  // 校准MPU6050
}

void loop()
{
    float accel_raw[3], gyro_raw[3];
    read_mpu6050(accel_raw, gyro_raw);
    filter_data(accel_raw, accel_filtered);
    filter_data(gyro_raw, gyro_filtered);
    float R[3][3];
    data_to_matrix(accel_filtered, gyro_filtered, R);
    // TODO: 使用R矩阵进行姿态解算
}

需要注意的是，以上代码仅为示例，实际应用中还需要根据具体情况进行调整和优化。