Dasar · 11 mnt baca

Kontrol PID Arduino: Mengatur Kp, Ki, Kd dengan Contoh Kode

Apa itu kontrol PID dan bagaimana cara kerjanya? Suku P, I, dan D, library PID Arduino, cara mengatur Kp/Ki/Kd, plus kode kontrol suhu dan robot pengikut garis.

Kontrol PID adalah metode umpan balik yang menjaga sistem tetap di nilai yang kamu inginkan. Caranya, selisih antara nilai terukur dan target (error) terus dihitung, lalu output disesuaikan berdasarkan error itu. Di proyek Arduino, PID dipakai untuk menahan pemanas tepat di 45 °C, memutar motor dengan kecepatan konstan, atau menjalankan robot pengikut garis tepat di tengah garis. Namanya berasal dari tiga bagiannya: suku Proporsional (P) melihat error sekarang, suku Integral (I) melihat error yang menumpuk di masa lalu, dan suku Derivatif (D) melihat seberapa cepat error berubah. Jumlah berbobot dari ketiganya menentukan nilai PWM yang dikirim ke motor atau pemanas.

Rumusnya memang terlihat menakutkan di awal, tapi logika PID mirip sekali dengan hal yang otomatis kamu lakukan ketika menyetir mobil. Di artikel ini kamu akan melihat dulu kenapa kontrol on-off sederhana selalu berosilasi, lalu mengenal tiga sukunya lewat contoh yang intuitif. Setelah itu kamu akan membuat kontrol suhu dengan library PID Arduino memakai NTC dan MOSFET, belajar mengatur Kp, Ki, dan Kd langkah demi langkah, dan menjalankan robot pengikut garis dengan PID yang ditulis tanpa library. Terakhir, kita jalankan algoritma yang sama di ESP32 dan di Raspberry Pi Pico dengan MicroPython.

Kenapa kontrol on-off tidak cukup?

Metode kontrol paling sederhana adalah kontrol on-off: kalau suhu di bawah target, nyalakan pemanas dengan daya penuh; kalau di atas, matikan. Termostat pemanas air di rumah dan pemanas akuarium sebagian besar bekerja seperti ini. Masalahnya, begitu pemanas mati, panas yang tersimpan di dalamnya tetap mengalir ke sekitarnya, sehingga suhu melewati target beberapa derajat. Ketika mulai mendingin, pemanas menyala lagi, tapi suhu sempat turun di bawah target sampai pemanasnya panas kembali. Hasilnya berupa gigi gergaji yang terus naik-turun di sekitar target. Untuk menghaluskannya, diberi celah (histeresis) di antara dua ambang; relay jadi lebih jarang berbunyi klik, tapi amplitudo ayunannya membesar. Pada bed printer 3D, inkubator, atau motor yang harus berputar dengan kecepatan konstan, yang harus tetap dalam ±0,5 °C, cara ini tidak cukup. PID justru menghasilkan output bertahap di antara daya penuh dan nol, dan menurunkan daya lebih awal ketika sistem mendekati target.

MetodeCara memutuskanKelebihanKekuranganPenggunaan umum
On-off (nyala-mati)Daya penuh di bawah target, mati di atasnyaSangat sederhana, bahkan bisa dengan relayOsilasi dan overshoot terus-menerus, relay cepat ausTermostat pemanas air, pemanas akuarium
POutput sebanding dengan errorRespons halus, mudah diaturMenyisakan error tunakKontrol posisi dan level sederhana
PIProporsional + error yang menumpukMenghapus error tunakOvershoot lebih besar, integral windupKontrol suhu, aliran, dan kecepatan motor
PIDProporsional + error yang menumpuk + laju perubahanCepat, overshoot kecil, presisiSulit diatur, sensitif terhadap derauPrinter 3D, drone, robot penyeimbang, robot pengikut garis

Apa itu kontrol PID dan bagaimana cara kerjanya?

Di setiap perulangan, PID pertama-tama menghitung error: error = nilai target (setpoint) − nilai terukur (input). Lalu error ini dievaluasi dengan tiga cara berbeda dan dijumlahkan: output = Kp·e + Ki·∫e·dt + Kd·de/dt. Di sini Kp, Ki, dan Kd adalah koefisien yang kamu atur; koefisien inilah yang menentukan seberapa besar kontribusi tiap suku ke output. Di mikrokontroler, integral dihitung dengan menambahkan hasil kali error dan waktu sampling ke sebuah jumlah berjalan di setiap sampel, sedangkan derivatif dihitung dengan membagi selisih dua pengukuran terakhir dengan waktu sampling. Karena itu, agar PID bekerja dengan baik, pengukuran harus dilakukan pada interval tetap, misalnya setiap 10 ms atau setiap 500 ms. Bayangkan kamu mengikuti lajur dengan mobil: makin jauh dari lajur, makin banyak kamu memutar setir (P); kalau angin samping terus mendorongmu, kamu belajar menahan setir sedikit miring (I); dan ketika mendekati lajur dengan cepat, kamu mengurangi belokan lebih awal (D).

