請教自走平衡腳踏車

lifer0107

請教各位先進前輩
我想製作一個自走平衡的腳踏車（就跟樂高上的平衡腳踏車一樣動作方式）
但程式寫好執行時會遇到mpu 6050 讀取訊號不穩定造成伺服馬達會嚴重抖動無法平衡
想請教各位前輩是否程式撰寫有誤造成讀取訊號異常
下圖為接線圖和程式
還請各位前輩批評與指教
謝謝

#include <Servo.h>
Servo myservoX; // Pitch
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
#include "Wire.h"
#endif
MPU6050 mpu;
#define OUTPUT_READABLE_YAWPITCHROLL
#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
bool blinkState = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

// packet structure for InvenSense teapot demo
uint8_t teapotPacket[14] = { '$', 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, '\r', '\n' };
//-----------------------------------自加程式下-------------------------------------------------------
int bicycle = 10 ; //設定後輪馬達輸出pin 10
int moto = 11;
//------------------------------------------------------------------------------------------

// ================================================================
// ===               INTERRUPT DETECTION ROUTINE                ===
// ================================================================

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
    mpuInterrupt = true;
}


//pid_compute,pid_adjust
unsigned long nowTime,lastTime,lastTime2,lastTime3;//現在時間、上次時間
double timeChange;//時間間隔
double feedback,output,setPoint = 90;//回授量、輸出量、設定點
//int feedback;
double error,errorSum,dError,lastError;//誤差、積分誤差、微分誤差、上次誤差
double kp = 5,ki = 0,kd = 5;//PID參數
//speed_adjust ,motor_control
int motor_speed = 0;
int max_speed = 90;
int min_speed = 0;


// ================================================================
// ===                      INITIAL SETUP                       ===
// ================================================================

void setup() {
    // join I2C bus (I2Cdev library doesn't do this automatically)
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)
    #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
        Fastwire::setup(400, true);
    #endif

//Attach servo

//  myservoY.attach(9); // Attach Y servo to pin 9
//  myservoX.attach(10);// Attach X servo to pin 10

    // initialize serial communication
    // (115200 chosen because it is required for Teapot Demo output, but it's
    // really up to you depending on your project)
    Serial.begin(115200);
    while (!Serial); // wait for Leonardo enumeration, others continue immediately

    // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3v or Ardunio
    // Pro Mini running at 3.3v, cannot handle this baud rate reliably due to
    // the baud timing being too misaligned with processor ticks. You must use
    // 38400 or slower in these cases, or use some kind of external separate
    // crystal solution for the UART timer.

    // initialize device
    Serial.println(F("Initializing I2C devices..."));
    mpu.initialize();

    // verify connection
    Serial.println(F("Testing device connections..."));
    Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));
/*
    // wait for ready
    Serial.println(F("\nSend any character to begin DMP programming and demo: "));
    while (Serial.available() && Serial.read()); // empty buffer
    while (!Serial.available());                 // wait for data
    while (Serial.available() && Serial.read()); // empty buffer again
*/
    // load and configure the DMP
    Serial.println(F("Initializing DMP..."));
    devStatus = mpu.dmpInitialize();

    // supply your own gyro offsets here, scaled for min sensitivity
    mpu.setXGyroOffset(220);
    mpu.setYGyroOffset(76);
    mpu.setZGyroOffset(-85);
    mpu.setZAccelOffset(1788); // 1688 factory default for my test chip

    // make sure it worked (returns 0 if so)
    if (devStatus == 0) {
        // turn on the DMP, now that it's ready
        Serial.println(F("Enabling DMP..."));
        mpu.setDMPEnabled(true);

        // enable Arduino interrupt detection
        Serial.println(F("Enabling interrupt detection (Arduino external interrupt 0)..."));
        attachInterrupt(0, dmpDataReady, RISING);
        mpuIntStatus = mpu.getIntStatus();

        // set our DMP Ready flag so the main loop() function knows it's okay to use it
        Serial.println(F("DMP ready! Waiting for first interrupt..."));
        dmpReady = true;

        // get expected DMP packet size for later comparison
        packetSize = mpu.dmpGetFIFOPacketSize();
    } else {
        // ERROR!
        // 1 = initial memory load failed
        // 2 = DMP configuration updates failed
        // (if it's going to break, usually the code will be 1)
        Serial.print(F("DMP Initialization failed (code "));
        Serial.print(devStatus);
        Serial.println(F(")"));
    }

    // configure LED for output
    pinMode(LED_PIN, OUTPUT);
    //-----------------------------------自加程式下-------------------------------------------------------
    myservoX.attach(7);// Attach X servo to pin 7
    pinMode(bicycle , OUTPUT); // bicycle 為輸出
    pinMode(moto , OUTPUT);
    //------------------------------------------------------------------------------------------
}



