Sistem Kendali Suhu pada Inkubator Penetasan Telur Berbasis PID Diskrit Menggunakan Sensor DHT11 dan Aktuator Lampu Pijar

Menetaskan telur pakai inkubator jadi salah satu cara yang cukup praktis buat membantu proses penetasan. Tapi, ada satu hal yang nggak boleh disepelekan, yaitu suhu di dalam inkubator. Telur ayam, bebek, maupun puyuh butuh suhu yang stabil, biasanya di kisaran 37–38°C. Kalau suhunya naik atau turun terlalu jauh, meskipun cuma beda 1–2°C dalam waktu tertentu, proses penetasan bisa terganggu dan bahkan bikin embrio nggak berkembang dengan baik. Masalahnya, sistem pemanas biasa yang cuma pakai metode nyala-mati sering bikin suhu di dalam inkubator jadi naik turun dan kurang stabil.

Nah, di proyek ini masalah tersebut diatasi dengan sistem kontrol PID berbasis Arduino Uno. Sistem ini bisa ngatur daya pemanas sesuai kondisi suhu di dalam inkubator, jadi nggak cuma sekadar nyala atau mati. Inkubatornya dibuat dari kaleng biskuit logam, lalu suhu dibaca menggunakan sensor DHT11. Sebagai sumber panas, digunakan lampu pijar 12V yang dikontrol lewat modul MOSFET dengan sinyal PWM. Hasilnya, daya lampu bisa diatur secara bertahap sehingga suhu bisa naik lebih halus dan stabil. Biar makin gampang dipantau, data suhu dan daya pemanas juga ditampilkan secara real-time lewat tampilan HMI berbasis HTML yang terhubung ke Arduino.

Alat dan Bahan

Buat bikin sistem inkubator ini, komponen yang digunakan cukup simpel dan total budget-nya juga masih aman di bawah Rp100.000.

Jadi, total biaya komponen yang perlu dibeli cuma sekitar Rp86.000, jadi masih aman dan nggak lewat dari budget Rp100.000.

Topologi Sistem

Sistem inkubator ini bekerja menggunakan sistem loop tertutup, jadi suhu di dalam inkubator terus dipantau dan otomatis disesuaikan kalau mulai berubah dari suhu yang diinginkan. Ada empat bagian utama yang terlibat, yaitu sensor suhu, Arduino sebagai kontroler PID, aktuator pemanas, dan inkubator sebagai plant. Sensor DHT11 bertugas membaca suhu aktual di dalam inkubator, lalu datanya dikirim ke Arduino. Setelah itu, Arduino membandingkan suhu tersebut dengan setpoint yang sudah ditentukan, yaitu 37,5°C.

Kalau ada perbedaan suhu, sistem PID akan menghitung seberapa besar daya pemanas yang dibutuhkan. Arduino kemudian mengirimkan sinyal PWM dengan nilai 0–255 ke modul MOSFET untuk mengatur tingkat daya lampu pijar. Lampu akan menghasilkan panas dan menaikkan suhu di dalam inkubator, lalu sensor DHT11 membaca kembali suhu terbaru. Proses ini terus berulang supaya suhu tetap stabil di sekitar setpoint. Selain itu, data suhu dan nilai PWM juga dikirim ke PC melalui komunikasi serial dan ditampilkan secara real-time pada dashboard HMI berbasis HTML.

Secara sederhana, alur sistemnya seperti ini:

Setpoint → PID (Arduino) → PWM → MOSFET → Lampu Pijar → Inkubator → Sensor DHT11 → kembali ke PID

Dengan adanya feedback dari sensor DHT11, sistem bisa langsung tahu kalau suhu terlalu rendah atau terlalu tinggi, lalu PID akan menyesuaikan daya lampu pada proses berikutnya. Jadi, sistemnya nggak cuma sekadar nyalain dan matiin pemanas, tapi bisa ngatur panas secara lebih halus sesuai kondisi di dalam inkubator.

Skematik rangkaian: Arduino Uno, sensor DHT11, modul MOSFET dual, lampu pijar 12VDC, dan adaptor 12VDC

Cara Kerja

Sistem inkubator ini bekerja dengan konsep loop tertutup dan melakukan pengecekan suhu setiap 2 detik. Jadi, sistem terus membaca suhu di dalam inkubator, membandingkannya dengan suhu target, lalu menyesuaikan daya pemanas sesuai kebutuhan. Prosesnya kurang lebih seperti ini:

a) Pembacaan Sensor

Setiap 2 detik, sensor DHT11 membaca suhu di dalam inkubator dan mengirimkan datanya ke Arduino melalui pin D2. Arduino kemudian membandingkan suhu yang terbaca dengan setpoint 37,5°C. Selisih antara suhu target dan suhu aktual ini disebut error. Kalau suhu masih di bawah 37,5°C, sistem akan menambah daya pemanas. Sebaliknya, kalau suhunya sudah terlalu tinggi, daya pemanas akan dikurangi.