SukuYang dilihatAnalogi intuitifKalau terlalu besar
P (Proporsional)Error sekarangMakin jauh dari lajur, makin banyak kamu memutar setirOsilasi cepat, bergetar
I (Integral)Error yang menumpuk seiring waktuKalau ada angin samping, kamu belajar menahan setir sedikit miringOsilasi lambat dan lebar, overshoot besar
D (Derivatif)Laju perubahan errorKetika mendekati lajur dengan cepat, kamu mengurangi belokan lebih awalBereaksi berlebihan terhadap derau, output bergetar

Suku proporsional (P): respons sebanding dengan error

Suku proporsional mengatur output sebanding langsung dengan besar error. Dengan Kp = 20, error 3 °C menghasilkan 60 unit PWM dan error 1 °C menghasilkan 20 unit; makin dekat ke target, daya turun dengan sendirinya. Makin besar Kp, makin cepat sistem merespons, tapi setelah titik tertentu sistem mulai melewati target lalu berbalik, dengan kata lain berosilasi. Kontrol dengan P saja punya kelemahan besar: error tunak (steady-state error). Misalnya, untuk menahan pemanas di 45 °C dibutuhkan daya terus-menerus sebesar 80 unit untuk mengimbangi panas yang lepas ke sekitar. Kalau hanya ada suku P, 80 unit itu hanya bisa dihasilkan selama ada error: 80 / 20 = 4 °C. Jadi sistem stabil di sekitar 41 °C dan tidak pernah mencapai target. Menaikkan Kp memperkecil selisih ini, tapi juga memperbesar osilasi.

Suku integral (I): menghapus error tunak

Suku integral menjumlahkan error seiring waktu. Error kecil pun, kalau berlangsung lama, membuat jumlahnya membesar dan output naik perlahan sampai error menjadi nol. Pada contoh di atas, daya 80 unit yang dibutuhkan sekarang disediakan oleh suku integral, suku P turun ke nol, dan suhu stabil tepat di 45 °C. Makin besar Ki, makin cepat error tunak tertutup; kalau terlalu besar, sistem berosilasi lambat dan lebar. Jebakan integral yang terkenal adalah kondisi yang disebut integral windup (penumpukan integral): kalau pemanas sudah di daya penuh tapi tetap tidak bisa mencapai target, integral terus membesar sia-sia, dan begitu target tercapai, nilai yang menumpuk ini membuat suhu tertahan di atas target dalam waktu lama. Solusinya adalah membatasi integral dengan batas output; library PID Arduino melakukannya otomatis dengan SetOutputLimits.

Suku derivatif (D): mengerem ketika mendekati target

Suku derivatif melihat seberapa cepat error berubah dan memberi semacam prediksi. Kalau suhu mendekati target dengan cepat, error mengecil dengan cepat; suku D memberi kontribusi berlawanan dengan perubahan ini, memotong daya lebih awal, dan mengurangi overshoot. Hal yang sama terjadi di robot: robot yang berbelok cepat ke arah garis akan melunakkan belokannya sebelum melewati garis. Kelemahan suku D adalah sensitivitasnya terhadap derau. Kalau pembacaan sensor analog melompat beberapa unit di setiap pengukuran, derivatif melihat lompatan kecil ini sebagai perubahan besar dan output jadi bergetar. Karena itu pembacaan sensor perlu dirata-rata atau difilter; lihat artikel menyaring data sensor untuk detailnya. Selain itu, implementasi PID yang baik mengambil derivatif dari pengukuran, bukan dari error; dengan begitu, ketika kamu mengubah target secara tiba-tiba, tidak ada lonjakan mendadak di output (derivative kick).

Contoh 1: Kontrol suhu dengan library PID Arduino

Di contoh pertama kita akan menahan pemanas kecil (heating pad 12 V atau resistor daya) di 45 °C. Suhu diukur dengan pembagi tegangan dari termistor NTC 10 kΩ dan resistor tetap 10 kΩ, lalu pemanas dikendalikan dengan PWM lewat MOSFET kanal-N logic-level (misalnya IRLZ44N). Di Arduino IDE, buka Library Manager, cari PID, lalu instal library PID karya Brett Beauregard (PID_v1). Library ini mengurus detail seperti pengelolaan waktu sampling, pembatasan output, perlindungan terhadap integral windup, dan pengambilan derivatif dari pengukuran untukmu. Untuk detail koneksi MOSFET, lihat artikel Memakai MOSFET dengan Arduino.

