Bikin Stabilizer 1-Axis Low Budget Pakai Arduino dan PID

Sobat Maker, pernah nggak sih lagi asik merekam video pakai robot atau drone, eh hasilnya malah goyang-goyang kayak jelly? Masalah kestabilan memang sering bikin pusing, tapi tenang, kita nggak perlu keluar uang jutaan rupiah buat beli gimbal mahal. Kita bisa banget rakit sendiri stabilizer 1-axis yang responsif cuma dengan modal di bawah 100 ribu! Dengan memanfaatkan Arduino dan algoritma PID, kita bakal bikin platform yang tetap anteng meski digoyang-goyang dengan cara yang sangat teknis tapi tetap ramah di kantong.

Kenalan dengan Alat dan Bahannya

Proyek ini benar-benar efisien karena kita cuma butuh beberapa komponen kunci yang gampang banget dicari. Berikut rincian biayanya:

Kalau dijumlahkan, total biayanya cuma sekitar Rp 55.000 (asumsi kamu sudah punya Arduino dan servo sendiri). Sangat ekonomis untuk sebuah sistem kendali otomatis yang canggih, kan?

Cara Kerja Sistem Stabilizer

Sistem ini bekerja dengan arsitektur closed-loop control atau sistem kendali loop tertutup. Artinya, ada aliran umpan balik yang terus-menerus terjadi, di mana sensor membaca kondisi sistem, kemudian controller memberikan koreksi berdasarkan hasil pembacaan tersebut. Konsep ini merupakan dasar dari banyak sistem kendali otomatis dan juga menjadi bagian penting dalam pembahasan PID Controller & Theory Explained dari National Instruments.

Setelah data diterima, Arduino akan menghitung seberapa besar simpangan yang terjadi dari titik setimbang. Hasil perhitungan ini kemudian dikonversi menjadi sinyal PWM untuk memerintahkan Motor Servo sebagai “otot” bergerak melawan arah kemiringan tersebut. Konsep kendali otomatis ini sebenarnya mirip banget dengan cara kita jaga tanaman tetap happy dengan sistem irigasi pintar berbasis PID dan Arduino yang memastikan variabel tetap berada di titik yang diinginkan secara konsisten.

Skematik Rangkaian

Menyusun rangkaiannya tergolong simpel. Sensor MPU6050 dihubungkan ke jalur I2C pada Arduino Uno, yaitu Pin A4 untuk SDA dan Pin A5 untuk SCL. Untuk penggeraknya, kabel sinyal Motor Servo SG90 disambungkan ke pin PWM, tepatnya Pin 9 pada Arduino.

Hal yang sangat krusial adalah memastikan jalur power terpasang dengan benar. Pastikan VCC dan GND pada sensor serta Motor Servo terhubung ke pin 5V dan GND pada Arduino. Jalur power yang stabil ini penting banget supaya pembacaan sensor nggak ngaco dan motor servo punya tenaga yang cukup buat melakukan koreksi posisi dengan secepat kilat.

Langkah Langkah Kalibrasi dan Persiapan

Saat alat pertama kali dinyalakan, sistem akan masuk ke fase kalibrasi dinamis selama 3 detik. Di sini, kamu harus pastikan sensor tetap diam dan nggak bergerak sama sekali. Sistem bakal merekam sudut awal kemiringan sebagai nilai offset supaya titik referensi keseimbangannya benar-benar murni berada di angka 0 derajat.

Uniknya, sistem ini juga dilengkapi antarmuka HMI sederhana lewat Serial Monitor. Motor servo nggak akan langsung bergerak liar saat dicolokkan ke listrik. Ia bakal berada di posisi siaga (90 derajat) dan baru akan mulai melakukan aksi stabilisasi setelah kita kirim perintah “START” lewat komputer. Nggak cuma itu, sistem ini juga mendukung real-time PID tuning, jadi kamu bisa langsung update parameter kendali lewat Serial Monitor tanpa perlu bolak-balik upload ulang kode program.

Bikin Sinyal Makin Halus dengan Filter EMA dan Deadband

Data mentah dari sensor biasanya punya banyak gangguan atau noise yang bikin gerakan motor jadi kasar dan getar. Untuk mengatasinya, kita pakai algoritma Exponential Moving Average (EMA). Algoritma ini bertugas menyaring sinyal supaya data orientasi yang diterima sistem jadi lebih halus dan stabil.

Selain filter, ada juga konsep deadband atau zona toleransi sebesar 0,8 derajat. Jadi, kalau kemiringannya cuma sedikit banget (di bawah batas itu), sistem menganggapnya sudah seimbang. Ini penting supaya motor servo nggak bergetar halus terus-menerus atau hunting saat posisinya sudah sangat dekat dengan titik setimbang, sehingga motor kamu jadi lebih awet.

Rahasia Keseimbangan Algoritma PID Diskrit

Kunci utama dari keandalan stabilizer ini ada pada algoritma PID (Proportional, Integral, Derivative) yang dijalankan dalam waktu diskrit:

• Proporsional (P) berperan sebagai reaksi langsung. Makin miring alat kita, makin besar pula gaya koreksi yang diberikan oleh servo.
• Integral (I) bertugas menghapus sisa kesalahan atau error yang nggak bisa diselesaikan oleh P. Di sini kita pakai fitur “Anti-Windup” (dibatasi di rentang -20 sampai 20) biar sistem nggak “kaget” atau mengalami ketidakstabilan saat terjadi guncangan ekstrem.
• Derivatif (D) adalah reaksi “anti-lebay”. Dia berfungsi sebagai peredam yang memprediksi gerakan dan memberikan efek ngerem agar posisi berhenti tepat di titik setimbang tanpa bergoyang berlebihan (osilasi).

Bedah Kode Program Arduino

Berikut adalah kode program utama yang bisa kamu gunakan untuk menjalankan sistem stabilizer 1-axis ini:

#include <Wire.h>
#include <MPU6050_tockn.h>
#include <Servo.h>

MPU6050 mpu6050(Wire);
Servo servo;

// PID Parameters
float Kp = 1.2;
float Ki = 0.0;
float Kd = 0.15;

float error = 0;
float lastError = 0;
float integral = 0;
float derivative = 0;
float output = 0;

// Filter & Sensor
float offsetX = 0;
float setpoint = 0;
float filteredAngle = 0;
float alpha = 0.1;

// Servo & System State
int servoCenter = 90;
int servoPos = 90;

bool systemRun = false;

unsigned long lastTime;

String serialBuffer = "";

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

  Wire.begin();

  mpu6050.begin();

  servo.attach(9);
  servo.write(90);

  Serial.println("Kalibrasi...");
  delay(3000);

  mpu6050.update();

  offsetX = mpu6050.getAngleX();

  lastTime = millis();
}

void loop() {
  bacaSerial();

  if (!systemRun) {
    servo.write(90);
    return;
  }

  mpu6050.update();

  float angle = mpu6050.getAngleX() - offsetX;

  // EMA Filter
  filteredAngle =
    alpha * angle +
    (1.0 - alpha) * filteredAngle;

  unsigned long now = millis();

  float dt = (now - lastTime) / 1000.0;

  if (dt <= 0) {
    dt = 0.01;
  }

  lastTime = now;

  // PID Calculation
  error = setpoint - filteredAngle;

  // Deadband
  if (abs(error) < 0.8) {
    error = 0;
  }

  // Integral
  integral += error * dt;

  // Anti-Windup
  integral = constrain(integral, -20, 20);

  // Derivative
  derivative = (error - lastError) / dt;

  // PID Output
  output =
    (Kp * error) +
    (Ki * integral) +
    (Kd * derivative);

  // Actuating Servo
  servoPos = servoCenter + output;

  servoPos = constrain(servoPos, 0, 180);

  servo.write(servoPos);

  lastError = error;

  // Kirim data ke Serial
  Serial.print(setpoint);
  Serial.print(",");
  Serial.println(filteredAngle);

  delay(20);
}

void bacaSerial() {
  while (Serial.available()) {
    char c = Serial.read();

    if (c == '\n') {
      serialBuffer.trim();

      if (serialBuffer == "START") {
        systemRun = true;

        integral = 0;
        lastError = 0;
      }

      else if (serialBuffer == "STOP") {
        systemRun = false;

        servo.write(90);
      }

      else if (serialBuffer.startsWith("PID")) {

        // Format:
        // PID,Kp,Ki,Kd

        int p1 = serialBuffer.indexOf(',');
        int p2 = serialBuffer.indexOf(',', p1 + 1);
        int p3 = serialBuffer.indexOf(',', p2 + 1);

        if (p1 > 0 && p2 > 0 && p3 > 0) {
          Kp = serialBuffer.substring(p1 + 1, p2).toFloat();

          Ki = serialBuffer.substring(p2 + 1, p3).toFloat();

          Kd = serialBuffer.substring(p3 + 1).toFloat();
        }
      }

      serialBuffer = "";
    }

    else {
      serialBuffer += c;
    }
  }
}

Dalam kode tersebut, fungsi setup() mengurus inisialisasi sensor dan kalibrasi otomatis. Di bagian loop(), kalkulasi PID dilakukan dengan menghitung selisih waktu (dt) yang sangat presisi. Penggunaan fungsi constrain di sana sangat vital untuk membatasi pergerakan servo agar nggak melebihi batas fisik 0-180 derajat, sehingga hardware kamu tetap aman dari kerusakan mekanis.

Kesimpulan

Proyek stabilizer 1-axis ini jadi bukti kalau teknologi keren nggak harus mahal. Cuma dengan Rp 55.000, kita sudah bisa bikin sistem penyeimbang yang responsif berkat perpaduan sensor MPU6050, filter EMA, dan algoritma PID diskrit. Buat kamu yang baru mau belajar dunia kendali otomatis, proyek ini adalah titik awal yang pas banget. Jangan ragu buat bereksperimen gonta-ganti nilai Kp, Ki, dan Kd lewat Serial Monitor supaya kamu bisa lihat langsung gimana pengaruhnya ke gerakan stabilizer kamu!