# **Self Balancing Robot**

# **Nama Kelompok**

Najwa Syafira Firdaus 1103223110
Andifa Rifqi Aquila 1103213159
Ardhien Fadhillah Suhartono 1103204137
Fikri Ashraf 1103213123
Dhanisa Zahratul Alya 1103213083
Arif Al Imran 1103210193

# Daftar Isi

> [TOC]

> **[CLO 4]** Memiliki kemampuan untuk menganalisis sistem kendali loop tertutup pada kondisi transien dan steady state untuk melihat performansinya.
> **[CLO 5]** Memiliki kemampuan merancang sistem kendali motor DC.
<!--
> **Capaian CLO 4:**
> 1.Mahasiswa mampu menjelaskan konsep kendali umpan balik.
> 2.Mahasiswa mampu merancang sistem kendali PID.
> 3.Mahasiswa mampu mengevaluasi dan optimasi sistem kendali PID.
> **Capaian CLO 5:**
> 1.Mahasiswa mampu mendapatkan fungsi transfer sistem dari mekanisme transfer daya.
> 2.Mampu menjelaskan cara kerja dan karakteristik motor listrik, khususnya motor DC.
> 3.Mampu menganalisis hubungan antara torsi dan kecepatan motor.
> 4.Mahasiswa mampu mendemonstrasikan sistem mekanisme transfer daya sederhana menggunakan gear dan motor DC.
>
-->

# Pendahuluan
Laporan ini dibuat untuk menyelesaikan tugas CLO 4 dan CLO 5 pada mata kuliah Sistem Kendali dan Mekanika. Pada tugas ini, kami memilih untuk membuat projek self-balancing robot menggunakan sistem kontrol PID. Pada projek ini, kami mengimplementasi kontrol PID untuk menjaga keseimbangan robot dengan cara menyesuaikan sudut kemiringan, untuk meminimalisir error.

Self-balancing robot merupakan robot yang memiliki dua buah roda sejajar di sisi kanan dan kiri yang dapat berjalan seimbang karena adanya sistem kendali. Karakteristik utama yang menjadi pembeda dari mobile robot tiga atau empat roda yakni, titik tumpu pada mobile robot beroda dua menjadikannya tidak stabil dibandingkan dengan mobile robot beroda tiga maupun beroda empat. Salah satu upaya agar robot beroda dua stabil ini dibutuhkan suatu rangkaian mekanik, elektronika, dan sistem kontrol yang baik. Metode sistem kendali yang cocok untuk menyeimbangkan self-balancing robot ini menggunakan metode PID (Proportional, Integral, Derivative) yang memperbaiki kesalahan antara sebuah nilai proses dan nilai set point yang diinginkan dengan menghitung dan melakukan pembenaran sehingga dapat meminimalisir kesalahan (error). Untuk mendukung perhitungan, sensor accelerometer dan gyroscope MPU6050 digunakan sebagai pendeteksi sudut kemiringan.

# Alat dan Bahan
Berikut merupakan alat dan bahan yang digunakan dalam pembuatan Self Balancing Robot:

1. **Arduino Uno**
Berfungsi sebagai mikrokontroler yang memproses data sensor MPU 6050 untuk mengukur orientasi dan gerakan. Arduino UNO memungkinkan agar robot dapat menjaga kesimbangan dan berfungsi secara efektif.
2. **MPU 6050**
MPU6050 adalah perangkat IMU yang merupakan singkatan dari Inertial Measurement Unit. Ini adalah perangkat pelacak gerak enam sumbu yang menghitung data akselerometer tiga sumbu dan giroskop tiga sumbu. Keuntungan terbesar dari board ini adalah hadirnya prosesor gerak digital. Arti penting dari DMP (Digital motion processor) adalah, ia melakukan perhitungan/operasi yang sangat kompleks dari sisinya, sehingga membebaskan kerja mikrokontroler. Ini menyediakan data gerakan seperti roll, pitch, yaw, sudut, lanskap, dan potret, dll.
3. **Breadboard**
Breadboard merupakan papan untuk membuat prototipe atau membuat sirkuit. Ini memungkinkan untuk menempatkan komponen dan koneksi di papan untuk membuat sirkuit tanpa menyolder. Lubang-lubang di papan tempat memotong roti menjaga koneksi secara fisik memegang bagian atau kabel tempat meletakkannya dan menghubungkannya secara elektrik di dalam papan.
4. **L2986**
L2986 adalah driver motor H-Bridge ganda yang memungkinkan kontrol kecepatan dan arah dua motor DC secara bersamaan. Modul tersebut dapat menggerakkan motor DC yang memiliki tegangan antara 5 dan 35V, dengan arus puncak hingga 2A.
5. **Gearbox dan Roda**
Gearbox berfungsi sebagai tempat penggerak robot agar dapat seimbang dan tidak terjatuh. Gearbox digerakkan atau mendapatkan daya melalui L2986.
6. **Kabel Jumper**
Kabel Jumper berfungsi untuk menyambungkan sensor ke dalam arduino dan L2986.
# Rancangan Sistem Kendali Loop Tertutup PID
Sistem kendali PID adalah salah satu dari metode yang sangat umum dipakai dalam sistem kendali umpan balik. Metode ini menghitung kesalahan (error) antara nilai yang kita inginkan (set point) dan nilai yang sebenarnya. Pada kendali PID, ada tiga kontrol yaitu, proporsional, integral dan kendali turunan. Ketiga komponen kontrol tersebut akan bekerja secara bersamaan agar dapat membantu robot bisa berdiri dengan seimbang.


**Diagram Loop Tertutup PID**
Pada diagram diatas dapat dijabarkan, sensor MPU6050 akan mengirimkan sinyal jika didapati kemiringan sudut pada robot. Error kemudian dapat dihitung dari sudut kemiringan yang terdeteksi dan setpointnya. Misalnya, jika nilai sudut kemiringan -30 derajat dan setpoint adalah 0 derajat maka error dapat dihitung sebagai |0-(-30)|= 30 derajat. Kemudian nilai error tersebut akan diproses oleh masing-masing kendali PID dan dihitung oleh masing-masing kendali PID kemudian diakumulasikan. Setelah diakumulasi, sinyal dari kontroler PID diteruskan ke mikrokontroler untuk diproses. Mikrokontroler kemudian mengirimkan sinyal ke aktuator, yaitu motor DC untuk, menggerakkan roda pada robot sehingga dapat menjaga keseimbangan.

**Penerapan Kendali PID pada Self-Balancing Robot**
Ketika menggunakan sistem kendali PID, self-balancing robot dapat berdiri dengan seimbang meskipun terdapat gangguan atau perubahan pada lingkungan sekitar. Hal ini dikarenakan kendali PID mampu menyesuaikan respons sistem berdasarkan kesalahan yang terjadi saat ini, kesalahan yang terakumulasi, dan perubahan kesalahan.

Implementasi nilai Kp, Ki, dan Kd pada Self-balancing robot ini jika nilai Kp terlalu besar, maka roda akan berputar sangat kencang dan begitupun sebaliknya. Jika nilai Ki terlalu besar maka akan memicu osilasi yang menimbulkan robot susah untuk seimbang. Nilai Kd untuk meredam osilasi yang ditimbulkan oleh Ki dan memicu untuk mencapai setpoint. Dengan penyesuaian nilai Kp, Ki, dan Kd yang tepat, robot dapat menjaga keseimbangannya secara efektif.

# Mekanik Motor DC/Aktuator
Prinsip kerja Motor DC pada self-balancing robot berperan penting dalam menjaga keseimbangan robot karena motor DC digunakan untuk menggerakkan kedua roda pada robot. Untuk menentukan agar gerakan roda menajadi bergerak maju atau mundur memerlukan sensor MPU 6050 yang berfungsi untuk mendeteksi kemiringan robot. Setelah mendapatkan data kemiringan nantinya data tersebut akan dikirimkan kedalam L2986N untuk menggerakan roda agar tetap seimbang dan tidak terjatuh.
Fungsi transfer pada motor DC ini menggambarkan hubungan tegangan sebagai input dan kecepatan roda berputar sebagai output.