Sensor suhu termistor NTC
Termistor NTC 10 kΩ: hambatannya turun ketika suhu naik; dipakai sebagai elemen pengukur di kontrol suhu PID.
KoneksiArduino UnoESP32Raspberry Pi Pico
Catu pembagi (ujung atas resistor tetap 10 kΩ)5V3V33V3
Titik sambungan NTC dan resistor tetapA0GPIO 34GP26 (ADC0)
Ujung bawah NTCGNDGNDGND
Gate MOSFET (lewat 220 Ω, dengan 10 kΩ ke GND)D9GPIO 25GP15
Source MOSFETGNDGNDGND
PemanasDi antara +12 V dan drain MOSFETDi antara +12 V dan drain MOSFETDi antara +12 V dan drain MOSFET
Jangan pernah memberi daya pemanas langsung dari pin Arduino; satu pin hanya bisa memberi sekitar 20–40 mA paling banyak, sedangkan pemanas menarik arus beberapa ampere. Kutub negatif adaptor 12 V harus tersambung bersama dengan GND Arduino, kalau tidak MOSFET tidak akan menyala dengan benar. Karena ESP32 dan Pico mengeluarkan 3,3 V, pilih MOSFET yang menyala penuh di 3,3 V (misalnya AO3400) sebagai pengganti IRLZ44N; dan kalau kamu mengendalikan beban induktif seperti kipas atau motor, pasang dioda flyback paralel dengan beban.
C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = A0;        // NTC bölücü orta noktası / NTC divider midpoint
4const int HEATER_PIN = 9;      // MOSFET gate (PWM) / MOSFET gate (PWM)
5
6const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
7const float R0 = 10000.0;      // NTC'nin 25 °C direnci / NTC resistance at 25 °C
8const float T0 = 298.15;       // 25 °C kelvin cinsinden / 25 °C in kelvin
9const float BETA = 3950.0;     // NTC Beta katsayısı / NTC beta coefficient
10
11double setpoint = 45.0;        // hedef sıcaklık / target temperature
12double input = 0;              // ölçülen sıcaklık / measured temperature
13double output = 0;             // ısıtıcı gücü 0-255 / heater power 0-255
14
15double Kp = 20.0, Ki = 0.5, Kd = 10.0;   // başlangıç değerleri / starting values
16PID heaterPID(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);
17
18float readTemperature() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {
21    sum += analogRead(NTC_PIN);            // 16 ölçüm ortalaması / average of 16 readings
22  }
23  float adc = sum / 16.0;
24  adc = constrain(adc, 1.0, 1022.0);       // sıfıra bölmeyi önle / avoid division by zero
25  float r = R_FIXED * adc / (1023.0 - adc);                // NTC direnci / NTC resistance
26  float kelvin = 1.0 / (1.0 / T0 + log(r / R0) / BETA);    // Beta denklemi / beta equation
27  return kelvin - 273.15;
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(HEATER_PIN, OUTPUT);
33  input = readTemperature();
34  heaterPID.SetOutputLimits(0, 255);       // analogWrite aralığı / analogWrite range
35  heaterPID.SetSampleTime(500);            // 500 ms'de bir hesapla / compute every 500 ms
36  heaterPID.SetMode(AUTOMATIC);            // PID'yi başlat / start the PID
37}
38
39void loop() {
40  input = readTemperature();
41  if (heaterPID.Compute()) {               // yeni çıkış hazırsa / if a new output is ready
42    analogWrite(HEATER_PIN, (int)output);
43    Serial.print(setpoint);                // Seri Çizici için / for the Serial Plotter
44    Serial.print(' ');
45    Serial.print(input);
46    Serial.print(' ');
47    Serial.println(output / 255.0 * 100.0); // güç yüzdesi / power percent
48  }
49}

Di kode, fungsi readTemperature() mengurangi derau dengan merata-rata 16 pembacaan, menghitung hambatan NTC dari rumus pembagi (R = 10 kΩ · adc / (1023 − adc)), lalu mengubahnya ke derajat Celsius dengan persamaan Beta (B = 3950). SetOutputLimits(0, 255) menjaga output tetap di rentang analogWrite dan mencegah integral melewati batas tersebut. SetSampleTime(500) membuat PID menghitung setiap setengah detik; karena panas adalah besaran yang berubah lambat, ini sudah cukup. Compute() hanya mengembalikan true ketika waktu sampling tiba, jadi kamu tidak boleh memakai delay() di dalam loop(). Kalau tiga nilai yang dikirim ke port serial kamu buka di Serial Plotter pada menu Tools, kamu akan melihat target, suhu, dan daya pemanas dalam persen di grafik yang sama, dan bisa langsung melihat efek pengaturanmu. Pada sistem pendingin (misalnya pendinginan dengan kipas), output harus naik ketika suhu naik; dalam kasus itu pakai REVERSE sebagai pengganti DIRECT.

