Jaga Tanaman Tetap Happy dengan Sistem Irigasi Pintar Berbasis PID dan Arduino

Halo Sobat Maker! Pernah nggak sih kalian lagi semangat-semangatnya menekuni hobi smart farming atau sekadar merawat tanaman di rumah, tapi malah pusing karena aliran air irigasinya nggak stabil? Kadang airnya muncrat terlalu kencang sampai tanahnya berantakan, kadang malah loyo karena tekanan pompa yang naik-turun.

Masalah debit air yang nggak konsisten ini sebenarnya bisa diatasi dengan cara yang keren dan presisi, yaitu menggunakan kontrol PID (Proportional-Integral-Derivative). Jangan ngeri dulu sama istilahnya! Dengan modal Arduino dan komponen yang ramah di kantong, kita bisa bikin sistem irigasi yang alirannya “anteng” dan sesuai keinginan. Yuk, kita bedah cara rakitnya!

Mengenal Sistem Irigasi Pintar Kita

Sistem yang kita buat ini mengadopsi konsep loop tertutup (closed-loop). Sederhananya, Arduino akan bertindak sebagai “otak” yang terus-menerus memantau aliran air melalui sensor.

Begini cara kerjanya: sensor akan memberikan laporan (feedback) mengenai berapa banyak air yang sedang mengalir. Arduino kemudian membandingkan data tersebut dengan target yang kita inginkan (setpoint). Jika alirannya kurang, Arduino bakal kasih perintah ke pompa untuk “ngegas”, dan jika kelebihan, kecepatannya bakal dikurangi secara otomatis. Hasilnya? Debit air jadi pas dan stabil sesuai kebutuhan tanaman, mau ada hambatan di selang pun sistem bakal otomatis menyesuaikan.

Alat dan Bahan Hemat Budget

Nggak perlu merogoh kocek dalam-dalam untuk bikin proyek ini. Dengan total biaya di bawah Rp100.000, kamu sudah bisa merakit sistem irigasi tingkat lanjut. Cekidot list belanjaannya, pas banget buat kantong pelajar!

Skematik Rangkaian

Merakit komponen-komponen ini cukup simpel, tapi ada satu aturan emas: Common Ground. Pastikan semua Ground (GND) dari Arduino, Driver L298N, dan Power Supply terhubung menjadi satu agar sinyal kontrolnya nggak “ngaco”. Berikut langkah koneksinya:

1. Water Flow Sensor: Hubungkan kabel sinyal ke pin digital D2. Pin ini digunakan sebagai interrupt untuk menghitung pulsa aliran air di background sambil Arduino mengerjakan kalkulasi PID. Sambungkan VCC ke 5V dan GND ke Ground.
2. Driver Motor L298N: Hubungkan pin D9 (ENA) sebagai “pengatur gas” (PWM). Untuk arah putaran, hubungkan pin D8 (IN1) dan D7 (IN2).
3. Pompa DC: Sambungkan kabel pompa ke output driver (OUT1 dan OUT2). Atur IN1 ke HIGH dan IN2 ke LOW di kode program agar pompa mendorong air keluar.
4. Powering: Gunakan tegangan 5V dari adaptor untuk memberi daya pada pompa melalui driver motor agar performanya maksimal dan tidak membebani Arduino.

Rahasia Aliran Stabil dengan Kontrol PID

Mengapa harus pakai PID? Tanpa PID, pompa biasanya hanya bekerja statis. Dengan algoritma PID, sistem menghitung selisih (error) antara debit air yang kita mau dengan kenyataan di lapangan.

• Proportional (P): Memberikan respons langsung sesuai besar error. Makin jauh dari target, makin kencang pompa ngegas.
• Integral (I): Mengoreksi sisa error yang menumpuk. Ini memastikan target debit tercapai 100% tanpa ada sisa selisih sedikit pun.
• Derivative (D): Bertindak sebagai “rem” agar aliran air tidak kaget atau melampaui target secara berlebihan (overshoot).

Prinsip ini mirip dengan tutorial kendali kecepatan motor DC Arduino PID yang sering digunakan untuk menjaga putaran mesin tetap stabil meski diberi beban berat.