Berikut parameter Untuk menentukan agar gerakan roda menjadi bergerak maju atau mundur:
* Waktu Naik (Rise Time): Waktu untuk respon ketika pertama kali mencapai nilai akhir dari kondisi awal. Implementasi pada self-balancing robot ini adalah waktu pertama kali roda mulai berputar atau diberi nilai Kp.
* Waktu Puncak (Peak Time): Waktu untuk untuk mencapai nilai yang dibutuhkan ke maksimum pertama setelah perubahan awal.
* Overshoot: Kelebihan respon nilai atas sebelum stabil. Implementasi pada self-balancing robot ini adalah ketika roda berputar melebihi dari posisi yang diinginkan sebelum kembali ke setpoint.
* Waktu Pemulihan (Settling Time): Waktu untuk respon dibutuhkan kedalam yang mencapai dan tetap berada dalam rentang nilai akhir yang diinginkan. Implementasi pada self-balancing robot ini adalah waktu yang dibutuhkan agar roda stabil dalam posisi setpoint dan diperlukan nilai Kd untuk meredam gerak osilasi pada robot.

# Analisis Transient Respon

#define PRINT_DEBUG_BUILD 0  //This is to print the mpu data on serial monitor to debug
#include <PID_v1.h>
#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    #include "Wire.h"
#endif

MPU6050 mpu;

#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards

bool dmpReady = false;
uint8_t mpuIntStatus;
uint8_t devStatus;
uint16_t packetSize;
uint16_t fifoCount;
uint8_t fifoBuffer[64];

Quaternion q;
VectorFloat gravity;
float ypr[3];
VectorInt16 gy;

volatile bool mpuInterrupt = false;
void dmpDataReady() {
    mpuInterrupt = true;
}

#define PID_MIN_LIMIT -255
#define PID_MAX_LIMIT 255
#define PID_SAMPLE_TIME_IN_MILLI 10

#define SETPOINT_PITCH_ANGLE_OFFSET 81

#define MIN_ABSOLUTE_SPEED 0

double setpointPitchAngle = SETPOINT_PITCH_ANGLE_OFFSET;
double pitchGyroAngle = 0;
double pitchPIDOutput = 0;

double setpointYawRate = 0;
double yawGyroRate = 0;
double yawPIDOutput = 0;

int speedOutput = 0;

// PID pitchPID(&pitchGyroAngle, &pitchPIDOutput, &setpointPitchAngle, PID_PITCH_KP, PID_PITCH_KI, PID_PITCH_KD, DIRECT);
// PID yawPID(&yawGyroRate, &yawPIDOutput, &setpointYawRate, PID_YAW_KP, PID_YAW_KI, PID_YAW_KD, DIRECT);

int enableMotor1 = 9;
int motor1Pin1 = 5;
int motor1Pin2 = 6;

int motor2Pin1 = 7;
int motor2Pin2 = 8;
int enableMotor2 = 10;

float error, prev_error, output, p_output, i_output, d_output;
float kp = 13;
float ki = -0.1;
float kd = 1.5;
#define TRIG_PIN 3
#define ECHO_PIN 4
#define BUZZER_PIN 11

// void setupPID() {
//   pitchPID.SetOutputLimits(PID_MIN_LIMIT, PID_MAX_LIMIT);
//   pitchPID.SetMode(AUTOMATIC);
//   pitchPID.SetSampleTime(PID_SAMPLE_TIME_IN_MILLI);

//   yawPID.SetOutputLimits(PID_MIN_LIMIT, PID_MAX_LIMIT);
//   yawPID.SetMode(AUTOMATIC);
//   yawPID.SetSampleTime(PID_SAMPLE_TIME_IN_MILLI);
// }

void setupMotors() {
  pinMode(enableMotor1, OUTPUT);
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  
  pinMode(enableMotor2, OUTPUT);
  pinMode(motor2Pin1, OUTPUT);
  pinMode(motor2Pin2, OUTPUT);

  rotateMotor(0, 0);
}