Cara mengatur Kp, Ki, dan Kd: langkah demi langkah

  1. Set Ki dan Kd ke nol, mulai Kp dari nilai kecil (misalnya 2), lalu buka Serial Plotter.
  2. Gandakan Kp langkah demi langkah; berhenti ketika sistem mendekati target dengan cepat dan mulai berosilasi terus-menerus di sekitarnya. Pakai sekitar setengah dari nilai itu sebagai Kp.
  3. Tambahkan Kd: mulai dari nilai kecil dan naikkan sampai overshoot dan osilasi hilang. Kalau output mulai bergetar atau motor mulai mendengung, berarti Kd terlalu besar atau sensornya berderau.
  4. Tambahkan Ki paling akhir: naikkan perlahan sampai error tunak tertutup dalam waktu yang wajar. Kalau suhu membentuk gelombang lambat dan lebar di sekitar target, turunkan Ki.
  5. Uji dengan gangguan: ubah target sebesar 5 °C, tiup pemanasnya, atau dorong robot pelan-pelan dengan tangan; perhatikan berapa lama sistem pulih dan seberapa besar overshoot-nya.
  6. Kalau mau, pakai metode Ziegler-Nichols sebagai titik awal: dengan P saja, ukur penguatan yang memicu osilasi terus-menerus (Ku) dan periode osilasinya (Tu, dalam detik); mulai dengan Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu, lalu lakukan penyetelan halus secara manual.
Kalau koefisien dinaikkanWaktu naikOvershootWaktu settlingError tunak
KpMakin singkatNaikSedikit berubahTurun
KiMakin singkatNaikMakin lamaHilang
KdSedikit berubahTurunMakin singkatSecara teori tidak berpengaruh

Contoh 2: PID di robot pengikut garis

Sensor garis inframerah TCRT5000
Sensor pantul inframerah TCRT5000: membedakan permukaan hitam dan putih; menjadi input PID di robot pengikut garis.

Di robot pengikut garis, tujuannya adalah agar garis tetap tepat di tengah robot. Dengan mengambil rata-rata berbobot dari pembacaan tiga sensor analog TCRT5000 yang dipasang di kiri, tengah, dan kanan, posisi garis diubah menjadi angka antara 0 (paling kiri) dan 2000 (paling kanan); 1000 berarti tepat di tengah. Error adalah selisih antara posisi dan 1000. Koreksi yang dihasilkan PID ditambahkan ke kecepatan motor kiri dan dikurangkan dari kecepatan motor kanan, sehingga robot berbelok halus ke arah garis. Robot dengan logika on-off sederhana (belok kiri kalau garis di kiri, belok kanan kalau di kanan) berjalan goyang dan lambat, sedangkan robot dengan PID melaju di lintasan yang sama jauh lebih cepat dan dengan jalur yang mulus. Di contoh ini kita menulis PID dari nol tanpa library; motornya dikendalikan dengan driver L298N.

C++ (Arduino IDE)
1const int SENSOR_PINS[3] = {A0, A1, A2};   // sol, orta, sağ / left, center, right
2
3const int ENA = 5, IN1 = 7, IN2 = 8;       // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 10;      // sağ motor / right motor
5
6const int BASE_SPEED = 150;                // düz giderken hız / cruising speed
7float Kp = 0.1, Ki = 0.0, Kd = 0.004;      // robota göre ayarla / tune for your robot
8
9float lastError = 0;
10float integral = 0;
11int lastPosition = 1000;
12unsigned long lastTime = 0;
13
14int readPosition() {
15  long sum = 0, weighted = 0;
16  int maxValue = 0;
17  for (int i = 0; i < 3; i++) {
18    int v = analogRead(SENSOR_PINS[i]);    // siyah çizgi = yüksek değer / black line = high value
19    weighted += (long)v * i * 1000L;
20    sum += v;
21    if (v > maxValue) maxValue = v;
22  }
23  if (maxValue > 500) {                    // çizgi görülüyor / line is visible
24    lastPosition = weighted / sum;         // 0 sol, 1000 orta, 2000 sağ / 0 left, 1000 center, 2000 right
25  }
26  return lastPosition;                     // çizgi kaybolursa son konum / last position if line is lost
27}
28
29void setMotor(int en, int inA, int inB, int speed) {
30  speed = constrain(speed, -255, 255);
31  if (speed >= 0) {
32    digitalWrite(inA, HIGH);               // ileri / forward
33    digitalWrite(inB, LOW);
34  } else {
35    digitalWrite(inA, LOW);                // geri / backward
36    digitalWrite(inB, HIGH);
37    speed = -speed;
38  }
39  analogWrite(en, speed);
40}
41
42void setup() {
43  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
44  for (int i = 0; i < 6; i++) {
45    pinMode(pins[i], OUTPUT);
46  }
47  lastTime = millis();
48}
49
50void loop() {
51  unsigned long now = millis();
52  if (now - lastTime < 10) return;         // 10 ms örnekleme / 10 ms sampling
53  float dt = (now - lastTime) / 1000.0;    // saniye cinsinden / in seconds
54  lastTime = now;
55
56  float error = readPosition() - 1000;     // negatif = çizgi solda / negative = line on the left
57  integral += error * dt;
58  integral = constrain(integral, -500.0, 500.0);   // windup sınırı / windup limit
59  float derivative = (error - lastError) / dt;
60  lastError = error;
61
62  float correction = Kp * error + Ki * integral + Kd * derivative;
63  setMotor(ENA, IN1, IN2, (int)(BASE_SPEED + correction));
64  setMotor(ENB, IN3, IN4, (int)(BASE_SPEED - correction));
65}

