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.
| Metode | Cara memutuskan | Kelebihan | Kekurangan | Penggunaan umum |
|---|---|---|---|---|
| On-off (nyala-mati) | Daya penuh di bawah target, mati di atasnya | Sangat sederhana, bahkan bisa dengan relay | Osilasi dan overshoot terus-menerus, relay cepat aus | Termostat pemanas air, pemanas akuarium |
| P | Output sebanding dengan error | Respons halus, mudah diatur | Menyisakan error tunak | Kontrol posisi dan level sederhana |
| PI | Proporsional + error yang menumpuk | Menghapus error tunak | Overshoot lebih besar, integral windup | Kontrol suhu, aliran, dan kecepatan motor |
| PID | Proporsional + error yang menumpuk + laju perubahan | Cepat, overshoot kecil, presisi | Sulit diatur, sensitif terhadap derau | Printer 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).
| Suku | Yang dilihat | Analogi intuitif | Kalau terlalu besar |
|---|---|---|---|
| P (Proporsional) | Error sekarang | Makin jauh dari lajur, makin banyak kamu memutar setir | Osilasi cepat, bergetar |
| I (Integral) | Error yang menumpuk seiring waktu | Kalau ada angin samping, kamu belajar menahan setir sedikit miring | Osilasi lambat dan lebar, overshoot besar |
| D (Derivatif) | Laju perubahan error | Ketika mendekati lajur dengan cepat, kamu mengurangi belokan lebih awal | Bereaksi 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.

| Koneksi | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Catu pembagi (ujung atas resistor tetap 10 kΩ) | 5V | 3V3 | 3V3 |
| Titik sambungan NTC dan resistor tetap | A0 | GPIO 34 | GP26 (ADC0) |
| Ujung bawah NTC | GND | GND | GND |
| Gate MOSFET (lewat 220 Ω, dengan 10 kΩ ke GND) | D9 | GPIO 25 | GP15 |
| Source MOSFET | GND | GND | GND |
| Pemanas | Di antara +12 V dan drain MOSFET | Di antara +12 V dan drain MOSFET | Di antara +12 V dan drain MOSFET |
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
- Set Ki dan Kd ke nol, mulai Kp dari nilai kecil (misalnya 2), lalu buka Serial Plotter.
- 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.
- 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.
- 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.
- 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.
- 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 dinaikkan | Waktu naik | Overshoot | Waktu settling | Error tunak |
|---|---|---|---|---|
| Kp | Makin singkat | Naik | Sedikit berubah | Turun |
| Ki | Makin singkat | Naik | Makin lama | Hilang |
| Kd | Sedikit berubah | Turun | Makin singkat | Secara teori tidak berpengaruh |
Contoh 2: 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.
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.
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.
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
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Sistem berosilasi cepat dan terus-menerus di sekitar target | Kp terlalu besar atau Kd kurang | Turunkan Kp sebesar 30–50% dan naikkan Kd sedikit |
| Tidak pernah mencapai target, tertahan beberapa derajat di bawah | Ki nol atau terlalu kecil | Naikkan Ki perlahan; cek apakah daya pemanas cukup |
| Overshoot besar dan lama di akhir pemanasan | Integral windup (penumpukan integral) | Batasi output dengan SetOutputLimits, batasi integral, turunkan Ki |
| Output bergetar, motor mendengung | Sensor berderau dan Kd besar | Rata-ratakan atau filter pengukuran, turunkan Kd |
| Output ikut naik ketika suhu naik | Arah kontrol terbalik | Pakai REVERSE untuk pendinginan atau balik tanda error |
| Koefisien yang sama kadang bekerja baik, kadang buruk | Sampling tidak teratur, ada delay() di loop | Pakai dt tetap dengan millis(), hindari delay() |
| Pemanas selalu di daya penuh tapi suhu tidak naik | Perangkat keras kurang memadai (daya, insulasi, MOSFET) | PID tidak bisa menutupi kekurangan perangkat keras; cek daya dan koneksinya |
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.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
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.

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.

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…

Deteksi Permukaan Hitam dan Putih TCRT5000
Dengan sensor kecil yang menjadi mata robot pengikut garis, kamu bisa tahu apakah lantainya hitam atau putih.

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.

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

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…

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.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

