Stabil Terus! Cara Bikin Kontrol Kelembapan Ruangan Otomatis Pakai Arduino dan PID

Halo, Sobat IoT! Pernahkah kamu merasa ruangan di rumah tiba-tiba terasa lembap sampai tembok berjamur, atau malah sebaliknya, udara jadi kering banget sampai bikin kulit gatal? Di iklim tropis seperti Indonesia, menjaga kelembapan ideal itu gampang-gampang susah. Masalahnya, sistem kontrol biasa yang cuma pakai “nyala-mati” (On/Off) sering kali bikin kelembapan naik-turun nggak karuan.

Nah, solusinya adalah menggunakan sistem kendali otomatis berbasis PID Diskrit. Tenang, jangan pusing dulu sama namanya! Intinya, kita akan membuat otak elektronik yang bisa berpikir halus untuk menjaga kelembapan ruangan tetap stabil di angka ideal secara otomatis. Yuk, kita bedah cara rakitnya!

Mengenal Komponen Utama

Untuk membangun sistem ini, kita butuh beberapa komponen “tempur” yang punya tugas spesifik:

Skematik Rangkaian Jalur Komunikasi dan Daya

Menghubungkan komponen ini butuh ketelitian agar sinyal kendali PWM (Pulse Width Modulation) bisa sampai dengan akurat.

1. Sensor Input: Hubungkan Sensor DHT11 ke Pin Digital 2 pada Arduino.
2. Output Aktuator: Sistem ini menggunakan dua jalur output PWM. Pin 9 dialokasikan untuk mengontrol Intake (Humidifier) dan Pin 10 digunakan untuk mengontrol Exhaust (Kipas DC).
3. Driver Daya: Karena Arduino tidak kuat menyalakan humidifier atau kipas secara langsung, kita menggunakan IRLZ44N sebagai driver.
4. Fitur Pengaman: Jangan lupa memasang Dioda 1N4007 secara paralel (flyback) pada terminal kipas. Dioda ini berfungsi sebagai pengaman untuk meredam lonjakan arus balik (back-EMF) dari motor kipas yang bisa merusak komponen lainnya.

Rahasia di Balik Layar Cara Kerja PID Diskrit

Sistem ini bekerja dengan prinsip Closed Loop Control. Bayangkan seperti menyetir mobil; kamu melihat target (garis jalan), lalu tanganmu terus mengoreksi setir agar mobil tetap di jalur. Di sini, target (Setpoint) kita adalah 70%.

Algoritma PID mengoreksi error (selisih antara kelembapan sekarang dengan 70%) melalui tiga aksi:

• Proportional (P): Memberikan respon cepat secara langsung berdasarkan seberapa jauh jarak kita dari target saat ini.
• Integral (I): Mengakumulasi kesalahan dari waktu ke waktu untuk menghilangkan sisa error yang bandel. Di sini, kita menggunakan Integral Limit sebesar 100 untuk mencegah Integral Windup (kondisi di mana nilai koreksi menjadi terlalu besar dan sulit dikendalikan).
• Derivative (D): Memprediksi perubahan di masa depan. Misalnya, jika jendela tiba-tiba dibuka dan kelembapan turun drastis, istilah “D” akan menyadari laju perubahan tersebut dan memerintahkan sistem untuk merespons lebih cepat sebelum error menjadi terlalu besar.

Bedah Kode Program Strategi Pengendalian

#include <DHT.h>

// =====================================================
// KONFIGURASI SENSOR
// =====================================================
#define DHT_PIN 2
#define DHT_TYPE DHT11

DHT dht(DHT_PIN, DHT_TYPE);


// =====================================================
// KONFIGURASI OUTPUT
// =====================================================
#define HUMIDIFIER_PIN 9
#define FAN_PIN 10


// =====================================================
// PARAMETER PID
// =====================================================
float Kp = 8.0;
float Ki = 0.08;
float Kd = 0.0;

float setpoint = 70.0;

// Sampling time = 1 detik
const unsigned long SAMPLE_TIME = 1000;

// Batas integral untuk mencegah Integral Windup
float integralLimit = 100.0;

float integral = 0.0;
float previousError = 0.0;


// =====================================================
// PWM BALANCE
// =====================================================
const int PWM_BALANCE = 80;

int humidifierPWM = 0;
int fanPWM = 0;


// =====================================================
// TIMER
// =====================================================
unsigned long lastSampleTime = 0;


// =====================================================
// SETUP
// =====================================================
void setup() {

  Serial.begin(9600);

  dht.begin();

  pinMode(HUMIDIFIER_PIN, OUTPUT);
  pinMode(FAN_PIN, OUTPUT);

  // Kondisi awal
  analogWrite(HUMIDIFIER_PIN, 0);
  analogWrite(FAN_PIN, 0);

  Serial.println("=================================");
  Serial.println("Kontrol Kelembapan PID Diskrit");
  Serial.println("Target Kelembapan: 70%");
  Serial.println("=================================");
}