Sensor dihubungkan ke A0, A1, dan A2, pin ENA dan ENB L298N ke pin PWM D5 dan D6, dan pin IN1–IN4 ke D7, D8, D9, dan D10; jangan lupa melepas jumper di ENA dan ENB. Perulangan berjalan setiap 10 ms memakai millis(); dengan begitu dt tetap konstan dan koefisien berperilaku konsisten. Alasan kita memakai millis() dan bukan delay() bisa kamu baca di artikel millis dan delay. Kalau error negatif, garis ada di kiri: koreksi menjadi negatif, motor kiri melambat, motor kanan makin cepat, dan robot berbelok ke kiri. Karena besar error paling banyak 1000, Kp = 0.1 berarti koreksi sekitar 100 unit PWM pada error terbesar. Karena derivatif dihitung per detik, wajar kalau Kd terlihat sekecil 0.004. Di robot pengikut garis, Ki biasanya dibiarkan nol atau sangat kecil; integral hanya berguna kalau robot terus bergeser ke satu arah (misalnya satu motor lebih lemah dari yang lain). Kalau sensormu membaca nilai tinggi di permukaan putih dan rendah di garis hitam, balik pembacaannya menjadi 1023 − v.

PID dengan ESP32 dan Raspberry Pi Pico

Karena library PID_v1 ditulis dengan C++ murni, library ini langsung jalan di ESP32; kamu cukup menghubungkan NTC ke GPIO 34 dan gate MOSFET ke GPIO 25. Perbedaannya ada di perangkat keras: ADC ESP32 adalah 12-bit (0–4095) dan tidak linear di dekat ujung rentangnya; menjaga tegangan terukur di antara 0,3 dan 2,8 V memperbaiki hasilnya. Untuk PWM, dipakai periferal LEDC sebagai pengganti analogWrite, dan karena API ini berubah sejak core 3.x, kodenya menyertakan pengecekan versi. Karena cepat dan dua inti, ESP32 bisa menerima target suhu baru dari halaman web sambil tetap menjalankan perulangan PID.

C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = 34;        // ADC1 girişi / ADC1 input
4const int HEATER_PIN = 25;     // MOSFET gate / MOSFET gate
5const int PWM_FREQ = 1000;     // 1 kHz PWM / 1 kHz PWM
6const int PWM_BITS = 8;        // 0-255 çözünürlük / 0-255 resolution
7
8double setpoint = 45.0, input = 0, output = 0;
9PID heaterPID(&input, &output, &setpoint, 20.0, 0.5, 10.0, DIRECT);
10
11float readTemperature() {
12  long sum = 0;
13  for (int i = 0; i < 16; i++) {
14    sum += analogRead(NTC_PIN);            // 12 bit: 0-4095 / 12-bit: 0-4095
15  }
16  double adc = constrain(sum / 16.0, 1.0, 4094.0);
17  double r = 10000.0 * adc / (4095.0 - adc);                     // NTC direnci / NTC resistance
18  return 1.0 / (1.0 / 298.15 + log(r / 10000.0) / 3950.0) - 273.15;
19}
20
21void setup() {
22  Serial.begin(115200);
23  analogReadResolution(12);
24#if ESP_ARDUINO_VERSION_MAJOR >= 3
25  ledcAttach(HEATER_PIN, PWM_FREQ, PWM_BITS);   // çekirdek 3.x / core 3.x
26#else
27  ledcSetup(0, PWM_FREQ, PWM_BITS);             // çekirdek 2.x, kanal 0 / core 2.x, channel 0
28  ledcAttachPin(HEATER_PIN, 0);
29#endif
30  input = readTemperature();
31  heaterPID.SetOutputLimits(0, 255);
32  heaterPID.SetSampleTime(500);
33  heaterPID.SetMode(AUTOMATIC);
34}
35
36void loop() {
37  input = readTemperature();
38  if (heaterPID.Compute()) {
39#if ESP_ARDUINO_VERSION_MAJOR >= 3
40    ledcWrite(HEATER_PIN, (uint32_t)output);    // pin ile yaz / write by pin
41#else
42    ledcWrite(0, (uint32_t)output);             // kanal ile yaz / write by channel
43#endif
44    Serial.printf("%.1f %.2f %.0f\n", setpoint, input, output / 255.0 * 100.0);
45  }
46}

