Temeller · 10 dk okuma

PID Kontrol Nedir? Arduino ile Kp, Ki, Kd Ayarı ve Örnekler

PID kontrol nedir, nasıl çalışır? Oransal, integral ve türev terimleri, Arduino PID kütüphanesi, Kp/Ki/Kd ayarı, sıcaklık ve çizgi izleyen robot kodu.

PID kontrol, bir sistemi istediğin bir değerde tutmak için ölçülen değerle hedef arasındaki farkı (hatayı) sürekli hesaplayan ve çıkışı bu hataya göre ayarlayan bir geri besleme yöntemidir. Arduino projelerinde bir ısıtıcıyı tam 45 °C'de tutmak, bir motoru sabit devirde döndürmek ya da çizgi izleyen robotu çizginin tam ortasında sürmek için kullanılır. Adı üç bileşeninden gelir: Oransal (P) terim şimdiki hataya, İntegral (I) terim geçmişte biriken hataya, Türev (D) terim ise hatanın ne kadar hızlı değiştiğine bakar. Bu üçünün ağırlıklı toplamı, motora ya da ısıtıcıya gidecek PWM değerini belirler.

Formüller ilk bakışta korkutucu görünse de PID'nin mantığı araba sürerken kendiliğinden yaptığın şeylere çok benzer. Bu yazıda önce basit aç-kapa kontrolün neden salındığını görecek, sonra üç terimi sezgisel örneklerle tanıyacaksın. Ardından Arduino PID kütüphanesiyle bir NTC ve MOSFET kullanarak sıcaklık kontrolü yapacak, Kp, Ki ve Kd değerlerini adım adım ayarlamayı öğrenecek ve kütüphanesiz yazılmış bir PID ile çizgi izleyen robotu süreceksin. Son olarak aynı algoritmayı ESP32'de ve Raspberry Pi Pico üzerinde MicroPython ile çalıştıracağız.

Aç-kapa kontrol neden yetmez?

En basit kontrol yöntemi aç-kapa (on-off) kontroldür: sıcaklık hedefin altındaysa ısıtıcıyı tam güçle aç, üstündeyse kapat. Evdeki kombi termostatı ve akvaryum ısıtıcısı büyük ölçüde böyle çalışır. Sorun şu ki ısıtıcı kapandığında içinde depolanan ısı ortama geçmeye devam eder; bu yüzden sıcaklık hedefi birkaç derece aşar. Soğumaya başladığında da ısıtıcı tekrar açılıp ısınana kadar sıcaklık hedefin altına düşer. Sonuç, hedefin etrafında sürekli inip çıkan bir testere dişidir. Bunu yumuşatmak için iki eşik arasında bir boşluk (histerezis) bırakılır; röle daha az tıklar ama salınımın genliği büyür. Hedefi ±0,5 °C içinde tutman gereken bir 3D yazıcı tablasında, kuluçka makinesinde ya da sabit hızla dönmesi gereken bir motorda bu yeterli değildir. PID ise tam güç ile sıfır arasında kademeli bir çıkış üretir ve sistem hedefe yaklaştıkça gücü önceden azaltır.

YöntemNasıl karar verir?ArtısıEksisiTipik kullanım
Aç-kapa (on-off)Hedefin altındaysa tam güç, üstündeyse kapalıÇok basit, röleyle bile yapılırSürekli salınım ve aşma, röle aşınmasıKombi termostatı, akvaryum ısıtıcısı
PÇıkış hatayla orantılıYumuşak tepki, kolay ayarKalıcı hata kalırBasit konum ve seviye kontrolü
PIOrantılı + biriken hataKalıcı hatayı silerDaha fazla aşma, integral birikmesiSıcaklık, akış ve motor hızı kontrolü
PIDOrantılı + biriken hata + değişim hızıHızlı, az aşmalı, hassasAyarı zor, gürültüye duyarlı3D yazıcı, drone, denge robotu, çizgi izleyen robot

PID kontrol nedir, nasıl çalışır?