Bedah Kode Program

Logika pemrograman sistem ini dirancang agar responsif namun tetap halus. Berikut poin-poin penting dalam kodenya:

// ============================================
// SMART IRRIGATION PID DENGAN ARDUINO UNO
// Water Flow Sensor YF-S401 + L298N + Pompa DC
// ============================================

// ---------- PIN KONFIGURASI ----------
#define FLOW_SENSOR_PIN 2

#define ENA_PIN 9
#define IN1_PIN 8
#define IN2_PIN 7

// ---------- KONFIGURASI FLOW SENSOR ----------
// Nilai ini perlu dikalibrasi sesuai sensor yang digunakan.
// Contoh awal, sesuaikan berdasarkan hasil pengujian.
const float PULSES_PER_LITER = 450.0;

// ---------- KONFIGURASI PID ----------
float Kp = 25.0;
float Ki = 2.0;
float Kd = 5.0;

// Target debit air dalam Liter per Menit
float SETPOINT_FLOW = 1.0;

// ---------- FILTER EMA ----------
const float EMA_ALPHA = 0.3;

// ---------- KONFIGURASI PWM ----------
const int BASE_PWM = 130;
const int MIN_PWM = 110;
const int MAX_PWM = 255;

// ---------- SOFT START ----------
const int SOFT_START_PWM = 180;
const unsigned long SOFT_START_TIME = 7000;

// ---------- VARIABEL INTERRUPT ----------
volatile unsigned long pulseCount = 0;

// ---------- VARIABEL FLOW ----------
float flowRate = 0.0;
float filteredFlowRate = 0.0;

// ---------- VARIABEL PID ----------
float error = 0.0;
float previousError = 0.0;

float integral = 0.0;
float derivative = 0.0;

float pidOutput = 0.0;

// ---------- TIMER ----------
unsigned long previousMillis = 0;
unsigned long startMillis = 0;

const unsigned long SAMPLE_TIME = 500;


// ============================================
// INTERRUPT SENSOR FLOW
// ============================================

void IRAM_ATTR flowSensorISR()
{
  pulseCount++;
}


// ============================================
// SETUP
// ============================================

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

  // Konfigurasi sensor
  pinMode(FLOW_SENSOR_PIN, INPUT_PULLUP);

  // Konfigurasi driver motor
  pinMode(ENA_PIN, OUTPUT);
  pinMode(IN1_PIN, OUTPUT);
  pinMode(IN2_PIN, OUTPUT);

  // Arah pompa
  digitalWrite(IN1_PIN, HIGH);
  digitalWrite(IN2_PIN, LOW);

  // Pasang interrupt
  attachInterrupt(
    digitalPinToInterrupt(FLOW_SENSOR_PIN),
    flowSensorISR,
    RISING
  );

  // Simpan waktu mulai
  startMillis = millis();
  previousMillis = millis();

  // Mulai dengan PWM 0
  analogWrite(ENA_PIN, 0);

  Serial.println("Sistem Irigasi PID Dimulai");
}


// ============================================
// LOOP UTAMA
// ============================================