Di Raspberry Pi Pico belum ada modul PID siap pakai untuk MicroPython, jadi algoritmanya kita tulis sebagai class kecil. Class ini meniru tiga hal penting yang dilakukan library Arduino: menjaga integral di dalam batas output (anti-windup), mengambil derivatif dari pengukuran, dan memperhitungkan waktu sampling (dt). ADC Pico mengembalikan nilai di rentang 0–65535 dengan read_u16(); output PID dihitung di rentang 0–255 lalu dikalikan 257 untuk diskalakan ke 16 bit bagi duty_u16(). Dengan begitu nilai Kp, Ki, dan Kd yang kamu temukan di Arduino bisa dipakai juga di Pico. Pembagi NTC dihubungkan ke GP26 dan gate MOSFET ke GP15. Kalau kamu baru mengenal MicroPython, kamu bisa mulai dari artikel dasar-dasar MicroPython.

MicroPython
1from machine import ADC, Pin, PWM
2import math
3import time
4
5ntc = ADC(26)                     # GP26 = ADC0, NTC bölücüsü / NTC divider
6heater = PWM(Pin(15))             # MOSFET gate / MOSFET gate
7heater.freq(1000)                 # 1 kHz PWM / 1 kHz PWM
8
9R_FIXED = 10000                   # sabit direnç / fixed resistor
10R0 = 10000                        # NTC'nin 25 °C direnci / NTC resistance at 25 °C
11T0 = 298.15                       # 25 °C kelvin cinsinden / 25 °C in kelvin
12BETA = 3950                       # Beta katsayısı / beta coefficient
13SETPOINT = 45.0                   # hedef sıcaklık / target temperature
14
15def read_temp():
16    total = 0
17    for _ in range(16):
18        total += ntc.read_u16()   # 16 ölçüm ortalaması / average of 16 readings
19    adc = min(max(total / 16, 1), 65534)
20    r = R_FIXED * adc / (65535 - adc)
21    return 1 / (1 / T0 + math.log(r / R0) / BETA) - 273.15
22
23class PID:
24    def __init__(self, kp, ki, kd, out_min, out_max):
25        self.kp, self.ki, self.kd = kp, ki, kd
26        self.out_min, self.out_max = out_min, out_max
27        self.i_term = 0
28        self.last_input = None
29
30    def compute(self, setpoint, measurement, dt):
31        error = setpoint - measurement
32        self.i_term += self.ki * error * dt                               # biriken hata / accumulated error
33        self.i_term = min(max(self.i_term, self.out_min), self.out_max)  # integral sınırı / anti-windup
34        if self.last_input is None:
35            d_input = 0
36        else:
37            d_input = (measurement - self.last_input) / dt                # ölçümden türev / derivative on measurement
38        self.last_input = measurement
39        out = self.kp * error + self.i_term - self.kd * d_input
40        return min(max(out, self.out_min), self.out_max)
41
42pid = PID(20, 0.5, 10, 0, 255)    # Arduino ile aynı katsayılar / same gains as Arduino
43last = time.ticks_ms()
44
45while True:
46    now = time.ticks_ms()
47    if time.ticks_diff(now, last) >= 500:                                 # 500 ms örnekleme / 500 ms sampling
48        dt = time.ticks_diff(now, last) / 1000
49        last = now
50        temp = read_temp()
51        power = pid.compute(SETPOINT, temp, dt)
52        heater.duty_u16(int(power * 257))                                 # 0-255 -> 0-65535
53        print(SETPOINT, round(temp, 2), round(power))