PID her döngüde önce hatayı hesaplar: hata = hedef değer (setpoint) − ölçülen değer (input). Sonra bu hatayı üç farklı şekilde değerlendirip toplar: çıkış = Kp·e + Ki·∫e·dt + Kd·de/dt. Burada Kp, Ki ve Kd senin ayarladığın katsayılardır; her terimin çıkışa ne kadar katkı yapacağını belirlerler. Mikrodenetleyicide integral, her örneklemede hata ile örnekleme süresinin çarpımının bir toplama eklenmesiyle; türev ise son iki ölçüm arasındaki farkın örnekleme süresine bölünmesiyle hesaplanır. Bu yüzden PID'nin düzgün çalışması için ölçümlerin sabit aralıklarla, örneğin her 10 ms'de ya da her 500 ms'de bir yapılması önemlidir. Arabayla bir şeridi takip ettiğini düşün: şeritten ne kadar uzaksan direksiyonu o kadar çevirirsin (P), yan rüzgâr seni sürekli itiyorsa direksiyonu hafif çevrik tutmayı öğrenirsin (I), şeride hızla yaklaşırken de dönüşü erkenden geri alırsın (D).

TerimNeye bakar?Sezgisel benzetmeFazla olursa
P (Oransal)Şimdiki hataŞeritten ne kadar uzaksan direksiyonu o kadar çevirirsinHızlı salınım, titreme
I (İntegral)Zaman içinde biriken hataYan rüzgâr varsa direksiyonu hafif çevrik tutmayı öğrenirsinYavaş ve geniş salınım, büyük aşma
D (Türev)Hatanın değişim hızıŞeride hızla yaklaşırken dönüşü erkenden geri alırsınGürültüye aşırı tepki, titreyen çıkış

Oransal (P) terim: hataya orantılı tepki

Oransal terim, çıkışı hatanın büyüklüğüyle doğru orantılı olarak ayarlar. Kp = 20 ise 3 °C'lik hata 60 PWM birimi, 1 °C'lik hata 20 birim üretir; hedefe yaklaştıkça güç kendiliğinden azalır. Kp'yi büyüttükçe sistem daha hızlı tepki verir ama belli bir noktadan sonra hedefi aşıp geri dönmeye, yani salınmaya başlar. Yalnız P ile yapılan kontrolün önemli bir zayıflığı vardır: kalıcı hata (steady-state error). Diyelim ki ısıtıcıyı 45 °C'de tutmak için ortama kaçan ısıyı dengeleyecek 80 birimlik sürekli bir güç gerekiyor. Yalnız P terimi varsa bu 80 birim ancak bir hata varken üretilebilir: 80 / 20 = 4 °C. Yani sistem 41 °C civarında dengeye oturur ve hedefe hiç ulaşmaz. Kp'yi artırmak bu farkı küçültür ama salınımı da artırır.

İntegral (I) terim: kalıcı hatayı siler

İntegral terim, hatayı zaman içinde toplar. Küçük bir hata bile uzun süre devam ederse toplam büyür ve çıkış yavaş yavaş artar; ta ki hata sıfırlanana kadar. Yukarıdaki örnekte gereken 80 birimlik gücü artık integral terimi sağlar, P terimi sıfıra iner ve sıcaklık tam 45 °C'ye oturur. Ki ne kadar büyükse kalıcı hata o kadar çabuk kapanır; fazla büyükse sistem yavaş ve geniş salınımlar yapar. İntegralin bilinen bir tuzağı integral birikmesi (windup) denen durumdur: ısıtıcı zaten tam güçteyken hedefe ulaşamıyorsa integral boşuna büyümeye devam eder ve hedefe varıldığında bu birikmiş değer yüzünden sıcaklık uzun süre hedefin üstünde kalır. Çözümü integrali çıkış sınırlarıyla kısıtlamaktır; Arduino PID kütüphanesi bunu SetOutputLimits ile otomatik yapar.

Türev (D) terim: hedefe yaklaşırken frenler