void setupMPU() {
  Wire.begin();
  Wire.setClock(400000);
  mpu.initialize();
  pinMode(INTERRUPT_PIN, INPUT);
  devStatus = mpu.dmpInitialize();

  // mpu.setXAccelOffset(-122); 
  // mpu.setYAccelOffset(111); 
  // mpu.setZAccelOffset(800);   
  // mpu.setXGyroOffset(17);
  // mpu.setYGyroOffset(-32);
  // mpu.setZGyroOffset(38);  

  if (devStatus == 0) {
      mpu.setDMPEnabled(true);
      mpuIntStatus = mpu.getIntStatus();
      dmpReady = true;
      packetSize = mpu.dmpGetFIFOPacketSize();
  } else {
      // ERROR!
  }
}

void setupUltrasonic() {
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
}

void setup() {
  Serial.begin(115200); // Inisialisasi serial monitor jika diperlukan
  setupMotors();   
  setupMPU();
  delay(2000);
  // setupPID();
  setupUltrasonic();
}

long readUltrasonicDistance() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  long duration = pulseIn(ECHO_PIN, HIGH);
  return duration * 0.034 / 2;
}

void loop() {
  if (!dmpReady) {
    // Serial.print("error");
    return;
  }

  if (mpu.dmpGetCurrentFIFOPacket(fifoBuffer)) {
    mpu.dmpGetQuaternion(&q, fifoBuffer);
    mpu.dmpGetGravity(&gravity, &q);
    mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
    // mpu.dmpGetGyro(&gy, fifoBuffer);

    // yawGyroRate = gy.z;
    pitchGyroAngle = ypr[1] * 180/M_PI;

    // pitchPID.Compute(); // Panggil Compute tanpa argumen
    // yawPID.Compute();   // Panggil Compute tanpa argumen
  
  }else{
    // Serial.print("error");
  }

  error = pitchGyroAngle-setpointPitchAngle;
  p_output = error * kp;
  i_output += error * ki;
  d_output = kd * (error - prev_error);
  prev_error = error;
  if(i_output > 60){
    i_output = 60;
  }else if(i_output < -60){
    i_output = -60;
  }
  speedOutput = p_output + i_output + d_output;
  if(speedOutput > 130){
    speedOutput = 130;
  }else if(speedOutput < -130){
    speedOutput = -130;
  }

    // long distance = readUltrasonicDistance();
    
    // if (distance < 20) { // Jika jarak kurang dari 20 cm, mundur dan nyalakan buzzer
    //   rotateMotor(-100, -100); // Mundur dengan kecepatan tertentu
    //   digitalWrite(BUZZER_PIN, HIGH); // Nyalakan buzzer
    // } else {
    //   rotateMotor(pitchPIDOutput + yawPIDOutput, pitchPIDOutput - yawPIDOutput);
    //   digitalWrite(BUZZER_PIN, LOW); // Matikan buzzer
    // }

    // rotateMotor(pitchPIDOutput + yawPIDOutput, pitchPIDOutput - yawPIDOutput);

    rotateMotor(speedOutput, speedOutput);

    #ifdef PRINT_DEBUG_BUILD
      // Serial.println("The gyro before ");
      Serial.print(pitchGyroAngle);
      Serial.print(" ");
      // Serial.println(setpointPitchAngle);
      // Serial.println("The pid output ");
      Serial.println(speedOutput);
      // Serial.println("");
      
      // delay(500);    
    #endif
  // Serial.print("error");
}

void rotateMotor(int speed1, int speed2) {
  if (speed1 < 0) {
    digitalWrite(motor1Pin1, LOW);
    digitalWrite(motor1Pin2, HIGH);    
  } else if (speed1 >= 0) {
    digitalWrite(motor1Pin1, HIGH);
    digitalWrite(motor1Pin2, LOW);      
  }

  if (speed2 < 0) {
    digitalWrite(motor2Pin1, LOW);
    digitalWrite(motor2Pin2, HIGH);    
  } else if (speed2 >= 0) {
    digitalWrite(motor2Pin1, HIGH);
    digitalWrite(motor2Pin2, LOW);      
  }

  speed1 = abs(speed1) + MIN_ABSOLUTE_SPEED;
  speed2 = abs(speed2) + MIN_ABSOLUTE_SPEED;

  speed1 = constrain(speed1, MIN_ABSOLUTE_SPEED, 255);
  speed2 = constrain(speed2, MIN_ABSOLUTE_SPEED, 255);
    
  analogWrite(enableMotor1, speed1);
  analogWrite(enableMotor2, speed2);    
}

