Bikin Robot Anti Tumbang Panduan Lengkap Self-Balancing Robot Pakai Arduino

Sobat Maker, pernah terpikir tidak kenapa robot beroda dua bisa berdiri tegak tanpa jatuh? Secara alami, robot dua roda itu bersifat tidak stabil atau underactuated system yang gampang banget tumbang gara-gara gaya gravitasi. Tapi tenang, solusinya ada di sistem kontrol yang cerdas. Proyek Self-Balancing Robot ini adalah cara paling keren buat kamu belajar sistem kontrol tingkat lanjut. Menariknya, prinsip keseimbangan ini juga mirip dengan teknologi yang dipakai pada proyek robotika lainnya, seperti saat kita mencoba bikin mobil parkir otomatis pakai arduino dan pid dengan budget di bawah 100 ribu yang pernah kita bahas sebelumnya.

Nah, kalau kemarin kita mainan budget di bawah 100 ribu, kali ini kita naik level sedikit ke sistem balance yang butuh presisi ekstra. Yuk, kita bedah rahasia di balik robot yang “anti tumbang” ini!

Alat dan Bahan

Untuk merakit robot ini, kamu butuh beberapa komponen utama yang punya tugas spesifik:

Skematik Rangkaian

Agar robot bisa bekerja, semua komponen harus terhubung dengan benar.

Catatan Penting (WAJIB): Pastikan semua komponen menggunakan common ground. Artinya, pin GND dari baterai, driver motor, dan Arduino harus saling terhubung. Tanpa common ground, referensi sinyal kendali bakal berantakan dan robotmu bakal glitch terus!

Cara Kerja Sistem

Sistem ini bekerja dalam sebuah lingkaran tertutup atau closed-loop system. Sensor MPU6050 akan terus membaca sudut kemiringan robot. Agar pembacaan gerakan lebih stabil dan tidak terlalu terganggu noise, kita memanfaatkan fitur DMP (Digital Motion Processor) pada chip MPU6050. Untuk memahami lebih detail mengenai fitur dan kemampuan sensor ini, kamu bisa melihat datasheet MPU6050 sebagai referensi teknisnya.

Target kita adalah membuat robot tetap tegak pada “angka ajaib” atau setpoint sebesar 175,7 derajat. Kenapa tidak 180 derajat? Karena 175,7 adalah mechanical balance point hasil kalibrasi fisik—titik di mana berat rangka robot benar-benar seimbang secara mekanis. Jika sudutnya bergeser dari angka ini, Arduino akan menghitung error dan memerintahkan motor untuk bergerak mengejar posisi seimbang tersebut.

Implementasi Kontrol PID

Agar gerakan robot halus dan tidak kaku, kita menggunakan kontrol PID. Bayangkan PID ini sebagai tiga asisten yang bekerja sama:

• Kp (Proportional) Pemberi torsi instan. Makin jauh robot miring, makin kencang motor menendang balik.
• Ki (Integral) Si teliti yang menghapus sisa error kecil. Tanpa Ki, robot mungkin berdiri tapi agak miring sedikit. Ki memastikan robot benar-benar tegak lurus.
• Kd (Derivative) Si peredam agar gerakan robot tidak “lebay” atau overshoot. Kd mencegah robot berayun terlalu heboh saat mengoreksi diri.

Berdasarkan hasil pengujian laboratorium, nilai paling stabil untuk proyek ini adalah Kp = 70, Ki = 200, dan Kd = 1,4.

Pemrograman Arduino

Pada bagian pemrograman, robot menggunakan beberapa library utama seperti PID_v1, LMotorController, I2Cdev, dan MPU6050_6Axis_MotionApps20. Beberapa pengaturan penting dalam kode dapat dilihat pada contoh berikut:

#include <PID_v1.h>
#include <LMotorController.h>
#include <I2Cdev.h>
#include <MPU6050_6Axis_MotionApps20.h>

MPU6050 mpu;

// ===============================
// PID
// ===============================
double input;
double output;
double setpoint = 175.7;

double Kp = 70;
double Ki = 200;
double Kd = 1.4;

PID pid(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);

// ===============================
// Konfigurasi Motor
// ===============================
#define MIN_ABS_SPEED 20

double motorSpeedFactor = 0.9;

// ===============================
// Hardware Interrupt MPU6050
// Pin D2
// ===============================
#define INTERRUPT_PIN 2

volatile bool mpuInterrupt = false;

void dmpDataReady()
{
  mpuInterrupt = true;
}

void setup()
{
  Serial.begin(115200);

  // Inisialisasi MPU6050
  mpu.initialize();

  // Hardware interrupt pada pin D2
  pinMode(INTERRUPT_PIN, INPUT);

  attachInterrupt(
    digitalPinToInterrupt(INTERRUPT_PIN),
    dmpDataReady,
    RISING
  );

  // Aktifkan PID
  pid.SetMode(AUTOMATIC);

  // PID dihitung setiap 10 ms
  pid.SetSampleTime(10);

  // Batas output PWM
  pid.SetOutputLimits(-255, 255);
}

void loop()
{
  // MPU6050 memberi tanda saat data baru tersedia
  if (mpuInterrupt)
  {
    mpuInterrupt = false;

    // Baca sudut dari MPU6050
    // input = sudut robot;

    // Hitung koreksi PID
    pid.Compute();

    // Ambil nilai PWM
    int motorPWM = abs(output);

    // Anti-stalling
    if (motorPWM > 0 && motorPWM < MIN_ABS_SPEED)
    {
      motorPWM = MIN_ABS_SPEED;
    }

    // Penyeimbang kecepatan motor kiri dan kanan
    int leftMotorPWM = motorPWM;
    int rightMotorPWM = motorPWM * motorSpeedFactor;

    // Perintah motor
    // leftMotor.setSpeed(leftMotorPWM);
    // rightMotor.setSpeed(rightMotorPWM);
  }
}

Kode menggunakan interrupt D2 untuk merespons data baru dari MPU6050, sedangkan SetSampleTime(10) membuat PID bekerja setiap 10 ms. motorSpeedFactor = 0.9 digunakan untuk mengimbangi perbedaan kecepatan motor kiri dan kanan, sementara MIN_ABS_SPEED = 20 mencegah motor berhenti atau hanya berdengung saat menerima PWM yang terlalu kecil.

Pengujian dan Hasil

Setelah di-ngoprek dan di-tuning, robot ini menunjukkan performa yang sangat solid:

• Pemulihan Cepat: Hanya butuh 1,3 detik untuk kembali stabil setelah didorong.
• Stabilitas Tinggi: Toleransi goyangan saat diam (steady state) cuma sekitar 0,3 derajat.

Berikut adalah data bagaimana algoritma PID mengubah error sudut menjadi gerakan motor (PWM):

Kesimpulan

Proyek ini membuktikan bahwa kombinasi Arduino, sensor MPU6050, dan algoritma PID adalah paket lengkap buat bikin sistem keseimbangan yang andal. Kuncinya ada di tiga hal: pembacaan sensor yang bersih (pakai DMP), penggunaan hardware interrupt, dan ketepatan tuning nilai Kp, Ki, serta Kd.

Buat Sobat Maker yang mau coba, jangan takut bereksperimen dengan nilai PID kalian sendiri. Ingat, beda berat robot, beda juga nilai “angka ajaibnya”. Selamat mengoprek!