Türev terim, hatanın ne kadar hızlı değiştiğine bakar ve bir tür öngörü sağlar. Sıcaklık hedefe hızla yaklaşıyorsa hata hızla küçülür; D terimi bu değişime ters yönde katkı yaparak gücü erkenden keser ve aşmayı (overshoot) azaltır. Robotta da aynı şey olur: çizgiye doğru hızla dönen robot, çizgiyi geçmeden dönüşünü yumuşatır. D teriminin zayıf yanı gürültüye duyarlılığıdır. Analog bir sensörün okuması her ölçümde birkaç birim zıplıyorsa türev bu küçük zıplamaları büyük değişimler gibi görür ve çıkış titrer. Bu yüzden sensör okumasını ortalamak ya da filtrelemek gerekir; ayrıntılar için sensör verisi filtreleme yazısına bakabilirsin. Ayrıca iyi PID uygulamaları türevi hatadan değil ölçümden alır; böylece hedefi aniden değiştirdiğinde çıkışta ani bir sıçrama (derivative kick) oluşmaz.

Örnek 1: Arduino PID kütüphanesiyle sıcaklık kontrolü

İlk örnekte küçük bir ısıtıcıyı (12 V ısıtma pedi ya da güç direnci) 45 °C'de tutacağız. Sıcaklığı 10 kΩ'luk bir NTC termistör ve 10 kΩ'luk sabit dirençten oluşan gerilim bölücüyle ölçecek, ısıtıcıyı mantık seviyeli bir N kanallı MOSFET (ör. IRLZ44N) üzerinden PWM ile süreceğiz. Arduino IDE'de Kütüphane Yöneticisi'ni açıp PID arat ve Brett Beauregard'ın PID kütüphanesini (PID_v1) kur. Bu kütüphane örnekleme süresi yönetimi, çıkış sınırlama, integral birikmesine karşı koruma ve ölçümden türev alma gibi ayrıntıları senin yerine halleder. MOSFET bağlantısının ayrıntıları için Arduino MOSFET kullanımı yazısına göz atabilirsin.

NTC termistör sıcaklık sensörü
10 kΩ NTC termistör: sıcaklık arttıkça direnci azalır; PID sıcaklık kontrolünde ölçüm elemanı olarak kullanılır.
BağlantıArduino UnoESP32Raspberry Pi Pico
Bölücü beslemesi (10 kΩ sabit direncin üst ucu)5V3V33V3
NTC ile sabit direncin birleşim noktasıA0GPIO 34GP26 (ADC0)
NTC'nin alt ucuGNDGNDGND
MOSFET gate (220 Ω üzerinden, 10 kΩ ile GND'ye)D9GPIO 25GP15
MOSFET sourceGNDGNDGND
Isıtıcı+12 V ile MOSFET drain arası+12 V ile MOSFET drain arası+12 V ile MOSFET drain arası
Isıtıcıyı asla doğrudan Arduino pininden besleme; bir pin en fazla yaklaşık 20–40 mA verebilir, ısıtıcı ise amperler çeker. 12 V adaptörün eksi ucu Arduino'nun GND'siyle ortak olmalıdır, yoksa MOSFET düzgün açılmaz. ESP32 ve Pico 3,3 V çıkış verdiği için IRLZ44N yerine 3,3 V'ta tam açılan bir MOSFET (ör. AO3400) seç; fan ya da motor gibi bobinli bir yük sürüyorsan yüke ters paralel bir diyot ekle.
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}

Kodda readTemperature() fonksiyonu 16 ölçümün ortalamasını alarak gürültüyü azaltır, NTC direncini bölücü formülünden (R = 10 kΩ · adc / (1023 − adc)) hesaplar ve Beta denklemiyle (B = 3950) santigrat dereceye çevirir. SetOutputLimits(0, 255) çıkışı analogWrite aralığında tutar ve integralin bu sınırların dışına taşmasını engeller. SetSampleTime(500) PID'nin yarım saniyede bir hesap yapmasını sağlar; ısı yavaş değişen bir büyüklük olduğu için bu yeterlidir. Compute() yalnızca örnekleme zamanı geldiğinde true döndürür, bu yüzden loop() içinde delay() kullanmamalısın. Seri porta yazılan üç değeri Araçlar menüsündeki Seri Çizici'de (Serial Plotter) açarsan hedefi, sıcaklığı ve ısıtıcı gücünü yüzde olarak aynı grafikte görür, ayarın etkisini anında izlersin. Soğutma yapan bir sistemde (ör. fanla soğutma) sıcaklık arttıkça çıkışın da artması gerekir; bu durumda DIRECT yerine REVERSE kullan.