Ide proyek dengan kontrol PID

  • Termostat presisi: Di proyek termostat Arduino, pakai PID sebagai pengganti on-off untuk menahan inkubator atau lemari fermentasi dalam ±0,3 °C.
  • Kecepatan kipas berdasarkan suhu: Di proyek kendali kipas, jalankan kipas dengan PID arah REVERSE untuk mendapatkan pendinginan yang senyap dan stabil.
  • Robot pengikut garis cepat: Tambahkan 5 sensor dan PID ke proyek Robot Pengikut Garis untuk mencapai kecepatan lomba.
  • Robot penyeimbang diri: Ukur sudut kemiringan dengan MPU-6050 dan jaga robot beroda dua tetap tegak; ini salah satu penerapan PID yang paling banyak mengajarkan.
  • Pelacak matahari: Di proyek pelacak matahari, pakai selisih dua LDR sebagai error dan putar panel dengan halus.
  • Stasiun solder atau oven mini: Ukur suhu tinggi dengan termokopel MAX6675 dan kendalikan pemanasnya dengan PID.
  • Motor berkecepatan konstan: Tahan kecepatan motor DC bergigi yang dilengkapi encoder tetap di target, bahkan ketika bebannya berubah.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Sistem berosilasi cepat dan terus-menerus di sekitar targetKp terlalu besar atau Kd kurangTurunkan Kp sebesar 30–50% dan naikkan Kd sedikit
Tidak pernah mencapai target, tertahan beberapa derajat di bawahKi nol atau terlalu kecilNaikkan Ki perlahan; cek apakah daya pemanas cukup
Overshoot besar dan lama di akhir pemanasanIntegral windup (penumpukan integral)Batasi output dengan SetOutputLimits, batasi integral, turunkan Ki
Output bergetar, motor mendengungSensor berderau dan Kd besarRata-ratakan atau filter pengukuran, turunkan Kd
Output ikut naik ketika suhu naikArah kontrol terbalikPakai REVERSE untuk pendinginan atau balik tanda error
Koefisien yang sama kadang bekerja baik, kadang burukSampling tidak teratur, ada delay() di loopPakai dt tetap dengan millis(), hindari delay()
Pemanas selalu di daya penuh tapi suhu tidak naikPerangkat keras kurang memadai (daya, insulasi, MOSFET)PID tidak bisa menutupi kekurangan perangkat keras; cek daya dan koneksinya
Mengubah koefisien dengan meng-upload ulang kode setiap kali akan melelahkan selama penyetelan. Kalau kamu menambahkan beberapa baris yang membaca perintah seperti “p2.5” atau “d0.8” dari port serial dan memperbarui koefisien selama program berjalan dengan SetTunings(Kp, Ki, Kd), kamu bisa menemukan setelan yang bagus dalam hitungan menit sambil melihat grafik di Serial Plotter. Agar nilai yang kamu temukan tersimpan permanen, kamu bisa menyimpannya ke EEPROM.

Kontrol PID menggabungkan siklus ukur-bandingkan-koreksi dengan tiga ide sederhana, dan dipakai di mana-mana, dari proyek hobi sampai oven industri. Lihat dulu batasan kontrol on-off, lalu mulai dengan P, rem dengan D, dan tutup error tunak dengan I; grafik di Serial Plotter akan memandumu di setiap langkah. Di aplikasi BlueGrays kamu bisa melihat langkah demi langkah, lengkap dengan skema rangkaian dan kode, proyek-proyek yang memakai komponen di artikel ini, seperti pengukuran suhu dengan NTC, deteksi permukaan dengan TCRT5000, mobil robot dengan L298N, dan kontrol PWM dengan potensiometer, lalu mulai menambahkan PID ke proyekmu sendiri dari sana.

Pertanyaan umum

Apa itu kontrol PID dan apa kegunaannya?

Kontrol PID adalah metode umpan balik yang terus menghitung error untuk menjaga nilai terukur tetap di nilai target, lalu menyesuaikan output berdasarkan error itu. Suku proporsional bereaksi terhadap error sekarang, suku integral terhadap error yang menumpuk, dan suku derivatif terhadap laju perubahan error. Untuk kontrol suhu, kecepatan motor, posisi, dan keseimbangan, PID memberi hasil yang jauh lebih stabil dan presisi dibanding kontrol on-off.

Bagaimana cara menemukan nilai Kp, Ki, dan Kd?

Cara paling praktis adalah penyetelan manual: set Ki dan Kd ke nol, naikkan Kp sampai sistem berosilasi lalu bagi dua, tambahkan Kd untuk meredam overshoot, dan tambahkan Ki paling akhir untuk menutup error tunak. Metode Ziegler-Nichols memberi titik awal yang bagus, tapi penyetelan halus hampir selalu dilakukan secara manual. Nilainya khusus untuk tiap sistem; koefisien yang disalin dari proyek lain belum tentu cocok di rangkaianmu.

Apa bedanya PID dengan kontrol on-off?

Kontrol on-off membuat output hanya nyala penuh atau mati total, sehingga terjadi osilasi dan overshoot terus-menerus di sekitar target. PID mengatur output secara bertahap, menurunkan daya lebih awal ketika mendekati target, dan menghapus error tunak dengan suku integral. On-off lebih sederhana dan murah; PID lebih presisi tapi perlu disetel.