b) Proses PID

Nilai error tadi kemudian diproses oleh kontrol PID (Proportional, Integral, Derivative). Secara sederhana, PID bekerja dengan mengatur output berdasarkan kondisi error supaya sistem bisa mencapai target dengan lebih stabil. Bagian P merespons error saat ini, bagian I membantu mengatasi error yang masih tersisa, sedangkan bagian D melihat perubahan error untuk membantu mengurangi overshoot. Kalau ingin memahami konsep PID lebih lanjut, kamu bisa melihat referensi tentang PID control.

Nilai Kp, Ki, dan Kd tidak perlu diubah langsung di program Arduino. Parameter tersebut dikirim dari HMI melalui komunikasi serial, sehingga proses tuning bisa dilakukan langsung dari komputer tanpa harus upload ulang program. Untuk mencegah output PID terlalu besar, hasil perhitungan dibatasi pada rentang 0–255, sesuai dengan nilai PWM 8-bit Arduino.

c) Pengaturan Pemanas

Hasil perhitungan PID kemudian dikirim ke pin D3 Arduino dalam bentuk sinyal PWM. Sinyal ini masuk ke modul MOSFET yang bertugas mengatur arus menuju dua lampu pijar 12V. Nilai PWM menentukan seberapa besar daya yang diberikan ke lampu. Semakin tinggi nilai PWM, semakin besar daya lampu dan semakin panas kondisi di dalam inkubator.

Jadi, pemanas nggak cuma bekerja dengan sistem nyala atau mati. Daya lampu bisa dinaikkan atau diturunkan secara bertahap sesuai kebutuhan suhu. Cara ini membuat proses pemanasan jadi lebih halus dan membantu menjaga suhu tetap stabil di sekitar 37,5°C.

d) Komunikasi Serial dan HMI

Setelah satu siklus kontrol selesai, Arduino mengirim data ke PC melalui komunikasi serial dengan baud rate 9600. Data yang dikirim berisi waktu, setpoint, suhu aktual, dan nilai PWM. Data tersebut kemudian ditampilkan pada dashboard HMI berbasis HTML yang berjalan di Google Chrome menggunakan Web Serial API.

Lewat dashboard ini, pengguna bisa melihat grafik suhu secara real-time, membandingkan suhu aktual dengan setpoint, serta memantau nilai PWM. Yang lebih praktis, parameter Kp, Ki, Kd, dan setpoint juga bisa diubah langsung dari HMI tanpa perlu mengupload ulang program Arduino.

e) Hasil Percobaan

Pada pengujian, suhu awal di dalam inkubator berada di sekitar 30°C, kemudian setpoint ditentukan pada 37,5°C. Parameter PID yang digunakan yaitu Kp = 55,0, Ki = 0,20, dan Kd = 4,2. Setelah sistem dijalankan, suhu naik secara bertahap dan berhasil mencapai 37,5°C dalam waktu sekitar 216 detik, dengan overshoot yang tidak terlalu signifikan.

Inkubator yang digunakan dibuat dari kaleng biskuit logam sebagai ruang tertutup. Sensor DHT11 dipasang di bagian atas tutup untuk membaca suhu di dalam ruang inkubator, sedangkan Arduino dan modul MOSFET ditempatkan di bagian luar kaleng. Dari hasil pengujian tersebut, sistem PID mampu mengatur daya pemanas secara otomatis sehingga suhu bisa mendekati dan bertahan di sekitar suhu target.

Perangkat Lunak

Software yang digunakan di proyek ini dibagi menjadi dua bagian utama. Pertama, ada firmware Arduino yang bertugas membaca sensor, menjalankan perhitungan PID, dan mengatur daya pemanas. Kedua, ada HMI berbasis HTML yang berjalan di browser untuk menampilkan data suhu dan mengontrol parameter sistem secara real-time.

Firmware Arduino

Berikut adalah kode lengkap firmware Arduino yang digunakan pada proyek ini. Nilai awal Kp, Ki, dan Kd dibuat 0 karena parameter tersebut nantinya diatur melalui HMI sebelum pengujian dimulai.

#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT11
#define PWM_PIN 3

DHT dht(DHTPIN, DHTTYPE);

// Parameter PID
float Kp = 0;
float Ki = 0;
float Kd = 0;

// Setpoint suhu
float setpoint = 37.5;

// Variabel PID
float error = 0;
float previousError = 0;
float integral = 0;
float derivative = 0;
float pidOutput = 0;

// Sampling setiap 2 detik
unsigned long previousMillis = 0;
const unsigned long sampleTime = 2000;