Kp, Ki ve Kd nasıl ayarlanır? Adım adım

  1. Ki ve Kd'yi sıfırla, Kp'yi küçük bir değerle (ör. 2) başlat ve Seri Çizici'yi aç.
  2. Kp'yi adım adım iki katına çıkar; sistem hedefe hızla yaklaşıp etrafında sürekli salınmaya başlayınca dur. Bu değerin yaklaşık yarısını Kp olarak kullan.
  3. Kd'yi ekle: küçük bir değerden başlayıp aşma ve salınım sönene kadar artır. Çıkış titremeye ya da motor cızırdamaya başlarsa Kd fazladır veya sensör gürültülüdür.
  4. Ki'yi en son ekle: kalıcı hata makul bir sürede kapanana kadar yavaşça artır. Sıcaklık hedefin etrafında yavaş ve geniş dalgalar çiziyorsa Ki'yi azalt.
  5. Bozucu etkiyle test et: hedefi 5 °C değiştir, ısıtıcıya üfle ya da robotu elinle hafifçe it; sistemin ne kadar sürede ve ne kadar aşmayla toparlandığını gözle.
  6. İstersen Ziegler-Nichols yöntemini başlangıç noktası olarak kullan: yalnız P ile sürekli salınım başlatan kazancı (Ku) ve salınım periyodunu (Tu, saniye) ölç; Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu değerleriyle başla ve ince ayarı elle yap.
Katsayıyı artırıncaYükselme süresiAşma (overshoot)Oturma süresiKalıcı hata
KpKısalırArtarAz değişirAzalır
KiKısalırArtarUzarSıfırlanır
KdAz değişirAzalırKısalırTeoride etkilemez

Örnek 2: Çizgi izleyen robotta PID

TCRT5000 kızılötesi çizgi sensörü
TCRT5000 kızılötesi yansıma sensörü: siyah ve beyaz zemini ayırt eder; çizgi izleyen robotta PID'nin girişini oluşturur.

Çizgi izleyen robotta hedef, çizginin robotun tam ortasında kalmasıdır. Sola, ortaya ve sağa yerleştirilmiş üç analog TCRT5000 sensörünün okumalarından ağırlıklı ortalama alarak çizginin konumunu 0 (tam sol) ile 2000 (tam sağ) arasında bir sayıya çeviririz; 1000 tam ortadır. Hata, konum ile 1000 arasındaki farktır. PID'nin ürettiği düzeltme sol motorun hızına eklenir, sağ motorun hızından çıkarılır; böylece robot çizgiye doğru yumuşakça döner. Basit aç-kapa mantığıyla (çizgi soldaysa sola dön, sağdaysa sağa dön) çalışan robotlar yalpalayarak ve yavaş ilerlerken, PID'li bir robot aynı pistte çok daha yüksek hızla ve düzgün bir hatla gider. Bu örnekte PID'yi kütüphanesiz, sıfırdan yazıyoruz; motorlar L298N sürücüyle kontrol ediliyor.

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}

Sensörler A0, A1 ve A2'ye, L298N'nin ENA ve ENB uçları D5 ve D6 PWM pinlerine, IN1–IN4 uçları ise D7, D8, D9 ve D10'a bağlıdır; ENA ve ENB üzerindeki atlama kablolarını (jumper) çıkarmayı unutma. Döngü millis() ile her 10 ms'de bir çalışır; böylece dt sabit kalır ve katsayılar tutarlı davranır. Neden delay() yerine millis() kullandığımızı millis ve delay yazısında bulabilirsin. Hata negatifse çizgi soldadır: düzeltme negatif olur, sol motor yavaşlar, sağ motor hızlanır ve robot sola döner. Hatanın büyüklüğü en fazla 1000 olduğu için Kp = 0,1 en büyük hatada yaklaşık 100 PWM birimlik düzeltme demektir. Türev saniye başına hesaplandığından Kd'nin 0,004 gibi küçük görünmesi normaldir. Çizgi izleyende Ki genellikle sıfır ya da çok küçük tutulur; integral ancak robot sürekli bir yöne kayıyorsa (ör. bir motor diğerinden zayıfsa) faydalıdır. Kendi sensörlerinde beyaz zeminde yüksek, siyah çizgide düşük değer okunuyorsa okumayı 1023 − v şeklinde ters çevir.