// =====================================================
// LOOP UTAMA
// =====================================================
void loop() {

  unsigned long currentTime = millis();

  // Jalankan PID setiap 1 detik
  if (currentTime - lastSampleTime >= SAMPLE_TIME) {

    lastSampleTime = currentTime;

    // -------------------------------------------------
    // BACA SENSOR
    // -------------------------------------------------
    float humidity = dht.readHumidity();
    float temperature = dht.readTemperature();

    // Cek apakah pembacaan sensor valid
    if (isnan(humidity) || isnan(temperature)) {

      Serial.println("Gagal membaca sensor DHT11!");
      return;
    }


    // -------------------------------------------------
    // HITUNG ERROR
    // -------------------------------------------------
    float error = setpoint - humidity;


    // -------------------------------------------------
    // BAGIAN PROPORTIONAL
    // -------------------------------------------------
    float proportional = Kp * error;


    // -------------------------------------------------
    // BAGIAN INTEGRAL
    // -------------------------------------------------
    integral += error * (SAMPLE_TIME / 1000.0);

    // Integral Limit
    integral = constrain(
      integral,
      -integralLimit,
      integralLimit
    );

    float integralTerm = Ki * integral;


    // -------------------------------------------------
    // BAGIAN DERIVATIVE
    // -------------------------------------------------
    float derivative =
      (error - previousError) /
      (SAMPLE_TIME / 1000.0);

    float derivativeTerm = Kd * derivative;


    // -------------------------------------------------
    // OUTPUT PID
    // -------------------------------------------------
    float pidOutput =
      proportional +
      integralTerm +
      derivativeTerm;

    previousError = error;


    // -------------------------------------------------
    // STRATEGI PUSH-PULL PWM
    // -------------------------------------------------
    humidifierPWM = PWM_BALANCE + pidOutput;
    fanPWM = PWM_BALANCE - pidOutput;


    // Batasi PWM 0-255
    humidifierPWM = constrain(
      humidifierPWM,
      0,
      255
    );

    fanPWM = constrain(
      fanPWM,
      0,
      255
    );


    // -------------------------------------------------
    // KIRIM PWM KE AKTUATOR
    // -------------------------------------------------
    analogWrite(
      HUMIDIFIER_PIN,
      humidifierPWM
    );

    analogWrite(
      FAN_PIN,
      fanPWM
    );


    // -------------------------------------------------
    // MONITORING SERIAL
    // -------------------------------------------------
    Serial.println("---------------------------------");

    Serial.print("Suhu       : ");
    Serial.print(temperature);
    Serial.println(" C");

    Serial.print("Kelembapan : ");
    Serial.print(humidity);
    Serial.println(" %");

    Serial.print("Setpoint   : ");
    Serial.print(setpoint);
    Serial.println(" %");

    Serial.print("Error      : ");
    Serial.print(error);
    Serial.println(" %");

    Serial.print("PID Output : ");
    Serial.println(pidOutput);

    Serial.print("Humidifier : ");
    Serial.println(humidifierPWM);

    Serial.print("Kipas      : ");
    Serial.println(fanPWM);
  }
}

Dalam kode program, kita mengatur parameter kestabilan dengan nilai: Kp = 8.0, Ki = 0.08, dan Kd = 0.0.

Mengapa Kd diatur ke angka nol? Sebagai ahli, kita tahu bahwa perubahan kelembapan ruangan biasanya terjadi secara perlahan (lambat). Dalam sistem yang lambat, parameter Derivative seringkali tidak diperlukan dan justru bisa membuat sistem bergetar jika pembacaan sensor sedikit berisik.

Sistem ini beroperasi dengan Sampling Time (Ts) sebesar 1 detik. Artinya, setiap satu detik, Arduino akan membaca sensor dan menghitung ulang koreksi. Pemahaman logika kendali seperti ini juga merupakan dasar yang sama jika kamu ingin bikin robot anti tumbang: panduan lengkap self-balancing robot pakai arduino.

Aksi Aktuator Strategi “Push-Pull” PWM

Satu hal yang membuat proyek ini profesional adalah penggunaan variabel PWM_BALANCE = 80. Sistem tidak mulai dari angka nol, melainkan memberikan tenaga dasar sebesar 80 pada kedua aktuator.

Logikanya bukan sekadar “nyala-mati”, tapi sebuah keseimbangan:

• Intake PWM = 80 + Output PID
• Exhaust PWM = 80 – Output PID

Artinya, jika kelembapan kurang dari 70%, nilai PID akan menambah kecepatan humidifier dan secara otomatis mengurangi kecepatan kipas. Begitu juga sebaliknya. Hasilnya? Transisi yang sangat halus dan kelembapan yang tidak “kaget” saat berubah.

Hasil Pengujian & Kesimpulan

Jika kita melihat grafik hasil pengujian, perbedaannya sangat mencolok. Pada kondisi “Before” tanpa PID, nilai kelembapan melonjak tidak menentu. Namun, setelah PID diaktifkan (“After”), grafik menunjukkan kelembapan merayap naik dan terkunci dengan stabil di angka 70%. Hal ini berkat parameter Ki = 0.08 yang bekerja efektif menyapu bersih sisa kesalahan.

Kesimpulannya, perpaduan Arduino Uno, sensor DHT11, dan algoritma PID diskrit adalah solusi ampuh untuk menciptakan sistem kontrol udara tingkat industri di rumah sendiri. Dengan komponen yang tepat seperti MOSFET logic-level dan teknik flyback diode, alat ini tidak hanya cerdas tapi juga tahan lama.

Ingin tahu lebih lanjut tentang mikrokontroler yang digunakan? Cek dokumentasi resmi Arduino Uno untuk mengeksplorasi lebih jauh!