// ================================================================
// ===                    MAIN PROGRAM LOOP                     ===
// ================================================================

void loop() {
    // if programming failed, don't try to do anything
    if (!dmpReady) return;

    // wait for MPU interrupt or extra packet(s) available
    while (!mpuInterrupt && fifoCount < packetSize) {
        // other program behavior stuff here
        // .
        // .
        // .
        // if you are really paranoid you can frequently test in between other
        // stuff to see if mpuInterrupt is true, and if so, "break;" from the
        // while() loop to immediately process the MPU data
        // .
        // .
        // .
    }

    // reset interrupt flag and get INT_STATUS byte
    mpuInterrupt = false;
    mpuIntStatus = mpu.getIntStatus();

    // get current FIFO count
    fifoCount = mpu.getFIFOCount();

    // check for overflow (this should never happen unless our code is too inefficient)
    if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
        // reset so we can continue cleanly
        mpu.resetFIFO();
        Serial.println(F("FIFO overflow!"));

    // otherwise, check for DMP data ready interrupt (this should happen frequently)
    } else if (mpuIntStatus & 0x02) {
        // wait for correct available data length, should be a VERY short wait
        while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

        // read a packet from FIFO
        mpu.getFIFOBytes(fifoBuffer, packetSize);
        
        // track FIFO count here in case there is > 1 packet available
        // (this lets us immediately read more without waiting for an interrupt)
        fifoCount -= packetSize;

        #ifdef OUTPUT_READABLE_YAWPITCHROLL
            // display Euler angles in degrees
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetGravity(&gravity, &q);
            mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
              nowTime = millis();
              feedback = int(ypr[1] * 180/M_PI)+90;
              pid_compute();
              speed_adjust();
              analogWrite(moto , 130);
              digitalWrite(bicycle , LOW);
              int final_angle = motor_speed+90;
              myservoX.write(final_angle);
              //myservoX.writeMicroseconds(motor_speed);
              Serial.print("feedback: ");
              Serial.print(feedback);
              Serial.print("error: ");
              Serial.print(error);
              Serial.print("setPoint: ");
              Serial.print(setPoint);
              Serial.print("output: ");
              Serial.print(output);
              Serial.print("final_angle: ");
              Serial.println(final_angle);
              
              //myservoX.write(int(ypr[1] * 180/M_PI)+90);   // Rotation around X
           //------------------------------------------------------------------------------------------
        #endif


        // blink LED to indicate activity
        blinkState = !blinkState;
        digitalWrite(LED_PIN, blinkState);
    }
   
}

void pid_compute(){
  /* 計算時間差*/
  timeChange = (double)(nowTime - lastTime);

  /* 計算誤差量*/
  error = setPoint - feedback;
  errorSum += (error * (timeChange/1000));
  dError = (error - lastError) / (timeChange/1000);

  /* 計算PID輸出*/
  output = kp * error + ki * errorSum + kd * dError;

  /* 誤差與時間暫存*/
  lastError = error;
  lastTime = nowTime;
}

void speed_adjust(){
  if(output>=max_speed){
      
      motor_speed = max_speed;
    }
    else if(output<=-max_speed){
      
      motor_speed = -max_speed;
    }
    else{
      motor_speed = (int)output;
    }
}