ESP32 ve Raspberry Pi Pico ile PID

PID_v1 kütüphanesi saf C++ ile yazıldığı için ESP32'de de aynen çalışır; NTC'yi GPIO 34'e, MOSFET'in gate ucunu GPIO 25'e bağlaman yeterlidir. Farklar donanımdadır: ESP32'nin ADC'si 12 bittir (0–4095) ve uçlara yakın bölgelerde doğrusal değildir; ölçülen gerilimi 0,3–2,8 V aralığında tutmak sonucu iyileştirir. PWM için analogWrite yerine LEDC birimi kullanılır ve bu API çekirdek 3.x ile değiştiği için kodda sürüm kontrolü var. Hızlı ve çift çekirdekli olması sayesinde ESP32, PID döngüsünü çalıştırırken aynı anda bir web sayfasından yeni hedef sıcaklığı da alabilir.

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}

Raspberry Pi Pico'da MicroPython için hazır bir PID modülü bulunmadığından algoritmayı küçük bir sınıf olarak yazıyoruz. Bu sınıf Arduino kütüphanesinin yaptığı üç önemli şeyi taklit eder: integrali çıkış sınırları içinde tutar (anti-windup), türevi ölçümden alır ve örnekleme süresini (dt) hesaba katar. Pico'nun ADC'si read_u16() ile 0–65535 aralığında değer döndürür; PID çıkışı 0–255 aralığında hesaplanıp 257 ile çarpılarak duty_u16() için 16 bite ölçeklenir. Böylece Arduino'da bulduğun Kp, Ki ve Kd değerlerini Pico'da da aynen kullanabilirsin. NTC bölücüsü GP26'ya, MOSFET'in gate ucu GP15'e bağlıdır. MicroPython'a yeniysen MicroPython temelleri yazısıyla başlayabilirsin.

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))

PID kontrol ile proje fikirleri

  • Hassas termostat: Bir Arduino termostat projesinde aç-kapa yerine PID kullanarak kuluçka makinesini ya da fermantasyon dolabını ±0,3 °C içinde tut.
  • Sıcaklığa göre fan hızı: Fan kontrolü projesinde fanı REVERSE yönlü PID ile sürerek sessiz ve sabit bir soğutma elde et.
  • Hızlı çizgi izleyen robot: Çizgi izleyen robot projesine 5 sensör ve PID ekleyerek yarışma hızına çık.
  • Kendini dengeleyen robot: MPU-6050 ile eğim açısını ölçüp iki tekerlekli robotu dik tut; PID'nin en öğretici uygulamalarından biridir.
  • Güneş takip sistemi: Güneş takip projesinde iki LDR arasındaki farkı hata olarak kullanıp paneli yumuşakça döndür.
  • Lehim istasyonu ya da mini fırın: MAX6675 termokupl ile yüksek sıcaklıkları ölçüp ısıtıcıyı PID ile sür.
  • Sabit devirli motor: Enkoderli bir redüktörlü DC motorun devrini, yük değişse bile hedefte tut.

Sık yapılan hatalar ve çözümleri