Transient response pada self-balancing robot adalah respon robot terhadap perubahan posisi awalnya hingga mencapai titik seimbang. Transient response sangat penting dalam memastikan robot bisa kembali ke posisi seimbang dengan cepat dan stabil setelah mengalami gangguan.

Terdapat tiga jenis sinyal respon berdasarkan bentuk kurva transien, yaitu:

* Underdamped Response: Respon osilasi dengan amplitudo yang semakin mengecil sebelum mencapai keadaan steady-state. Implementasi pada self-balancing robot, ketika diberi nilai Ki yang besar
* Overdamped Response: Respon lambat untuk mencapai keadaan steady-state tanpa adanya osilasi. Implementasi pada self-balancing robot, ketika diberi nilai Ki yang kecil
* Critically Damped Response: Respon tercepat untuk mencapai keadaan steady-state tanpa osilasi. Implementasi pada self-balancing robot, ketika diberi nilai Ki yang optimal


# Analisis Mekanika

* Gear Ratio
Diketahui driver gear pada motor DC adalah 8 sedangkan driven gear adalah 29 maka rasio yang didapatkan adalah 29:8 = 3.63. Hal ini berarti untuk setiap putaran motor DC, driven gear akan berputar 3.63 kali.

Motor DC menghasilkan torsi ketika arus listrik mengalir melalui gulungan kawat sehingga menciptakan medan magnet yang menyebabkan rotor bergerak. Pemilihan rasio yang tepat sangat mempengaruhi bagaimana torsi yang dihasilkan oleh motor DC untuk menjalankan roda.

* Kesimpulan

Pada self-balancing robot, lebih baik menggunakan driver gear yang memiliki jumlah gigi lebih kecil dibandingkan driven gear. Hal ini karena driver gear yang kecil akan meningkatkan torsi pada output gear (driven gear). Selain itu, penggunaan driver gear yang kecil dapat mengurangi beban pada motor sehingga robot dapat merespon perubahan sudut dengan lebih stabil dan cepat.

## Analisis Kecepatan Motor terhadap Beban
Analisis mekanika pada self-balancing robot melibatkan penggunaan motor DC sebagai penggerak dan gearbox sebagai komponen yang mengubah putaran motor menjadi torsi yang dihasilkan. Motor DC digunakan adalah Motor drive l298n.

Gearbox adalah komponen mekanik yang digunakan untuk meningkatkan torsi motor DC dengan mengurangi kecepatan keluaran. Pada self-balancing robot, gearbox memainkan peran penting dalam memastikan motor menghasilkan torsi yang cukup untuk mengatasi beban dan menjaga keseimbangan robot.

Hubungan antara torsi dan beban pada robot sangat erat. Beban robot, yang mencakup berat seluruh komponen dan potensi muatan tambahan, membutuhkan torsi tertentu untuk diimbangi. Jika torsi yang dihasilkan oleh motor melalui gearbox tidak cukup, robot akan kesulitan menjaga keseimbangan dan bisa jatuh. Sebaliknya, torsi yang memadai memungkinkan robot untuk merespons perubahan posisi dengan cepat dan efisien, mempertahankan stabilitas meskipun ada gangguan eksternal atau perubahan beban.

Pemilihan gearbox yang tepat sangat penting untuk mengoptimalkan torsi yang dibutuhkan robot sesuai bebannya. Gearbox mentranslasikan kecepatan motor menjadi torsi yang lebih besar, sehingga motor DC dapat menghasilkan torsi yang cukup untuk mengimbangi beban dan menjaga stabilitas robot dalam berbagai kondisi operasi.

# Hasil dan Saran
Hasil
Dalam pengembangan self-balancing robot hasil yang didapatkan adalah motor DC L2986 dapat menyeimbangan roda yang membuat robot tidak jatuh. Metode kendali Proporsional-Integral-Derivatif (PID) untuk menjaga keseimbangan. Namun, jika pengaturan PID tidak optimal, robot bisa mengalami masalah seperti tidak stabil dan osilasi.