Library PID Arduino mana yang sebaiknya dipakai dan bagaimana cara menginstalnya?

Yang paling umum adalah library PID karya Brett Beauregard (PID_v1). Di Arduino IDE, cari “PID” di Library Manager untuk menginstalnya, lalu sertakan header PID_v1.h di kodemu. Library ini mengurus sendiri waktu sampling, pembatasan output, dan perlindungan terhadap integral windup.

Apa itu integral windup dan bagaimana mencegahnya?

Integral windup adalah kondisi ketika error terus menumpuk di integral padahal output sudah mentok di batasnya (misalnya pemanas sudah di daya penuh). Begitu target tercapai, nilai yang menumpuk ini membuat sistem melewati target dalam waktu lama. Untuk mencegahnya, integral harus dijaga di dalam batas output; di library PID Arduino, SetOutputLimits melakukannya secara otomatis.

Apakah kontrol PID bisa dilakukan dengan relay?

Bisa, dengan metode time proportioning (proporsi waktu): misalnya dalam jendela 5 detik, kalau output PID 40%, relay dinyalakan selama 2 detik dan dimatikan selama 3 detik. Karena relay mekanis cepat aus kalau sering berpindah, solid-state relay (SSR) lebih cocok untuk tugas ini. Untuk sistem yang responsnya lambat seperti pemanas, metode ini bekerja sama baiknya dengan PWM.

Lihat semua proyek
Suhu dan Kelembapan dengan DHT11
AR-55Menengah

Suhu dan Kelembapan dengan DHT11

Seberapa hangat kamarmu, dan apakah udaranya lembap atau kering? Sensor DHT11 mengukur suhu dan kelembapan, dan Arduino menulis nilainya di layar LCD dua baris, diperbarui setiap beberapa detik.

4.7(47)
83
Pengukuran Jarak HC-SR04 (Tampilan Serial)
AR-27Pemula

Pengukuran Jarak HC-SR04 (Tampilan Serial)

Sensor HC-SR04 bekerja persis seperti kelelawar yang mencari jalan dalam gelap: ia mengirim suara yang tidak bisa kamu dengar, mendengarkan pantulannya, dan mengukur seberapa jauh benda di depannya.

4.6(50)
82
Mengukur Suhu dengan NTC dan Layar LCD 2x16
AR-44Pemula
Premium

Mengukur Suhu dengan NTC dan Layar LCD 2x16

Ukur suhu di sekitarmu dengan sensor yang mirip manik-manik kecil. Komponen bernama NTC ini makin mudah dilewati listrik ketika makin hangat; Arduino membaca perubahan itu, mengubahnya menjadi…

4.5(33)
44
Deteksi Permukaan Hitam dan Putih TCRT5000
AR-78Menengah
Premium

Deteksi Permukaan Hitam dan Putih TCRT5000

Dengan sensor kecil yang menjadi mata robot pengikut garis, kamu bisa tahu apakah lantainya hitam atau putih.

4.7(40)
49
Membaca Pantulan (Kedekatan) dengan TCRT5000
AR-77Menengah
Premium

Membaca Pantulan (Kedekatan) dengan TCRT5000

Dengan sensor kecil yang memancarkan cahaya tak terlihat dan mengukur berapa banyak yang terpantul kembali, kamu bisa mendeteksi permukaan di depannya.

4.6(33)
43
Robot Penghindar Rintangan
AR-81Mahir
Premium

Robot Penghindar Rintangan

Bagaimana kalau membuat kendaraan pintar yang mencari jalannya sendiri? Robot Penghindar Rintangan terus memindai sekelilingnya berkat sensor ultrasonik di depannya.

5.0(38)
49
Mobil Kendali Bluetooth dengan L298N
AR-80Mahir
Premium

Mobil Kendali Bluetooth dengan L298N

Jadikan ponselmu remote dan kendarai mobil robotmu sendiri. Arduino menerima perintah dari aplikasi remote control di ponselmu lewat modul Bluetooth dan memutar roda dengan driver motor; mobil maju…

5.0(39)
66
Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)
ES-13Menengah
Premium

Kendali Kecerahan LED dengan Potensiometer ESP32 (Analog → PWM)

Di proyek ini, kita mengendalikan kecerahan LED secara analog memakai potensiometer. Pin ADC ESP32 membaca tegangan 0-3,3V dari potensiometer, lalu nilai ini diubah menjadi sinyal PWM (Pulse Width Modulation) dan dikirim ke LED. Hasilnya, ketika kamu memutar potensiometer, LED perlahan menerang dan meredup. Dengan Arduino Core 3.0+, analogWrite() bisa langsung dipakai; di ESP32-S2/S3, resolusi ADC tetap 12-bit.

4.5(19)
32