BelirtiOlası sebepÇözüm
Sistem hedefin etrafında sürekli ve hızlı salınıyorKp çok yüksek ya da Kd yetersizKp'yi %30–50 düşür, Kd'yi biraz artır
Hedefe hiç ulaşmıyor, birkaç derece altta kalıyorKi sıfır ya da çok küçükKi'yi yavaşça artır; ısıtıcının gücünün yeterli olduğunu kontrol et
Isınmanın sonunda büyük ve uzun süren aşmaİntegral birikmesi (windup)SetOutputLimits ile çıkışı sınırla, integrali kısıtla, Ki'yi düşür
Çıkış titriyor, motor cızırdıyorGürültülü sensör ve yüksek KdÖlçümü ortala ya da filtrele, Kd'yi düşür
Sıcaklık arttıkça çıkış da artıyorKontrol yönü tersSoğutmada REVERSE kullan ya da hatanın işaretini çevir
Aynı katsayılar bazen iyi, bazen kötü çalışıyorDüzensiz örnekleme, loop içinde delay()millis() ile sabit dt kullan, delay()'den kaçın
Isıtıcı hep tam güçte ama sıcaklık yükselmiyorDonanım yetersiz (güç, yalıtım, MOSFET)PID donanım eksikliğini telafi edemez; gücü ve bağlantıları kontrol et
Ayar yaparken katsayıları her seferinde kodu yeniden yükleyerek değiştirmek yorucu olur. Seri porttan "p2.5" ya da "d0.8" gibi komutlar okuyup SetTunings(Kp, Ki, Kd) ile katsayıları çalışırken güncelleyen birkaç satır eklersen, Seri Çizici'deki grafiğe bakarak dakikalar içinde iyi bir ayar bulursun. Bulduğun değerleri kalıcı yapmak için EEPROM'a kaydedebilirsin.

PID kontrol, ölç-karşılaştır-düzelt döngüsünü üç basit fikirle birleştiren ve hobi projelerinden endüstriyel fırınlara kadar her yerde kullanılan bir yöntemdir. Önce aç-kapa kontrolün sınırlarını gör, sonra P ile başla, D ile frenle ve I ile kalıcı hatayı kapat; Seri Çizici'deki grafik sana her adımda yol gösterecektir. BlueGrays uygulamasında NTC ile sıcaklık ölçümü, TCRT5000 ile zemin algılama, L298N'li robot araba ve potansiyometreyle PWM kontrolü gibi bu yazıdaki parçaları kullanan projelere devre şemaları ve kodlarıyla adım adım bakabilir, PID'yi kendi projene eklemeye oradan başlayabilirsin.

Sıkça sorulan sorular

PID kontrol nedir, basitçe ne işe yarar?

PID kontrol, ölçülen bir değeri hedef değerde tutmak için hatayı sürekli hesaplayan ve çıkışı buna göre ayarlayan bir geri besleme yöntemidir. Oransal terim şimdiki hataya, integral terim biriken hataya, türev terim ise hatanın değişim hızına tepki verir. Sıcaklık, motor hızı, konum ve denge kontrolünde aç-kapa yöntemine göre çok daha kararlı ve hassas sonuç verir.

Kp, Ki ve Kd değerleri nasıl bulunur?

En pratik yol elle ayarlamadır: Ki ve Kd'yi sıfırla, sistem salınana kadar Kp'yi artırıp yarısına indir, aşmayı bastırmak için Kd ekle, kalıcı hatayı kapatmak için en son Ki ekle. Ziegler-Nichols yöntemi iyi bir başlangıç noktası verir ama ince ayar neredeyse her zaman elle yapılır. Değerler sisteme özeldir; başka bir projeden kopyalanan katsayılar senin devrende çalışmayabilir.

PID ile aç-kapa kontrol arasındaki fark nedir?

Aç-kapa kontrol çıkışı yalnızca tam açık ya da tam kapalı yapar; bu yüzden hedefin etrafında sürekli salınım ve aşma oluşur. PID ise çıkışı kademeli olarak ayarlar, hedefe yaklaşırken gücü önceden azaltır ve kalıcı hatayı integral terimiyle siler. Aç-kapa daha basit ve ucuzdur, PID daha hassastır ama ayar ister.

Arduino PID kütüphanesi hangisi, nasıl kurulur?

En yaygın olanı Brett Beauregard'ın PID kütüphanesidir (PID_v1). Arduino IDE'de Kütüphane Yöneticisi'nde "PID" aratıp kurabilir, koduna PID_v1.h başlık dosyasını ekleyerek kullanabilirsin. Kütüphane örnekleme süresini, çıkış sınırlamayı ve integral birikmesine karşı korumayı kendisi yönetir.

İntegral windup nedir, nasıl önlenir?