void loop()
{
  unsigned long currentMillis = millis();

  // ------------------------------------------
  // SOFT START / PRIMING
  // ------------------------------------------

  if (currentMillis - startMillis < SOFT_START_TIME)
  {
    analogWrite(ENA_PIN, SOFT_START_PWM);

    Serial.print("Soft Start | PWM: ");
    Serial.println(SOFT_START_PWM);

    return;
  }


  // ------------------------------------------
  // PEMBACAAN SENSOR SETIAP SAMPLE_TIME
  // ------------------------------------------

  if (currentMillis - previousMillis >= SAMPLE_TIME)
  {
    // Hitung interval waktu dalam detik
    float deltaTime =
      (currentMillis - previousMillis) / 1000.0;

    previousMillis = currentMillis;


    // ----------------------------------------
    // AMBIL DATA PULSE SECARA AMAN
    // ----------------------------------------

    noInterrupts();

    unsigned long pulses = pulseCount;
    pulseCount = 0;

    interrupts();


    // ----------------------------------------
    // HITUNG DEBIT AIR
    // ----------------------------------------

    // Liter selama periode sampling
    float liters =
      pulses / PULSES_PER_LITER;

    // Konversi menjadi Liter per Menit
    flowRate =
      (liters / deltaTime) * 60.0;


    // ----------------------------------------
    // FILTER EMA
    // ----------------------------------------

    filteredFlowRate =
      (EMA_ALPHA * flowRate) +
      ((1.0 - EMA_ALPHA) * filteredFlowRate);


    // ----------------------------------------
    // PERHITUNGAN PID
    // ----------------------------------------

    // Hitung error
    error =
      SETPOINT_FLOW - filteredFlowRate;


    // Bagian Integral
    integral += error * deltaTime;


    // Anti windup sederhana
    integral = constrain(
      integral,
      -10.0,
      10.0
    );


    // Bagian Derivative
    derivative =
      (error - previousError) / deltaTime;


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


    // Simpan error sebelumnya
    previousError = error;


    // ----------------------------------------
    // HITUNG PWM FINAL
    // ----------------------------------------

    int pwmOutput =
      BASE_PWM + (int)pidOutput;


    // Batasi PWM
    pwmOutput =
      constrain(
        pwmOutput,
        MIN_PWM,
        MAX_PWM
      );


    // Kirim PWM ke L298N
    analogWrite(
      ENA_PIN,
      pwmOutput
    );


    // ----------------------------------------
    // TAMPILKAN DATA SERIAL MONITOR
    // ----------------------------------------

    // Format sederhana agar bisa
    // digunakan di Serial Plotter

    Serial.print(SETPOINT_FLOW);
    Serial.print(",");

    Serial.print(flowRate);
    Serial.print(",");

    Serial.print(filteredFlowRate);
    Serial.print(",");

    Serial.println(pwmOutput);
  }
}

• Fungsi Interrupt: Arduino menghitung setiap pulsa dari baling-baling sensor secara real-time. Dengan cara ini, tidak ada satu tetes air pun yang terlewat dari hitungan meski program sedang sibuk.
• Filter EMA (Exponential Moving Average): Data fisik dari sensor seringkali punya “noise” atau goyangan. Trik filter EMA (dengan nilai alpha 0.3) digunakan untuk menyaring gangguan ini supaya data debit yang dibaca lebih halus.
• Fitur Soft Start: Saat baru menyala, sistem akan melakukan priming selama 7 detik dengan kekuatan PWM 180. Tujuannya agar selang terisi air dulu sebelum kendali PID mengambil alih.
• Baseline & Batasan PWM: Agar pompa punya torsi awal yang cukup, sistem menggunakan Base PWM 130. Jadi, output PID akan menambah atau mengurangi kecepatan mulai dari angka 130 tersebut, dengan batasan aman di rentang 110 hingga 255.

Proses Pengujian dan Hasil

Saat sistem dijalankan, Sobat Maker bisa memantau pergerakan data melalui Serial Monitor. Tapi kalau mau lebih keren, gunakan Serial Plotter di Arduino IDE! Kamu bisa melihat grafik setpoint vs debit aktual secara visual.

Dalam pengujian, sistem ini terbukti sangat tangguh. Saat selang sedikit ditekuk (gangguan), sensor akan mendeteksi penurunan debit, dan PID langsung memerintahkan pompa untuk bekerja lebih keras guna menjaga aliran tetap di angka yang kita minta. Vibes-nya bener-bener kayak sistem industri profesional!

Kesimpulan

Membangun sistem irigasi dengan kontrol PID memberikan presisi tinggi yang nggak bisa didapat dari sistem biasa. Dengan budget yang sangat bersahabat, tanaman kamu bisa mendapatkan pasokan air yang konsisten secara otomatis.

Sekarang giliran kamu buat bereksperimen! Coba ulik nilai tuning Kp, Ki, dan Kd di dalam kode program untuk mendapatkan respon yang paling pas dengan jenis pompa yang kamu pakai. Selamat mencoba, Sobat Maker!