// Batas integral untuk mencegah wind-up
const float integralMax = 60.0;

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

  dht.begin();

  pinMode(PWM_PIN, OUTPUT);

  // Pemanas awal dalam kondisi mati
  analogWrite(PWM_PIN, 0);
}

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

  if (currentMillis - previousMillis >= sampleTime) {
    previousMillis = currentMillis;

    // Membaca suhu
    float temperature = dht.readTemperature();

    // Cek apakah pembacaan sensor valid
    if (isnan(temperature)) {
      analogWrite(PWM_PIN, 0);
      return;
    }

    // Menghitung error
    error = setpoint - temperature;

    // Komponen Integral
    integral += error * (sampleTime / 1000.0);

    // Anti-Windup
    if (integral > integralMax) {
      integral = integralMax;
    }

    if (integral < -integralMax) {
      integral = -integralMax;
    }

    // Komponen Derivative
    derivative = (error - previousError)
                 / (sampleTime / 1000.0);

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

    // Membatasi output PID ke rentang PWM Arduino
    if (pidOutput > 255) {
      pidOutput = 255;
    }

    if (pidOutput < 0) {
      pidOutput = 0;
    }

    // Mengirim output PWM ke MOSFET
    analogWrite(PWM_PIN, (int)pidOutput);

    // Menyimpan error untuk perhitungan berikutnya
    previousError = error;

    // Mengirim data ke HMI
    Serial.print(currentMillis / 1000.0);
    Serial.print("\t");
    Serial.print(setpoint);
    Serial.print("\t");
    Serial.print(temperature);
    Serial.print("\t");
    Serial.println((int)pidOutput);
  }

  // Membaca perintah dari HMI
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();

    // Format:
    // P:55.0,I:0.20,D:4.2
    if (command.startsWith("P:")) {
      int pIndex = command.indexOf("P:");
      int iIndex = command.indexOf(",I:");
      int dIndex = command.indexOf(",D:");

      if (pIndex >= 0 && iIndex >= 0 && dIndex >= 0) {
        Kp = command.substring(pIndex + 2, iIndex).toFloat();
        Ki = command.substring(iIndex + 3, dIndex).toFloat();
        Kd = command.substring(dIndex + 3).toFloat();

        // Reset integral
        integral = 0;
      }
    }

    // Format:
    // S:37.5
    else if (command.startsWith("S:")) {
      setpoint = command.substring(2).toFloat();

      // Reset integral saat setpoint berubah
      integral = 0;
    }
  }
}

Kode tersebut mengatur sistem kontrol suhu inkubator menggunakan Arduino Uno, sensor DHT11, dan PWM. Arduino membaca suhu setiap 2 detik, lalu membandingkannya dengan setpoint 37,5°C untuk mendapatkan nilai error. Error tersebut diproses oleh kontrol PID melalui parameter Kp, Ki, dan Kd untuk menentukan seberapa besar daya pemanas yang dibutuhkan. Hasil perhitungan PID kemudian diubah menjadi nilai PWM 0–255 dan dikirim ke pin D3 untuk mengatur MOSFET dan lampu pemanas. Kode juga sudah dilengkapi anti-windup untuk membatasi nilai integral serta komunikasi serial dengan HMI, sehingga pengguna bisa mengubah parameter PID dan setpoint secara langsung tanpa perlu upload ulang program.

Kesimpulan

Dari proyek yang sudah dibuat dan diuji, sistem kontrol suhu inkubator menggunakan Arduino Uno dan PID berhasil menjaga suhu di sekitar setpoint 37,5°C. Sensor DHT11 digunakan untuk membaca suhu, kemudian Arduino mengolah data tersebut dengan algoritma PID dan mengatur daya lampu pemanas melalui PWM dan MOSFET. Dengan cara ini, pemanas nggak cuma bekerja dengan sistem nyala atau mati, tapi bisa menyesuaikan daya sesuai kondisi suhu sehingga proses pemanasan jadi lebih halus dan stabil.

Hasil pengujian menunjukkan suhu awal sekitar 30°C bisa mencapai suhu target dalam waktu kurang lebih 216 detik dengan overshoot yang tidak terlalu signifikan. Ditambah HMI berbasis HTML, kondisi suhu dan daya pemanas juga bisa dipantau secara real-time sekaligus digunakan untuk mengatur parameter PID tanpa perlu upload ulang program Arduino. Kalau kamu juga lagi ngulik proyek mikrokontroler yang menggunakan PWM, kamu bisa lanjut baca artikel Cara Menghubungkan TB6612FNG dengan Raspberry Pi untuk Mengontrol Arah Motor DC untuk melihat contoh penggunaan PWM dan motor driver pada proyek lainnya.