İntegral windup, çıkış zaten sınırdayken (ör. ısıtıcı tam güçteyken) hatanın integralde birikmeye devam etmesidir. Hedefe ulaşıldığında bu birikmiş değer yüzünden sistem hedefi uzun süre aşar. Önlemek için integrali çıkış sınırları içinde tutmak gerekir; Arduino PID kütüphanesinde SetOutputLimits bunu otomatik yapar.

Röle ile PID kontrol yapılabilir mi?

Evet, zaman oransal (time proportioning) yöntemiyle yapılabilir: örneğin 5 saniyelik bir pencerede PID çıkışı yüzde 40 ise röle 2 saniye açık, 3 saniye kapalı tutulur. Mekanik röleler sık anahtarlamada çabuk aşındığı için bu iş için katı hal rölesi (SSR) daha uygundur. Isıtıcı gibi yavaş tepki veren sistemlerde bu yöntem PWM kadar iyi sonuç verir.

Tüm projeleri gör
DHT11 İle Sıcaklık Ve Nem
AR-55Orta

DHT11 İle Sıcaklık Ve Nem

Odan kaç derece, hava nemli mi, kuru mu? DHT11 sensörü sıcaklığı ve nemi ölçer, Arduino da bu değerleri iki satırlık LCD ekrana yazar ve birkaç saniyede bir yeniler.

4.7(47)
83
HC-SR04 Mesafe Ölçme (Serial Ekran)
AR-27Başlangıç

HC-SR04 Mesafe Ölçme (Serial Ekran)

Yarasalar karanlıkta yollarını nasıl buluyorsa HC-SR04 sensörü de öyle çalışır: duyamadığın bir ses gönderir, yankısını dinler ve önündeki cismin ne kadar uzakta olduğunu ölçer.

4.6(50)
82
NTC ve 2x16 Lcd Ekran İle Sıcaklık Ölçümü
AR-44Başlangıç
Premium

NTC ve 2x16 Lcd Ekran İle Sıcaklık Ölçümü

Ortamın sıcaklığını küçük bir boncuk gibi görünen sensörle ölç. NTC adlı bu parça ısındıkça elektriği daha kolay geçirir; Arduino bu değişimi okuyup bir formülle santigrat dereceye çevirir ve iki…

4.5(33)
44
TCRT5000 Siyah Beyaz Zemin Tespiti
AR-78Orta
Premium

TCRT5000 Siyah Beyaz Zemin Tespiti

Çizgi izleyen robotların gözü olan küçük bir sensörle zeminin siyah mı beyaz mı olduğunu anlarsın.

4.7(40)
49
TCRT5000 ile Yansıma (Yakınlık) Okuma
AR-77Orta
Premium

TCRT5000 ile Yansıma (Yakınlık) Okuma

Görünmez ışık yollayıp yansımasını ölçen küçük bir sensörle önündeki yüzeyi algılarsın.

4.6(33)
43
Engelden Kaçan Robot
AR-81İleri
Premium

Engelden Kaçan Robot

Kendi yolunu bulan akıllı bir araç yapmaya ne dersin? Engelden Kaçan Robot, önündeki ultrasonik sensör sayesinde çevresini sürekli tarar.

5.0(38)
49
L298N ile Bluetooth Kontrollü Araba
AR-80İleri
Premium

L298N ile Bluetooth Kontrollü Araba

Telefonunu kumandaya çevirip kendi robot arabanı sür. Arduino, Bluetooth modülü üzerinden telefondaki bir kumanda uygulamasından gelen komutları alır ve motor sürücüyle tekerlekleri döndürür; araba…

5.0(39)
66
ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)
ES-13Orta
Premium

ESP32 Potansiyometre ile LED Parlaklık (Analog → PWM)

Bu projede bir potansiyometre ile LED parlaklığını analog olarak kontrol ediyoruz. ESP32'nin ADC pini potansiyometreden gelen 0-3.3V gerilimi okur, ardından bu değer PWM (Pulse Width Modulation) sinyaline çevrilerek LED'e gönderilir. Böylece potansiyometreyi çevirdikçe LED kademeli olarak parlar ve söner. Arduino Core 3.0+ ile analogWrite() doğrudan kullanılabilir; ESP32-S2/S3'te ADC çözünürlüğü 12-bit'e sabitlenir.

4.5(19)
32