something is wrong about my self balanced robot

Hi everyone. I try to do a self balanced robot. But i am doing something wwrong. First i want to say my parts in the robot.
1-arduino nano
2-mpu6050 (gyro&accelerometer)
3-2 motor 650 rpm
4-2 wheel from pololu
5-tb6612fng motor driver
6-7.4 volt battery

I did some exercises about motors and gyro first.

I can drive motors forward and reverse. there is no problem there.

After that i read datas from mpu6050 in the serial monitor. I use the this library:

there is no problem there too.

After i implemented PID library in my code..

But my robot is really shaking a lot.. is there anyone to check my code and tell me where i am doing wrong..

here is my video:

#include <PID_v1.h>
#include "I2Cdev.h"

#include "MPU6050_6Axis_MotionApps20.h"

#include "Wire.h"

#define LOG_INPUT 1

MPU6050 mpu;

// 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
VectorFloat gravity;    // [x, y, z]            gravity vector
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector

double originalSetpoint = 174.29;
double setpoint = originalSetpoint;
double input, output;
PID pid(&input, &output, &setpoint, 5, 5,0.1 , DIRECT);

int STBY = 6; //standby

//Motor right
int PWMA = 3; //Speed control
int AIN1 = 5; //Direction
int AIN2 = 4; //Direction

//Motor left
int PWMB = 9; //Speed control
int BIN1 = 7; //Direction
int BIN2 = 8; //Direction

void move(int motor, int speed, int direction) {
 //Move specific motor at speed and direction
 //motor: 1 for left motor 2 for right motor
 //speed: 0 is off, and 255 is full speed
 //direction: 0 clockwise, 1 counter-clockwise

 digitalWrite(STBY, HIGH); //disable standby

 boolean inPin1 = LOW;
 boolean inPin2 = HIGH;

 if (direction == 1) {
   inPin1 = HIGH;
   inPin2 = LOW;

 if (motor == 1) {
   digitalWrite(AIN1, inPin1);
   digitalWrite(AIN2, inPin2);
   analogWrite(PWMA, speed);
 } else {
   digitalWrite(BIN1, inPin1);
   digitalWrite(BIN2, inPin2);
   analogWrite(PWMB, speed);

void stop() {
 //disable standby
 digitalWrite(STBY, LOW);

const int speed_max = 200;
const int speed = 100;

void motor_adjust()
 signed int adjust;
 adjust = (signed int) speed + output;
 if (adjust > speed_max) adjust = speed_max;
  move(1, adjust, 0); //left forward
  move(2, adjust, 0); //right forward
  adjust = (signed int) speed-output;
  if (adjust < -speed_max) adjust = -speed_max;
  move(1, adjust, 1); //left back
  move(2, adjust, 1); //right back

 Serial.println("PID output");

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

void setup()
 pinMode(STBY, OUTPUT);
 pinMode(PWMA, OUTPUT);
 pinMode(AIN1, OUTPUT);
 pinMode(AIN2, OUTPUT);
 pinMode(PWMB, OUTPUT);
 pinMode(BIN1, OUTPUT);
 pinMode(BIN2, OUTPUT);

 // join I2C bus (I2Cdev library doesn't do this automatically)
 TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)
 Fastwire::setup(400, true);

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

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

 // verify connection
 Serial.println(F("Testing device connections..."));
 Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));

 // load and configure the DMP
 Serial.println(F("Initializing DMP..."));
 devStatus = mpu.dmpInitialize();

 // supply your own gyro offsets here, scaled for min sensitivity
 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..."));

   // 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();

   //setup PID

   // 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 "));

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)


 // 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
   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;

   mpu.dmpGetQuaternion(&q, fifoBuffer);
   mpu.dmpGetGravity(&gravity, &q);
   mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
   Serial.print(ypr[0] * 180 / M_PI);
   Serial.print(ypr[1] * 180 / M_PI);
   Serial.println(ypr[2] * 180 / M_PI);
   input = ypr[2] * 180 / M_PI + 180;


Please edit your post to add code tags (select and use the "</>" button).

You aren't using the PID algorithm correctly, and need to do some more reading. In particular, PID algorithms need to be tuned for each individual application. Google "PID tuning" for tutorials, but for Arduino, this thread might help.

Thanks for reply. i try to use pid library and i can read output value in the serial monitor. I think i can not do motor adjust fine. i am gonna work ..:slight_smile:

Tune the PID - start with low gain, no I, no D, then turn up the gain till it
starts to do something - too much gain will always cause oscillation. Then experiment with
the D term, increasing it will allow more gain without oscillation or overshoot, too much will
cause random noise to become noticeable. I term needs a little to remove bias, but will tend
to increase tendancy to oscillate, so use sparingly.