Link video percobaan: https://drive.google.com/file/d/1NTy8cs_7YnvUl39mFeKccPdiOwg96J9K/view

Saran
Adapun saran dari self-balancing robot dapat melanjutkan pengembangan pada pid penelitian lebih lanjut bisa dilakukan untuk mengeksplorasi algoritma kontrol yang lebih canggih seperti fuzzy logic atau neural networks untuk meningkatkan stabilitas dan adaptabilitas robot dalam berbagai kondisi.

# Referensi

Source: RANCANG BANGUN PENGENDALI SELF BALANCING ROBOT DENGAN METODE PROPORTIONAL INTEGRAL DERIVATIVE (PID) - eSkripsi Universitas Andalas [(unand.ac.id](http://scholar.unand.ac.id/14953/#:~:text=Self%20balancing%20robot%20pada%20dasarnya%20merupakan%20jenis%20robot,dibutuhkan%20untuk%20mengontrol%20sistem%20agar%20seimbang%20dan%20stabil.))
10024-19353-1-SM.pdf
12452 ([unnes.ac.id](https://journal.unnes.ac.id/nju/index.php/jte/article/viewFile/33414/12452))
(PDF) Rancang Bangun Robot Self Balancing Berbasis Mikrokontroler ATmega328P Dengan Kendali PID ([researchgate.net](https://www.researchgate.net/publication/323640352_Rancang_Bangun_Robot_Self_Balancing_Berbasis_Mikrokontroler_ATmega328P_Dengan_Kendali_PID#:~:text=Robot%20self%20balancing%20merupakan%20robot%20yang%20memiliki%20dua,sehingga%20respon%20sistem%20yang%20diperoleh%20dapat%20mencapai%20setpoint.))

# Rubrik Penilaian

| Penilaian Indikator Ketercapaian CLO | Bobot |
| ------------------------------------ | ----- |
| Mahasiswa mampu mengevaluasi dan optimasi sistem kendali PID (soal CLO 4).| 50 % |
| Mahasiswa mampu mendemonstrasikan sistem mekanisme transfer daya sederhana menggunakan gear dan motor DC (soal CLO 5).| 50 % |

# Kriteria Nilai

| 4 | 3 | 2 | 1 | 0 |
| -------- | -------- | -------- | --- | --- |
| CLO 4 | | | | |
| Mampu menjelaskan konsep kendali umpan balik, merancang sistem kendali PID, hingga mengevaluasi dan optimasi sistem kendali PID. | Mampu menjelaskan konsep kendali umpan balik, merancang, dan mengevaluasi sistem kendali PID. | Mampu menjelaskan konsep kendali umpan balik dan merancang sistem kendali PID. | Mampu menjelaskan konsep kendali umpan balik dan PID, tetapi kesulitan dalam merancang dan mengevaluasi sistem kendali PID. | Kesulitan dalam menjelaskan konsep kendali umpan balik dan PID. |
| CLO 5 | | | | |
| Mampu mendapatkan fungsi transfer sistem dari mekanisme transfer daya, menganalisis hubungan antara torsi dan kecepatan motor, menjelaskan cara kerja dan karakteristik motor listrik, serta mendemonstrasikan sistem mekanisme transfer daya sederhana menggunakan gear dan motor DC. | Mampu mendapatkan fungsi transfer sistem dari mekanisme transfer daya, menganalisis hubungan antara torsi dan kecepatan motor, menjelaskan cara kerja dan karakteristik motor listrik, tetapi kesulitan dalam mendemonstrasikan sistem mekanisme transfer daya sederhana menggunakan gear dan motor DC. | Mampu mendapatkan fungsi transfer sistem dari mekanisme transfer daya, menganalisis hubungan antara torsi dan kecepatan motor, tetapi kesulitan dalam menjelaskan cara kerja dan karakteristik motor listrik. | Mampu mendapatkan fungsi transfer sistem dari mekanisme transfer daya dan menganalisis hubungan antara torsi dan kecepatan motor. | Tidak dapat menentukan satu langkah pun untuk menjelaskan mengenai mekanisme transfer daya. |